python函数之内置函数

内置函数

匿名函数

定义：没有名字的函数
匿名函数的构建：

匿名函数只能构建简单的函数，一句话函数
```
func = lambda x,y: x+y
print(func(1,2))
# 3
```

匿名函数最常用的就是与内置函数结合使用

# 写匿名函数：接收一个可切片的数据，返回索引为 0与2的对应的元素（元组形式）。
func = lambda li : (li[0],li[2])
print(func([1,2,3]))
# (1, 3)

# 写匿名函数：接收两个int参数，将较大的数据返回。
func = lambda x,y: x if x>y else y
print(func(2,3))
# 3

内置函数Ⅰ（了解）

eval exce

# eval 剥去字符串的外衣，返回里面的本质
s1 = "{1: 'alex'}"
ret = eval(s1)
print(ret,type(ret)) # {1: 'alex'} <class 'dict'>
########
s2 = '1 + 3'
print(eval(s2)) # 4
########
s3 = input('>>>') #输入1+2
print(eval(s3)) #

# exec 代码流，过程。
s3 = '''
for i in range(3):
    print(i)
'''
exec(s3) # 0 1 2

hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
```
print(hash(123214134)) #123214134
print(hash('fkljdsaklgjdfs')) #6499605431360755377
```
help：函数用于查看函数或模块用途的详细说明。
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
```
name = 'alex'
def func():
    pass
print(callable(name))  # False
print(callable(func))  # True
```

int：函数用于将一个字符串或数字转换为整型。

print(int())  # 0
print(int('12'))  # 12
print(int(3.6))  # 3
print(int('0100',base=2))  # 将2进制的 0100 转化成十进制。结果为 4

float：函数用于将整数和字符串转换成浮点数。
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(7,2))  # (3, 1)
```
round：保留浮点数的小数位数，默认保留整数。
```
print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
```

pow：求x**y次幂。（三个参数为x的y次幂的结果对z取余）

print(pow(2,3))  # 两个参数为2**3次幂
print(pow(2,3,3))  # 三个参数为2**3次幂，对3取余。

bytes：用于不同编码之间的转化。

s = '你好'
bs = bytes(s,encoding='utf-8')
print(bs)

ord:输入字符找该字符编码的位置

print(ord('a')) # 97
print(ord('中')) # 20013

chr:输入位置数字找出其对应的字符

print(ord(97)) # 'a'
print(ord(20013)) # '中'

repr:返回一个对象的string形式（原形毕露）。

# %r  原封不动的写出来
# name = 'taibai'
# print('我叫%r'%name) # 我叫'taibai'
# repr 原形毕露
print(repr('{"name":"alex"}')) # '{"name":"alex"}'
print('{"name":"alex"}') # {"name":"alex"}

all：可迭代对象中，全都是True才是True
```
   print(all([1,2,True,0])) #     False
```
any：可迭代对象中，有一个True 就是True
```
   print(any([1,'',0])) # Ture
