2.4-内置函数,匿名函数
目录
- 内置函数,匿名函数
- 内置函数
- 比较重要-----------------------------------------------------------
- eval 执行字符串类型的代码,返回最终结果
- exec 执行字符串类型的代码
- hash 获取一个对象(可哈希对象:int,str, book, tuple)的哈希值
- help 函数用于查看函数或模块用途的详细说明
- callable 检查对象是否可调用
- int 将一个字符串或数字转换成整型
- float 用于将整数和字符串转化成浮点数
- complex 创建一个值为real +imag * j 的复数,或转化一个字符串或数为复数
- bin 将十进制转化成二进制并返回
- oct 将十进制转化成八进制并返回
- hex 将十进制转化成十六进制并返回
- divmod 计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)
- round 保留浮点数的小数位数,默认保留整数
- pow 求x ** y次幂(三个参数为x**y的结果对z取余)
- bytes 不同编码之间的转化
- ord 输入字符找该字符编码的位置
- chr 输入位置数字找其对应的字符
- repr 返回一个对象的string形式
- all 可迭代对象中,全都是True才是True
- 重要---------------------------------------------------------------------
- pring 屏幕输出
- int pass
- str pass
- bool pass
- set pass
- list 将可迭代对象转化成列表
- tuple 将可迭代对象转化成元组
- sum 求和
- min 最小值
- max 最大值,用法和min相同
- reversed 将一个序列翻转,返回翻转序列的迭代器
- bytes 把字符串转成bytes类型
- zip 拉链方法
- sorted 排序函数
- filter 筛选过滤
- map 映射函数
- reduce
- 匿名函数
- 内置函数
内置函数,匿名函数
内置函数
函数是以功能为导向,一个函数封装一个功能,python将一些常用的功能封装成一个个函数,供我们使用(效率高(底层是c语言)),而且拿来即用,避免重复造轮子。这些函数就称为内置函数,目前为止,python一共提供了68个内置函数
了解:
all() any() bytes() callable() chr() complex() divmod() eval() exec() format() frozenset() globals() hash() help() id() input() int() iter() locals() next() oct() ord() pow() repr() round()
重要:
abs() enumerate() filter() map() max() min() open() range() print() len() list() dict() str() float() reversed() set() sorted() sum() tuple() type() zip() dir()
其他:
classmethod() delattr() getattr() hasattr() issubclass() isinstance() object() property() setattr() staticmethod() super()
比较重要-----------------------------------------------------------
eval 执行字符串类型的代码,返回最终结果
print(eval('2 + 2')) # 4
n = 88
print(eval('n + 1')) # 89
eval('print(777)') # 777
exec 执行字符串类型的代码
s = '''
for i in [1, 2, 3]:
print(i)
'''
exec(s)
hash 获取一个对象(可哈希对象:int,str, book, tuple)的哈希值
print(hash(123))
print(hash('123'))
print(hash('aaa'))
print(hash(True))
print(hash(False))
print(hash((1, 2, 3)))
# 123
# 3891538836099095335
# 907318982906182040
# 1
# 0
# 2528502973977326415
help 函数用于查看函数或模块用途的详细说明
print(help(list))
callable 检查对象是否可调用
# 如果返回True, object仍然可能调用失败;但如果返回False,调用对象object肯定不会成功
name = '黑色利穆'
def func():
pass
print(callable(name)) # False
print(callable(func)) # True
int 将一个字符串或数字转换成整型
print(int()) # 0
print(int('123')) # 123
print(int(4.6)) # 4
print(int('0100', base=2)) # 4 二进制转化成十进制
float 用于将整数和字符串转化成浮点数
print(float(3)) # 3.0
complex 创建一个值为real +imag * j 的复数,或转化一个字符串或数为复数
# 如果第一个参数为字符串,则不需要指定第二个参数
print(complex(1, 2)) # (1+2j)
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'>
divmod 计算除数与被除数的结果,返回一个包含商和余数的元组(a // b, a % b)
print(divmod(9, 4)) # (2, 1)
round 保留浮点数的小数位数,默认保留整数
print(round(7/3, 2)) # 2.33
print(round(7/3)) # 2
print(round(3.1415926, 4)) # 3.1416
pow 求x ** y次幂(三个参数为x**y的结果对z取余)
print(pow(2, 3)) # 8
print(pow(2, 3, 3)) # 2
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')
print(b) # b'\xc4\xe3\xba\xc3'
b1 = b.decode('gbk')
print(b1) # 你好
print(b1.encode('utf-8')) # b'\xe4\xbd\xa0\xe5\xa5\xbd'
ord 输入字符找该字符编码的位置
print(ord('a')) # 97
print(ord('利')) # 21033
chr 输入位置数字找其对应的字符
print(chr(97)) # a
print(chr(21033)) # 利
repr 返回一个对象的string形式
# %r 原封不动的写出来
name = '黑色利穆'
print('我叫%r'%name) # 我叫'黑色利穆'
# repr 原形毕露
print(repr('{"name":"黑色利穆"}')) # '{"name":"黑色利穆"}'
print('{"name":"黑色利穆"}') # {"name":"黑色利穆"}
all 可迭代对象中,全都是True才是True
print(all([1, 2, True, 0])) # False
```python
### any 可迭代对象中,有一个True就是True
```python
print(any([1, '', 0])) # True
重要---------------------------------------------------------------------
pring 屏幕输出
''' 源码分析
def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
"""
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(222) # 111222
f = open('log', mode='w', encoding='utf-8')
print('写入文件', file=f,flush=True)
int pass
str pass
bool pass
set pass
list 将可迭代对象转化成列表
l1 = list('abcd')
print(l1) # ['a', 'b', 'c', 'd']
tuple 将可迭代对象转化成元组
```python
tu = tuple('abcd')
print(tu) # ('a', 'b', 'c', 'd')
### dict 将可迭代对象转化成字典
### abs 返回绝对值
```python
i = -8
print(abs(i)) # 8
sum 求和
print(sum([1, 2, 3])) # 6
print(sum((1,2,3), 100)) # 106
min 最小值
print(min([1,2,3])) # 1
ret = min([-7, 2, -3,], key=abs) # 按照绝对值的大小,返回此序列最小值
print(ret)
# 加key是可以加函数名,min自动回获取传入函数中的参数的每个元素,然后通过设定的返回值比较大小,返回最小的传入的那个参数
print(min(1,2,-4,5,-6,key=lambda x:abs(x))) # 1 可以设置很多参数比较大小
dic = {'a':1, 'b':2, 'c':3}
print(min(dic,key=lambda x:dic[x]))
# x为dic的key,lambda的返回值(即dic的值进行比较)返回最小的值对应的键
max 最大值,用法和min相同
reversed 将一个序列翻转,返回翻转序列的迭代器
l = reversed('你好') # 获取到一个生成器
print(list(l)) # ['好', '你']
ret = reversed([1, 2, 3, 4, 5, 6])
print(list(ret)) # [6, 5, 4, 3, 2, 1]
bytes 把字符串转成bytes类型
s = '黑色利穆'
bs = s.encode('utf-8')
print(bs) # b'\xe9\xbb\x91\xe8\x89\xb2\xe5\x88\xa9\xe7\xa9\x86'
s1 = bs.decode('utf-8')
print(s1) # 黑色利穆
bs = bytes(s, encoding='utf-8') # 字符串转成字节
print(bs) # b'\xe9\xbb\x91\xe8\x89\xb2\xe5\x88\xa9\xe7\xa9\x86'
s1 = str(bs, encoding='utf-8') # 字节转成字符串
print(s1) # 黑色利穆
zip 拉链方法
# 用于将可迭代对象作为参数,将对象中对应的元素打包转成一个个元组;
# 然后返回由这些元组组成的内容,如果各个迭代器的元素个数不一致,按长度最短的返回
lst1 = [1, 2, 3]
lst2 = ['a', 'b', 'c', 'd']
lst3 = (4, 5, 6, 7, 8, 9)
for i in zip(lst1, lst2, lst3):
print(i)
# (1, 'a', 4)
# (2, 'b', 5)
# (3, 'c', 6)
sorted 排序函数
# 语法:sorted(iterable, key=None, reverse=False)
# iterable 可迭代对象
# key 排序规则,在sorted内部会将可迭代对象的每一个元素传递给这个函数的参数,根据函数运算的结果进行拍粗
# reverse 是否倒序,True倒序,False正序
lst = [1,2,3,6,5,4]
lst2 = sorted(lst)
print(lst) # [1, 2, 3, 6, 5, 4]
print(lst2) # [1, 2, 3, 6, 5, 4]
lst3 = sorted(lst, reverse=True)
print(lst3) # [6, 5, 4, 3, 2, 1]
# 字典排序
dic = {1:'a', 3:'c', 2:'b', 4:'d'}
print(sorted(dic)) # [1, 2, 3, 4] # 返回排序后的key
# 和函数组合使用
# 定义一个列表,根据元素长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
# 计算字符串长度
def func(s):
return len(s)
print(sorted(lst, key=func)) # ['西游记', '红楼梦', '天龙八部', '三国演义']
# 和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst, key=lambda s:len(s), reverse=True)) # ['天龙八部', '三国演义', '西游记', '红楼梦']
lst = [{'id':1,'name':'xiaoming','age':18},
{'id':2,'name':'xiaohong','age':17},
{'id':3,'name':'xiaozhang','age':16},]
# 按照年龄对学生信息进行排序
print(sorted(lst, key=lambda s:s['age']))
# [{'id': 3, 'name': 'xiaozhang', 'age': 16}, {'id': 2, 'name': 'xiaohong', 'age': 17}, {'id': 1, 'name': 'xiaoming', 'age': 18}]
filter 筛选过滤
# 语法 filter(function, iterable)
# function 用来筛选函数,在filter中自动把iterable中的元素传递给funciton
# 然后根据function返回的True或者False判断是否保留此项数据
# iterable 可迭代对象
lst = [{'id':1,'name':'xiaoming','age':18},
{'id':2,'name':'xiaohong','age':17},
{'id':3,'name':'xiaozhang','age':16},]
print(list(filter(lambda s:s['age'] > 16, lst)))
# [{'id': 1, 'name': 'xiaoming', 'age': 18}, {'id': 2, 'name': 'xiaohong', 'age': 17}]
map 映射函数
# 语法 map(function, iterable)
# 可以对可迭代对象中的每一个元素进行映射,分别去执行function
# 计算列表中每个元素的平方,返回新列表
lst = [1,2,3,4,5]
def func(s):
return s*s
print(list(map(func, lst)))
# [1, 4, 9, 16, 25]
# 改写成lambda
lst = [1,2,3,4,5]
print(list(map(lambda s:s*s, lst)))
# [1, 4, 9, 16, 25]
# 计算两个列表中相同位置的数据的和
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]
reduce
# reduce的作用是先把列表中的前两个元素取出计算出一个值然后临时保存;
# 用临时保存的值和列表中第三个元素进行计算,求出䘝新的值覆盖上一步临时保存的值;
# 然后用这个新的和第四个元素进行计算,一次类推
# reduce使用方法:reduce(函数名, 可迭代对象)
from functools import reduce
def func(x,y):
return x + y
ret = reduce(func, [1,2,3,4,5,6])
print(ret) # 21
# 先有[2,3,4,5]想让列表中的数编程2345,使用reduce
# 普通版
def func(x, y):
return x * 10 + y
# step1:x=2,y=3 ,2*10+3=23,23临时保存
# step2:x=23,y=4,23*10+4=234,234临时保存
# step3:x=234,y=4,234*10+5=2345,返回
print(reduce(func, [2,3,4,5])) # 2345
# 匿名函数版
print(reduce(lambda x,y:x*10+y, [2,3,4,5])) # 2345
# python2中reduce可以直接import,python3需要从functools这个包中导入
匿名函数
匿名函数,没有名字的函数。lambda(一句话函数)
def func(a, b):
return a+b
print(func(3,4))
# 用匿名函数完成上面函数
func = lambda a,b: a+b
print(func(3,4))
语法:
- 函数名 = lambda 参数: 返回值
- 此函数不是没有名字,名字就是设置的变量,比如func
- lambda是定义匿名函数的关键字,相当于函数的def
- lambda后面直接加形参,形参加多少都可以,只用逗号隔开就行
- 返回值在冒号之后设置,返回值和正常的函数一样,可以是任意数据类型
- 匿名函数不管多复杂,只能写一行,且逻辑结束后直接返回数据
func = lambda a,b,*args,sex='女',c,**kwargs: kwargs
print(func(3,4,c=5,name='hslm')) # {'name': 'hslm'}
练习:
# 写匿名函数,接收一个可切片数据,返回索引为0与2的对应的元素(元组形式)
func = lambda x:(x[0], x[2])
print(func('黑色利穆'))
# ('黑', '利')
# 写匿名函数:接收两个int参数,将较大的数据返回
func = lambda x,y:x if x > y else y
print(func(1, 2))