Self-study Python Fish-C Note-8 P34to36

序列

定义：
序列（sequence）：Sequences are an object type in Python that allows the user to store data one after each other. Operations can be performed on a sequence, to examined and manipulated the stored items.
在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作（即：索引、切片、相加、相乘、和下文介绍的序列相关的函数），但集合和字典不支持索引、切片、相加和相乘操作。
分类：
根据是否可以修改可以分为：可变序列（如列表），不可变序列（如元组）
根据是否有特定顺序可分为：有序序列（如列表，字符串，元组），无序序列（字典，集合）

索引与切片

举几个例子：

a = [1,2,3]
print(a[1])    # 索引 （都从0起始）
print(a[1:2])  # 切片 （都左闭右开）
a = 'happy'
print(a[2])
print(a[1:4])
a = (1,3,5,7,9)
print(a[0])
print(a[0:3])

2
[2]
p
app
1
(1, 3, 5)

可以作用于序列的算术运算符（相加与相乘）

相加 +

序列的加法表示将两个序列进行拼接

print([1,2]+[3,4]+[5,6])
print((1,2)+(3,4)+(5,6))

[1, 2, 3, 4, 5, 6]
(1, 2, 3, 4, 5, 6)

相乘 *

序列的乘法表示将序列进行重复（拷贝）

print([1,3,6]*3)
print((2,3,6)*3)
print('135'*3)

[1, 3, 6, 1, 3, 6, 1, 3, 6]
(2, 3, 6, 2, 3, 6, 2, 3, 6)
135135135

增量赋值也是可以的，但是注意：
NB ：
（1）在python中每一个对象都有三个基本属性：唯一标志（用 id()检验），类型（函数 isinstance() 如 isinstance(12, int) 和 函数 type() 检验），值。唯一标志是在对象创建时生成的，不可修改，不会重复，只要这个对象在内存中，就不会有重复的值。（可以理解为对象的身份证）
对于可变序列列表使用增量赋值不会改变id：

a = [1,2]
print(f"a为 {a}，id为 {id(a)}")
a+=a
print(f"运算 a+=a 后，a为 {a}， id为 {id(a)}")
a*=2 # 此时的 a 已经是 [1,2,1,2] 
print(f"再运算 a*=2 后，a为 {a}， id为 {id(a)}")
# 但是 正常的 a= a*2 (不增量赋值）还是会改变id的
print('不用增量赋值：')
b = [5,666]
print(f"b为 {b}，id为 {id(b)}")
b = b*2
print(f"运算 b = b*2 后，b为 {b}， id为 {id(b)}")

a为 [1, 2]，id为 2026922936704
运算 a+=a 后，a为 [1, 2, 1, 2]， id为 2026922936704
再运算 a*=2 后，a为 [1, 2, 1, 2, 1, 2, 1, 2]， id为 2026922936704
不用增量赋值：
b为 [5, 666]，id为 2026923212032
运算 b = b*2 后，b为 [5, 666, 5, 666]， id为 2026923213184

对于不可变序列列表使用增量赋值id会改变：

a = (1,2)
print(f"元组a为 {a}，id为 {id(a)}")
a*=2 # 此时的 a 已经是 [1,2,1,2] 
print(f"运算 a*=2 后，a为 {a}， id为 {id(a)}")
print('-----------------------------------------------------------------')
a = 'happy'
print(f"字符串a为 {a}，id为 {id(a)}")
a*=2 # 此时的 a 已经是 [1,2,1,2] 
print(f"运算 a*=2 后，a为 {a}， id为 {id(a)}")

元组a为 (1, 2)，id为 2026922263040
运算 a*=2 后，a为 (1, 2, 1, 2)， id为 2026923637872
-----------------------------------------------------------------
字符串a为 happy，id为 2026924033840
运算 a*=2 后，a为 happyhappy， id为 2026924062320

其他常用于序列的运算符 & del 语句

同一性运算符 （is 和 is not)

也叫身份运算符， 用于检测对象的id是否相等，判断是否是同一个对象。

# 字符串
a = 'good'
b = 'good'
a is b

True

# 列表 
a = [1,2,3]
b = [1,2,3]
a is b # a 和 b 不是同一个对象

False

# 元组
a = (1,2,3)
b = (1,2,3)
print(a is b) # a 和 b 不是同一个对象
print(a is not b)

False
True

成员运算符 （in 和 not in)

in 运算符用于序列，可以判断某个元素是否包含在序列中

print(1 in ['1', 2, 3])
print('o' in 'aogvndou')
print(666 not in (1,2,3, 666))

False
True
False

del 语句

