Ming-Log's Blog

记录生活中的点点滴滴

0%

Python数据科学_1_Python编程基础复习

发表于 更新于 分类于
本文字数： 15k 阅读时长 ≈ 13 分钟

Python输入输出

获取用户输入 input()函数

1
2
3
# input获取到的所有输入内容全部都是字符串
a = int(input('请输入a【整数】:'))
b = int(input('请输入b【整数】:'))
请输入a【整数】:3
请输入b【整数】:2

输出

简单输出

1
print(a)
3

%格式化输出

通配符

  • %d:整数型
  • %f:浮点型
  • %s:字符串
1
print('%d加上%d的值是%d' % (a, b, a+b))
3加上2的值是5

.format()方法进行格式化输出

1
print('{}加上{}的值是{}'.format(a, b, a+b))
3加上2的值是5

f””进行格式化输出

1
print(f'{a}加上{b}的值是{a+b}')
3加上2的值是5

赋值方法

简单赋值

1
a = 1

序列赋值

将不同的值，赋值给不同的变量

1
a, b = 2, 3

链式赋值

将同一个值，赋值给不同的变量

1
a = b = 3

增强赋值

1
2
3
a = 2
a += 6  # ==> a = a + 6
print(a)
8

Python中的注释符号

1
2
3
4
5
6
7
8
# c = 3  单行注释
# \n:换行符
'这种注释方法，利用了在Python中不会对字符串内部的代码执行解释'
''' 多行注释
d = 4
c = a + d
print(c)
'''
'\nd = 4\nc = a + d\nprint(c)\n'

变量名的命名规范

  1. 必须以字母、数字和下划线构成，区分字符大小写
  2. 不能以数字开头
  3. 不能够使用Python中的关键字和保留字进行命名
1
2
# 变量名的命名区分大小写
print(A)
-----------------------------------------------

NameError     Traceback (most recent call last)

<ipython-input-17-939330b76721> in <module>
----> 1 print(A)


NameError: name 'A' is not defined

1
2
3
# 变量名不能以数字开头
1_a = '123'
print(1_a)
  File "<ipython-input-19-1b85b8992030>", line 1
    1_a = '123'
     ^
SyntaxError: invalid decimal literal

1
2
# 不能使用Python的关键字和保留字进行命名
True = 123
  File "<ipython-input-20-cc0f27f3a6b4>", line 1
    True = 123
    ^
SyntaxError: cannot assign to True

1
2
3
4
5
# 查看Python中所有的关键字和保留字
import keyword
print(keyword.kwlist)
# 不用去死记这些内容，现在多数Python编辑器都有代码高亮功能，
# 像Python中的关键字和保留字都会以高亮的形式展示
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

1
2
3
4
5
6
# _下划线变量虽然是符合Python的命名规范的
# 但是我们在写代码过程中我们一般不使用其作为变量名
# 其一般被作用于
# 在循环过程中不需要使用遍历的中间变量时使用_代替
_ = 123
print(_)
123

1
2
# 查看变量的数据类型
type(a)
int

数值

  1. int 数型
  2. float 浮点型
  3. boolean 布尔值类型
  4. complex 复数型

数值型基本运算

