元组
元组 & 列表
异:
- 列表使用方括号,元组使用圆括号
- 列表中的元素可以被修改,元组不行
- 列表“推导式”叫列表推导式,元组“推导式”叫生成器表达式
同:
- 可通过下标访问
- 支持切片操作
- 支持 count() 和 index()
- 支持拼接(+)和重复(*)
- 支持嵌套
- 支持迭代
元组只有一个元素时的写法(加逗号)
>>> x = (520,)
打包 & 解包
打包:生成元组
>>> t = (123, "FishC", 3.14)
解包:将元组赋值给变量
>>> x, y, z = t
>>> x
123
>>> y
'FishC'
>>> z
3.14
(多重赋值的实质 = 元组赋值)
“修改”元组
如果元组内含列表,仍可通过修改列表改变元组数值
>>> s = [1, 2, 3]
>>> t = [4, 5, 6]
>>> w = (s, t)
>>> w
([1, 2, 3], [4, 5, 6])
>>> w[0][0] = 0
>>> w
([0, 2, 3], [4, 5, 6])
删除元组
del a
元组内置函数
序列
列表、元组和字符串统称为序列。
列表是可变序列,元组和字符串是不可变序列。
共同点:有索引、可切片、运算符有效。
可变性
可变序列:在原位置修改 “扩容”
>>> s = [1, 2, 3]
>>> id(s)
2285532322944
>>> s *= 2
>>> s
[1, 2, 3, 1, 2, 3]
>>> id(s)
2285532322944
不可变序列:将内容 “扩容” 后放到一个新位置上
>>> t = (1, 2, 3)
>>> id(t)
2285532205952
>>> t *= 2
>>> t
(1, 2, 3, 1, 2, 3)
>>> id(t)
2285532393920
is 和 is not
同一性运算符,用于检测两个对象的 id 值是否相等
>>> x = "FishC"
>>> y = "FishC"
>>> x is y
True
>>> x = [1, 2, 3]
>>> y = [1, 2, 3]
>>> x is not y
True
in 和 not in
用于判断某个元素是否包含在序列中
>>> "Fish" in "FishC"
True
>>> "鱼" in "鱼C"
True
>>> "C" not in "FishC"
False
del
删除一个或多个指定对象。
list()、tuple() 和 str()
这三个 BIF 函数主要实现列表、元组和字符串的转换。
min() 和 max()
对比传入的参数,返回最小值和最大值。
使用时需传入一个可迭代对象或多个参数:
>>> s = [1, 1, 2, 3, 5] #可迭代对象
>>> min(s)
1
>>> t = "FishC" #可迭代对象
>>> max(t)
's'
>>> min(1, 2, 3, 0, 6) #多个参数
0
len() 和 sum()
len(range(2 ** 10))
1024
sum(range(2 ** 10)) #计算迭代过程中各项的和
523776
len() 可输出的最大数值:
通常对于 32 位平台来说,这个最大的数值是 2**31 - 1
对于 64 位平台来说,这个最大的数值是 2 ** 63 - 1
sorted() 和 reversed()
sorted() 函数重新排序,返回新列表:
>>> s = [1, 2, 3, 0, 6]
>>> sorted(s)
[0, 1, 2, 3, 6]
sorted() 函数也支持 key(干预排序算法的函数)和 reverse(反向迭代器)两个参数,用法跟列表的 sort() 方法一致:
>>> sorted(s, reverse=True)
[6, 3, 2, 1, 0]
>>> s.sort(reverse=True)
>>> s
[6, 3, 2, 1, 0]
>>> t = ["FishC", "Apple", "Book", "Banana", "Pen"]
>>> sorted(t)
['Apple', 'Banana', 'Book', 'FishC', 'Pen']
>>> sorted(t, key=len)
['Pen', 'Book', 'FishC', 'Apple', 'Banana']
sorted(t, key=len)中,我们指定为 len() 函数。排序过程中列表中的每一个元素就会先调用一次 len() 函数。所以sorted(t, key=len) 比较的是 len() 返回的结果,即每个元素的长度。
注意反向迭代器的使用/输出:
>>> s = [1, 2, 5, 8, 0]
>>> reversed(s)
<list_reverseiterator object at 0x0000022926732AC0>
>>> list(reversed(s))
[0, 8, 5, 2, 1]
reversed() 函数同样支持任何形式的可迭代对象:
>>> list(reversed("FishC"))
['C', 'h', 's', 'i', 'F']
>>> list(reversed((1, 2, 5, 9, 3)))
[3, 9, 5, 2, 1]
>>> list(reversed(range(0, 10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
all() 和 any()
all() 函数是判断可迭代对象中是否所有元素的值都为真;
any() 函数则是判断可迭代对象中是否存在某个元素的值为真。
>>> x = [1, 1, 0]
>>> all(x)
False
>>> any(x)
True
enumerate()
返回一个枚举对象,即将可迭代对象中的每个元素及从 0 开始的序号共同构成一个二元组的列表。
>>> seasons = ["Spring", "Summer", "Fall", "Winter"]
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
start 参数可以自定义序号开始的值:
>>> for i, j in enumerate(seasons, start=10):
... print(i, "->", j)
...
10 -> Spring
11 -> Summer
12 -> Fall
13 -> Winter
zip()
用于创建一个聚合多个可迭代对象的迭代器。即将作为参数传入的每个可迭代对象的每个元素依次组合为元组,即第 i 个元组包含来自每个参数的第 i 个元素。
>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]
>>> z = [7, 8, 9]
>>> zipped = zip(x, y, z)
>>> list(zipped)
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
如果传入的可迭代对象长度不一致,以最短的为准。
>>> z = "FishC"
>>> zipped = zip(x, y, z)
>>> list(zipped)
[(1, 4, 'F'), (2, 5, 'i'), (3, 6, 's')]
如果仍需要长的那些,可使用 itertools 模块的 zip_longest() 函数代替。
import itertools
a = [1, 2, 3]
b = [4, 5, 6]
c = "sdfghjkl;"
new = itertools.zip_longest(a, b, c)
list(new)
[(1, 4, 's'), (2, 5, 'd'), (3, 6, 'f'), (None, None, 'g'), (None, None, 'h'), (None, None, 'j'), (None, None, 'k'), (None, None, 'l'), (None, None, ';')]
map()
根据提供的函数对指定的可迭代对象的每个元素进行运算,并返回运算结果的迭代器:
>>> mapped = map(ord, "FishC")
>>> list(mapped)
[70, 105, 115, 104, 67]
如果指定的函数需要两个参数,后面跟着的可迭代对象的数量也应该是两个:
>>> mapped = map(pow, [2, 3, 10], [5, 2, 3])) #求幂(power)
>>> list(mapped)
[32, 9, 1000]
相当于:
>>> [pow(2, 5), pow(3, 2), pow(10, 3)]
[32, 9, 1000]
因此需要进行大量相同运算时,使用 map() 函数更方便。
可迭代对象长度不同时,在最短可迭代对象终止时结束。
filter()
根据传入的函数,对指定的可迭代对象的每个元素进行运算,并将运算结果为真的元素,以迭代器的形式返回:
list(filter(str.islower, "FishC")) #判断是否小写字母
['i', 's', 'h']
如果传入的函数是 None,则成为 “鉴真” 函数,即可迭代对象中所有值为假的元素会被移除:
>>> list(filter(None, [True, False, 1, 0]))
[True, 1]
可迭代对象和迭代器
可对可迭代对象进行重复操作,而迭代器则是一次性的。
将可迭代对象转换为迭代器:
>>> x = [1, 2, 3, 4, 5]
>>> y = iter(x)
next() 函数专门针对迭代器:
>>> z = iter(x)
>>> next(z, "没啦,被你掏空啦~")
1
>>> next(z, "没啦,被你掏空啦~")
2
>>> next(z, "没啦,被你掏空啦~")
3
>>> next(z, "没啦,被你掏空啦~")
4
>>> next(z, "没啦,被你掏空啦~")
5
>>> next(z, "没啦,被你掏空啦~")
'没啦,被你掏空啦~'