赋值语句

格式：变量名=数据

1
2
3
x=2 
x=y=2   #多个变量同时具有相同的值，id(x)查看变量的内存地址 
x,y=1,2  #多个变量同时具有不相同的值 x,y=y,x  #变量交换

数据类型

整数类型、字符串类型、列表类型

常用内置数据类型

整数、实数、复数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import math
print(math.factorial(32))               # 计算32的阶乘
print(0.4-0.3 == 0.1)                   # 实数之间尽量避免直接比较大小
print(math.isclose(0.4-0.3, 0.1))       # 测试两个实数是否足够接近
num = 7
squreRoot = num ** 0.5                  # 计算平方根
print(squreRoot**2 == num)
print(math.isclose(squreRoot**2, num))
---------------------------------------
263130836933693530167218012160000000
False
True
False
True
c = 3+4j                                # Python内置支持复数及其运算
print(c+c)                              # 复数相加
print(c**2)                             # 幂运算
print(c.real)                           # 查看复数的实部
print(c.imag)                           # 查看复数的虚部
print(3+4j.imag)                        # 相当于3+(4j).imag
print(c.conjugate())                    # 查看共轭复数
print(abs(c))                           # 计算复数的模
------------------------------------
(6+8j)
(-7+24j)
3.0
4.0
7.0
(3-4j)
5.0

列表、元组、字典、集合

列表、元组、字典、集合是Python内置的容器对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
# 创建列表对象
x_list = [1, 2, 3]
# 创建元组对象
x_tuple = (1, 2, 3)
# 创建字典对象，元素形式为“键:值”
x_dict = {'a':97, 'b':98, 'c':99}
# 创建集合对象
x_set = {1, 2, 3}

# 使用下标访问列表中指定位置的元素，元素下标从0开始
print(x_list[1])
# 元组也支持使用序号作为下标，1表示第二个元素的下标
print(x_tuple[1])
# 访问字典中特定“键”对应的“值”，字典对象的下标是“键”
print(x_dict['a'])
# 查看列表长度，也就是其中元素的个数
print(len(x_list))
# 查看元素2在元组中首次出现的位置
print(x_tuple.index(2))
# 查看字典中哪些“键”对应的“值”为98
for key, value in x_dict.items():
    if value == 98:
        print(key)
# 查看集合中元素的最大值
print(max(x_set))
----------------------------------
2
2
97
3
1
b
3

字符串

在字符串前面加上英文字母r或R表示原始字符串，其中每个字符都表示字母含义，不再进行转义。如果字符串中含有反斜线“\”，建议在字符串前面直接加上字母r使用原始字符串。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
text = '''Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.'''

print(len(text))                 # 字符串长度，即所有字符的数量
print(text.count('is'))          # 字符串中单词is出现的次数
print('beautiful' in text)       # 测试字符串中是否包含单词beautiful
print('='*20)                    # 字符串重复
print('Good '+'Morning')         # 字符串连接
---------------------------------------
208
6
False
====================
Good Morning

运算符与表达式

算术运算符

（1）+运算符

+运算符除了用于算术加法以外，还可以用于列表、元组、字符串的连接。

1
2
3
4
5
6
7
8
9
10
11
12
13
print(3 + 5)
print(3.4 + 4.5)
print((3+4j) + (5+6j))
print('abc' + 'def')
print([1,2] + [3,4])
print((1,2) + (3,))
------------------------------
8
7.9
(8+10j)
abcdef
[1, 2, 3, 4]
(1, 2, 3)

（2）-运算符

-运算符除了用于整数、实数、复数之间的算术减法和相反数之外，还可以计算集合的差集。需要注意的是，在进行实数之间的运算时，有可能会出现误差。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
print(7.9 - 4.5)                    # 注意，结果有误差
print(5 - 3)
num = 3
print(-num)
print(--num)                        # 注意，这里的--是两个负号，负负得正
print(-(-num))                      # 与上一行代码含义相同
print({1,2,3} - {3,4,5})            # 计算差集
print({3,4,5} - {1,2,3})
--------------------------------------
3.4000000000000004
2
-3
3
3
{1, 2}
{4, 5}

（3）*运算符

*运算符除了表示整数、实数、复数之间的算术乘法，还可用于列表、元组、字符串这几个类型的对象与整数的乘法，表示序列元素的重复，生成新的列表、元组或字符串。

