本文主要介绍Python推导式和内置函数。推导式是构建有规律对象的简便方式，包括列表、生成器、字典和集合推导式。内置函数有68个，重点讲解了all、any、bytes等，还介绍了匿名函数lambda，以及print、list等重要内置函数的用法。
10. 推导式
推导式就是构建比较有规律的列表、生成器、字典等一种简便的方式
10.1 列表推导式
首先我们先看一下这样的代码，给出一个列表，通过循环，想列表中添加1~10
li = []
for i in range(10):
li.append(i)
print(li)
那么按照上面的要求我们用列表推导式写一下
print([i for i in range(10)])
列表推导式分为两种模式：
-
1、循环模式：[ 变量(加工的变量) for 变量 in iterable ]
-
2、筛选模式：[ 变量(加工的变量) for 变量 in iterable if 条件 ]
10.2 循环模式
刚才我们看到的就是循环模式，那么有同学会问到，什么叫' 加工的变量'？这个也比较简单，接下来我们做几道题：
- 练习1：将10以内所有整数的平方写入列表
print( [i*i for i in range(1,11)] )
- 练习2：100以内所有的偶数写入列表
print( [i for i in range(2,101,2)] )
- 练习3：从python1期到python10期写入列表lst
print([f'python{i}期'for i in range(1,11)])
上面那个格式化输出的变量 f'python{i}期'，就是加工的变量
10.3 筛选模式
筛选模式就是在上面的基础上加上一个判断条件，将满足条件的变量留到列表中
- 练习1：三十以内可以被三整除的数
print( [i for i in range(30) if i % 3 is 0] )
- 练习2：过滤掉长度小于3的字符串列表，并将剩下的转换成大写字母
l = ['qingyan', 'yuluo', 'aa', 'b']
print([i.upper() for i in l if len(i) > 3])
- 练习3：找到嵌套列表中名字含有两个‘e’的所有名字（有难度）
------- 正常写法 -------
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Yuluo', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
lst = []
for i in names:
for j in i:
if j.count('e') > 1:
lst.append(j)
print(lst)
# 输出结果：
['Jefferson', 'Wesley', 'Steven', 'Jennifer']
----- 列表推导式写法 -----
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'],
['Yuluo', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
print([j for i in names for j in i if j.count('e') > 1])
# 输出结果：
['Jefferson', 'Wesley', 'Steven', 'Jennifer']
10.4 生成器表达式
生成器表达式和列表推导式的语法上一模一样，只是把 [] 换成 () 就行了
-
例如：比如将十以内所有数的平方放到一个生成器表达式中
gen = (i**2 for i in range(10))
print(gen)
# 输出结果:
<generator object <genexpr> at 0x0000026046CAEBF8>
生成器表达式也可以进行筛选
- 例如：获取1-100内能被3整除的数
gen = (i for i in range(1,100) if i % 3 == 0)
for num in gen:
print(num)
生成器表达式和列表推导式的区别:
- 1、列表推导式比较耗内存，所有数据一次性加载到内存。而生成器表达式遵循迭代器协议，逐个产生元素
- 2、得到的值不一样，列表推导式得到的是一个列表，生成器表达式获取的是一个生成器
- 3、列表推导式一目了然，生成器表达式只是一个内存地址
推导式只能构建相对复杂的并且有规律的对象，对于没有什么规律，而且嵌套层数比较多（for循环超过三层）这样就不建议大家用推导式构建
生成器的惰性机制：生成器只有在访问的时候才取值，说白了，你找他要才给你值，不找他要，他是不会执行的
10.5 字典推导式
需要一个key，一个value，用法基本上都差不多
lst1 = ['jay','jj','yuluo']
lst2 = ['周杰伦','林俊杰','雨落']
dic = { lst1[i]:lst2[i] for i in range(len(lst1)) }
print(dic)
# 输出结果：
{'jay': '周杰伦', 'jj': '林俊杰', 'yuluo': '雨落'}
10.6 集合推导式
集合的特点是无序且不重复，所以集合推导式自带去重功能
lst = [1,2,3,-1,-3,-7,9]
s = {abs(i) for i in lst}
print(s)
# 输出结果：
{1, 2, 3, 7, 9}
11. 内置函数一
函数就是以功能为导向，一个函数封装一个功能，那么Python将一些常用的功能（比如len）给我们封装成了一个一个的函数，供我们使用，他们不仅效率高（底层都是用C语言写的），而且是拿来即用，避免重复早轮子，那么这些函数就称为内置函数，到目前为止python给我们提供的内置函数一共是68个
- 重点讲解以下内置函数：
abs() enumerate() filter() map() max() min()
open() range() print() len() list() dict()
str() float() reversed() set() sorted() sum()
tuple() type() zip() dir()
- 自主掌握以下内置函数：
all() any() bytes() callable() chr() ord()
divmod() eval() exec() format() iter() globals()
hash() help() id() input() int() complex()
locals() next() oct() frozenset() pow() repr() round()
- 未来需要掌握：
classmethod() delattr() getattr() hasattr() staticmethod()
isinstance() object() property() setattr() issubclass() super()
11.1 all、any
all：可迭代对象中，全都是True才是True
print( all([1,2,True,0]) ) # False
any：可迭代对象中，有一个True 就是True
print( any([1,'',0]) ) # Ture
11.2 bytes
bytes：用于不同编码之间的转化
s = '你好'
bs = s.encode('utf-8')
print(bs) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
s1 = bs.decode('utf-8')
print(s1) # 你好
bs = bytes(s,encoding='utf-8')
print(bs) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
b = '你好'.encode('gbk')
b1 = b.decode('gbk')
print(b1.encode('utf-8')) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
11.3 callable
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功
name = 'yuluo'
def func():
pass
print(callable(name)) # False
print(callable(func)) # True
11.4 chr与ord
ord：输入字符找该字符编码的位置
print(ord('a')) # 'a'在编码里是97位
print(ord('中')) # '中'在编码里是20013位
chr：输入位置数字找出其对应的字符
print(chr(97)) # 编码里第97位是'a'
print(chr(20013)) # 编码里第20013位是'中'
11.5 eval
eval：执行字符串类型的代码，并返回最终结果
eval('2 + 2') # 直接计算2+2=4
n = 81
eval("n + 4") # 可设置开始值，使得81+4=85
eval('print(666)') # 直接把输出结果返回666
11.6 exec
exec：执行字符串类型的代码
s = '''
for i in [1,2,3]:
print(i)
'''
exec(s) # 1 2 3 直接把字符串内的代码运行了
11.7 hash
hash：获取一个对象的哈希值（可哈希对象：int，str，bool，tuple）
print(hash(111)) # 111
print(hash('字符串')) # 3226097080720691364
print(hash(True)) # 1
print(hash(False)) # 0
print(hash((1,2,3))) # 529344067295497451
11.8 help
help：函数用于查看函数或模块用途的详细说明
print(help(list)) # 查看list的详细说明
print(help(str.split)) # 查看split方法的详细说明
11.9 int、float、complex
int：函数用于将一个字符串或数字转换为整型
print(int()) # 0
print(int('12')) # 12
print(int(3.6)) # 3
print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4
float：函数用于将整数和字符串转换成浮点数
print(float(3)) # 3.0
函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数
print(complex(1,2)) # (1+2j)
11.10 bin、oct、hex
bin：将十进制转换成二进制并返回
print(bin(10),type(bin(10))) # 0b1010 <class 'str'>
oct：将十进制转化成八进制字符串并返回
print(oct(10),type(oct(10))) # 0o12 <class 'str'>
hex：将十进制转化成十六进制字符串并返回
print(hex(10),type(hex(10))) # 0xa <class 'str'>
11.11 divmod、round、pow
divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)
print(divmod(7,2)) # (3, 1)
round：保留浮点数的小数位数，默认保留整数
print(round(7/3)) # 默认结果（保留整数）：2
print(round(7/3,2)) # 结果保留2位小数：2.33
print(round(3.32567,3)) # 保留3位小数3.326
pow：求 x**y次幂（三个参数为x**y的结果对z取余）
print(pow(2,3)) # 8 两个参数为2**3次幂
print(pow(2,3,3)) # 2 三个参数为2**3次幂，对3取余
11.12 repr
repr：返回一个对象的string形式（原形毕露）
# %r 原封不动的写出来
name = 'yuluo'
print('我叫%r' %name) # 我叫'yuluo'
# repr 原形毕露
print(repr('{"name":"yuluo"}')) # '{"name":"yuluo"}'
print('{"name":"yuluo"}') # {"name":"yuluo"}
11.13. 匿名函数lambda
匿名函数，顾名思义就是没有名字的函数，那么什么函数没有名字呢？这个就是我们以后面试或者工作中经常用匿名函数 lambda，也叫一句话函数
现在有一个需求：你们写一个函数，此函数接收两个int参数，返回和值
def func(a,b):
return a+b
print(func(3,4))
# 输出结果：
7
那么接下来我们用匿名函数完成上面的需求：
func = lambda a,b: a+b
print(func(3, 4))
# 输出结果：
7
我们分析一下上面的代码：函数名 = lambda 参数: 返回值
1）此函数不是没有名字，他是有名字的，他的名字就是你给其设置的变量，比如func
2）lambda 是定义匿名函数的关键字，相当于函数的def
3）lambda 后面直接加形参，形参加多少都可以，只要用逗号隔开就行
func = lambda a,b,*args,sex= 'man',c,**kwargs: kwargs
print(func(3, 4,c=666,name='alex')) # {'name': 'alex'}
"""注意：
所有类型的形参都可以加，但是一般使用匿名函数只是加位置参数，其他的用不到"""
4）返回值在冒号之后设置，返回值和正常的函数一样，可以是任意数据类型
5）匿名函数不管多复杂，只能写一行，且逻辑结束后直接返回数据
- 练习1：写匿名函数：接收一个可切片的数据，返回索引为0与2的对应的元素（元组形式）
func = lambda x:(x[0],x[2])
print(func('afafasd'))
# 输出结果：
('a', 'a')
- 练习2：写匿名函数：接收两个int参数，将较大的数据返回
func = lambda x,y: x if x > y else y
print(func(3,100))
# 输出结果：
100
12. 内置函数二（重要）
12.1 print
print：屏幕输出
def print(self, *args, sep=' ', end='\n', file=None):
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件
sep: 打印多个值之间的分隔符，默认为空格
end: 每一次打印的结尾，默认为换行符
flush: 立即把内容输出到流文件，不作缓存
print(111,222,333,sep='*') # 111*222*333
print(111,end='') # 原先print默认换行，被改成了空
print(222) # 111222
f = open('log','w',encoding='utf-8')
print('写入文件',fle=f,flush=True)
12.2 list、tuple
list：将一个可迭代对象转换成列表
l1 = list('abcd')
print(l1) # ['a', 'b', 'c', 'd']
tuple：将一个可迭代对象转换成元组
tu1 = tuple('abcd')
print(tu1) # ('a', 'b', 'c', 'd')
12.3 abs
abs：返回绝对值
i = -5
print(abs(i)) # 5
12.4 sum
sum：求和
print(sum([1,2,3])) # 6
print(sum((1,2,3),100)) # 106
12.5 max、min
max：求最大值
min：求最小值（max用法与之相同）
print(min([1,2,3])) # 1 返回此序列最小值
ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值
print(ret) # 1
"""注意：加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，
然后通过你设定的返回值比较大小，返回最小的传入的那个参数"""
print(min(1,2,-5,6,-3,key=lambda x:abs(x))) # 1 可以设置很多参数比较大小
dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x])) # c 比较值得大小，输出键
"""x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键"""
12.6 reversed
reversed：将一个序列翻转，返回翻转序列的迭代器
l = reversed('你好') # l 获取到的是一个生成器
print(list(l)) # ['好', '你']
ret = reversed([1, 4, 3, 7, 9])
print(list(ret)) # [9, 7, 3, 4, 1]
12.7 zip
zip：拉链方法，函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的内容，如果各个迭代器的元素个数不一致，则按照长度最短的返回
lst1 = [1,2,3]
lst2 = ['a','b','c','d']
lst3 = (11,12,13,14,15)
for i in zip(lst1,lst2,lst3):
print(i) # 此时lst1内的元素最少，故生成三个元组
# 输出结果：
(1, 'a', 11)
(2, 'b', 12)
(3, 'c', 13)
12.8 sorted
sorted：排序函数，默认是升序（从小到大）
语法：sorted( iterable, key=None, reverse=False)
- iterable：可迭代对象
- key：排序规则(排序函数)，在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数，根据函数运算的结果进行排序
- reverse：是否倒序，True 倒序，False 正序
--------- 正常用法 ---------
lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst) # [1, 3, 2, 5, 4]
print(lst2) # [1, 2, 3, 4, 5]
lst3 = sorted(lst,reverse=True) # 倒序
print(lst3) # [5, 4, 3, 2, 1]
------ 字典使用sorted排序 ------
dic = {1:'a',3:'c',2:'b'}
print(sorted(dic)) # [1,2,3] 字典排序返回的就是排序后的key
------ 和函数组合使用 ------
lst = ['天龙八部','西游记','红楼梦','三国演义']
def func(s):
return len(s) # 计算字符串的长度
print(sorted(lst,key=func)) # ['西游记', '红楼梦', '天龙八部', '三国演义']
------ 和lambda组合使用 ------
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))
------ 列表中含字典的类型 ------
lst = [{'id':1,'name':'雨雨','age':18},
{'id':2,'name':'落落','age':17},
{'id':3,'name':'雨落','age':16},]
print(sorted(lst,key=lambda e:e['age'])) # 按照年龄对学生信息进行排序
# 输出结果:
[{'id': 3, 'name': '雨落', 'age': 16},
{'id': 2, 'name': '落落', 'age': 17},
{'id': 1, 'name': '雨雨', 'age': 18}]
12.9 filter
filter：筛选过滤
语法：filter(function, iterable)
- function：用来筛选的函数，在filter中会自动的把iterable中的元素传递给function，然后根据function返回的True或者False来判断是否保留此项数据
- iterable：可迭代对象
lst = [{'id': 1, 'name': '雨雨', 'age': 18},
{'id': 1, 'name': '落落', 'age': 17},
{'id': 1, 'name': '雨落', 'age': 16},]
ls = filter(lambda e: e['age'] > 16, lst)
print(list(ls))
# 输出结果:
[{'id': 1, 'name': '雨雨', 'age': 18},
{'id': 1, 'name': '落落', 'age': 17}]
12.10 map
map：映射函数
语法：map(function, iterable)
- 可以对可迭代对象中的每一个元素进映射，分别取执行function
------- 示例1：计算列表中每个元素的平方,返回新列表 -------
lst = [1,2,3,4,5]
def func(s):
return s*s
mp = map(func,lst)
print(mp) # <map object at 0x000002201954F9D0>
print(list(mp)) # [1, 4, 9, 16, 25]
lst = [1,2,3,4,5] # 改写成lambda
print(list(map(lambda s:s*s,lst))) # [1, 4, 9, 16, 25]
------- 示例2：计算两个列表中相同位置的数据的和 -------
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))
# 输出结果:
[3, 6, 9, 12, 15]
12.11 reduce
reduce：接收一个函数作为累加器，数组中的每个值（从左到右）开始缩减，最终计算为一个值
语法：reduce(function, iterable)
ret = reduce(func,[3,4,5,6,7])
print(ret) # [7,5,6,7] = [12,6,7] = [18,7] = 25
------- 普通函数版 -------
from functools import reduce
def func(x,y):
return x * 10 + y
l = reduce(func,[1,2,3,4])
print(l)
# 第一步：1 * 10 + 2 = 12 [12,3,4]
# 第二步：12 * 10 + 3 = 123 [123,4]
# 第三步：123 * 10 + 4 = 1234
------- lambda函数版 -------
l = reduce(lambda x,y: x * 10 + y,[1,2,3,4])
print(l)
扫一扫
1591
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
