1. 【判断可迭代对象是否包括假值】all()函数

语法参考

all()函数用于判断可迭代对象是否包括假值即0、空、False，除此之外都属于真值。如果包括假值结果就为False，否则结果就为True。all()函数的语法格式如下：

all(iterable)

参数说明：

• iterable：可迭代对象，如列表、元组等。

• 返回值：返回值为True或False，如果可迭代对象不包括空、0、False的元素，那么返回值为True，否则返回值为False。

锦囊1 使用all()函数判断可迭代对象是否包括空、0、False的元素

下面使用all()函数判断下列可迭代对象是否包括空、0、False的元素，代码如下：

print(all([1,3,5,7,9]))            # 列表元素都不为空、0、False，返回True
print(all(('Python','Java')))      # 元组元素都不为空、0、False，返回True
print(all([0,2,4,6,8]))            # 列表元素中存在一个为0的元素，返回False
print(all(['a','b','c','']))       # 列表元素中存在一个为空的元素，返回False

注意：如果可迭代对象中元素个数为0，则返回值为True，例如空列表、空元组、空字典的返回值为True，代码如下：

print(all([]))    		# 空列表，返回True
print(all(()))    		# 空元组，返回True
print(all({}))    		# 空字典，返回True

提示：all()函数以一个可迭代器对象为参数，当参数为空或者提供的参数不是可迭代器对象时将提示TypeError错误信息，代码如下：

# 将提示TypeError: all() takes exactly one argument       (0 given)
print(all())     		# 参数不能为空# 将提示TypeError: 'int' object is not iterable
print(all(2))     		# 参数必须为可迭代对象

锦囊2 判断列表中是否包括0

生成随机数列表，并通过all()函数的返回值判断随机数列表中是否包括0，如果包括0则输出该列表，如果不包括0则程序重新执行，代码如下：

import random                           		# 导入随机数模块while 1:a=[random.randint(0,5) for _ in range(5)]  	# 生成0-5之间的随机数列表if all(a)==False:print(a)breakelse:print('随机数列表中没有0，程序重新执行！')

2.【判断可迭代对象是否全为假值】any()函数

语法参考

any()函数用于判断可迭代对象元素是否都是假值即0、空、False。如果全部为假值则返回False，否则返回True。any()函数的语法格式如下：

any(iterable)

参数说明：

• iterable：可迭代对象，如列表、元组等。

• 返回值：返回值为True或False，如果可迭代对象中只要有一个元素不是假值，则返回值为True，如果可迭代对象中所有的元素都是假值，则返回值为False。

锦囊1 使用any()函数判断可迭代对象是否全为假值

下面通过any()函数分别判断下列可迭代对象是否全为假值，代码如下：

# 使用any()函数判断下列可迭代对象是否全为假值
a1=any(['python', 'java', 'c++', '.net',' '])
a2=any([0,1,2,3,4,5])       			# 有一个元素为True，则返回True
a3=any([0, '', False])    				# 全部元素为False，则返回False
a4=any((0,0))
a5=any([])                				# 可迭代对象为空(元素个数为0)，返回False# 输出判断结果
print('第一个序列：',a1)
print('第二个序列：',a2)
print('第三个序列：',a3)
print('第四个序列：',a4)
print('第五个序列：',a5)

注意：如果可迭代对象为空（元素个数为0），返回值为False，如空列表、空元组返回值为False。

提示：any()函数以一个可迭代器对象为参数，当参数为空或者提供的参数不是可迭代器对象时将提示TypeError错误信息，代码如下：

# 将提示TypeError: any() takes exactly one argument (0 given)
print(any())      			# 参数不能为空# 将提示TypeError: 'int' object is not iterable
print(any(2))     			# 参数必须为可迭代对象

3. 【通过指定条件过滤序列】filter()函数

语法参考

filter()函数用于过滤掉可迭代对象中不符合条件的元素，返回由符合条件的元素组成的新的迭代器。filter()函数把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。filter()函数的语法格式如下：

filter(function,iterable)

参数说明：

• function：用于实现判断的函数；

• iterable：可迭代对象，如列表、range对象等；

• 返回值：返回一个迭代器对象。

锦囊1 filter()函数的基本应用

使用filter()函数过滤出0~100（不包括100）之间的所有偶数，代码如下：

def evennumber(num):                          	# 定义一个判断偶数的函数return num % 2 == 0newlist = filter(evennumber,range(100))       	# 使用filter()函数过滤出序列中的偶数
print(newlist)                          		# 返回一个迭代器对象
print(list(newlist))                   			# 使用list()函数将迭代器转换为列表

锦囊2 筛选指定范围的数据

