序列

序列概述

列表、元组、字符串共同点：

• 都可以通过索引获取每一个元素。
• 第一个元素的索引值都为零。
• 都可以通过切片的方法获得一个范围内元素集合。
• 都有很多共同的运算符。

其实他们都统称为序列，根据可变性可以将序列分为：可变序列和不可变序列，可变序列：列表，不可变序列：元组和字符串，对于可变序列使用增量赋值，赋值的对象本身的 id 没有变化，但是对于不可变序列，采用增量赋值，被增量赋值的对象 id 会发生改变，通过 is 和 is not 可以进行对象的 Iid 值检测。

is 和 is not 用法

对于不可变序列相同值对应的 id 相同，而对于可变序列，每个序列的 id 都不一样。

# is / not is
a = "test"
b = "test"
a is b  # True
x = []
y = []
x is y. # False

in 和 not in 用法

判断某个元素是否包含在序列中，not in 相反。

# in / not in
"holle" in "hello word"  # True

del 用法

del 语句： 用于删除一个或多个指定的对象，还可以删除指定可变序列的指定元素。

# del
d = []
del d  # 删除d对象，还可以删除多个del a, b
e = [1, 2, 3, 4, 5]
del e[1, 2]  # 此时e=[1, 4, 5]
del e[::2]  # 设置步进此时e=[2, 4]

序列相关函数使用

列表、字符串、元组相互转换函数

list() str() tuple()，直接进行调用即可转换成对应序列类型。

min() 和 max() 函数

返回序列的最大最小值，如果传入是字符串比较的是字符串对应的编码值，26 字母，大写字母比小写字母小。

共有两种用法语法：

min()

• min(interable, *[, key, default])
• min(arg1, arg2, *args[, key])

max()

• max(interable, *[, key, default])
• max(arg1, arg2, *args[, key])

min(1, 2, 3)  # --> 1
min([1, 2, 3])  # --> 1
max(1, 2, 3)  # --> 3
max([1, 2, 3])  # --> 3

# 如果传入空序列则会引发错误，此时可以使用default参数，传入默认值min和max用法相同
min([], default="传入参数有误！")  # 此时执行default内容

len() 和 sum() 函数

len()： 计算序列内元素的个数，当然len()函数也有最大长度限制：32 系统最大为 2 的 31 次方减 1，64 位系统则是 2 的 63 次方减 1。

sum()： 计算序列元素的和，适用于 int 类型求和，如果存在字符串会引发错误。

a = [1, 2, 3]
len(a)  # --> 3
sum(a)  # --> 6
# sum()有一个start参数，设置一个起始值然后开始累加
sum(a, 100)  # --> 106

sorted() 和 reversed() 函数

sorted()： 对可变序列进行排序，默认为升序排序，区别于 sort() 函数，该函数返回的是新序列，而 sort()： 直接对原始序列修改，函数有两个参数： reverse 和 key ， reverse 用于传入是否反转，默认升序，反转则为降序， key 则可以传入方法，比如 key=len 此时则会按照长度进行排序，注意如果传入为字符串会按照字符串第一个字母进行排序，如果第一个一样则会按照第二个再进行排序，以此类推，可以接受任何可迭代对象作为参数，sort() 仅仅支持列表。

reversed()： 将序列反过来，然后返回出一个可迭代对象，支持任何序列进行反转。

# sorted()
a = [1, 4, 3]
sorted(a)  # --> [1, 3, 4] 返回一个新的序列，不修改之前的a
sorted(a, reverse=True)  # 升序后将元素反过来，返回一个新的序列，不修改之前的a
s = ["hello", "word"]
sorted(a, key=len)  # --> ["word", "hello"]  # 使用len()方法排序

# reversed()
a = [1, 3, 6]
reversed(a)  # 返回一个可迭代对象
b = list(reversed(a))  # b --> [6, 3, 1]

all() 和 any() 函数

all()： 判断序列所有元素是否为真。

any()： 判断序列是否存在某个元素为真。

a = [0, 1]
all(a)  # False
any(a)  # True

enumerate() 函数

enumerate()： 函数用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素以及从 0 开始的序号共同构成一个二元组的列表。

a = ["a", "b", "c"]
b = list(enumerate(a))  # b --> [(0, "a"), (1, "b"), (2, "c")]
# 指定开始的值
b = list(enumerate(a, 10))  # b --> [(10, "a"), (11, "b"), (12, "c")]

zip() 函数

zip()： 用于创建一个聚合多个可迭代对象的迭代器。它会将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第 i 个元组包含来自每个参数的第 i 个元素，如果传入的迭代对象长度不同会以最短的作为长度进行组合，如果不想舍去长元素，则可以使用模块itertools 的 zip_longest() 函数。

a = [1, 2, 3]
b = [1, 2, 3]
c = "hello"
x = list(zip(a, b, c))  # x --> [(1, 1, "h"), (2, 2, "e"), (3, 3, "l")]

import itertools
d = [1, 2]
e = [1, 2, 3]
x = itertools.zip_longest(a, e)
list(x)  # --> [(1, 1), (2, 2), (None, 3)]

map()函数

map()： 函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果的迭代器。

a = map(ord, "hello")  # 指定ord函数，将传入的可迭代对象每个元素进行ord求机器码运算，返回一个可迭代对象
list(a)  # --> [104, 101, 108, 108, 111] 将每个元素的机器码返回
# 如果传入的函数有多个参数，可以跟多个值
b = map(pow, [1, 3], [2, 2])
list(b)  # --> [1, 9]  等价于 [pow(1, 2), pow(3, 2)]

filter() 函数

filter()： 函数会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回。

list(filter(str.islower, "Hello"))  # --> ["e", "l", "l", "o"]
# str.islower 如果字母为小写返回True，filter返回运算结果为真

迭代器和可迭代对象

一个迭代器肯定是一个可迭代对象，可迭代对象可以进行重复引用，迭代器则只可以使用一次。

# map函数返回的是一个迭代器
a = map(ord, "hello")
for i in a:
  print(i)
# 此时返回值104, 101, 108, 108, 111
# 再次list(a)
list(a)  # --> []
# 迭代器只可以使用一次

iter()函数

iter()： 将可迭代对象转换成迭代器。

a = [1, 2, 3, 4]
b = iter(a)
print(type(b))  # --> <class 'list_iterator'> --> 类型迭代器

next() 函数

next()： 将迭代器元素逐个提取出来，如果元素全部提取完成，继续执行 next() 就会引发异常。

a = [1, 2]
b = iter(a)
next(b)  # 1
next(b)  # 2
next(b)  # 提取完了再执行就会引发异常
# 可以添加默认参数进行避免异常
next(b, "提取完成！")