Python-序列

序列
1.可以通过索引获取每一个元素
2.第一个元素的索引值是0
3.都可以通过切片的方法获取一个范围
4.与元组、字符串都有很多共同的运算符
根据是否能修改，将序列分为可变序列和不可变序列
列表就是可变序列
元组、字符串就是不可变序列
序列的运算符
+将序列进行拼接
*将序列进行拷贝、重复
同一性运算符，检测id是否相等
is是返回True
is not不是返回True

x = 'hello'
y = 'hello'
print(x is y)  # True
print(x is not y)  # False
x = [1, 2, 3]
y = [1, 2, 3]
print(x is y)  # False
print(x is not y)  # True

检测某个元素是否包含在序列中
in该元素包含在序列中则返回True
not in该元素不包含在序列中则返回True

x = [1, 2, 3]
print(1 in x)  # True
print(4 in x)  # False

del用于删除一个或多个指定的对象

x = [1, 2, 3]
del x  # 删除x
y = [1, 2, 3, 4]
del y[1:3]  # 删除从下标为1到下标为3的元素，不包括下标为3
print(y)  # [1, 4]
# 用切片实现
y = [1, 2, 3, 4]
y[1:3] = []
print(y)  # [1, 4]
z = [1, 2, 3, 4]
z[1:3] = [5]
print(z)  # [1, 5, 4]
'''分两步
 1.将赋值号左边指定位置的内容清空
 2，将赋值号右边可迭代对象的内容插入
 到左侧列表被清空的地方'''

x = [1, 2, 3, 4]
del x[::1]
print(x)  # []

序列的函数
all()判断可迭代对象中是否所有的元素都为真
any()判断可迭代对象中是否存在某个元素的值为真，即其中一个元素为真即为真

x = [1, 0, 0]
y = [1, 2, 3]
print(all(x))  # False,0为假
print(all(y))  # True
print(any(x))  # True,其中一个元素为真即为真
print(any(y))  # True

enumerate(x, n)n可省略。用于返回一个枚举对象，它的功能就是将可迭代对象中的每个元素及从0开始的序号共同构成一个二元组的列表
不能单独使用list(enumerate(x))，list()将得到的变成列表，列表是可迭代对象
n是得到的二元组的起始值

x = ['春', '夏', '秋', '冬']
print(list(enumerate(x))) # 默认从0开始 
# [(0, '春'), (1, '夏'), (2, '秋'), (3, '冬')]
print(list(enumerate(x, 1)))  # 从1开始
 # [(1, '春'), (2, '夏'), (3, '秋'), (4, '冬')]

zip()用于创建一个聚合多个迭代对象的迭代器。
它会将作为参数传入的每个迭代对象的每个元素依次组合成元组，即第i个元组包含来自每个参数的第i个元素
不能单独使用list(zip(x, y,...,n))
长度不一致时以最短的为准，多余的直接丢掉

x = [1, 2, 3]
y = [4, 5, 6]
zipped = list(zip(x, y))
print(zipped)  # [(1, 4), (2, 5), (3, 6)]
z = [7, 8, 9]
zipped = list(zip(x, y, z))
print(zipped)  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
z = [7, 8, 9, 10]
zipped = list(zip(x, y, z))
print(zipped)  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
''' 长度不一致时以最短的为准，多余的直接丢掉'''

list(itertools.zip_longest(x, y, z))不会丢掉多余的。是以最长的位标准，短的填充None

import itertools
x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9, 10]
zipped = list(itertools.zip_longest(x, y, z))
print(zipped)  
# [(1, 4, 7), (2, 5, 8), (3, 6, 9), (None, None, 10)]

map(计算方法,计算的对象)会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将返回运算结果
长度不一致时，以最短的为标准
不能单独使用list(map(计算方法,计算的对象))
ord求出字符对应的Unicode编码
pow计算次方

un = list(map(ord, 'hello')) 
print(un)  # [104, 101, 108, 108, 111]
powd = list(map(pow, [1, 2, 3], [2, 2, 2]))
print(powd)  # [1, 4, 9]
powd = list(map(pow, [1, 2, 3], [2, 2]))
print(powd)  # [1, 4]
'''长度不一致时，以最短的为标准'''

filter()会根据提供的函数对指定的可迭代对象的每个元素进行运算，并将运算结果为真的元素，以迭代器的形式返回
不能单独使用list(filter(计算方法,计算的对象))

print(list(filter(str.islower, 'AbCdEf')))
# ['b', 'd', 'f'],islower,小写为真，大写为假

迭代器和可迭代对象
一个迭代器肯定是一个可迭代对象
可迭代对象可以重复使用，而迭代器则是一次性的

un = (map(ord, 'hello'))
for i in un:
    print(i, end=',')  # 104,101,108,108,111,
print()
print(list(un))  # []

iter()迭代对象变成迭代器

x = [1, 2, 3]
y = iter(x)
print(type(x))  # <class 'list'>
print(type(y))  # <class 'list_iterator'>

next(x)将迭代器中的元素逐个输出，依次只能输出一个元素，元素输出完后再输出就会报错

x = [1, 2, 3]
y = iter(x)
print(next(y))  # 1
print(next(y))  # 2
print(next(y))  # 3
print(next(y))  # 报错

next(x，'什么什么')元素输出完后不会报错，而是出现什么什么，未输完则不会出现

x = [1, 2, 3]
y = iter(x)
print(next(y))  # 1
print(next(y))  # 2
print(next(y, '没有啦'))  # 3
print(next(y, '没有啦'))  # 没有啦