```

内置函数Ⅱ（重点）

print() 屏幕输出。

print(111,222,333,sep='*')  # 111*222*333
print(111,end='')
print(222)  #两行的结果 111222
f = open('log','w',encoding='utf-8')
print('写入文件',fle=f,flush=True)

int()、str()、bool()、set()、tuple()

list() 将一个可迭代对象转换成列表

l1 = list('abcd')
print(l1)  # ['a', 'b', 'c', 'd']

dict() 通过相应的方式创建字典。

li = ['盖伦', '德邦', '皇子', '剑圣']
print({i:li[i] for i in range(len(li))})
# {0: '盖伦', 1: '德邦', 2: '皇子', 3: '剑圣'}

abs() 返回绝对值
```
i = -5
print(abs(i))  # 5
```

sum() 求和

print(sum([1,2,3])) # 6
print(sum((1,2,3),100)) # 106   100为起始值

min() 求最小值

print(min([1,2,3]))  # 返回此序列最小值
ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
print(ret)
# 加key是可以加函数名，min自动会获取传入函数中的参数的每个元素，然后通过你设定的返回值比较大小，返回最小的传入的那个参数。
print(min(1,2,-5,6,-3,key=lambda x:abs(x)))  # 可以设置很多参数比较大小

dic = {'a':3,'b':2,'c':1}
# 将dic值最小的键返回。
# 将dic值最小的值返回。
print(min(dic,key=lambda x:dic[x])) # c x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键
print(dic[min(dic,key=lambda x:dic[x])]) # 1 对键取值

dic = {'a':['铁憨憨',67],'b':['碎小梦', 95],'c':['逆小寒', 85]}
# 将成绩最低的从属于的那个列表返回。
# 将成绩最低的分数返回。
print(dic[min(dic,key=lambda x:dic[x][1])]) # ['铁憨憨', 67]
print(dic[min(dic,key=lambda x:dic[x][1])][1]) # 67

max() 最大值与最小值用法相同。

reversed() 将一个序列翻转, 返回翻转序列的迭代器

l = reversed('你好')  # l 获取到的是一个生成器
print(l) # <reversed object at 0x00000147D4178780>
print(list(l)) # ['好', '你']

zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,

然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回，
```
li = [1,2,3,4]
s = 'hjk'
dic = {1:'德玛',2:'盖伦',3:'草丛伦'}
for i in zip(li,s,dic):
    print(i)  #以元素个数最小的为准,字典返回的是键
# (1, 'h', 1) 
# (2, 'j', 2)
# (3, 'k', 3)
```

sorted排序函数

语法:sorted(iterable,key=None,reverse=False)

li = [12,43,23,56,13]
print(sorted(li)) # [12, 13, 23, 43, 56]
print(sorted(li,reverse=True)) # [56, 43, 23, 13, 12]

# 对字典使用返回的是排序后的key
dic = {'信手斩龙':99,'赝品':80,'奥里奥':90,'残雪':98}
print(sorted(dic,key=lambda x:dic[x]))
# ['赝品', '奥里奥', '残雪', '信手斩龙']

# 按照列表中每一项的分数排序
l1 = [{'id':'信手斩龙','评分':99}, {'id':'奥里奥','评分':90}, {'id':'赝品','评分':80}, {'id':'残雪','评分':98}]
print(sorted(l1,key=lambda x:x['评分']))
# [{'id': '赝品', '评分': 80}, {'id': '奥里奥', '评分': 90}, {'id': '残雪', '评分': 98}, {'id': '信手斩龙', '评分': 99}]

filter筛选过滤，与生成器的筛选模式类似

语法: filter(function,iterable)

function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返

回的True或者False来判断是否保留此项数据

# 筛选出评分在90以下的
l1 = [{'id':'信手斩龙','评分':99}, {'id':'奥里奥','评分':90}, {'id':'赝品','评分':80}, {'id':'残雪','评分':98}]
print(filter(lambda x: x['评分'] > 90,l1))
# <filter object at 0x000001F8531F9A20> 直接用filter()产生的是一个迭代器
print(list(filter(lambda x: x['评分'] > 90,l1))) # 通过list()对其进行取值
# [{'id': '信手斩龙', '评分': 99}, {'id': '残雪', '评分': 98}]

map映射函数

语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别取执行function

# 计算列表中每个元素的平方,返回新列表
lst = [1,2,3,4,5]
print(map(lambda x:x**2,lst))
# <map object at 0x000001E17B879828>
print(list(map(lambda x:x**2,lst)))
#[1, 4, 9, 16, 25]

reduce

reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推.
```
from functools import reduce
l = reduce(lambda x,y:x+y,[1,2,3,4])
print(l) # 10
li = reduce(lambda x,y:x+y,['ab','c'])
print(li) # abc
```

python函数之内置函数

内置函数

猜你喜欢