python打印序列号标签 python生成序列号

转载

mob6454cc719119 2024-02-18 20:35:18

文章标签 python打印序列号标签 python Powered by 金山文档迭代字符串 文章分类 Python 后端开发

这次是python序列的一些基础知识，以代码+ 注释的形式作为笔记，供复习使用

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   序列乘法将序列重复若干次

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值就会发生改变

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则是判断他们是否不相等

print("我" in "我爱学习")
print("C" not in "MyC")
#TODO   in运算符与not in运算符语法为：A in B(A not in B)，in判断A序列是否在B序列内，not in作用反之

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] = []是不被允许的

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则删除整个序列

x = list("I love Study")
y = list((1, 2, 3, 4, 5))
print(x,y)
#TODO   list函数可以将序列转化为列表

x = [1, 2, 3 ,4, 5]
z = "I love Python"
y1 = tuple(x)
y2 = tuple(z)
print(y1, y2)
#TODO   tuple函数可以将序列转化为元组

x = [1, 2, 3, 4, 5]
z = "I love Study"
y1 = str(x)
y2 = str(z)
print(y1,y2)
#TODO   str函数可以将序列转化为字符串，是单纯给序列加上引号罢了，圆括号和方括号还在

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函数可以有更多的参数，于是函数会在这些参数里面求最值

x = range(2 ** 100)
#TODO   range是一个迭代器，用来生成指定整数范围的列表，规则是左闭右开，如 2**100 生成 0 ~ 2**100 - 1的列表
print(x)
#!  lx = len(x)
#!  print(lx)
#!  注意，len函数如果检测的数值过大，就会报错
#TODO   len函数可以得到一个序列的长度

s = [1, 0, 0, 8, 6]
summary1 = sum(s)
print(summary1)
#!  haha = "can you calculate me ?"
#!  summary2 = sum(haha)
#!  print(summary2)
#!  上面的代码是不被允许的，因为sum函数不能计算字符串中元素和
#TODO   sum函数将计算序列的元素和

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
#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)))

x = [1, 1, 0]
y = [1, 1, 9]
print(all(x))   #*all函数判断序列是否每个元素为真
print(any(y))   #*any函数判断序列是否有一个元素为真

seasons = ["Spring", "Summer", "Autunm", "Winter"]
print(list(enumerate(seasons)))
#TODO   enumerate函数将根据参数里面的可迭代对象创建一个枚举对象，可以用list函数，
#TODO   将枚举对象转化成列表打印出来。
#TODO   enumerate参数的可迭代对象的每一个元素，都会配以一个整数，构成一个二元组，
#TODO   这些整数为从0开始的索引，可以指定enumerate的第二个参数，作为索引开始，而不是从0开始。
print(list(enumerate(seasons,10)))

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))

#?  那么如果z长度为4，也就是说有4个元素呢？这时候第四个元素由于没有匹配对象，所以第四个元素没有被连接
#?  那么如果我还是需要这第四个元素呢？可以考虑itertools模块里面的zip_longest函数，
#*  这时候，即使没有与之下标相同的元素，最远的元素也会被保留下来
import itertools
zipped = itertools.zip_longest(x,y,z)
print(list(zipped))

#*  下面介绍加工函数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函数不同的是，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本身，已经是空的了，这是因为迭代器是一次性使用的，
#!  而可迭代对象是可以重复使用的，如列表，字符串，元组。

#TODO   我们可以用iter函数，将可迭代对象转化为迭代器
x = [1, 2, 3, 4, 5]
y = iter(x)
print(type(x))
print(type(y))
#*  通过type函数可以看到他们的类型

#TODO   通过next函数，将迭代器每个元素取出来
print(next(y))
print(next(y))
print(next(y))
print(next(y))
z = iter(x)
print(next(z, "无了"))
#*  我们可以指定next函数的第二个参数，这是一个字符串，当迭代器取不出元素时，
#*  我们输出这个字符串