Python基础—内置函数（Day14）

一、内置函数

1.***eval:执行字符串类型的代码，并返回最终结果(去掉括号里面是什么就返回什么)。

print(eval('3+4')) #7
ret = eval('{"name":"laonanhai"}')
print(ret,type(ret)) #{'name': 'laonanhai'}

2.***exec:执行字符串类型的代码，流程语句(没有返回值，打印执行过程)。

ret1='''
li= [1,2,3]
for i in li:
    print(i)
'''
print(exec('3+4')) #None
print(exec(ret1)) #返回执行过程

3.***print:打印输出。

print(self ,*args, sep=' ', end='\n',file=None )

print(333,end='') # 每一次打印的结尾默认为换行符
print(666) #333666
print(111,222,333,sep='|')# 打印多个值之间的分隔符，默认为空格111|222|333

with open('log',encoding='utf-8',mode='a') as f1:
    print('555',file=f1) # 默认是输出到屏幕，如果有文件句柄，输出到文件

4.***callable:函数用于检查一个对象是否是可调用的。如果返回True,object仍然可能调用失败，但如果返回False,调用对象object绝不会成功。

def func1():
    print(555)
a = 3
f = func1
print(callable(f)) # True
print(callable(a)) # False

5.***dir:返回参数的方法

print(dir(list))

6.***sum:对可迭代对象进行求和计算（可设置初始值）

print(sum([1,2,3])) # 6
print(sum([1,2,3],100)) # 106

7.***max:返回可迭代对象的最大值（可加key,key为函数名，通过函数的规则，返回最大值）

print(max([1,2,3]))
ret = max([1,2,-5],key=abs)# -5 按照绝对值（abs）的大小返回此序列的最大值。
print(ret)

8.***min:返回可迭代对象的最小值，按照绝对值（abs）的大小返回此序列的最小值。

ret = min([1,2,-5],key=abs)
print(ret)  #1

9.***reversed:将一个序列翻转，并返回此翻转序列的迭代器。

ite = reversed(['a',2,3,'c',4,2])
print(ite)
for i in ite:
    print(i)

10.***format:用于格式化输出

s1 = format('test','<30')
print(format('test','<30'))
print(format('test','>20'))
print(format('test','^20'))
print(len(s1))

11.***repr 返回一个对象的string形式（原形毕露）repr括号里面是什么就返回什么。

print(repr('{"name":"alex"}')) #'{"name":"alex"}'
print('{"name":"alex"}') #{"name":"alex"}

12.***sorted:对所有可迭代对象进行排序。

l1 = [1, -2, 7, -8, 5]
print(sorted(l1,reverse=True,key=abs)) #[-8, 7, 5, -2, 1]

13.***enumerate:枚举(迭代器)，返回一个枚举对象(返回索引及对应的元素)。

li = ['laonanhai','alex','wusir','taibai']
print(enumerate(li))
print('__iter__' in dir(enumerate(li))) # True
print('__next__' in dir(enumerate(li))) # True
li = ['laonanhai','alex','wusir','taibai']
for k,v in enumerate(li):
    print(k,v)
执行结果：
0 laonanhai
1 alex
2 wusir
3 taibai
for k,v in enumerate(li,1):
    print(k,v)
执行结果：
1 laonanhai
2 alex
3 wusir
4 taibai

14.***zip(迭代器) 拉链方法，将可迭代的对象作为参数，将对象中对应的元素打包成一个元组，返回由这些元组组成的列表，形成元组的个数与最短的可迭代对象的长度一样。

l1 = [1, 2, 3, 4]
l2 = ['a','b','c','d','e']
l3 = ['*', '**',(1,2,3),11]
l4 = ['0','99',(1,2,3),11]
print('__iter__'in dir(zip(l1,l2,l3,l4))) #True
print('__next__'in dir(zip(l1,l2,l3,l4))) #True
for i in zip(l1,l2,l3,l4):
    print(i)

执行结果：
(1, 'a', '*', '0')
(2, 'b', '**', '99')
(3, 'c', (1, 2, 3), (1, 2, 3))
(4, 'd', 11, 11)

15.compile:将字符串类型的代码编译，代码对象能够通过exec语句来执行，或者eval来执行。

codel='for i in range(0,10):print(i)'
compilel=compile(codel,'','exec')
exec(compilel)

16.hash：获取一个对象的哈希值。

print(hash('123'))
print(hash('args'))

-4595678429660868460
4807300187244893110

17.heip：用于查看函数或模块用途的详细说明。

print(help(list))

18.next：内部实际使用了__next__方法，返回迭代器的下一个项目。

it =iter([1,2,3,4,5])
while True:
    try:
        x=next(it)
        print(x)
    except StopIteration:
        break

19.iter:函数用来生成迭代器（将一个可迭代对象，生成迭代器）。

20.int:将字符串或数字转化成整型。

21.float将整数或字符串转换成浮点型。

