Python–list、tuple、dict、set，新增：字符串及相关方法 + 序列相关函数和方法
查看类型：type(i)
数值类型：int, float, complex, bool
容器：不可变容器：str, tuple frozenset, bytes，可变的容器：list, dict, set, bytearray
值：None, False, True
序列相关函数：
序列有5种：str, list, tuple, bytes, bytearray
| 名称 | 用途 |
|———–|———–|———–|
| len(L) | 序列长度 |
| max(L) | 最大值元素 |
| min(L) | 最小值元素 |
| sum(L) | 所有元素的和 |
| any(L) | 只要有值为真则返回 True |
| all(L) | 所有值为真则返回 True |
| reversed(L) | 返回反向顺序的可迭代对象 |
| sorted(L) | 返回已排序的列表 |
range()函数：1
2
3
4
5
6
7range(4) # 0, 1, 2, 3
range(0, 4) # 0, 1, 2, 3
range(0, 4, 1) # 0, 1, 2, 3
range(0, 4, 2) # 0, 2
range(4, 0, -2) # 4, 2
range(4, 0, -1) # 4, 3, 2, 1
range(4, 0) # 空
字符串
创建：字符串构造函数：str(i)（字符串转数字int(i)）
原始字符串：r'字符串内容'让\无效
运算：1
2
3
4
5# * 乘：用于生成重复的字符春
"123" * 3 # '123123123'
# + 加：用于拼接
"123" * "456" # '123456'
切片：
语法：[开始索引:结束索引:步长]，步长为正数时正向切片，步长为负数时反向切片，默认最后一个元素开始，第一元素的前一个位置结束1
2
3
4
5
6
7
8
9# 字符： A B C D E
# 正向： 0 1 2 3 4
# 反向：-5 -4 -3 -2 -1
s = "ABCDE"
print(s[1:4]) # BCD
print(s[1:4:2]) # BD
print(s[::-1]) # EDCBA
编码转换函数：
| 名称 | 用途 |
|———–|———–|———–|
| ord(i) | 返回字符i的Unicode值 |
| chr(i) | 返回整数i(Unicode)对应的字符 |
整数转字符串函数：
| 名称 | 用途 |
|———–|———–|———–|
| bin(i) | 整数转二进制字符串 |
| oct(i) | 整数转八进制字符串 |
| hex(i) | 整数转十六进制字符串 |
常用的字符串方法：
| 名称 | 用途 |
|———–|———–|———–|
| S.isalpha() | 是否全是英文字符 |
| S.isdigit() | 是否全是数字字符 |
| S.isspace() | 是否全是空白字符 |
| S.islower() | 字母是否全是小写 |
| S.isupper() | 字母是否全是大写 |
| S.istitle() | 是否是首字母大写 |
| S.center(width) | 根据传入的width，将S居中，左右默认填充空格 |
| S.count(sub, start, end) | 获取sub在S中的个数，第2、3个参数指定查找位置 |
| S.find(sub, start, end) | 获取sub在S中的索引，失败返回-1 |
| S.strip() | 去除所有空格 |
| S.lstrip() | 去除左侧空格 |
| S.rstrip() | 去除右侧空格 |
| S.upper() | 英文转大写 |
| S.lower() | 英文转小写 |
| S.replace(old, new, count) | 将old替换成new，count为替换的个数 |
| S.startswith(prefix, start, end) | S是否是prefix开头的 |
| S.endswith(suffix, start, end) | S是否是suffix结尾的 |
| S.split(sub) | 根据sub分割S成列表，默认为’ ‘ |
| ‘sep’.join(seq) | 连接字符串数组，@sep：分隔符 @seq：列表、字符串、字典 |
格式化字符串中的占位符和类型码：%[- + 0 宽度.精度]，其中：-左对齐，+显示正号，0左侧空白位置补零，精度默认6位
| 名称 | 用途 |
|———–|———–|———–|
| %s | 字符串，使用str(obj)转为字符串 |
| %r | 字符串，使用repr(obj)转为字符串 |
| %c | 整数转为字符串，使用chr(i)函数 |
| %d | 十进制整数 |
| %o | 八进制整数 |
| %x | 十六进制整数（小写） |
| %X | 十六进制整数（大写） |
| %e | 指数型浮点数（E小写） |
| %E | 指数型浮点数（E大写） |
| %f, %F | 浮点十进制 |
| %g, %G | 浮点、指数形式自动转化 |
| %% | 等同%字符，如50% |
列表 list
创建：构造函数：list()，可用 [] 创建
取值：根据索引，如 L[0] 取出索引为 0 的值；
切片赋值：能修改、添加、删除列表中的元素，如：L[0:3] 取出从索引 0-3 的值，其中不包括索引 3 的值（删除：del 列表[索引 || 切片] 删除列表中的元素）
特点：有序集合。list 能修改。查找速度随元素的增加而变慢。内存占用小
列表推导式：[ 表达式 for 变量 in 可迭代对象 if 真值表达式 ]，if子句可省略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# 比较两个列表元素
cmp(L1, L2)
# 生成列表
L = range(1,4) # [1, 2, 3]
### 尾部添加元素
L.append(4) # [1, 2, 3, 4]
### 指定位置添加元素
L.insert(2,66) # [1, 2, 66, 3, 4] 第一个值是索引位置，第二个值是新元素
### 删除最后一个元素
L.pop() # [1, 2, 66, 3]
### 删除指定位置元素
L.pop(2) # [1, 2, 3] 传入的 2 是索引位置
### 计算表达式的长度
print(len(L)) # 3
### list合并拼接
zip([1,2,3],['A','B','C']) # [(1,'A'),(2,'B'),(3,'C')]
[1,2,3] + ['A','B','C'] # [1,2,3,'A','B','C']
[1,2,3]*2 # [1, 2, 3, 1, 2, 3]
### 迭代中拿到索引（迭代取出的都是元素本身的值）
for index,value in enumerate(L):
print(index, ':' , value) # 0 : 1 1 : 2 2 : 3 使用enumerate(L)
for index,value in zip(range(0,3),L):
print(index, ':' , value) # 0 : 1 1 : 2 2 : 3 使用zip()拼接的方法
# 列表推导式
L = [i**2 for i in range(1, 10)] # [1, 4, 9, 16, 25, 36, 49, 64, 81]
L = [i**2 for i in range(1, 10) if i <= 5] # [1, 4, 9, 16, 25]
常用列表方法：
| 名称 | 用途 |
|———–|———–|———–|
| L.index(value, begin, end) | 返回对应元素的索引下标，不存在时报错 |
| L.insert(index, value) | 在index的索引处插入value |
| L.count(i) | 返回i的个数 |
| L.remove(i) | 删除第一次出现在列表中的i |
| L.copy() | 复制L，只复制一层（浅拷贝），相当于L[:] |
| L.append(i) | L列表最后添加单个元素 |
| L.extend(list) | 相当于合并两个列表 |
| L.clear() | 清空列表 |
| L.reverse() | 反转列表 |
| L.sort() | 将列表中的元素进行排序，默认从小到大 |
| L.pop(index) | 默认最后一个，指定索引则删除对应元素 |
深拷贝和浅拷贝：1
2
3
4
5
6L1 = L # 不拷贝，创建一个变量同事绑定原对象
L2 = L.copy() # 浅拷贝，等同于 L2 = L[:]
import copy
L3 = copy.deepcopy(L) # 深拷贝
元组 tuple
创建：构造函数：tuple() ，可用 () 创建，空元组直接用 () 创建，单个元素的元素后加,，避免歧义，如 (1,)
取值：根据索引，如 T[0] 取出索引为 0 的值；切片，如：T[0:3] 取出从索引 0-3 的值，其中不包括索引 3 的值
特点：有序集合。一旦创建不能修改（不支持索引赋值和切片赋值），每个元素的指向永远不变，但是如果指向的是一个list，list是可变的
序列赋值：x, y, z = (100, 200, 300)
元组方法：T.index(value, begin, end)和T.count(i)1
2
3
4
5
6
7
8
9
10# 单个元组元素后加逗号，避免歧义
t = 1, # 相当于：元组 (1,)
t = 1, 2, 3 # 相当于：元组 (1, 2, 3)
t = (1) # 相当于：整数 1 括号的作用：提高优先级
# 比较两个元组元素
cmp(T1, T2)
# 列表转换为元组
tuple(L)
字典 dict
创建：构造函数：dict()，如：dict(a=1, b=2)，可用 {} 创建，如： {key: value} 的形式，和JS中的 map、object 类似
取值：根据 key，如 D[key] 取出 key 的 value；get方法，如：D.get[key]
特点：无序集合（打印顺序和创建顺序可能不一样）。查找速度快。内存占用大。key元素必须是不可变的，所以不能是 list 。key 不重复
字典推导式：{ 键:值 for 变量 in 可迭代对象 if 真值表达式 in 可迭代对象 }1
2
3
4
5
6
7
8
9
10# 以列表返回一个字典所有的键
D.keys()
# 迭代字典中的 value
D.values() # 把 value 转为 list
D.itervalues() # 不转为 list，省内存
# 迭代字典中的 key 和 value
D.items() # 把 value 转为 list
D.iteritems() # 不转为 list，省内存
集合 set
创建：构造函数：set(可迭代) ，可用 {} 创建，如:{value, value}，但是空集合只能用set()创建，{}表示空字典
取值：不能通过索引来访问值，但是可用 in 进行判断
特点：无序集合。不包含重复元素。判断元素是否在set中很快。储存的元素是不可变对象（可以用in判断但不能循环，可以新增和添加但不能修改），集合中只能放不可变类型，可变类型不能放进去，如：列表、字典、集合
与字典的区别：字典有键和值，集合没有值，值即键，如：{ 1, 2, 3 }为集合，有键值对的为字典，{}为空字典
集合推导式：{ 表达式 for 变量 in 可迭代对象 if 真值表达式 }，if子句可省略
集合的运算：1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17# 交集 &
{ 1, 2, 3 } & { 3, 4, 5 } # { 3 }
# 并集 |
{ 1, 2, 3 } | { 3, 4, 5 } # { 1, 2, 3, 4, 5 }
# 补集 -
{ 1, 2, 3 } - { 3, 4, 5 } # { 1, 2 } s1 - s2
# 对称补集 ^
{ 1, 2, 3 } ^ { 3, 4, 5 } # { 1, 2, 4, 5 } （s1 - s2） | （s2 - s1）
# 子集 <
{ 3 } < { 3, 4, 5 } # True s1 < s2
# 超集 >
{ 1, 2, 3 } > { 3 } # True s1 > s2
集合的方法：
| 名称 | 用途 |
|———–|———–|———–|
| S.add(i) | 集合中添加新元素，如果已存在不会添加进去，但是也不会报错 |
| S.remove(i) | 集合中删除元素，元素不存在报错 |
| S.discard(i) | 集合中移除元素，元素不存在什么也不做 |
| S.copy() | 浅拷贝集合 |
| S.clear() | 清空集合 |
| S.pop() | 集合中删除一个随机元素（默认第一个元素？） |
| S.update(s2) | 相当于合并两个集合 |
固定集合 forzenset
构造函数：forzenset(可迭代序列)
特点：不可变的、无序的、含有唯一元素的集合
作用：可以作为字典的键，还可以做集合的值