python基础12_序列操作函数

序列操作函数

这类函数的操作对象一般为序列：列表和元组。而且在python3.x版本中一般是返回iterator对象迭代器，返回的iterator对象可以用list()函数转化为列表。

到这里，其实我发现其实所谓的iterator对象就是一般说的迭代器，而迭代器其实就是一个内存存储空间，能看到的就是对应的内存地址。（不知道这个理解是否有问题？暂时先这样）

函数名称和功能语法列表

序号	函数名	功能	语法
1	all()	用于判断给定的可迭代参数 iterable 的对象中的所有元素是否都为 TRUE，如果是返回 True，否则返回 False。 比如：列表、元组中的元素是否存在有0、空、None、False ，没有就返回 True。另外，空元组、空列表返回值为True，这里要特别注意。	all(iterable) iterable – 元组或列表。
2	any()	用于判断给定的可迭代参数 iterable 的对象中的所有元素是否全部为 False，则返回 False，只要有一个为 True，则返回 True。 元素除了是 0、空、FALSE 外都算 TRUE。	any(iterable) iterable – 元组或列表。
3	filter()	用于过滤序列，过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。 该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。	filter(function, iterable) function – 判断函数。 iterable – 可迭代对象。
4	map()	函数会根据提供的函数对指定序列做映射。 第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。	map(function, iterable, …) unction – 函数 iterable – 一个或多个序列
5	next()	返回迭代器的下一个项目。函数要和能生成迭代器的函数一起使用。比如：iter()	next(iterator[, default]) iterator – 迭代器 default – 可选，用于设置在没有下一个元素时返回该默认值，如果不设置，又没有下一个元素则会触发 StopIteration 异常。
6	reversed()	函数返回一个反转的迭代器。	reversed(seq) seq – 要转换的序列，可以是 tuple, string, list 或 range。
7	sorted()	函数对所有可迭代的对象进行排序操作,返回重新排序的列表。 sort 与 sorted 区别： sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。 list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。	sorted(iterable, key=None, reverse=False) iterable ----> 可迭代对象。 function ----> 比较的函数，这个具有两个参数，参数的值都是从可迭代对象中取出，此函数必须遵守的规则为，大于则返回1，小于则返回-1，等于则返回0。 key ----> 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。 reverse ----> 排序规则，reverse = True 降序 ， reverse = False 升序（默认）。
8	zip()	函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的iterator对象，这样做的好处是节约了不少的内存。 可以使用 list() 转换来输出列表。 如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 ***** 号操作符，可以将元组解压为列表。	zip([iterable, …]) iterabl – 一个或多个迭代器;

单个函数的用法示例

all()判断列表、元组中是否存在有0、空、None、False等元素

# all()判断列表、元组中是否存在有0、空、None、False等元素，存在False，没有则True.
# 有意思的是不管参数是空字符串、空列表、空元组、空集合、空字典，返回的都是True。
# 等同于下述效果：
# iterable = '列表或元组'
# def all(iterable):
#     for element in iterable:
#         if not element:
#             return False
#     return True
# print(all(iterable))

print(all(['a', 'b', 'c', 'd']))  # 列表list，元素都不为空或0，返回True
print(all(['a', 'b', '', 'd'])) # 列表list，存在一个为空的元素，返回False
print(all([0, 1,2, 3]))    # 列表list，存在一个为0的元素，返回False
print(all(('a', 'b', 'c', 'd')))  # 元组tuple，元素都不为空或0，返回True
print(all(('a', 'b', '', 'd'))) # 元组tuple，存在一个为空的元素，返回False
print(all((0, 1, 2, 3)))    # 元组tuple，存在一个为0的元素，返回False
print(all([]))   # 空列表，返回True
print(all(()))   # 空元组，返回True

运行结果：

True
False
False
True
False
False
True
True

any()判断给定的是否都是False

# any()判断给定的可迭代参数 iterable 的对象中的所有元素是否全部为 False。
# 等同于下述代码：（刚好是all的否定）
# def any(iterable):
#     for element in iterable:
#         if element:
#             return True
#     return False
# 示例（略），可参考all()。

filter()按给定的函数过滤不符合条件的元素

# filter()过滤掉不符合条件的元素，返回一个迭代器对象，如果要转换为列表，可以使用 list() 来转换。
#选出列表中的奇数
def is_odd(n):
    return n % 2 == 1
 
tmplist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
newlist = list(tmplist)
print(newlist)

# 选出0-100中算术平凡根为整数的数
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
tmplist = filter(is_sqr, range(1, 101))
newlist = list(tmplist)
print(newlist)

运行结果:

[1, 3, 5, 7, 9]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

map()把一个列表中的数值代入给定函数进行处理

# map()把一个列表中的数值代入给定函数进行处理
# 平方运算
def square(x) : # 计算平方数
    return x ** 2
print(map(square, [1,2,3,4,5]) ) # 计算列表各个元素的平方, 返回迭代器
squ = list(map(square, [1,2,3,4,5])) # 使用 list() 转换为列表
print(squ)
print(list(map(lambda x: x + 2, [1, 2, 3, 4, 5]))) # 使用 lambda 匿名函数

运行结果:

<map object at 0x00000172F13D7E20>
[1, 4, 9, 16, 25]
[3, 4, 5, 6, 7]

next()返回序列中的下一个项目

# next()返回序列中的下一个项目，与迭代器一起使用
 