1
2
3
4
5
6
7
8
9
10
11
print(33333 * 55555)
print((3+4j) * (5+6j))
print('重要的事情说三遍！' * 3)
print([0] * 5)
print((0,) * 3)
--------------------------------------
1851814815
(-9+38j)
重要的事情说三遍！重要的事情说三遍！重要的事情说三遍！
[0, 0, 0, 0, 0]
(0, 0, 0)

（4）运算符/和//

在Python中分别表示真除法和求整商。在使用时，要特别注意整除运算符//“向下取整”的特点。例如，-17 / 4的结果是-4.25，在数轴上小于-4.25的最大整数是-5，所以-17 // 4的结果是-5。

1
2
3
4
5
6
7
8
9
print(17 / 4)
print(17 // 4)
print((-17) / 4)
print((-17) // 4)
--------------------------
4.25
4
-4.25
-5

（5）%运算符

%运算符可以用于求余数运算，还可以用于字符串格式化。在计算余数时，结果与%右侧的运算数符号一致。

1
2
3
4
5
6
7
print(365 % 7)
print(365 % 2)
print('%c,%c, %c' % (65, 97, 48))   # 把65、97、48格式化为字符
---------------------------------------
1
1
A,a, 0

*（6）*运算符

运算符表示幂运算。使用时应注意，该运算符具有右结合性，也就是说，如果有两个连续的运算符，那么先计算右边的再计算左边的，除非使用圆括号明确修改表达式的计算顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
print(2 ** 4)
print(3 ** 3 ** 3)
print(3 ** (3**3))           # 与上一行代码含义相同
print((3**3) ** 3)           # 使用圆括号修改计算顺序
print(9 ** 0.5)              # 计算9的平方根
print((-1) ** 0.5)           # 对复数计算平方根得到复数
--------------------------------------
16
7625597484987
7625597484987
19683
3.0
(6.123233995736766e-17+1j)

关系运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
print(3+2 < 7+8)                          # 关系运算符优先级低于算术运算符
print(3 < 5 > 2)                          # 等价于3<5 and 5>2
print(3 == 3 < 5)                         # 等价于3==3 and 3<5
print('12345' > '23456')                  # 第一个字符'1'<'2'，直接得出结论
print('abcd' > 'Abcd')                    # 第一个字符'a'>'A'，直接得出结论
print([85, 92, 73, 84] < [91, 82, 73])    # 第一个数字85<91，直接得出结论
print([180, 90, 101] > [180, 90, 99])     # 前两个数字相等，第三个数字101>99
print({1, 2, 3, 4} > {3, 4, 5})           # 第一个集合不是第二个集合的超集
print({1, 2, 3, 4} <= {3, 4, 5})          # 第一个集合不是第二个集合的子集
print([1, 2, 3, 4] > [1, 2, 3])           # 前三个元素相等
                                          # 并且第一个列表有多余的元素
----------------------------------
True
True
True
False
True
True
True
False
False
True

成员测试运算符

1
2
3
4
5
6
7
8
9
10
11
print(60 in [70, 60, 50, 80])
print('abc' in 'a1b2c3dfg')
print([3] in [[3], [4], [5]])
print('3' in map(str, range(5)))
print(5 in range(5))
-----------------------------------
True
False
True
True
False

集合运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
A = {35, 45, 55, 65, 75}
B = {65, 75, 85, 95}
print(A | B)
print(A & B)
print(A - B)
print(B - A)
print(A ^ B)
------------------------------
{65, 35, 75, 45, 85, 55, 95}
{65, 75}
{35, 45, 55}
{85, 95}
{35, 45, 85, 55, 95}

逻辑运算符

计算结果只要不是0、0.0、0j、None、False、空列表、空元组、空字符串、空字典、空集合、空range对象或其他空的容器对象，都被认为等价于True。

1
2
3
4
5
6
7
8
9
print(3 in range(5) and 'abc' in 'abcdefg')
print(3-3 or 5-2)
print(not 5)
print(not [])
-------------------------------------------
True
3
False
True

常用内置函数

在Python程序中，可以直接使用内置函数，不需要导入任何模块。

使用语句print(dir(builtins))可以查看所有内置函数和内置对象，注意builtins两侧各有两个下划线，一共4个。

类型转换

（1）int()、float()、complex()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
print(int(3.5))                 # 获取实数的整数部分
print(int('119'))               # 把整数字符串转换为整数
print(int('1111', 2))           # 把1111看作二进制数，转换为十进制数
print(int('1111', 8))           # 把1111看作八进制数，转换为十进制数
print(int('1111', 16))          # 把1111看作十六进制数，转换为十进制数
print(int('  9\n'))             # 自动忽略字符串两个的空白字符
print(float('3.1415926'))       # 把字符串转换为实数
print(float('-inf'))            # 负无穷大
print(complex(3, 4))            # 复数
print(complex(6j))
print(complex('3'))
----------------------------------------------
3
119
15
585
4369
9
3.1415926
-inf
(3+4j)
6j
(3+0j)

（2）bin()、oct()、hex()

1
2
3
4
5
6
7
8
print(bin(8888))              # 把整数转换为二进制
print(oct(8888))              # 把整数转换为八进制
print(hex(8888))              # 把整数转换为十六进制
-------------------------------------------
0b10001010111000
0o21270
0x22b8
1

（3）ord()、chr()、str()

1
2
3
4
5
6
7
8
9
10
11
12
13
print(ord('a'))               # 返回字符的ASCII码
print(ord('董'))              # 返回汉字字符的Unicode编码
print(chr(65))                # 返回指定ASCII码对应的字符
print(chr(33891))             # 返回指定Unicode编码对应的汉字
print(str([1, 2, 3, 4]))      # 把列表转换为字符串
print(str({1, 2, 3, 4}))      # 把集合转换为字符串
----------------------------------------------------
97
33891
A
董
[1, 2, 3, 4]
{1, 2, 3, 4}

（4）list()、tuple()、dict()、set()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
print(list(), tuple(), dict(), set())  
s = {3, 2, 1, 4}
print(list(s), tuple(s))
lst = [1, 1, 2, 2, 3, 4]
# 在转换为集合时会自动去除重复的元素
print(tuple(lst), set(lst))
# list()会把字符串中每个字符都转换为列表中的元素
# tuple()、set()函数也具有类似的特点
print(list(str(lst)))
print(dict(name='Dong', sex='Male', age=41))
---------------------------------------------
[] () {} set()
[1, 2, 3, 4] (1, 2, 3, 4)
(1, 1, 2, 2, 3, 4) {1, 2, 3, 4}
['[', '1', ',', ' ', '1', ',', ' ', '2', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']']
{'name': 'Dong', 'sex': 'Male', 'age': 41}

（5）eval()

  • 计算字符串或字节串的值
  • 实现类型转换的功能
  • 还原字符串中数据的实际类型
1
2
3
4
5
6
7
8
9
print(eval('3+4j'))              # 对字符串求值得到复数
print(eval('8**2'))              # 计算表达式8**2的值
print(eval('[1, 2, 3, 4, 5]'))   # 对字符串形式求值得到列表
print(eval('{1, 2, 3, 4}'))      # 对字符串求值得到集合
---------------------------------------------------
(3+4j)
64
[1, 2, 3, 4, 5]
{1, 2, 3, 4}

最大值、最小值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
data = [3, 22, 111]
print(data)
# 对列表中的元素直接比较大小，输出最大元素
print(max(data))
print(min(data))
# 返回转换成字符串之后最大的元素
print(max(data, key=str))
data = ['3', '22', '111']
print(max(data))
-------------------------------------------
[3, 22, 111]
111
3
3
3
# 返回长度最大的字符串
print(max(data, key=len))
data = ['abc', 'Abcd', 'ab']
# 最大的字符串
print(max(data))
# 长度最大的字符串
print(max(data, key=len))
# 全部转换为小写之后最大的字符串
print(max(data, key=str.lower))
data = [1, 1, 1, 2, 2, 1, 3, 1]
------------------------------------
111
abc
Abcd
Abcd
# 出现次数最多的元素
# 也可以查阅资料使用标准库collections中的Counter类实现
print(max(set(data), key=data.count))
# 最大元素的位置，列表方法__getitem__()用于获取指定位置的值
print(max(range(len(data)), key=data.__getitem__))
----------------------------------------------------------
1
6

元素数量、求和

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
data = [1, 2, 3, 4]
# 列表中元素的个数
print(len(data))
# 所有元素之和
print(sum(data))
data = (1, 2, 3)
print(len(data))
print(sum(data))
---------------------
4
10
3
6
data = {1, 2, 3}
print(len(data))
print(sum(data))
data = 'Readability counts.'
print(len(data))
data = {97: 'a', 65: 'A', 48: '0'}
print(len(data))
print(sum(data))
------------------------------------
3
6
19
3
210

排序、逆序

（1）sorted

sorted()可以对列表、元组、字典、集合或其他可迭代对象进行排序并返回新列表，支持使用key参数指定排序规则，key参数的值可以是函数、类、lambda表达式、方法等可调用对象。

另外，还可以使用reverse参数指定是升序(reverse=False)排序还是降序(reverse=True) 排序，如果不指定的话默认为升序排序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from random import shuffle

data = list(range(20))
shuffle(data)                  # 随机打乱顺序
print(data)
print(sorted(data))            # 升序排序
print(sorted(data, key=str))   # 按转换成字符串后的大小升序排序
print(sorted(data, key=str,    # 按转换成字符串后的大小
             reverse=True))    # 降序排序
----------------------------------------------------------------------
[5, 3, 0, 10, 1, 11, 8, 2, 9, 13, 16, 6, 17, 19, 15, 7, 12, 4, 14, 18]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]
[0, 1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 2, 3, 4, 5, 6, 7, 8, 9]
[9, 8, 7, 6, 5, 4, 3, 2, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 1, 0]

（2）reversed

reversed()可以对可迭代对象（生成器对象和具有惰性求值特性的zip、map、filter、enumerate、reversed等类似对象除外）进行翻转并返回可迭代的reversed对象。

在使用时应注意，reversed对象具有惰性求值特点，其中的元素只能使用一次，并且不支持使用内置函数len()计算元素个数，也不支持使用内置函数reversed()再次翻转。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from random import shuffle

data = list(range(20))        # 创建列表
shuffle(data)                 # 随机打乱顺序
print(data)
reversedData = reversed(data) # 生成reversed对象
print(reversedData)
print(list(reversedData))     # 根据reversed对象得到列表
print(tuple(reversedData))    # 空元组，reversed对象中元素只能使用一次
--------------------------------------------------------------------------
[3, 19, 6, 17, 11, 5, 18, 15, 8, 1, 12, 7, 16, 4, 14, 10, 0, 9, 13, 2]
<list_reverseiterator object at 0x000001B79034F700>
[2, 13, 9, 0, 10, 14, 4, 16, 7, 12, 1, 8, 15, 18, 5, 11, 17, 6, 19, 3]
()

基本输入输出

（1）内置函数input

内置函数input()用来接收用户的键盘输入，不论用户输入什么内容，input()一律作为字符串对待，必要的时候可以使用内置函数int()、float()或eval()对用户输入的内容进行类型转换。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
num = int(input('请输入一个大于2的自然数：'))
# 对2的余数为1的整数为奇数，能被2整除的整数为偶数
if num%2 ==1:
    print('这是个奇数。')
else:
    print('这是个偶数。')

lst = eval(input('请输入一个包含包含若干大于2的自然数的列表：'))
print('列表中所有元素之和为：', sum(lst))
-----------------------------------------------------------------
请输入一个大于2的自然数：6
这是个偶数。
请输入一个包含包含若干大于2的自然数的列表：[4,7,8,9]
列表中所有元素之和为： 28

（2）内置函数print

内置函数print()用于以指定的格式输出信息，语法格式为：

print(value1, value2, …, sep=’ ‘, end=’\n’)

其中，sep参数之前为需要输出的内容（可以有多个）；sep参数用于指定数据之间的分隔符，如果不指定则默认为空格；end参数表示输出完所有数据之后的结束符，如果不指定则默认为换行符。

1
2
3
4
5
6
7
8
print(1, 2, 3, 4, 5)            # 默认情况，使用空格作为分隔符
print(1, 2, 3, 4, 5, sep=',')   # 指定使用逗号作为分隔符
print(3, 5, 7, end=' ')         # 输出完所有数据之后，以空格结束，不换行
print(9, 11, 13)
--------------------------------------------------
1 2 3 4 5
1,2,3,4,5
3 5 7 9 11 13

range()

range([start,] stop [,step])

其中，参数start默认为0，step默认为1，左开右闭区间[start,stop)

  • range(stop)
  • range(start,stop)
  • range(start,stop,step)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
range1 = range(4)           # 只指定stop为4，start默认为0，step默认为1
range2 = range(5, 8)        # 指定start=5和stop=8，step默认为1
range3 = range(3, 20, 4)    # 指定start=3、stop=20和step=4
range4 = range(20, 0, -3)   # step也可以是负数
print(range1, range2, range3, range4)
print(range4[2])
print(list(range1), list(range2), list(range3), list(range4))
for i in range(10):
    print(i, end=' ')
------------------------------------------------------------------
range(0, 4) range(5, 8) range(3, 20, 4) range(20, 0, -3)
14
[0, 1, 2, 3] [5, 6, 7] [3, 7, 11, 15, 19] [20, 17, 14, 11, 8, 5, 2]
0 1 2 3 4 5 6 7 8 9

zip()

zip()用来把多个可迭代对象中对应位置上的元素分别组合到一起，返回一个可迭代的zip对象，其中每个元素都是包含原来的多个可迭代对象对应位置上元素的元组，最终结果中包含的元素个数取决于所有参数序列或可迭代对象中最短的那个。

zip对象中的每个元素只能使用一次，访问过的元素不可再次访问，并且只能从前往后逐个访问zip对象中的元素，不能使用下标直接访问指定位置上的元素。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
data = zip('1234', [1, 2, 3, 4, 5, 6])
print(data)
# 在转换为列表时，使用了zip对象中的全部元素，zip对象中不再包含任何内容
print(list(data))
# 如果需要再次访问其中的元素，必须重新创建zip对象
data = zip('1234', [1, 2, 3, 4, 5, 6])
print(tuple(data))
data = zip('1234', [1, 2, 3, 4, 5, 6])
# zip对象是可迭代的，可以使用for循环逐个遍历和访问其中的元素
for item in data:
    print(item)
---------------------------------------------------------
<zip object at 0x000001B790734940>
[('1', 1), ('2', 2), ('3', 3), ('4', 4)]
(('1', 1), ('2', 2), ('3', 3), ('4', 4))
('1', 1)
('2', 2)
('3', 3)
('4', 4)

map()、reduce()、filter()

（1）map()

map(func,*iterables)

map()函数把一个可调用对象func 依次映射到序列的每个元素上，并返回一个可选代的 map对象，其中每个元素是原序列中元素经过可调用对象func处理后的结果，该函数不对原序列做任何修改。 该函数返回的map对象可以转换为列表、元组或集合，也可以直接使用for 循环遍历其中的元素， 但是map对象中的每个元素只能使用一次。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from operator import add

print(map(str, range(5)))
print(list(map(str, range(5))))
print(list(map(len, ['abc', '1234', 'test'])))
# 使用operator标准库中的add运算add运算相当于运算符+
# 如果map()函数的第一个参数func能够接收两个参数，则可以映射到两个序列上
for num in map(add, range(5), range(5,10)):
    print(num)
--------------------------------------------------
<map object at 0x000001B79034F400>
['0', '1', '2', '3', '4']
[3, 4, 4]
5
7
9
11
13

（2）reduce()

reduce(func,seq[,initial])

reduce()可以将一个接收2个参数的函数以迭代的方式从左到右依次作用到一个序列或可迭代对象的所有元素上，并且每一次计算的中间结果直接参与下一次计算，最终得到一个值。

1
2
3
4
5
6
7
8
9
10
11
12
from functools import reduce
from operator import add, mul, or_

seq = range(1, 10)
print(reduce(add, seq))       # 累加seq中的数字
print(reduce(mul, seq))       # 累乘seq中的数字
seq = [{1}, {2}, {3}, {4}]
print(reduce(or_, seq))       # 对seq中的集合连续进行并集运算
-------------------------------------------------------
45
362880
{1, 2, 3, 4}

（3）filter()

filter(func or None, iterable)

过滤。将一个函数func作用到一个序列上，返回一个filter对象，其中包含原序列中使得函数func返回值等价于True的那些元素。每个元素只能使用一次。

1
2
3
4
5
6
7
8
9
10
seq = ['abcd', '1234', '.,?!', '']
print(list(filter(str.isdigit, seq)))   # 只保留数字字符串
print(list(filter(str.isalpha, seq)))   # 只保留英文字母字符串
print(list(filter(str.isalnum, seq)))   # 只保留数字字符串和英文字符串
print(list(filter(None, seq)))          # 只保留等价于True的元素
------------------------------------------------------
['1234']
['abcd']
['abcd', '1234']
['abcd', '1234', '.,?!']

来自书籍：《Python数据分析、挖掘与可视化》