一、序列加法与序列乘法回顶
s1 = [1, 2, 3]
s2 = [4, 5, 6]
print(s1+s2)
#TODO 序列加法将序列拼接起来
s3 = (1, 2, 3)
s4 = (4, 5, 6)
print(s3,s4)
print(s2*3,s4*3)
#TODO 序列乘法将序列重复若干次
二、id函数回顶
s5 = [1, 2, 3]
print(id(s5))
s5 *= 2
print(s5,id(s5))
t = (1, 2, 3)
print(id(t))
t *= 2
print(t,id(t))
#TODO id函数可以获取一个变量的id值，对于一个可变序列，如列表，其元素发生改变，元素增多，其列表的id值都是不变的，
#TODO 但是对于不变序列，如元组和字符串，内容发生改变，那么id值就会发生改变
三、is关键字回顶
x1 = "I love Study"
y1 = "I love Study"
print("相同字符串id是否一样:", x1 is y1)
x2 = [1, 2, 3]
y2 = [1, 2, 3]
print("相同列表id是否一样:", x2 is y2)
#TODO 判断序列id值是否相等，使用is运算符，语法为 A is B，如果相同，则返回True，反之返回False，同理is not则是判断他们是否不相等
四、in与not in关键字回顶
print("我" in "我爱学习")
print("C" not in "MyC")
#TODO in运算符与not in运算符语法为：A in B(A not in B)，in判断A序列是否在B序列内，not in作用反之
五、del关键字与切片删除法回顶
del x1, x2
print(y1,y2)
#TODO del关键字用来删除指定对象
x = [1, 2, 3, 4, 5]
del x[1:4]
print(x)
x = [1, 2, 3, 4, 5]
x[1:4] = []
print(x)
#TODO 可以使用切片语法删除列表中的某一范围元素，但是列表还存在，当然单纯用切片语法也可以实现，那就是将空列表赋给指定区域的列表
x = [1, 2, 3, 4, 5]
del x[::2]
print(x)
#TODO del语句结合切片语法还可以设置步长进行隔各删除
#! 'str' object does not support item deletion 不能用del直接删除字符串的字符
#! x[::2] = []是不被允许的
六、clear函数回顶
x = [1, 2, 3, 4, 5]
y = [1, 2, 3, 4, 5]
print(x.clear())
del y[:]
print(y)
#TODO 上面的语句都是删除整个列表的元素，但是列表还存在，为空，只有当del y时，y才不存在
#* clear()函数只作用于列表，而del语句可以作用于序列
#! del + 切片，是删除可变序列中的元素，而单独的del则删除整个序列
七、list函数回顶
x = list("I love Study")
y = list((1, 2, 3, 4, 5))
print(x,y)
#TODO list函数可以将序列转化为列表
八、tuple函数回顶
x = [1, 2, 3 ,4, 5]
z = "I love Python"
y1 = tuple(x)
y2 = tuple(z)
print(y1, y2)
#TODO tuple函数可以将序列转化为元组
九、str函数回顶
x = [1, 2, 3, 4, 5]
z = "I love Study"
y1 = str(x)
y2 = str(z)
print(y1,y2)
#TODO str函数可以将序列转化为字符串，是单纯给序列加上引号罢了，圆括号和方括号还在
十、序列的min与max函数回顶
s = [1, 2, 3, 4, 5]
print(min(s))
t = "I love Study"
print(max(t))
#TODO min与max函数将得到序列中的最大值，如果参数是字符串，那么将按照阿斯克码(字典序)来确定最值
s = []
print(min(s,default="It is empty!"))
#! 如果单纯用min(s)作用求空列表的话，会报错，但是如果设置了第二个参数default的内容，那么程序不会报错，而是打印这段default内容
print(max(1, 2, 3, 0, 6))
print(min(1, 2, 3, 0, 6))
#! print(min(1,"can you?"))这是不被允许的，因为参数类型不一样
#TODO min与max函数可以有更多的参数，于是函数会在这些参数里面求最值
十一、range迭代器回顶
x = range(2 ** 100)
#TODO range是一个迭代器，用来生成指定整数范围的列表，规则是左闭右开，如 2**100 生成 0 ~ 2**100 - 1的列表
print(x)
#! lx = len(x)
#! print(lx)
#! 注意，len函数如果检测的数值过大，就会报错
#TODO len函数可以得到一个序列的长度
十二、序列的sum函数回顶
s = [1, 0, 0, 8, 6]
summary1 = sum(s)
print(summary1)
#! haha = "can you calculate me ?"
#! summary2 = sum(haha)
#! print(summary2)
#! 上面的代码是不被允许的，因为sum函数不能计算字符串中元素和
#TODO sum函数将计算序列的元素和
十三、sort与sorted回顶
s = [1, 2, 3, 0, 6]
print(sorted(s), s)
print(sorted("I love Study"))
print(sorted((1, 2, 3, 4, 5)))
#TODO sorted函数针对序列，以列表的形式返回排序结果，而原序列不变，默认从小到大排序
#! 序列.sort()函数将原序列就地排序，没有返回值
print(s.sort())
#* sorted也有第三个参数，reverse=参数如果为True，就倒序排序，从大到小
print(sorted(s,reverse=True))
#* sorted的第二个参数是key，是排序方法，通常是某些函数，如：len，将根据元素长度进行排序，
#* 通常作用于字符串，根据字符串长度排序
t = ["Study","Apple", "Book", "Banana", "Pen"]
print(sorted(t))
print(sorted(t, key=len))
#! sort函数的key参数也是有的，效果和sorted相同，但也要注意sort函数没有返回值
print(t.sort(key=len))
print(t)
十四、reverse与reversed函数回顶
#? 回顾一下，列表有reverse函数，将列表根据数值就地倒序，没有返回值，那么序列也有倒序函数，它就是reversed
#TODO reversed函数将序列倒序的结果作为一个迭代器返回，可以用list函数将这个迭代器转化为列表展现
s = [1, 2, 5, 8, 0]
print(reversed(s))
sl = list(reversed(s))
print(sl)
print(s.reverse())
print(s)
s = "I love Study"
print(reversed(s))
s = (1, 2, 5, 9, 3)
print(reversed(s))
print(reversed(range(0,10)))
十五、all与any函数回顶
x = [1, 1, 0]
y = [1, 1, 9]
print(all(x)) #*all函数判断序列是否每个元素为真
print(any(y)) #*any函数判断序列是否有一个元素为真
十六、enumerate函数回顶
seasons = ["Spring", "Summer", "Autunm", "Winter"]
print(list(enumerate(seasons)))
#TODO enumerate函数将根据参数里面的可迭代对象创建一个枚举对象，可以用list函数，
#TODO 将枚举对象转化成列表打印出来。
#TODO enumerate参数的可迭代对象的每一个元素，都会配以一个整数，构成一个二元组，
#TODO 这些整数为从0开始的索引，可以指定enumerate的第二个参数，作为索引开始，而不是从0开始。
print(list(enumerate(seasons,10)))
十七、zip函数回顶
x = [1, 2, 3]
y = [4, 5, 6]
zipped = zip(x, y)
print(list(zipped))
#TODO zip函数将两个可迭代对象连接起来组成一个新的迭代器。可以用list函数将他们转化为列表
#TODO 连接的法则是：下标相同的组合成一个二元组。
z = [7, 8, 9]
zipped = zip(x, y, z)
print(list(zipped))
十八、iteretools的zip_loggest函数回顶
#? 那么如果z长度为4，也就是说有4个元素呢？这时候第四个元素由于没有匹配对象，所以第四个元素没有被连接
#? 那么如果我还是需要这第四个元素呢？可以考虑itertools模块里面的zip_longest函数，
#* 这时候，即使没有与之下标相同的元素，最远的元素也会被保留下来
import itertools
zipped = itertools.zip_longest(x,y,z)
print(list(zipped))
十九、map函数回顶
#* 下面介绍加工函数map，map函数有多个参数，第一个参数是加工函数，通常是某些函数，
#* 之后的参数个数取决于前面那个加工函数，如果加工函数只需要一个参数，那么后面就只需要一个可迭代对象
#* 比如说ord函数，得到参数的阿斯克编码。如果加工函数需要两个参数，那么后面就要有两个可迭代对象，
#* 比如说pow函数，计算次方。
#TODO 总之，map函数将对可迭代对象的每个元素都进行一次函数操作，将计算结果返回一个迭代器，
#TODO 这样避免了多次使用函数操作可迭代对象的情况。
mapped = map(ord,"I love Study")
print(list(mapped))
mapped = map(pow,[2,3,10], [5, 2, 3]) #TODO 求2五次方，3两次方，10三次方
print(list(mapped))
print(list(map(max, [1, 3, 5], [2, 2, 2], [0, 3, 9, 8])))
#TODO 如果参数的可迭代对象的长度不一样，如上面的3：3：4类型，那么4中超出的部分就会被抛弃
二十、filter函数与map函数进阶回顶
#* filter函数和map函数类似，第一个参数也是函数，后面的参数也由函数确定，
#* 但是filter函数与map函数不同的是，map函数将返回计算的结果，
#* 而filter函数的第一个参数通常叫做过滤函数，将可迭代对象的每个元素用过滤函数进行判断
#* 结果为真，那么返回这个元素本身，而不是返回计算的结果
print(list(filter(str.islower,"I love Study")))
#? 那么怎么得到返回的每个结果呢？map函数返回计算的结果，我怎么一个个得到呢？
#? filter返回结果为真的元素，我怎么一个个得到他们呢？
#* 可以考虑用for循环得到每个结果
mapped = map(ord,"I love Study")
for each in mapped:
print(each)
print(mapped)
#! 我们知道mapped是一个存放迭代器的变量，经过for循环，其中的每个元素都被得到了
#! 这时候再看mapped本身，已经是空的了，这是因为迭代器是一次性使用的，
#! 而可迭代对象是可以重复使用的，如列表，字符串，元组。
二十一、iter函数回顶
#TODO 我们可以用iter函数，将可迭代对象转化为迭代器
x = [1, 2, 3, 4, 5]
y = iter(x)
print(type(x))
print(type(y))
#* 通过type函数可以看到他们的类型
二十二、next函数回顶
#TODO 通过next函数，将迭代器每个元素取出来
print(next(y))
print(next(y))
print(next(y))
print(next(y))
z = iter(x)
print(next(z, "无了"))
#* 我们可以指定next函数的第二个参数，这是一个字符串，当迭代器取不出元素时，
#* 我们输出这个字符串