python入门笔记(4)

元组

元组 & 列表

异：

• 列表使用方括号，元组使用圆括号
• 列表中的元素可以被修改，元组不行
• 列表“推导式”叫列表推导式，元组“推导式”叫生成器表达式

同：

• 可通过下标访问
• 支持切片操作
• 支持 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, "没啦，被你掏空啦~")
'没啦，被你掏空啦~'