定义学生列表，实现按照2019年高考理科成绩进行筛选，得出成绩在600分到700分之间的学生信息，代码如下：

def find(item):                     		# 创建函数total= int(item[1])if total>=600 and total<700:    		# 判断条件return Truereturn Falselist1 = [('小明',600),('小刚',601),('小雅',524),('小旭',714),('小章',624),('小白',635),('小赵',480),('小高',580),('小王',541),('小琪',680)]newList = filter(find,list1)        		# 过滤序列中不符合条件的元素
list2=list(newList)                 		# 使用list()函数转换为列表
print(list2)                        		# 输出学生列表
print('600分以上：',len(list2),'人')			# 输出人数

锦囊3 筛选类型不是字符的元素

例如，在一个集合中有一组数据，包括字符串、数字等，下面筛选出类型不是字符串的元素，代码如下：

a = {'mingrisoft',123,12.1,-1}
print(set(filter(lambda x:type(x)!=str,a)))

锦囊4 取出字符串中的数字并转换为整型

取出一组注册信息中的数字，然后转换为整数。首先判断字符串是否为数字，然后使用filter()函数过滤数字，最后转换为整型输出，代码如下：

a1 =  'ISVO20N2WTRJ4T0XXGQ5QWP9Z'
a2 = filter(str.isdigit, a1)       		# 过滤数字
a3 = list(a2)                      		# 转换为列表num = ''.join(a3)                  		# 连接列表
print(int(num))                    		# 转换为整型输出

锦囊5 从脏数据中取出有效信息

现在需要将其中的手机号提取出来，并且写入到数据库内。首先中国的手机号码一般是12位的，所以这里创建phone()函数，使用字符串函数len()判断手机号是否12位，然后使用filter()函数过滤，代码如下：

mylist = [101000000000,'mr','IT','888科技',102000000000,103000000000,4006751066]def phone(x):return len(str(x)) == 12                # 字符串长度为12
print(list(filter(phone,mylist)))           # 过滤手机号并输出

4. 【用于生成迭代器】iter()函数

语法参考

iter()函数用于根据指定的可迭代集合对象或可调用对象来生成一个迭代器。iter()函数的语法格式如下：

iter(object)                       	# 一个参数形式
iter(object[, sentinel])          	# 两个参数形式

参数说明：

• object：支持迭代的集合对象；

• sentinel：如果指定参数sentinel，则参数object必须是一个可调用的对象（如函数），此时，iter创建了一个迭代器对象，每次调用这个迭代器对象的__next__()方法时，都会调用object；

• 返回值：返回一个iterator（迭代器）对象。

锦囊1 将序列转换为迭代器对象

使用iter()函数将序列转换为迭代器对象，代码如下：

s = iter('mr')     				# 将字符串创建迭代器对象
print(s)
print(next(s))     				# 返回迭代器的下一个元素
print(next(s))# 根据字典创建迭代器对象
dict = iter({'Monday':'星期一','Tuesday':'星期二','Wednesday':'星期三','Thursday':'星期四','Friday':'星期五','Saturday':'星期六','Sunday ':'星期日'})print(dict)
print(next(dict))     			# 返回迭代器的下一个元素，遍历字典中的键（key）
print(next(dict))
print(next(dict))
print(next(dict))
print(next(dict))
print(next(dict))
print(next(dict))

锦囊2 实现累加计数

使用iter()函数创建迭代器并实现函数回调以及设置截止次数，从而实现累加计数，代码如下：

class add:        #定义类def __init__(self, _start, _end):self.start = _startself.end = _enddef get_next(self):s = self.startif (self.start < self.end):self.start += 1else:raise StopIterationreturn s# 使用iter()函数创建迭代器并实现函数回调以及设置截止次数
a = add(1, 20)
iterator = iter(a.get_next, 6)
for i in iterator:print(i)

5. 【通过函数实现对可迭代对象的操作】map()函数

语法参考

map()函数接收一个函数为参数和一个或者多个可迭代对象为参数，返回一个迭代器。此迭代器中每个元素都是函数参数依次作用于可迭代对象后的结果。map()函数的语法格式如下：

map(function, iterable, …)

参数说明：

• function：函数；

• iterable：一个或多个可迭代对象；

• 返回值：返回迭代器。

注意：map()函数在Python 2.x返回的是列表，而在Python 3.x中返回的是可迭代器对象。

锦囊1 将列表中的元素转换为Unicode字符

定义一个整数列表，通过map()函数实现将该列表每一个元素转换为Unicode字符，代码如下：

num1 = [26126,26085,31185,25216]
a=map(chr,num1)     				# 返回一个迭代器对象print(a)
print(list(a))      				# 使用list()函数转换为列表

