文章目录
列表的字符串文本解析方法split和join
s.split(sep=None)将字符串使用sep作为分隔符分割s字符串，返回分割后的字符串的列表，当不给定参数时，用空白字符作为分隔符进行分割。
s.join(iterable)用可迭代对象中的字符串，返回一个中间用s进行分割的字符串
示例：
s = 'beijing is capital'
l = s.split(' ') # ['beijing', 'is', 'capital']
s = '\\'
l = ['C:', 'Programe files', 'python3']
s2 = s.join(l) # 'C:\\Programe files\\python3'
列表的深拷贝deep copy$浅拷贝shallow copy
浅拷贝：是指在复制过程中只复制一层变量，不会复制深层变量绑定的对象的复制过程，此时两个变量绑定的是同一个数据对象。
l = [3.1, 3.2]
l1 = [1, 2, l] # l1 = [1, 2, [3.1, 3.2]]
l2 = l1.copy() # l2 = [1, 2, [3.1, 3.2]], 等同于l1[:]
l2[2][0] = 3.14 # l2 = [1, 2, [3.14, 3.2]], 此时l1也改变了 l1 = [1, 2, [3.14, 3.2]], 这说明l列表是l1,l2共有的
深拷贝：深拷贝通过只对可变对象进行复制，不可变对象通常不变
import copy # 导入copy模块
l = [3.1, 3.2]
l1 = [1, 2, l] # l1 = [1, 2, [3.1, 3.2]]
l2 = copy.deepcopy(l1) # l2 = [1, 2, [3.1, 3.2]] 深拷贝
l2[2][0] = 3.14 # l2 = [1, 2, [3.14, 3.2]], 此时l1没有改变 l1 = [1, 2, [3.1, 3.2]]
列表推导式 list comprehension
列表推导式是用可迭代对象一层生成带有多个元素的列表的表达式
作用：用简易方法生成列表
语法：[表达式 for 变量 in 可迭代对象]
或 [表达式 for 变量 in 可迭代对象 if 真值表达式]
示例：
# 以下生成一个数值为1-9的平方的列表
L = [x*x for x in range(1, 10)] # [1, 4, 9, 16, 25, 36, 49, 64, 81]
# 以下用推导式生成1-100内的基数列表
L = [x for x in range(1, 100) if x % 2 == 1]
列表推推导式的嵌套：
语法：[表达式1
for 变量1 in 可迭代对象1 if 真值表达式1
for 变量1 in 可迭代对象2 if 真值表达式2…]
示例：
L1 = [2, 3, 5]
L2 = [7, 11, 13]
# 将L1中的全部元素与L2中的全部元素一次相乘后放到列表L3中
L3 = [x*y for x in L1 for y in L2] # [14, 22, 26, 21, 33, 39, 35, 55, 65]
元祖 tuple
元祖是不可改变的序列，同list一样，元祖可以存放任意类型的元素，一旦元祖生成，它便不可以改变。
元祖的表示方式：用小括号()括起来，单个元素括起来用逗号(,)区分是单个对象还是元祖。
创建空元祖的字面值：t = ()
创建非空元祖的字面值: t = 200,
t = (20, )
t = (1, 2, 3)
t = 100, 200, 300
元祖的错误示例：
t = 20 # t是绑定整数的
x, y, z = 100, 200, 300 # 序列赋值
x, y, z = 'ABC'
x, y, z = [10, 20, 30]
元祖的构造函数tuple
tuple()生成一个空的元祖，等同于()
tuple(iterable) 用可迭代对象生成一个元祖
示例：
t = tuple()
t = tuple(range(10))
t = tuple('hello')
t = tuple([1, 2, 3, 4])
t = tuple((5, 6, 7, 8))
元祖的算术运算：
+ += * *=
用法和列表的用法完全相同
元祖的比较运算：
< <= > >= == !=
in/not in
索引取值
切片取值
规则与列表完全相同
区别：元祖是不可变对象，不支持索引赋值和切片赋值
元祖的方法：
help(tuple) # 查看元祖的方法
t.count(v) # 用于获取元祖中v的个数，用法和list相同
t.index(v[, begin[, end]]) # 用于获取v元素的索引
可以用于序列的函数：len, max, min, sum, all, any
三个构造函数：
str(obj)
list(iterable)
tuple(iterable)
用于创建相应的对象
其他函数：
reversed(seq) # 返回反向顺序的可迭代对象
sorted(iterable, reversed=False) # 返回已排序的列表
示例：
for x in reversed("ABCD"):
print(x) # DCBA
L = [8, 6, 3, 5, 7]
L2 = sorted(L)
print(L2) # [3, 5, 6, 7, 8]
L3 = sorted(L, reverse=True)
print(L3) # [8, 7, 6, 5, 3]
print(L) # [8, 6, 3, 5, 7]
字符串、列表、元祖都可以用索引搜索，搜索的速度比较快，且速度不受数据量大小的影响。但是in/not in运算速度比较慢，且与数据量大小相关。
字典 dict
- 字典是一种可变的容器，可以存储任意类型的数据
- 字典中的每个数据都是用"键"(key)进行索引，而不像序列可以用下标来进行索引
- 字典的数据没有先后顺序关系，字典的存储是无序的
- 字典中的数据以键(key)-值(value)对进行映射存储
- 字典的键不能重复，且只能用不可变类型作为字典的键
字典的字面值表示方式：用{}括起来，以冒号(:)分隔键-值对，各键值对用分号分隔开。
创建空字典：d = {}
创建非空的字典：d = {‘name’: ‘hsr’, ‘age’: 15}
d = {‘姓名’: ‘hsr’}
d = {1: ‘一’, 2: ‘二’}
字典的构造函数dict：
dict() 创建一个空字典，等同于{}
dict(iterable) 用可迭代对象初始化一个字典
dict(**kwargs) 关键字传参形式生成一个字典
示例：
d = dict()
# 可迭代对象
d = dict([('name', 'tarena'), ('age', 15)]) # {'name': 'tarena', 'age': 15}
d = dict(("AB", "CD")) # {'A': 'B', 'C': 'D'}
d = dict(("AB", "CD", [1, 2], (3, 4))) # {'A': 'B', 'C': 'D', 1: 2, 3: 4}
# 关键字传参
d = dict(name='tarena', age=15) # {'name': 'tarena', 'age': 15}
字典的键索引：
用[]运算符可以获取字典内‘键’所对应的‘值’，语法：字典[键]
获取数据元素：
d = dict(name='terena', age=15)
print(d['age']) # 15
添加和修改字典中的元素：字典[键] = 表达式
示例：
d = {}
d['name'] = 'tarena' # 创建一个新的键值对
d['age'] = 15 # 创建键值对
d['age'] = 16 # 修改键值对
del 语句删除字典的元素：
语法：del 字典[键]
示例：
d = {'name': 'china', 'pos': 'asia'}
del d['pos']
print(d) # {'name': 'china'}
del d['name']
print(d) # {}
字典的in/not in运算符
可以用in运算符来判断一个’键’是否存在于字典中，如果存在则返回True，否则返回False
not in 与 in返回值相反
示例：
d = {'a': 1, 'b': 2}
'a' in d # True
1 in d # False
100 not in d # True
2 not in d # True
字典的迭代访问：
字典是可迭代对象，字典只能对键进行迭代访问
示例：
d = {'name': 'tarena', (2002, 1, 1): '生日'}
for x in d:
print(x, d[x]) # name tarena (2002, 1, 1) 生日
可以用于字典内的内建函数
len(x) 返回字典键-值对的个数
max(x) 返回字典的键的最大值
min(x) 返回字典的键的最小值
sum(x) 返回字典所有键的和
any(x) 真值测试，只对键测试，如果其中一个键为True，结果为True
all(x) 真值测试，全部键为True时，结果才为True
字典的方法
d.clear() # 清除字典
d.pop(key) # 移除键，同事返回此键所对应的值
d.copy() # 返回字典d的副本，只复制一层(浅拷贝)
d.update(d2) # 将字典d2合并到d中，如果键相同，则此键的值取d2的值作为新值
d.get(key, default) # 返回键key所对应的值，如果没有此键，则返回default
d.keys() # 返回可迭代的dict_key集合对象
d.values() # 返回可迭代的dict_values值对象
d.items() # 返回可迭代的dict_items对象
字典推导式
字典推导式是用可迭代对象依次生成字典内元素的表达式
语法：{键表达式: 值表达式 for 变量 in 可迭代对象 [if 真值表达式]}
注：[]的内容代表可省略
示例：
d = {x: x**2 for x in range(10)} # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25, 6: 36, 7: 49, 8: 64, 9: 81}
d = {x: x**2 for x in range(10) if x % 3 == 0} # {0: 0, 3: 9, 6: 36, 9: 81}
集合set
集合是可变的容器
集合内的数据对象时唯一的(不能重复多次的)
集合是无序的存储结构
集合中的数据没有先后关系
集合内的元素必须是不可变对象
集合是可迭代的
集合是相当于只有键没有值的字典(键则是集合的数据)
创建空集合
s = set() # set() 创建一个空的集合
创建非空集合
s = {1, 2, 3} # 集合中的三个整数1，2，3
集合的构造函数 set
set() # 创建空集合
set(iterable) # 用可迭代对象创建一个新的集合对象
示例：
s = set("ABC") # {'C', 'A', 'B'}
s = set('ABCCBA') # {'C', 'A', 'B'} 会将重复的对象去掉
s = set({1:"一", 2: "二", 3: "三"}) # {1, 2, 3} 只有键没有值
s = set([1, 3.14, False]) # {False, 1, 3.14}
s = set((2, 3, 5, 7)) # {2, 3, 5, 7}
# s = set([1, 2, [3.1, 3.2], 4]) # 错的，[3.1, 3.2]是可变对象
集合的运算
交集，并集，补集，子集，超集
& 生成两个集合的交集:
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 & s2 # {2, 3}
| 生成两个集合的并集：
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 | s2 # {1, 2, 3, 4}
- 生成两个集合的补集：
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 - s2 # {1}
^ 生成两个集合的对称补集
s1 = {1, 2, 3}
s2 = {2, 3, 4}
s3 = s1 ^ s2 # {1, 4}
< 判断一个集合是另一个集合的子集
> 判断一个集合是另一个集合的超级
s1 = {1, 2, 3}
s2 = {2, 3}
s2 < s1 # True 判断子集
s1 > s2 # True 判断超集
== != 集合相同\不同
s1 = {1, 2, 3}
s2 = {2, 3, 1}
s1 == s2 # True
s1 != s2 # False 集合的数据没有先后关系
in/not in 运算符
等同于字典，in运算符用于集合中，当某个值存在于集合中，则为真，否则为假
not in 与 in 返回值相反
示例：
s = {1, 'TWO', 3.14}
1 in s # True
2 in s # False
3.14 not in s # False
4 not in s # True
python3 中可用于集合的函数
len(x) # 容器内的元素个数
max(x) # 容器内元素的最大值
min(x) # 容器内元素的最小值
sum(x) # 容器内元素的和
any(x)
all(x)
集合的迭代访问
s = {1, 2, 3}
for x in s:
print(x)
集合中的方法
s.add(e) # 在集合中添加一个新的元素e，如果元素已经存在，则不添加
s.remove(e) # 从集合删除一个元素，如果元素不存在与集合中，则产生一个keyerror错误
s.discard(e) # 从集合S中移除一个元素e，在元素e不存在时什么都不做
s.clear() # 清空集合内的所有元素
s.copy() # 将集合进行一次浅拷贝
s.pop() # 将集合s中删除一个随机元素，如果此集合为空，则引发keyerror错误
s.update(s2) # 用s与s2得到的全集更新变量s
s.difference(s2) # 用s-s2运算，返回存在于在s中，但不在s2中的所有元素
s.difference_update(s2) # 等同于s = s - s2
s.intersection(s2) # 等同于 s & s2
s.intersection_update(s2) # 等同于s = s & s2
s.isdisjoint(s2) # 如果s与s2交集为空返回True，非空则返回False
s.issubset(s2) # 如果s与s2交集为非空返回True，空则返回False
集合推导式
用可迭代对象来创建(生成)集合的表达式
语法：{表达式 for 变量 in 可迭代对象 [if 真值表达式]} []括号部分内容代表可省略
示例：
L = [2, 3, 5, 7, 3, 5, 7, 11]
s = {x**2 for x in L} # {4, 9, 49, 121, 25}
集合推导式的嵌套规则与列表推导式相同
{x + y for x in "ABC" for y in '123'} # {'A1', 'C2', 'A2', 'A3', 'C1', 'B2', 'B3', 'B1', 'C3'}
固定集合 frozenset
固定集合是不可变的，无序的，含有唯一元素的集合
作用：固定集合可以作为字典的键，也可以作为集合的值
创建空的固定集合：
fs = frozenset()
创建非空的固定集合：
fs = frozenset([2, 3, 5, 7])
构造函数：
frozenset()
frozenset(iterable) # 同set函数一致，返回固定集合
示例：
fz = frozenset([2, 3, 5])
d = {fz: 'hello'}
print(d) # {frozenset({2, 3, 5}): 'hello'}
######固定集合的运算
& 交集
| 并集
- 补集
^ 对称补集
> >= < <= == !=
in / not in
#(以上规则等同于set中的用法)
固定集合的方法：相当于集合的全部方法去掉修改集合的方法
fz.copy()
fz.difference()
fz.intersection()
fz.isdisjoint()
fz.issubset()
fz.issuperset()
fz.symmetric_difference()
fz.union()
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
