1、列表、元组、字符串的共同点
- 都可以通过索引获取每一个元素
- 第一个元素的索引值都是 0
- 都支持+ * 运算符
- 都支持切片操作
因此，列表、元组和字符串，Python 将它们统称为序列。
- 根据是否能被修改这一特性，可以将序列分为可变序列和不可变序列：比如列表就是可变序列，而元组和字符串则是不可变序列。
2、关于可变与不可变
可变序列
>>> 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
可变序列是在原位置修改 “扩容”，而不可变序列则是将内容 “扩容” 后再放到一个新的位置上去。
序列总结1.png
3、可迭代对象支持的函数
list() 将对象转换成列表
>>> a = (1,2,3,4,5,6)
>>> a
(1, 2, 3, 4, 5, 6)
>>> list(a)
[1, 2, 3, 4, 5, 6]
tuple() 将对象转换成元组
>>> a = [1,2,3,4,5,6]
>>> a
[1, 2, 3, 4, 5, 6]
>>> tuple(a)
(1, 2, 3, 4, 5, 6)
str() 将对象转换成字符串
>>> a = (1,2,3,4,5)
>>> a
(1, 2, 3, 4, 5)
>>> str(a)
'(1, 2, 3, 4, 5)'
min() 可以传入可迭代对象，也可以直接传值
"""min的可选参数在没有找到最小值是可以设置默认返回"""
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])
max() 可以传入可迭代对象，也可以直接传值
"""max的可选参数可min一样，在没有找到最大值的时候返回设置的默认值"""
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])
len() 获取对象的长度
"""注意：len函数对于对象有个最大可承受的范围，超出最大范围就会报错"""
"""通常对于 32 位平台来说，这个最大的数值是 2**31 - 1；而对于 64 位平台来说，这个最大的数值是 2**63 - 1。"""
>>> a = [1,2,3,4,5]
>>> a
[1, 2, 3, 4, 5]
>>> len(a)
5
>>> a = "Jason"
>>> len(a)
5
>>> a = (1,2,3,4,5)
>>> len(a)
5
sum() 求和
>>> s = [1, 0, 0, 8, 6]
>>> sum(s)
15
# sum可以指定一个开始求和的初始值
sum(s,start=100)
115
sorted() 方法返回一个新的列表，原列表不受影响
>>> s = [1,2,3,0,6]
>>> sorted(s)
[0, 1, 2, 3, 6]
>>> s
[1, 2, 3, 0, 6]
列表对象的sort()方法和sorted()方法类似，但是sort方法是直接给原对象进行排序
>>> s
[1, 2, 3, 0, 6]
>>> s.sort()
>>> s
[0, 1, 2, 3, 6]
"""sort()与sorted()用法展示"""
>>> 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']
>>> t.sort(key=len,reverse=True)
>>> t
['Banana', 'FishC', 'Apple', 'Book', 'Pen']
>>> t.sort(key=len,reverse=False)
>>> t
['Pen', 'Book', 'FishC', 'Apple', 'Banana']
并且 sort()和sorted()方法同时支持key，reverse 这两个参数
"""key 指定的是一个干预排序算法的函数,列表中的每一个元素都会先执行一遍key指定的函数"""
>>> t = ["FishC", "Apple", "Book", "Banana", "Pen"]
>>> sorted(t, key=len)
['Pen', 'Book', 'FishC', 'Apple', 'Banana']
"""比如这里我们指定为 len() 函数，那么 Python 在排序的过程中，就会先将列表中的每一个元素调用一次 len() 函数，然后比较的是 len() 返回的结果。所以，sorted(t, key=len) 比较的就是每个元素的长度。"""
reversed() 函数将返回参数的反向迭代器。
"""这个方法不会直接给你返回一个对象"""
>>> s = [1, 2, 5, 8, 0]
>>> reversed(s)
<list_reverseiterator object at 0x0000022926732AC0>
"""可以将这个反向迭代器转换成list"""
>>> list(reversed(s))
[0, 8, 5, 2, 1]
序列2.png
sort()与sorted()两个方法的比较
sort&sorted.png
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)
>>> z = "Jas"
>>> u = list(zip(x,y,z))
>>> u
[(1, 4, 'J'), (2, 5, 'a'), (3, 6, 's')]
如果参与zip 的某个可迭代对象较短，则最终输出的那个“迭代器”长度与参与聚合的那个最短可迭代对象一致
>>> x = [1,2,3,4,5,6]
>>> y = (7,8,9,0,11)
>>> z = "Jas"
>>> u = list(zip(x,y,z))
>>> u
[(1, 7, 'J'), (2, 8, 'a'), (3, 9, 's')]
>>> len(u)
3
>>> len(z)
3
当我们不关心较长的可迭代对象多出的数据时，使用 zip() 函数无疑是最佳的选择，因为它自动裁掉多余的部分。
但是，如果那些值对于我们来说是有意义的，我们可以使用 itertools 模块的 zip_longest() 函数来代替：
>>> import itertools
>>> x
[1, 2, 3, 4, 5, 6]
>>> y
(7, 8, 9, 0, 11)
>>> z
'JasonYang'
>>> u = list(itertools.zip_longest(x,y,z))
>>> u
[(1, 7, 'J'), (2, 8, 'a'), (3, 9, 's'), (4, 0, 'o'), (5, 11, 'n'), (6, None, 'Y'), (None, None, 'a'), (None, None, 'n'), (None, None, 'g')]
最终较短的迭代器无法补足的元素将会用None代替
map()
函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器：
>>> mapped = map(ord, "FishC")
>>> list(mapped)
[70, 105, 115, 104, 67]
如果指定的函数需要两个参数，后面跟着的可迭代对象的数量也应该是两个：
"""pow(要升幂运算的数，要升的次幂)"""
>>> mapped = map(pow, [2, 3, 10], [5, 2, 3]))
>>> list(mapped)
[32, 9, 1000]
如果可迭代对象的长度不一致，那么 Python 采取的做法跟 zip() 函数一样，都是在最短的可迭代对象终止时结束：
>>> list(map(max, [1, 3, 5], [2, 2, 2], [0, 3, 9, 8]))
[2, 3, 9]
filter()
与 map() 函数类似，filter() 函数也是需要传入一个函数作为参数，不过 filter() 函数是根据提供的函数，对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回：
>>> filter(str.islower, "FishC")
<filter object at 0x000001B5170FEFA0>
上面代码我们传入的是字符串的 islower() 方法，作用就是判断传入的参数是否为小写字母，结合到 filter() 函数中使用，就是剔除大写字母，保留小写字母的作用。
如果提供的函数是 None，则会假设它是一个 “鉴真” 函数，即可迭代对象中所有值为假的元素会被移除：
>>> list(filter(None, [True, False, 1, 0]))
[True, 1]
4、可迭代对象和迭代器
可迭代对象可以对齐进行重复多次的操作
迭代器是一次性的
iter()函数可以将可迭代对象转换成迭代器
>>> x = [1, 2, 3, 4, 5]
>>> y = iter(x)
可以通过type()函数看出区别
>>> type(x)
<class 'list'>
>>> type(y)
<class 'list_iterator'>
next() 函数是专门针对迭代器的。
它的作用就是逐个将迭代器中的元素提取出来：
>>> next(y)
1
>>> next(y)
2
>>> next(y)
3
>>> next(y)
4
>>> next(y)
5
>>> next(y)
Traceback (most recent call last):
File "<pyshell#52>", line 1, in <module>
next(y)
StopIteration
next()函数可以指定抛出的异常
>>> z = iter(x)
>>> next(z, "没啦，被你掏空啦~")
1
>>> next(z, "没啦，被你掏空啦~")
2
>>> next(z, "没啦，被你掏空啦~")
3
>>> next(z, "没啦，被你掏空啦~")
4
>>> next(z, "没啦，被你掏空啦~")
5
>>> next(z, "没啦，被你掏空啦~")
'没啦，被你掏空啦~'
总结：
序列3.png