提示：从程序的运行结果可以看出，map()函数返回的是一个可迭代器对象，我们通过使用list()函数将其转换为列表。

锦囊2 规范英文的大小写

通过map()函数规范英文短句中单词的大小写（即首字母大写，其余字母小写），代码如下：

mylist=['Jilin','mingrisoft','technology','co.','LTD'] 		# 创建列表def function(x):                                       		# 定义函数return x[0].upper() + x[1:].lower()                		# 实现首字母大写，其他字母小写print("规范后的英文短句：",list(map(function,mylist))) 		# 使用list()函数转换为列表
aa=list(map(function,mylist))
print(' '.join(aa))                                    		# 连接列表

锦囊3 对列表中的元素进行平方计算

生成0到9的数字列表，然后通过map()函数实现对该列表每一个元素的平方计算，代码如下：

list1=[]                           # 创建空列表for i in range(10):list1.append(i)def square(x):                     # 定义函数return x**2list2=map(square,list1)            # 返回一个迭代器对象
print(list(list2))                 # 使用list()函数转换为列表

锦囊4 传入多个可迭代对象

当使用map()函数传入多个可迭代对象时，且里面的元素长度不一致时，生成的迭代器以最短长度为主，例如下面的代码：

list1 = [1,3,5]                         # 列表1
list2 = [2,4,6,8,10]                    # 列表2def func(x,y):                          # 定义函数return x+yresult = map(func,list1,list2)        	# 返回一个迭代器对象
print(list(result))                    	# 使用list()函数转换为列表

注意：当map()函数传入多个可迭代对象时，参数function必须能够接收足够多的参数，以保证每个可迭代对象同一索引的值均能正确传入函数，否则将出现错误提示TypeError。

6. 【返回迭代器的下一个元素】next()函数

语法参考

next()函数以迭代器为参数，每次调用的时候，返回迭代器中的下一个元素。next()函数的语法格式如下：

next(iterator[,default])

参数说明：

• iterator：迭代器；

• default：可选参数，用于设置在没有下一个元素时返回该值，如果不设置，又没有下一个元素则会出现停止迭代StopIteration的异常。

• 返回值：返回迭代器中的下一个元素。

锦囊1 使用next()函数返回迭代器中的下一个元素

使用next()函数返回迭代器中的下一个元素，代码如下：

s = iter('mr')     		# 将字符串序列转为迭代器对象
print(next(s))     		# 返回迭代器的下一个元素
print(next(s))
print(next(s))     		# 没有下一个元素，出现停止迭代StopIteration异常

当迭代完最后⼀个元素值之后，再次调用next()函数会抛出StopIteration的异常。此时，我们可以传入可选参数default，如果还有元素没有返回，则依次返回其元素值，如果所有元素已经返回，则返回default指定的默认值而不抛出StopIteration异常。代码如下：

s = iter('mr')          			# 将字符串序列转为迭代器对象
print(next(s, 'x'))
print(next(s, 'x'))
print(next(s, 'x'))    				# 返回default指定的默认值
print(next(s, 'x'))

锦囊2 循环推进迭代器元素

循环推进迭代器元素，当到达结尾后，通过try…except捕获异常，并输出提示信息，代码如下：

list=iter(['a','b','c','d','e'])  		# 使用iter()函数创建迭代器while 1:try:print(next(list))            	# 获取下一个值except StopIteration:print('停止迭代')    			# 输出提示break                			# 退出循环

锦囊3 循环推进迭代器元素并设置默认值

循环推进迭代器元素并设置默认值。通过判断是否是默认值决定是否结束循环，代码如下：

list1=iter([1,2,3,4,5])      	# 创建可迭代对象
while 1:y=next(list1,0)     	# 设置default的值为0if y:               	# 条件为真，则输出y的值print(y)else:               	# 否则退出循环break

7. 【生成器函数】range()函数

语法参考

range()函数用于生成一个新的range类型，多用于for循环语句中，用于生成指定范围的整数。range()函数的语法格式如下：

range(start,end,step)

参数说明：

• start：表示起始整数(包含起始整数)，默认起始值为0，起始整数可以省略，如果省略则表示从0开始；

• end：表示结束整数（但不包括该值，如range(7)得到的值为0~6，不包括7），结束数值不能省略。当range()函数中只有一个参数时，即表示指定计数的结束值。结束整数可以大于0，也可以小于或等于0，但是结束整数小于或等于0时，生成的range对象是不包含任何元素的；

• step：表示步长，即两个数之间的间隔，参数step可以省略，如果省略则表示步长为1。例如，range(1,7)将得到1、2、3、4、5、6。

