三元表达式、各种生成式、匿名函数、常见重要内置函数、常见内置函数
学习内容总结
今日学习内容汇总
在昨日的学习中，我们了解到多层语法糖的本质，递归函数的使用，以及算法的一定了解。而今日的学习内容，复杂的不多，主要是方法多。能让我们的代码更简洁。
三元表达式
三元表达式，推荐在二选一时使用。代码示例：
# 编写一个求两个数大小的函数
def index(x, y):
if x > y:
return x
else:
return y
# 我们加上函数的定义，用了五行代码实现这个功能。
# 三元表达式
x = 10
y = 11
print(x) if x > y else print(y) # 11
# 除了定义变量，我们只用简短的一句代码就实现了，这就是三元表达式
三元表达式的写法就是：值1 if 条件 else 值2，条件如果成立则使用值1(if前面的数据)，条件如果不成立则使用值2(else后面的数据)。所以三元表达式适合二选一的写法。
各种生成式
列表生成式
将列表中所有的人名后面加上 NB
a_list = ['jason', 'Tom', 'jack']
# 之前的学习实现该功能
b_list = []
for name in a_list:
res = name + ' NB'
b_list.append(res)
print(b_list) # ['jason NB', 'Tom NB', 'jack NB']
# 列表生成式
res = [name + ' NB' for name in a_list]
print(res) # ['jason NB', 'Tom NB', 'jack NB']
# 列表生成式可以简化代码，也可以不用，无外乎写的复杂一点而已。其中列表生成式的复杂用法还具备筛选功能
res = [name + ' NB' for name in a_list if name == 'Tom']
print(res) # ['Tom NB']
字典生成式
将两个列表分别制作成字典的键值
a1 = ['name', 'age', 'hobby']
a2 = ['jason', 18, 'run']
# 用之前的方法实现
new_dict = {}
for i in range(len(a1)):
new_dict[a1[i]] = a2[i]
print(new_dict) # {'name': 'jason', 'age': 18, 'hobby': 'run'}
# 字典生成式
res = {a1[i]: a2[i] for i in range(len(a1))}
print(res) # {'name': 'jason', 'age': 18, 'hobby': 'run'}
# 当然，字典生成式也可以筛选
res = {a1[i]: a2[i] for i in range(len(a1)) if i == 1}
print(res) # {'age': 18}
集合生成式
直接代码示例：
res = {i for i in range(10)}
print(res, type(res)) # {0, 1, 2, 3, 4, 5, 6, 7, 8, 9} <class 'set'>
匿名函数
匿名函数的意思就是没有函数名，需要结合其他函数一起使用。匿名函数不需要显示地定义函数名，使用[lambda + 参数 +表达式]的方式代码示例：
# 原函数写法
def f(x,y):
return x*y
f(2,3) # 6
# 匿名函数
func = lambda x, y: x * y # 我们把匿名函数对象赋给一个变量，只要直接调用该对象就可以使用匿名函数
print(func(2, 3)) # 6
匿名函数的优点。1.不用取名称，因为给函数取名是比较头疼的一件事，特别是函数比较多的时候，2.可以直接在使用的地方定义，如果需要修改，直接找到修改即可，方便以后代码的维护工作，3.语法结构简单，不用使用def 函数名(参数名):这种方式定义，直接使用lambda 参数:返回值 定义即可
常见重要内置函数
map映射
# 元素自增x
a = [11, 22, 33, 44]
# 方法1 列表生成式
res = [name + 10 for name in a]
print(res) # [21, 32, 43, 54]
# 方法2 内置函数
def index(n):
return n + 10
res = map(index,a)
print(list(res)) # [21, 32, 43, 54,]
res = map(lambda x: x + 10, a)
print(list(res)) # [21, 32, 43, 54]
zip拉链
# 将两个列表中的元素一一对应成对即可
a = [11, 22, 33 ,44]
b = ['jason', 'Tom', 'jack']
res = zip(a, b)
print(res) # <zip object at 0x0000020A2B802908> 这是一个迭代器。想查看内部元素需要用list转换
print(list(res)) # [(11, 'jason'), (22, 'Tom'), (33, 'jack')]
# zip可以整合多个数据集 如果数据集之间个数不一致 那么依据短的
filter过滤
a = [11, 22, 33, 44, 55, 66, 77]
# 筛选出大于45的元素
# 方法1 列表生成式
res = [name for name in a if name > 45]
print(res) # [55, 66, 77]
# 方法2 filter过滤
def index(x):
return x > 45
res = filter(index, a)
print(list(res)) # [55, 66, 77]
res = filter(lambda x: x > 45, a)
print(list(res)) # [55, 66, 77]
reduce归总
# 以前是内置函数 现在是某个模块下面的子函数
# 列表中所有的元素相加
from functools import reduce
a = [11, 22, 33]
def index(x,y):
return x + y
res = reduce(index,a)
print(res) # 66
# 匿名函数写法
res = reduce(lambda x, y: x + y, a)
print(res) # 66
常见内置函数
获取绝对值
print(abs(-1)) # 1
print(abs(3)) # 3
all()与any()
all：判断可迭代对象的每个元素是否都为True值。any：判断可迭代对象的元素是否有为True值的元素。
a = [0, 1, 0, True]
print(all(a)) # False
print(any(a)) # True
bin() oct() hex()
产生对应的进制数
print(bin(100)) # 0b1100100 将整数转换成2进制字符串
print(oct(100)) # 0o144 将整数转化成8进制数字符串
print(hex(100)) # 0x64 将整数转换成16进制字符串
bytes()
类型转换
a = 'jason 牛逼'
print(bytes(a, 'utf8')) # b'jason \xe7\x89\x9b\xe9\x80\xbc'
callable()
判断当前对象是否可以加括号调用
a= 'jason'
def index():pass
print(callable(a)) # False 变量名不能加括号调用
print(callable(index)) # True 函数名可以加括号调用
chr()、ord()
字符与数字的对应转换。chr：返回整数所对应的Unicode字符。ord：返回Unicode字符对应的整数
print(chr(65)) # A 根据数字转字符 依据ASCII码
print(ord('A')) # 65 根据字符转数字 依据ASCII码
dir()
返回数据类型可以调用的内置方法(查看对象内部可调用的属性)
print(dir(10))
print(dir('jason'))
divmod()
函数把除数和余数运算结果结合起来，返回一个包含商和余数的元组
print(divmod(7, 2)) # (3, 1)
# 这种方法可以使用在网页的分页制作上
def get_page_num(total_num,page_num): # 后面django分页器使用
more,others = divmod(total_num, page_num)
if others:
more += 1
print('需要%s页'%more)
get_page_num(1000,30) # 需要34页
enumerate()
# 枚举
a= ['jason', 'Tom', 'Jack']
for name in a:
print(name)
for i,j in enumerate(a):
print(i,j) # i类似于是计数 默认从0开始
for i,j in enumerate(a,start=1):
print(i,j) # 还可以控制起始位置
eval() exec()
识别字符串中的python代码,使用频率很低。区别：
eval函数：计算指定表达式的值。也就是说它要执行的Python代码只能是单个运算表达式（注意eval不支持任意形式的赋值操作），而不能是复杂的代码逻辑，这一点和lambda表达式比较相似。
exec函数：动态执行Python代码。也就是说exec可以执行复杂的Python代码，而不像eval函数那么样只能计算一个表达式的值。
eval()函数只能计算单个表达式的值，而exec()函数可以动态运行代码段。
eval()函数可以有返回值，而exec()函数返回值永远为None。
res = """
for i in range(10):
print(i)
"""
eval(res) # 报错 （SyntaxError: invalid syntax）
exec(res) # 可以正常执行
课堂练习
import time
a = [1, 123, 465, 457, 555, 666, 777, 778, 779, 805, 1000] # 查找一个数，666
def outer(func):
def start(*args, **kwargs):
start_time = time.time()
res = func(*args, **kwargs)
end_time = time.time()
print(end_time - start_time)
return res
return start
@outer
def findup(a, lookup):
if len(a) == 0: # 考虑没有你找的数据的情况，列表a可能无限制的二分
print('没有该数据')
return
res = len(a) // 2 # 获取中间元素的索引值,只能是整数
if lookup > a[res]: # 判断中间索引对应的数据与目标数据的大小
find_res = a[res + 1:]
print(find_res)
findup(find_res, lookup) # 对右侧进行再次二分，重复执行相同代码，并且复杂程度降低
elif lookup < a[res]: # 判断中间索引对应的数据与目标数据的大小
look_res = a[:res]
print(look_res)
findup(look_res, lookup) # 对左侧进行再次二分，重复执行相同代码，并且复杂程度降低
else:
print('有该数据', lookup)
findup(a, 666) # 有该数据 666 0.0
浙公网安备 33010602011771号