# 首先获得Iterator对象（迭代器）:
it = iter([1, 2, 3, 4, 5])
# 也可以用匿名函数
# it = map(lambda x: x , [1,2,3,4,5])
# 循环:因为迭代器里的序列是有限的，所以在循环next时，最终会提示StopIteration异常。
# 这里就可以利用来对while循环终止
while True:
    try:
        # 获得下一个值:
        x = next(it)
        print(x, '\t', end='')  # 输出做了一些格式化：空格、不换行输出
    except StopIteration:
        # 遇到StopIteration就退出循环
        break
print()

运行结果:

1       2       3       4       5

reversed()反转序列

# reversed()反转序列，返回一个迭代器。
#!/usr/bin/env python3
 
# 字符串
seqString = 'Runoob'
print(reversed(seqString))  # 返回值是一个迭代器
print(list(reversed(seqString)))
 
# 元组
seqTuple = ('R', 'u', 'n', 'o', 'o', 'b')
print(list(reversed(seqTuple)))
 
# range
seqRange = range(5, 9)
print(list(reversed(seqRange)))
 
# 列表
seqList = [1, 2, 4, 3, 5]
print(list(reversed(seqList)))

运行结果:

<reversed object at 0x000001D541CE7E20>
['b', 'o', 'o', 'n', 'u', 'R']
['b', 'o', 'o', 'n', 'u', 'R']
[8, 7, 6, 5]
[5, 3, 4, 2, 1]

sorted()对所有可迭代的对象进行排序

# sorted()函数对所有可迭代的对象进行排序
dis_lst = [5, 2, 3, 1, 4]
# lst = sorted(dis_lst)
print(sorted(dis_lst))   # 默认为升序
print(dis_lst)  # sorted（）不会修改原列表，而是生成一个新列表

# 使用list内sort()函数后，原列表被修改了。
dis_lst.sort()   # 默认为升序
print(dis_lst)

运行结果:

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

记录一个菜鸟网站上看到的综合排序示例：

# 记录一个菜鸟网站上看到的综合排序示例：
s = "德国 10 11 16\n意大利 10 10 20\n荷兰 10 12 14\n法国 10 12 11\n英国 22 21 22\n中国 38 32 18\n日本 27 14 17\n美国 39 41 33\n俄罗斯奥委会 20 28 23\n澳大利亚 17 7 22\n匈牙利 6 7 7\n加拿大 7 6 11\n古巴 7 3 5\n巴西 7 6 8\n新西兰 7 6 7"
# 用字符串内置函数split()，以'\n'作为切割符，切割字符串s，生成列表stodata
stodata = s.split('\n')

# print(stodata)  # 查看列表stodata，可以注释。

# 创建一个空字典
para = {}
# 使用sorted排序
for line in range(len(stodata)):
    # 以空格切割列表stodata中元素（此时的元素是字符串）,生成另一个列表data
    data = stodata[line].split(' ')  
    print(data) # 查看每次循环生成的列表data，可以注释。
   
    # 把列表data中的元素，添加到字典para中，
    # 组装数据的结构para={'China': [], 'Russia': []}
    # int('-' + i)是把所有正数变负数，为的是后边使用默认升序排序。
    para[data[0]] = [int('-' + i) for i in data[1:]]
   
    # print(para) # 查看每次增加键值对后的情况，可注释。
print() # 打印空格。
# 使用sorted排序，排序对象为para，生成新的已经排序的列表new_para
# 排序的规则有匿名函数lambda定义(x[1]代表奖牌数目, x[0]代表国家)
# para.items()是返回字典的所有键值对，形式为：[(key,value),(key,value),...]
# print(para.items())  # 查看排序前情况，其实没啥意义，字典本来就是无序的，只是使用.items后生成了新的有序的列表
new_para = sorted(para.items(), key = lambda x: (x[1], x[0]))
# print(new_para) # 查看排序后情况
# 创建新列表c，用来放排序好的国家名。
c=[]
for i in new_para:
    c.append((i[0]))
# 按顺序打印列表c里的元素（国家）
for j in range(15):
    print(f"{(j+1):2d} {c[j]}")

# 运行结果：
# ['德国', '10', '11', '16']
# ['意大利', '10', '10', '20']
# ['荷兰', '10', '12', '14']
# ['法国', '10', '12', '11']
# ['英国', '22', '21', '22']
# ['中国', '38', '32', '18']
# ['日本', '27', '14', '17']
# ['美国', '39', '41', '33']
# ['俄罗斯奥委会', '20', '28', '23']
# ['澳大利亚', '17', '7', '22']
# ['匈牙利', '6', '7', '7']
# ['加拿大', '7', '6', '11']
# ['古巴', '7', '3', '5']
# ['巴西', '7', '6', '8']
# ['新西兰', '7', '6', '7']

#  1 美国
#  2 中国
#  3 日本
#  4 英国
#  5 俄罗斯奥委会
#  6 澳大利亚
#  7 荷兰
#  8 法国
#  9 德国
# 10 意大利
# 11 加拿大
# 12 巴西
# 13 新西兰
# 14 古巴
# 15 匈牙利

zip()把两个列表的对应元素拼合成元组

# zip()把两个列表的对应元素拼合成元组，返回iterator对象。也可以使用*号反向操作。
a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
zipped = zip(a,b)   # 返回一个对象
print(zipped)
print(list(zipped)) # list() 转换为列表
print(list(zip(a,c)))   # 元素个数与最短的列表一致

a1, a2 = zip(*zip(a,b))     # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式
print(list(a1))
print(list(a2))

# 三个列表的例子
# a = ["**", "**", "**"]
# b = ["PDA课程", "Python搞笑编程", "办公自动化"]
# for i,j,k in zip(a, b, a)
#	 print(i, j, k)

运行结果:

<zip object at 0x000001C49DC13600>
[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]
[1, 2, 3]
[4, 5, 6]