• 返回值：返回一个range对象。

注意：range()函数接收的参数必须是整数，不能是浮点数等其他数据类型，否则会提示类型错误。

注意：在使用range()函数时，如果只有一个参数，那么表示指定的是stop结束整数；如果是两个参数，则表示指定的是start开始整数和end结束整数；只有三个参数都存在时，最后一个参数才表示step步长。

锦囊1 根据提供的参数生成一个range类型

下面根据提供的参数生成一个range类型，代码如下：

print(range(15))
print(range(50,100,1))
print(range(50,100,10))

锦囊2 使用list()函数将range类型转换为列表

下面使用list()函数将range类型转换为列表，代码如下：

print(list(range(0)))           	# 参数为0，生成的列表不包含任何元素
print(list(range(-88)))         	# 参数为负数，生成的列表不包含任何元素
print(list(range(9)))           	# 不包括9
print(list(range(5,15)))        	# 不包括15
print(list(range(10,100,10)))   	# 不包括100，步长为10
print(list(range(10,101,5)))    	# 包括100，步长为5

锦囊3 使用range()函数实现数字的累加

使用range()函数实现从1到100的累加，代码如下：

result = 0             				# 保存累加结果的变量
for i in range(101):result += i        				# 实现累加功能
print(result)          				# 在循环结束时输出结果

锦囊4 遍历字符串

下面使用range()函数结合for循环输出英文单词“Python”中的每个字母，代码如下：

str1 = 'Python'
for i in range(len(str1)):print(str1[i])

锦囊5 生成指定步长的数值序列

下面使用range()函数分别输出12月份中的奇数月份和偶数月份，代码如下：

num1=range(2,14,2)
num2=range(1,13,2)
print('偶数月份:',end=' ')     		# 输出偶数月份for i in num1:print(i,end=' ')print('\n',end='')             		# 换行
print('奇数月份:',end=' ')     		# 输出奇数月份for i in num2:print(i,end=' ')

8. 【反转序列对象】reversed()

语法参考

reversed()函数用于反转一个序列对象，将其元素从后向前颠倒构建成一个新的迭代器，reversed()函数的语法格式如下：

reversed(seq)

参数说明：

• seq：序列，如列表、元组、字符串或range对象等。

• 返回值：返回一个反转的迭代器。

锦囊1 反转迭代器对象转换为列表后输出

下面使用reversed()函数返回反转后的迭代器对象，然后将其转换为列表后输出，代码如下：

str = reversed('mingrisoft')                 	# 定义字符串
print(str)                                   	# 返回一个反转的迭代器
print(list(str))                             	# 使用list()函数将可迭代对象转换为列表list1 = [1001,888,999,666]                   	# 列表
print(list(reversed(list1)))num = range(0,101,10)                        	# range对象
print(list(reversed(num)))
tuple = ('Python', 'Java', 'C语言')          	# 元组
print(list(reversed(tuple)))

锦囊2 反转数字列表并排序

定义一个保存数学学习成绩的列表，然后使用sort()方法排序，使用reversed()函数对列表反转，实现降序排序，代码如下：

num_list = [100,85,56,59,75,77]    # 分数列表
num_list.sort()                    # 对分数排序print(num_list)
print(list(reversed(num_list)))    # 降序输出

锦囊3 反转英文句子

经常在Python面试题中看到这样的题目：反转英文句子，下面使用reversed()函数实现反转英文句子，代码如下：

s = input('请输入英文句子：')
s1 = s.split(' ')       			# 按空格切分
l = []for i in reversed(s1):  			# 反转单词l.append(i)mystr=' '.join(l)
print(mystr)

9. 【对可迭代对象进行排序】sorted()

语法参考

sorted()函数用于对可迭代对象进行排序，返回一个重新排序的列表，使用该函数进行排序后，原列表的元素顺序不变。storted()函数的语法格式如下：

sorted(iterable, key=None, reverse=False)

参数说明：

• iterable：表示可迭代对象，如列表、字符串、字典等；

• key：可选参数，命名参数key是一个方法，用来指定排序的规则（即按照指定的方法或函数对可迭代对象进行排序），例如，设置“key=str.lower”，表示可迭代对象中的每个元素转换为小写字母后再进行排序，返回的仍然是可迭代对象中的元素。默认key=None，表示直接比较元素进行排序；

• reverse：可选参数，排序规则，默认reverse=False，表示升序排列，如果reverse=True，则表示降序排列；

• 返回值：返回重新排序的列表。

锦囊1 对数字列表进行排序

定义一个保存10名学生高考理科成绩在600分以上的列表，然后应用sorted()函数对其进行升序和降序排列，代码如下：