查了一下python3的文档，del 是个 语句 (statement)(https://docs.python.org/3/reference/simple_stmts.html#grammar-token-python-grammar-del_stmt)，不是个函数（很多帖子应该是搞错了这里）。语句 statement 有常见的在 控制流工具（Control Flow Tools）里的 if statement, for statement 等。在python3 文档里 del 归于简单语句 （simple statement）（文档中定义：简单语句由一个单独的逻辑行构成。 多条简单语句可以存在于同一行内并以分号分隔；https://docs.python.org/zh-cn/3/reference/simple_stmts.html ），简单语句的列子还有 import，raise，return，pass, break等。 而for, while, if，try 是复合语句 （Compound statements）（文档中写道：复合语句是包含其它语句（语句组）的语句；它们会以某种方式影响或控制所包含其它语句的执行。 通常，复合语句会跨越多行，虽然在某些简单形式下整个复合语句也可能包含于一行之内；https://docs.python.org/zh-cn/3/reference/compound_stmts.html?highlight=%E8%AF%AD%E5%8F%A5 ）。
(1) del 语句用于删除一个或多个指定对象

x = 'sfgws'
y = [1,2,3]
z = (1,3,5)
del x
del y,z
# 此时再调 x, y, 或者 z 就会报错如 NameError: name 'x' is not defined

(2) del 语句用于删除可变序列中的指定元素
例1：

a = [1,2,3,4,5,6,7,8,9]
del a[1:5]
print(a)
# 这里用切片也可以
a = [1,2,3,4,5,6,7,8,9]
a[1:5] = []
print(a)
# ！！理解：切片操作其实是进行了两步，第一步是将赋值号左侧指定位置的内容清空，第二步是将赋值号右侧可迭代对象的内容插入到左侧列表被清空的位置

[1, 6, 7, 8, 9]
[1, 6, 7, 8, 9]

例2：
这个例子切片无法完成，del 语句却可以

a = [1,2,3,4,5,6,7,8,9]
del a[::2] #从第一个元素开始删除，步进值设置为2
print(a)

x = [1,2,3,4,5]
del x[::2]
print(x) 
# 这里 如果用切片依葫芦画瓢 x[::2] = [] 会报错

[2, 4, 6, 8]
[2, 4]

例3：

a = [1,2,3,4,5,6,7,8,9] 
del a[:]
print(a)
# 等同 clear 的效果
a = [1,2,3,4,5,6,7,8,9] 
a.clear()
print(a)

[]
[]

和序列相关的一些函数

以下函数也是python BIF中与可迭代对象相关的函数

1. 将可迭代对象转化为 列表，元组，字符串 的函数 （list(), tuple(), str()）

例：

list('very good')

['v', 'e', 'r', 'y', ' ', 'g', 'o', 'o', 'd']

list((1,2,3))

[1, 2, 3]

tuple('hi')

('h', 'i')

str([1,2,3]) # str() 只会在外面加个引号表示字符串，括号还保留着

'[1, 2, 3]'

str((1,2,3))

'(1, 2, 3)'

2. min() & max() 函数

功能：对比传入的参数，返回最小值 （最大值）
用法：
（1）min(iterable, *[, key, default]) & max(iterable, *[, key, default]) 传入可迭代对象
例：

a = [1,2,3,4,5,6,7,8,9]
print(max(a))
a = 'ndoivneadfcs' #如果传入的可迭代对象是字符，则会比较其编码值
print(min(a))
# 但是 'int' 和 'str' 是不能比较的 （以下代码会报错：TypeError: '<' not supported between instances of 'str' and 'int'）
# a = (1,2,3,4,5,'aehtntntb')
# min(a)

9
a

如果传入为空集会报错，此时可以使用 default 参数

a = []
# 如果直接 min(a)， 会报错: ValueError: min() arg is an empty sequence
# 此时可以用default参数
min(a, default = '这是个空的')

'这是个空的'

（2）min(arg1, arg2, *args[, key]) & max(arg1, arg2, *args[, key]) 传入多个参数，找出其中最大或最小
例：

min(1,2,3,4,5,6,7,8,90,-2)

-2

max(-3,-5,-90)

-3

3. len() & sum() 函数

这俩函数用的比较多了，这里就举简单例子过。
a. len() 函数 注意其有最大可承受范围。如：

# len(range(2**100)) 会报错 `OverflowError: Python int too large to convert to C ssize_t`。
# python为了执行效率，内部是由效率更高的C语言写的。这个len()函数，是直接读取C语言结构体里面的对象的长度。所以如果检测的对象超过某个数值就会报错。通常，对于32位平台来说最大值是2的32次方减1，对于64位平台来说是2的63次方减1.

b. sum() 函数

a = (1,2,3,4,5)
sum(a)
# 但是字符串不能sum() 相加：
# a = 'sntnw'
# sum(a)
# 报错：TypeError: unsupported operand type(s) for +: 'int' and 'str'

15

# 还可以使用 start 参数来指定求和计算的起始值
a = [1,2,3,4,5]
sum(a, start = 1000) # 此时即从1000开始加，加1，加2……

1015

3. sorted() & reversed() 函数

a. sorted() 函数
sorted() 函数，用于排序，类似与列表的 sort() 方法，也都可以使用 reverse 和 key 两个参数，但两者也有不同

a = [5,3,0,-1,666]
sorted(a)

[-1, 0, 3, 5, 666]

与列表的 sort() 方法不同，sorted() 并不会改变原来的列表

a = [5,3,0,-1,666]
print(sorted(a))
print(a) #此时原来列表a并没有改变
# 如果用sort() 方法
a.sort()
print(a) #原来的列表a直接更新成排序后的了

[-1, 0, 3, 5, 666]
[5, 3, 0, -1, 666]
[-1, 0, 3, 5, 666]

sorted() 可以作用与字符串和元组，sort()方法是列表的 attribute 不能作用于字符串和元组。但是 sorted() 作用与字符串和元组后，返回值都是列表。

a = 'fgege'
sorted(a) # 返回的是列表
# 如果 a.sort() 会报错 AttributeError: 'str' object has no attribute 'sort'。 元组同理

['e', 'e', 'f', 'g', 'g']

a = (5,3,0,-1,666)
sorted(a) # 返回的是列表

[-1, 0, 3, 5, 666]

a = ('s', 'sgsasgabbs', 'a', 'e', 'sae', 'z')
sorted(a) # 返回的是列表
# 但是同时包含 str 和 int 不能比较

['a', 'e', 's', 'sae', 'sgsasgabbs', 'z']

sorted() 函数也都可以使用 reverse 和 key 两个参数

a = (5,3,0,-1,666)
sorted(a, reverse = True) # 返回的是列表

[666, 5, 3, 0, -1]

a = ('s', 'sgsasgabbs', 'a', 'e', 'sae', 'z')
sorted(a, reverse = True) # 返回的是列表

['z', 'sgsasgabbs', 'sae', 's', 'e', 'a']

a = ('s', 'sgsasgabbs', 'a', 'e', 'sae', 'z')
sorted(a) # 返回的是列表
# 此处对比的是字符串每一个字符的编码值，以每个元素字符串中第一个字符比较，若第一个字符相同再比较第二个

['a', 'e', 's', 'sae', 'sgsasgabbs', 'z']

sorted(a, key = len) # 此时 key 参数为指定一个干预排序算法的函数，这里指定 len()函数，
# 注意再key 参数里函数不用写括号，只写函数名就可以
# 此时 python 会将可迭代对象（这里是a元组）中每个元素去调用一遍len()函数，再比较len()函数的返回结果。即此时比较每个元素长度

['s', 'a', 'e', 'z', 'sae', 'sgsasgabbs']

b. reversed() 函数
reversed() 函数，用于排序，类似与列表的 reverse() 方法。但是reversed() 函数返回的是给定参数的反向迭代器
例：

a = [1,2,3,4,5,6]
reversed(a)  # 返回的是一个迭代器

<list_reverseiterator at 0x24fc3f4d040>

list(reversed(a))

[6, 5, 4, 3, 2, 1]

等同于列表的 reverse() 方法

a = [1,2,3,4,5,6]
a.reverse()
a

[6, 5, 4, 3, 2, 1]

同理 reversed() 函数可以用于字符，元组等其他可迭代对象 （但是列表的 reverse() 方法只能用于列表）：

a = 'good'
tuple(reversed(a))

('d', 'o', 'o', 'g')

list(reversed(range(1,7))) # 用于其他可迭代对象

[6, 5, 4, 3, 2, 1]

4. all() & any() 函数

作用：all() 函数用于判断可迭代对象中是否所有元素的值都为真；any()函数用于判断可迭代对象中是否存在某个元素的值为真
例:

x = [6,7,0]
y = [5,2,3]
print(f'all(x) 运算结果 {all(x)}')
print(f'all(y) 运算结果 {all(y)}')
print(f'any(x) 运算结果 {any(x)}')
print(f'any(y) 运算结果 {any(y)}')

all(x) 运算结果 False
all(y) 运算结果 True
any(x) 运算结果 True
any(y) 运算结果 True

5. enumerate() 函数

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

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
enumerate(seasons) # 得到一个 enumerate object （枚举对象）

<enumerate at 0x24fc4069840>

list(enumerate(seasons))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]

