Python21期 day4（内置函数，匿名函数）

一、内置函数

什么是内置函数，就是Python内部提供的，直接能用的函数，比如input、print函数。目前Python提供了68个函数

 

1.1 作用域相关

locals：函数以字典的类型返回当前位置的全部局部变量

globals：函数以字典的类型返回全部全局变量

1.2 其他相关

 eval ：执行字符串类型的代码，并返回最终结果

eval('2 + 2')  # 4


n=81
eval("n + 4")  # 85


eval('print(666)')  # 666

exec ：执行字符串类型的代码

s = '''
for i in [1,2,3]:
    print(i)
'''
exec(s)

有返回值的字符串类型使用eval，没有返回值的字符串类型用exec

input：函数接受一个标准输入数据，返回string类型

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','w',encoding='utf-8')
print('写入文件',file=f,flush=True)

 abs：取绝对值，数据类型必须是整型

print(abs(1))
print(abs(-1))

#结果：
1
1

all（可迭代对象）返回布尔值，只要任何一个值不为真，返回False，可迭代对象为空时，返回True

print(all(''))
print(all((1,'',None,0)))
print(all(i for i in range(1,10)))


#返回结果：
True
False
True

any(可迭代对象)，返回布尔值，只要有一个值为真，返回True，可迭代对象为空时，返回False

print(any(''))
print(any([None,1,2,'']))

#返回结果
False
True

数据类型：int() 整型；str()字符串；list()列表；tuple()元祖；dict()字典；set()集合；frozenset()不可变集合

num = 1
s = 'abcd'
l = [1,2,3,4]
d = {1:1,'z':2}

d1 = dict(x=1,y=2,z='3')
print(d1)
#{'x': 1, 'y': 2, 'z': '3'}

bool 判断布尔值，返回True或False

print(bool(2>1))
print(bool(2<1))

#结果
True
False

ASCII码转换，chr() 数字转字符；ord() 字符转数字

print(chr(65))
#A
print(chr(97))
#a

print(ord('a'))
#97
print(ord('A'))
#65

divmod(int1,int2) ：两个数相除int1/int2，返回得到一个元祖（整除的值，取余的值），主要用于网页的分页

print(divmod(5,2))
#（2,1）

enumerate()：

list = ['ni', 'hao', 'ma', 'hello', 'world']
for i in enumerate(list):
    print(i)

#
(0, 'ni')
(1, 'hao')
(2, 'ma')
(3, 'hello')
(4, 'world')

eval：将字符串转换成表达式形式进行运算

eval('print(123)')
print(eval('2+2'))

#结果
123
4

exec：执行字符串类型代码

s = '''
for i in [1,2,3]:
    print(i)
'''
exec(s)

#结果
1
2
3

zip：拉链，函数将可迭代对象作为参数，，一一对应重新取值，以元祖形式输出。如果各迭代器个数不一致，以长度最短的迭代器个数返回

l = [1,2,3,4,5]
s = 'hell'
z = zip(l,s)
for i in z:
    print(i)

#结果
(1, 'h')
(2, 'e')
(3, 'l')
(4, 'l')


l1 = [1,2,3]
l2 = ['a','b','c',5]
l3 = ('*','**',(1,2,3))
for i in zip(l1,l2,l3):
    print(i)

#结果
(1, 'a', '*')
(2, 'b', '**')
(3, 'c', (1, 2, 3))

sorted()：对所有可迭代对象进行排序，默认是按升序排序，reverse= True反转，降序

sorted(iterable, key=None , reverse=False)
参数说明：
iterable：是可迭代类型;
key：传入一个函数名，函数的参数是可迭代类型中的每一项，根据函数的返回值大小排序;
reverse：排序规则. reverse = True  降序 或者 reverse = False 升序，有默认值。
返回值：有序列表


例子：
1、
l1 = [1,3,2,5,-2,-4,-6]
l2 = sorted(l1,key=abs)
print(l2)

#结果
[1,2,-2,3,-4,5,-6]


2、
l = [[1,2],[3,4,5,6],(7,),'123']
print(sorted(l,key=len))

#结果
[(7,),[1,2],'123',[3,4,5,6]]


3、
salaries={
        'egon':3000,
        'alex':100000000,
        'wupeiqi':10000,
        'yuanhao':250
    }
按用户钱的大小，输出结果：['yuanhao', 'egon', 'wupeiqi', 'alex']
匿名函数：print(sorted(salaries,key=lamba x:salaries[x]))
普通函数：
def get_value(k):
    return salaries[k]

按用户名字排序，输出结果：['alex', 'egon', 'wupeiqi', 'yuanhao']
print(sorted(salaries))

max() 返回可迭代对象最大值 ，min()返回可迭代对象最小值，sum()对可迭代对象求和计算

print(sum((1,2,3)))
print(sum([1,2,3],10))

print(max([4,9,20]))    #返回最大值
print(min([2,5,4,1]))    #返回最小值

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

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

print(max(dic,key=lambda x:dic[x]))   #x为dic的key，lambda的返回值(即dic的值进行比较)，返回最大值对应的键

map：根据提供的函数对指定序列做映射

map(func,list) 是Python内置的高阶函数，接收一个函数func和一个列表list，并通过把函数func依次作用在list的每一个元素上，得到一个新的list并返回

def square(x):
    return x**2     #计算平方数

ret = map(square,[1,2,3,4,5])
print(list(ret))
#结果
[1,4,9,16,25]

使用lambda匿名函数
ret1 = map(lambda x:x**2 ,[1,2,3,4,5])
print(list(ret1))


提供两个列表，对相同位置的列表数据相加
ret2 = map(lambda x,y:x+y,[1,3,5,7],[2,4,6,8])
print(list(ret2))
#结果
[3,7,11,15]

l = [1,2,3,4]
m = map(lambda x:x*2,l)  
print(list(m))

filter 过滤器

会有一个判断的过程，输出的结果是布尔值，会将布尔值为True的结果过滤出来

filter（）函数接收一个func和一个list，这个函数func的作用是对list每一个元素进行判断，返回True或False，filter()根据判断结果自动过滤掉不符合条件的元素，返回由符合条件元素组成的新list

def func(x):return x%2 == 0

ret = filter(func,[1,2,3,4,5,6])
print(list(ret))

#结果
[2, 4, 6]

 

二、匿名函数

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

def calc(n):
    return n**n
print(calc(10))

#匿名函数
calc = lambda n:n**n
print(calc(3))

匿名函数的格式说明：

函数名 = lambda 参数： 返回值

#参数可以有多个，用逗号隔开
#匿名函数不管逻辑多复杂，只能写一行，且逻辑执行结束后的内容就是返回值
#返回值和正常的函数一样可以是任意数据类型

练习：

现有两个元组(('a'),('b')),(('c'),('d'))，请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]


t1 = (('a'),('b'))
t2 = (('c'),('d'))
t = list(zip(t1,t2))

re = lambda t:[{i:j}for i,j in t]
print(re(t))