1
2
3
4
5
6
7
# 简单的加、减、乘、除运算不再赘述
# 取模运算（取余运算）
print(5%3)
# 乘方运算
print(3**3)
# 取商运算
print(5//3)
2
27
1

增强赋值运算

1
2
3
a = 5
a *= 6  # ==> a = a * 6
print(a)
30

1
2
a %= 7  # ==> a = a % 7
print(a)
2

比较运算符

  1. ==判断是否相等
  2. !=判断是否不相等
  3. >判断是否大于
  4. <判断是否小于
  5. >=
  6. <=

字符串

字符串的定义

1
2
str1 = 'hello world!'
print(str1)
hello world!

1
2
str2 = "你好，世界！"
print(str2)
你好，世界！

1
2
str3 = """hi,jupyter notebook!"""
print(str3)
hi,jupyter notebook!

1
2
3
4
# 不可用来定义换行符字符串
str5 = "hellp,
pycharm"
print(str5)
  File "<ipython-input-2-172b211de0cf>", line 1
    str5 = "hellp,
                  ^
SyntaxError: EOL while scanning string literal

1
2
3
4
# 可以用来定义具有换行符号的字符串
str4 = """hello,
pycharm."""
print(str4)
hello,
pycharm.

序列型数据的索引和切片

1
2
3
# 取出str1中的w
print(str1[6])
print(str1[-6])
w
w

1
str1[6:9]  # 切分区间的取值范围是左闭右开的
'wor'

字符串的相关用法

增

1
2
str1 = str1 + str2
print(str1)
hello world!hello world!你好，世界！

1
2
str1 = str1 * 2
print(str1)
hello world!hello world!你好，世界！hello world!hello world!你好，世界！

删

1
2
# 删除字符串首尾的指定字符
print(str1.strip('！'))
hello world!hello world!你好，世界！hello world!hello world!你好，世界

修改

1
2
str1 = str1.replace('你好', 'hello')
print(str1)
hello world!hello world!hello，世界！hello world!hello world!hello，世界！

1
2
# 将字符串替换为空字符串，达到间接删除的目的
str1.replace('hello', '')
' world! world!，世界！ world! world!，世界！'

查找

1
print(str1)
hello world!hello world!hello，世界！hello world!hello world!hello，世界！

1
2
# 查找指定字符第一次出现的下标位置
print(str1.find('w'))
6

1
2
# 查找l出现的次数
print(str1.count('l'))
16

切分字符串

1
2
print(str2)
print(str2.split('，'))
你好，世界！
['你好', '世界！']

列表

列表的定义

使用特定符号进行定义

1
2
list1 = ['a', 'b', 'c', 'd']
print(list1)
['a', 'b', 'c', 'd']

使用特定的函数进行定义

1
2
3
# 将其他序列型的数据转化为列表
list2 = list('qwertyu')
print(list2)
['q', 'w', 'e', 'r', 't', 'y', 'u']

列表的索引和切片

对列表进行索引操作

1
2
3
# 取出元素't' 
print(list2[4])
print(list2[-3])
t
t

对列表进行切片操作

1
2
# 取出wer
print(list2[1:4])
['w', 'e', 'r']

1
2
3
# 取出qwe
print(list2[0:3])
print(list2[:3])  # 从第一个元素开始取值，可以省略第一个位置的0
['q', 'w', 'e']
['q', 'w', 'e']

1
2
3
4
5
# 取出tyu
print(list2[4:7])
print(list2[4:])
print(list2[-3:])  
# 从某一个位置开始进行取值，一直取值到最后一个，可省略最后一个元素的下标
['t', 'y', 'u']
['t', 'y', 'u']
['t', 'y', 'u']

1
2
# 取出列表的奇数项元素
print(list2[::2])
['q', 'e', 't', 'u']

1
2
# 取出偶数项
print(list2[1::2])
['w', 'r', 'y']

对列表进行增删改查

1
list3 = [12, 'a', [1, 2, 3], True]
1
2
3
list4 = [[1, 2, 3], 
         [3, 4, 5], 
         [5, 6, 7]]

增

insert() 在指定的位置上增加某个元素

1
2
# 在'a' 后面增加一个'b'
list3.insert(2, 'b')
1
list3
[12, 'a', 'b', [1, 2, 3], True]

append() 在列表的末尾进行追加元素

1
2
# 在列表末尾追加一个None
list3.append(None)
1
list3
[12, 'a', 'b', [1, 2, 3], True, None]

1
2
# 在内层列表[1, 2, 3]的末尾追加一个4
list3[3].append(4)
1
list3
[12, 'a', 'b', [1, 2, 3, 4], True, None]

在列表的末尾追加多个元素

1
2
# 直接使用+
print(list3 + list1)
[12, 'a', 'b', [1, 2, 3, 4], True, None, 'a', 'b', 'c', 'd']

1
list3
[12, 'a', 'b', [1, 2, 3, 4], True, None]

1
2
# 调用extend()方法
list3.extend(list1)  # ==> list3 += list1
1
print(list3)
[12, 'a', 'b', [1, 2, 3, 4], True, None, 'a', 'b', 'c', 'd']

删

根据值进行删除

1
2
list3.remove(None)
list3
[12, 'a', 'b', [1, 2, 3, 4], True, 'a', 'b', 'c', 'd']

根据下标位置进行删除，并删除的结果可以被使用

1
list3.pop(3)
[1, 2, 3, 4]

1
list3
[12, 'a', 'b', True, 'a', 'b', 'c', 'd']

改

1
2
# 把True改为False
list3[3] = False
1
list3
[12, 'a', 'b', False, 'a', 'b', 'c', 'd']

查

1
2
# 查找字符c首次出现的下标位置
list3.index('c')
6

1
2
# 查找字符a在列表中出现的次数
list3.count('a')
2

1
list3.index('a')
1

元组

元组的定义

使用特定的符号进行定义

1
2
tuple1 = (1, 2, 3, 4, 5)
print(tuple1)
(1, 2, 3, 4, 5)

1
2
3
# 小括号可以省略
tuple3 = 2, 3, 4, 5, 6
print(tuple3)
(2, 3, 4, 5, 6)

1
2
# 元组的解包
a, b = (3, 4)  # ==> 序列赋值  a, b = 3, 4

使用特定的函数进行定义

1
2
# 将其他类型的序列数据转化为元组
tuple2 = tuple(list3)
1
tuple2
(12, 'a', 'b', False, 'a', 'b', 'c', 'd')

1
2
# 元组的元素是不支持修改的
tuple2[0] = 10
---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-88-2f5390dc6863> in <module>
      1 # 元组的元素是不支持修改的
----> 2 tuple2[0] = 10


TypeError: 'tuple' object does not support item assignment

因为元组不支持修改，所以其没有相关的增、删、改操作。

元组的查找操作

1
tuple2.index('c')
6

1
tuple2.count('a')
2

序列型数据的两个通用方法

1
2
3
4
# 查看序列型数据中元素的个数  len()
print(len(tuple2))
print(len(list3))
print(len('abcdefg'))
8
8
7

1
2
3
4
# 查看某个元素是否在序列型数据中   in
print(False in list3)
print(False in tuple2)
print('bc' in 'abcdefg')
True
True
True

集合

  1. 唯一性
  2. 无序性
  3. 确定性

集合的定义

使用特殊的符号进行定义

1
set1 = {1, 2, 3, 4, 5, 5, 6, 2, 3, True, False, 'a', 'v', 'b', 'c'}
1
2
# 在Python的解释器中默认会把True当作数字1处理，False当作数字0处理
set1
{1, 2, 3, 4, 5, 6, False, 'a', 'b', 'c', 'v'}

使用特殊的函数进行定义

1
2
3
# 将序列型数据转化为集合
set2 = set([1, 3, 5, 7, 9, 11, 13])
print(set2)
{1, 3, 5, 7, 9, 11, 13}

集合的增删改查

增

向集合中增加单个元素

1
set2.add(8)
1
print(set2)
{1, 3, 5, 7, 8, 9, 11, 13}

增加多个元素（将一个集合中的元素添加到另一个集合）

1
2
set3 = set('asdfgh')
print(set3)
{'a', 's', 'g', 'f', 'h', 'd'}

1
set2.update(set3)
1
print(set2)
{'a', 1, 3, 5, 7, 8, 9, 's', 11, 'g', 13, 'f', 'h', 'd'}

删

1
2
# 按照值进行删除
set2.remove('a')
1
print(set2)
{1, 3, 5, 7, 8, 9, 's', 11, 'g', 13, 'f', 'h', 'd'}

1
set2.remove('a')  # 使用remove方法对集合中不存在的元素进行删除时会报错
---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-104-72d16a574818> in <module>
----> 1 set2.remove('a')  # 使用remove方法对集合中不存在的元素进行删除时会报错


KeyError: 'a'

1
2
# 安全删除，如果集合中存在元素时删除，如果不存在就什么也不做
set2.discard('a')  # 不会报错
1
2
# 随机删除一个元素
set2.pop()
1

1
print(set2)
{3, 5, 7, 8, 9, 's', 11, 'g', 13, 'f', 'h', 'd'}

改

1
2
3
4
# 无法直接修改
# 可间接修改，先删除，再增加
set2.remove('s')
set2.add('S')
1
set2
{11, 13, 3, 5, 7, 8, 9, 'S', 'd', 'f', 'g', 'h'}

查

1
's' in set2
False

1
'S' in set2
True

拓展(利用集合的无序性进行元素的去重)

1
2
list_tmp = [2, 3, 4, 1, 2, 5, 4, 6, 7, 4, 6, 8]
list(set(list_tmp))
[1, 2, 3, 4, 5, 6, 7, 8]

集合之间的运算

1
2
print(set1)
print(set2)
{False, 1, 2, 3, 4, 5, 6, 'b', 'v', 'c', 'a'}
{3, 5, 7, 8, 9, 11, 'd', 13, 'S', 'g', 'f', 'h'}

并集

1
2
# 使用符号
print(set1 | set2)
{False, 1, 2, 3, 4, 5, 6, 'b', 7, 8, 9, 11, 13, 'f', 'h', 'd', 'v', 'S', 'g', 'c', 'a'}

1
2
# 使用方法
print(set1.union(set2))
{False, 1, 2, 3, 4, 5, 6, 'b', 7, 8, 9, 11, 13, 'f', 'h', 'd', 'v', 'S', 'g', 'c', 'a'}

交集

1
2
# 使用符号
set1 & set2
{3, 5}

1
2
# 使用方法
set1.intersection(set2)
{3, 5}

差集

1
2
3
4
5
# 使用符号
# 取出在set1中但是不再set2中的元素
print(set1 - set2)
# 取出在set2中但是不再set1中的元素
print(set2 - set1)
{False, 1, 2, 'b', 4, 6, 'v', 'c', 'a'}
{7, 8, 9, 11, 'd', 13, 'S', 'g', 'f', 'h'}

1
2
3
4
5
# 使用方法
# 取出在set1中但是不再set2中的元素
print(set1.difference(set2))
# 取出在set2中但是不再set1中的元素
print(set2.difference(set1))
{False, 1, 2, 'b', 4, 6, 'v', 'c', 'a'}
{7, 8, 9, 11, 'd', 13, 'S', 'g', 'f', 'h'}

异或集

1
2
# 使用符号
print(set1 ^ set2)
{False, 1, 2, 4, 6, 7, 8, 9, 11, 13, 'f', 'h', 'g', 'c', 'a', 'b', 'd', 'v', 'S'}

1
2
# 使用方法
print(set1.symmetric_difference(set2))
{False, 1, 2, 4, 6, 7, 8, 9, 11, 13, 'f', 'h', 'g', 'c', 'a', 'b', 'd', 'v', 'S'}

超子集关系

1
2
set11 = {1, 2, 3}
set22 = {1, 2, 3, 4, 5, 6}
1
2
# 判断set11是否是set22的子集
set11.issubset(set22)
True

1
2
# 判断set22是否是set11的超集
set22.issuperset(set11)
True

字典

创建字典

1
2
3
4
5
dict1 = {'数学分析': 80, 
         '高等代数': 90, 
         '解析几何': 99,
         '概率论': 90,
         '数理统计': 90}

字典的取值

1
dict1['高等代数']
90

字典的增删改查

增

1
2
3
4
5
# 这种赋值方法，在Python内部会做下面的事情
# 首先，判断一下"回归分析"这个键，在字典中是否出现过
# 如果出现过，就是对其值进行重新赋值（修改）
# 如果没有出现过，就是重新创建一个新的键值对。
dict1['回归分析'] = 98
1
print(dict1)
{'数学分析': 80, '高等代数': 90, '解析几何': 99, '概率论': 90, '数理统计': 90, '回归分析': 98}

删

使用pop方法进行删除

1
dict1.pop('解析几何')
99

1
print(dict1)
{'数学分析': 80, '高等代数': 90, '概率论': 90, '数理统计': 90, '回归分析': 98}

使用del进行强制内存清除

1
del dict1['数学分析']
1
print(dict1)
{'高等代数': 90, '概率论': 90, '数理统计': 90, '回归分析': 98}

改

1
dict1['数理统计'] = 80
1
print(dict1)
{'高等代数': 90, '概率论': 90, '数理统计': 80, '回归分析': 98}

查找

1
dict1['高等代数']
90

使用一个字典对另外一个字典进行更新

1
print(dict1)
{'高等代数': 90, '概率论': 90, '数理统计': 80, '回归分析': 98}

1
2
dict2 = {'数学分析': 78,
         '数理统计': 82}
1
2
3
4
# 使用dict2对dict1进行更新
dict1.update(dict2)
# dict1['数学分析'] = 78
# dict1['数理统计'] = 82
1
print(dict1)
{'高等代数': 90, '概率论': 90, '数理统计': 82, '回归分析': 98, '数学分析': 78}

查看字典中对应的键和值

查看字典中所有的键

1
dict1.keys()
dict_keys(['数学分析', '高等代数', '解析几何', '概率论', '数理统计', '回归分析'])

查看字典中所有的值

1
dict1.values()
dict_values([80, 90, 99, 90, 90, 98])

查看字典的键值对

1
dict1.items()
dict_items([('数学分析', 80), ('高等代数', 90), ('解析几何', 99), ('概率论', 90), ('数理统计', 90), ('回归分析', 98)])

Python中的程序控制流

循环

for循环

1
2
3
4
5
6
7
# 在Python中是如何区分代码片段的
# 是以空格进行区分，一般4个空格作为一个代码分割符
# 遍历: 是指循环取到序列型数据的每一个元素
list1 = [1, 2, 3, 4, 5, 6]
for i in list1:
    print(i ** 2)
    print('-'*10)
1
----------
4
----------
9
----------
16
----------
25
----------
36
----------

1
2
# 输出从0开始的连续n个整数
list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

1
2
3
# 当指定三个参数时
# range(start, end, step)
list(range(0, 10, 2))
[0, 2, 4, 6, 8]

while循环

1
2
3
4
a = 1
while a < 10:
    print(a)
    a += 1
1
2
3
4
5
6
7
8
9
  1. break：中断整个循环
  2. continue：中断当次循环，不会中断整个循环

分支（判断）

单分支

1
2
3
4
5
6
a = 1
while True:
    print(a)
    if a == 9:
        break
    a += 1
1
2
3
4
5
6
7
8
9

双分支

1
2
3
4
5
num = int(input('请输入一个整数：'))
if num % 2 == 0:
    print(f"{num}是偶数")
else:
    print(f"{num}是奇数")
请输入一个整数：17
17是奇数

多分支

1
2
3
4
5
6
7
8
9
10
11
# 获取用户输入
# 判断用户输入的整数是非负数还是负数，
# 当用户输入的是非负数的时候，
# 再判断一下这个非负数是奇数还是偶数
num = int(input('请输入一个整数：'))
if num < 0:
    print(f'{num}是一个负数。')
elif num % 2 == 0:
    print(f"{num}是偶数")
else:
    print(f"{num}是奇数")
请输入一个整数：7
7是奇数

for … else … 语句

当循环正常结束【在运行的过程中没有执行break语句】时会运行else里面的语句

1
2
3
4
5
6
for i in range(10):
    if i == 5:
        continue
    print(i)
else:
    print('欸，我正常结束啦！')
0
1
2
3
4
6
7
8
9
欸，我正常结束啦！

1
2
3
4
5
6
for i in range(10):
    if i == 5:
        break
    print(i)
else:
    print('欸，我正常结束啦！')
0
1
2
3
4

1
2
3
4
5
6
7
8
9
10
# 判断一个数是否是素数
num = int(input('请输入一个整数:'))
n = 0
for i in range(1, num + 1):
    if num % i == 0:
        n += 1
if n == 2:
    print(f"{num}是素数！")
else:
    print(f"{num}不是素数！")
请输入一个整数:4
4不是素数！

1
2
3
4
5
6
7
num = int(input('请输入一个整数:'))
for i in range(2, num):
    if num % i == 0:
        print(f"{num}不是素数！")
        break
else:
    print(f"{num}是素数！")
请输入一个整数:15
15不是素数！

列表推导式

1
2
3
4
5
6
# 取出0-100中所有的偶数
list_1 = []
for i in range(101):
    if i % 2 == 0:
        list_1.append(i)
print(list_1)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

1
2
list_2 = [i for i in range(101) if i % 2 == 0]
print(list_2)
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100]