22.complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。

23.bin:将十进制转换成二进制并返回。

24.october：将十进制转换成八进制字符串并返回。

25.hex：将十进制转换成十六进制字符串并返回。

26.abs：返回数字的绝对值。

print(abs(-10)) #10

27.divmod：计算除数与被除数的结果，返回一个包含商和余数的元组

print(divmod(11,3)) #3,2

28.round：保留浮点数的小数位数，默认保留整数。

print(round(3.1415,2)) #3.14

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

print(pow(2,3)) #8
print(pow(2,3,5)) #3

30.slice：构造一个切片对象，用于列表的切片。

li = ['a','b','c','c','d','e']
sli_obj = slice(3)
print(li[sli_obj]) # ['a', 'b', 'c']
sli_obj = slice(6,0,-2)
print(li[sli_obj]) #['e', 'c', 'b']

31.bytes：不同编码之间的转换，将unicode转化成非unicode。

32.bytearry：返回一个新字节数组，这个数组例的元素是可变的，并且每个元素的值范围0<=x<256。

ret = bytearray('alex',encoding='utf-8')
print(id(ret)) #144623497488
print(ret) #bytearray(b'alex')

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

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

35.ascii:是ascii码中的返回该值，不是就返回

36.all：可迭代对象中全都是True才是True。

37.any：可迭代对象中有一个True就是True。

print(all([1,2,True,0])) #False
print(any([1,'',0])) #True

38.filter()函数接收一个函数f和一个list，list的每个元素作为参数传递给函数f进行判断，返回true或false，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list。

例如，要从一个list [1, 4, 6, 7, 9, 12, 17]中删除偶数，保留奇数，首先，要编写一个判断奇数的函数：

def is_odd(x):
    return x % 2 == 1

然后利用filter()过滤掉偶数：

filter(is_odd, [1, 4, 6, 7, 9, 12, 17])
结果：[1, 7, 9, 17]

39.map()函数接收一个函数f和一个list,并把函数f一次作用在list的每一个元素上，得到一个新的list返回。

例如，对于list [1, 2, 3, 4, 5, 6, 7, 8, 9]，如果希望把list的每一个元素都做平方，就可以用map()函数名

def f(x):
    return x*x

print map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
输出结果：[1, 4, 9, 16, 25, 36, 49, 64, 81]

注：利用map()函数，可以把一个 list 转换为另一个 list，只需要传入转换函数。

由于list包含的元素可以是任何类型，因此，map() 不仅仅可以处理只包含数值的 list，事实上它可以处理包含任意类型的 list，只要传入的函数f可以处理这种数据类型。

40.reduce()函数接收的参数和map()函数类似，一个函数并返回f,一个list,单行为和map()不同，reduce()传入的函数f必须接收两个参数，reduce()对list的每个元素反复调用函数f， 并返回最终的结果值。

例如，编写一个f函数，接收x,y两个参数，返回x和y的和：

def f(x,y):
    return x + y

reduce(f,[1,3,5,7,9])

调用 reduce(f,[1,3,5,7,9])时，reduce()函数做如下计算：

先计算头两个元素：f(1, 3)，结果为4；
再把结果和第3个元素计算：f(4, 5)，结果为9；
再把结果和第4个元素计算：f(9, 7)，结果为16；
再把结果和第5个元素计算：f(16, 9)，结果为25；
由于没有更多的元素了，计算结束，返回结果25。

reduce()还可以接收第3个可选参数，作为计算的初始值。如果把初始值设为100，结果将变为125

reduce(f, [1, 3, 5, 7, 9], 100)

使用lambda函数写法：reduce(lambda x,y:x+y,[1,3,5,7,9])

备注：python3中，reduce()函数已经被从全局名称空间中移除，它现在被放置在 fucntools 模块  里，如果想要使用它，则需要通过引入 functools 模块来调用 reduce() 函数：

from functools import reduce

def add(x,y):
    return x + y

print (reduce(add, range(1, 101)))

二、匿名函数

为了解决那些功能很简单的需求而设计的一句话函数。

函数名 = lambda 参数： 返回值

func = lambda x:x**2
print(func(5)) #25
func1 = lambda x,y:x+y
print(func1(2,3)) #5

lambda函数与内置函数的结合：

dic={'k1':10,'k2':20,'k3':30}
print(max(dic,key=lambda x: dic[x])) #k3
print(dic[max(dic,key=lambda x: dic[x] )]) #30

# print(dic[max(dic,key=lambda x: dic[x] )]) #30
res = map(lambda x:x**2,[1,4,8])
for i in res:
    print(i) #1 16 64

l1 = [1,2,3,11,12,40,20,50,79]
def func(x):
    return x > 10
ret = filter(lambda x:x >10,l1)
for i in ret:
    print(i)

lambda后面可以加三元运算符

func = lambda x,y:x if x > y else y
print(func(4,2)) #4