还可以用 start 参数 自定义序号开始的值

list(enumerate(seasons, start = 1))

[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

6. zip() 函数

作用：zip() 函数用于创建一个聚合多个可迭代对象的迭代器。它会将作为参数传入的每个可迭代对象的每个元素依次组合成元组，即第i个元组包含来自每个参数的第i个元素 (zip 英文拉链的意思）
例：

a = [1,3,5]
b = [2,4,6]
zip_ab = zip(a,b)
list(zip_ab)

[(1, 2), (3, 4), (5, 6)]

c = ['a', 'b', 'c']
zip_abc = zip(a,b,c)
list(zip_abc)

[(1, 2, 'a'), (3, 4, 'b'), (5, 6, 'c')]

如果传入的可迭代对象长度不一致, 会以最短的为准：

d = 'abcde'
zip_abd = zip(a,b,d)
list(zip_abd)

[(1, 2, 'a'), (3, 4, 'b'), (5, 6, 'c')]

如果想以最长的为准，可以使用itertools 里的 zip_longest() 函数

import itertools
zip_abd = itertools.zip_longest(a,b,d)
list(zip_abd)

[(1, 2, 'a'), (3, 4, 'b'), (5, 6, 'c'), (None, None, 'd'), (None, None, 'e')]

7. map() 函数

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

a = map(ord, 'good') # 这里参数就给函数名（ord）就行，不用加括号
list(a)

[103, 111, 111, 100]

如果提供的函数需要两个或多个参数，只需要同步修改后面提供的可迭代对象的数量

a = map(pow, [2,3,10], [5,2,3]) # map 函数用于计算次方，需要两个参数
list(a)
# 等价与 [pow(2,5), pow(3,2), pow(10,3)]

[32, 9, 1000]

如果后面提供的可迭代对象的长度不一致，map() 函数与zip() 函数一样，都是在最短的可迭代对象终止的时候停止

list(map(max, [1,90,5], [20,2,62], [0,3,9,8]))

[20, 90, 62]

list(map(pow, [2,3,10], [5,2,3,5,6]))

[32, 9, 1000]

8. filter() 函数

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

list(filter(str.islower, 'Good')) # str.islower 方法是判断是否为小写

['o', 'o', 'd']

list(filter(ord, 'good'))

['g', 'o', 'o', 'd']

概念 迭代器 与 可迭代对象

一个迭代器肯定是一个可迭代对象。两者最大的区别是可迭代对象可以重复使用而迭代器是一次性的。如：

a = map(ord, 'abc') # 这里我们用 map() 函数生成一个可迭代对象
print(a)
for i in a:  #进行 for 操作
    print(i)
# 我们再去调 a 时候， 发现a已经是空列表了
print(a) # 虽然直接 print 看起来没差别
list(a) # 但事实上里面已经空了

<map object at 0x0000024FC4058700>
97
98
99
<map object at 0x0000024FC4058700>





[]

a = map(ord, 'abc') # 这里我们用 map() 函数生成一个可迭代对象
print(a)
print(list(a)) #进行转化为列表
# 我们再去调 a 时候， 发现a已经是空列表了
print(a) # 虽然直接 print 看起来没差别
list(a) # 但事实上里面已经空了

<map object at 0x0000024FC4058C10>
[97, 98, 99]
<map object at 0x0000024FC4058C10>





[]

将可迭代对象转化为迭代器 可以用到 iter() 函数

a = [1,2,3,4,5,6]
b = iter(a)
type(a) # a 的类型还是列表

list

type(b) # b 的类型是迭代器

list_iterator

next() 函数

作用：逐个将迭代器中的元素提取出来
用法： next(iterable[, default])
参数：
iterable – 可迭代对象
default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。

a = [1,2,3]
b = iter(a)
next(b) #逐步一个个将元素提取出来

1

next(b) #逐步一个个将元素提取出来

2

next(b) #逐步一个个将元素提取出来
# 此时如果再 next(b) 迭代器里没有元素了，就会“报错“ （异常）StopIteration: 

3

可以加一个参数default, 避免这个异常

a = [1,2]
b = iter(a)
next(b, '空') #逐步一个个将元素提取出来

1

next(b, '空')

2

next(b, '空')

'空'

next(b, '空')

'空'

附言：
题目：Self-study Python Fish-C Note-8 P34-P36
本文为自学B站上鱼C的python课程随手做的笔记。一些概念和例子我个人为更好的理解做了些查询和补充
因本人水平有限，如有任何问题，欢迎大家批评指正！
原视频链接：https://www.bilibili.com/video/BV1c4411e77t?p=8