函数、类和模块

函数

1
2
3
4
5
6
7
8
# 判断某个整数是不是素数
def func_1(num):
    for i in range(2, num):
        if num % i == 0:
            print(f"{num}不是素数！")
            break
    else:
        print(f"{num}是素数！")
1
2
3
# 调用函数
func_1(5)
func_1(13)
5是素数！
13是素数！

1
2
3
4
5
6
7
8
9
10
11
12
# 查找出列表中某个元素
# 第n次出现的下标位置
def list_index_n(list_, a, n):
    a_n = list_.count(a)
    if a_n >= n:
        res_index = []  # 用来存储所有的a元素出现的下标位置
        for i in range(len(list_)):
            if list_[i] == a:
                res_index.append(i)
        return res_index[n-1]
    else:
        return '列表中存在元素的数量小于搜索的位置'
1
list1 = [1, 'a', 2, 3, 1, 'b', 'a', 'c', 2, 5]
1
list_index_n(list1, 1, 1)
0

1
list_index_n(list1, 1, 3)
'列表中存在元素的数量小于搜索的位置'

类

1
2
3
4
5
6
7
8
9
10
11
class People:
    # 初始化方法：一般用来定义类属性
    def __init__(self, name, sex):
        self.name = name
        self.sex = sex
    
    def eat(self):
        print(f'{self.name}正在干饭！')
        
    def run(self):
        print('哒哒哒！')
1
2
# 类的实例化
zhangsan = People('张三', '男')
1
zhangsan.eat()
张三正在干饭！

模块

1
2
3
# 查看当前工作路径
import os
os.getcwd()
'D:\\泰迪智能科技有限公司\\10 培训相关\\实训方案\\01 生产实习\\湖北师范大学\\demo\\day01'

1
import demo
1
demo.func_1(14)
14不是素数！

1
from demo import func_1 as f
1
f(123)
123不是素数！
-------------本文结束感谢您的阅读-------------