grade = [656,602,610,618,663,695,622,645,677,640]      	# 10名600分以上的学生列表
print('升序排列：', sorted(grade))                     	# 升序排列
print('降序排列：', sorted(grade, reverse = True))     	# 降序排列

锦囊2 对字符列表进行排序

定义一个保存字符的列表，然后应用sorted()函数对其进行排序，并指定参数key=str.lower，代码如下：

c = ['a','b','c','d','*','M','R','S','O','F','T']       			# 定义列表# 默认按字符ASCII码进行排序
print('升序：',sorted(c))                               				# 进行升序排列
print('降序：',sorted(c,reverse = True))                				# 进行降序排列
print('转换为小写后升序：',sorted(c,key=str.lower))     				# 转换为小写后升序排序，a和A的值一样
print('转换为小写后降序：',sorted(c,key=str.lower,reverse = True))   	# 转换为小写后降序排列

提示：*的ASCII值为42，A的ASCII值为65，a的ASCII值为97。

锦囊3 按照列表中嵌套元组的指定元素进行排序

下面分别依据英语小A班学生列表students中元组的第1个下标值（年龄）和第2个下标值（身高）进行升序和降序排列，代码如下：

# 定义列表（姓名、年龄、身高）
students = [('Adas', 3, 99), ('Lily', 4, 110), ('Bella',4, 112),('Anna',3,95)]  
s1 = sorted(students, key=lambda x:x[2])                  	# 按身高进行升序排列
print('按身高升序：', s1)
s2  =sorted(students, key=lambda x:x[2], reverse=True)   	# 按身高进行降序排列
print('按身高降序：', s2)
s3 = sorted(students, key=lambda x:x[1])                  	# 按年龄进行升序排列
print('按年龄升序：', s3)
s4  =sorted(students, key=lambda x:x[1], reverse=True)   	# 按年龄进行降序排列
print('按年龄降序：', s4)

10. 【将可迭代对象打包成元组】zip()

语法参考

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的zip对象。zip()函数的语法格式如下：

zip(iterable1,iterable2,…])

参数说明：

• iterable1,iterable2,…：可迭代对象，如列表、字典、元组、字符串等，zip()函数允许多个可迭代对象作为参数。
  Ø 当zip()函数没有参数时，则返回空的迭代器；
  Ø 当zip()函数只有一个参数时，则从参数中依次取一个元素组成一个元组，再将依次组成的元组组合成一个新的迭代器。
  Ø 当zip()函数有两个参数时，分别从两个参数中依次各取出一个元素组成元组，再将依次组成的元组组合成一个新的迭代器；

• 返回值：返回一个可迭代的zip对象，其内部元素为元组，可以使用list()函数或tuple()函数将其转换为列表或元组。

锦囊1 用zip()函数将列表合在一起

简单来说，zip()函数就是将两个列表合在一起。例如，将X、Y坐标合在一起，代码如下：

x=[1, 2, 3, 4, 5 ]
y=[6, 7, 8, 9, 10]
print(list(zip(x, y)))

锦囊2 使用zip()函数建立字典

下面有2个数组name、num、name保存了班级里的学生姓名，num是每个学生的考试分数，下面通过某个学生姓名来查找他的考试分数，那么需要一个字典，zip可以很方便地建立字典，代码如下：

name = ['小明','小白','小西','小罗','小聪']  		# 定义列表name
num = [80,96,77,88,91]                       	# 定义列表num
mydict=dict(zip(name,num))                   	# 使用dict()函数将zip对象转换为字典
print(mydict['小聪'])

锦囊3 zip()函数妙用1（矩阵的旋转）

矩阵是高等代数学中的常见工具，也常用于统计分析和数学应用中。下面使用zip()函数实现一个xyz的矩阵的旋转，代码如下：

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = list(zip(x, y, z))
print(xyz)

锦囊4 zip()函数妙用2（矩阵的行列转置）

矩阵的转置是矩阵的一种运算，在矩阵的所有运算法则中占有重要地位。例如，把矩阵A的行和列互相交换所产生的矩阵称为A的转置矩阵，这一过程称为矩阵的转置。下面实现将xyz矩阵进行转置，代码如下：

x = [1, 2, 3]
y = [4, 5, 6]
z = [7, 8, 9]
xyz = list(zip(x, y, z))
print(xyz)
for a, b,c in zip(x,y,z):print(f"{a}, {b},{c}")

锦囊5 zip()函数妙用3（4×3矩阵转置成3×4矩阵）

data1 = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (9, 10, 11))
data2= zip(*data1)
print(tuple(data2))