python内置函数及匿名函数

locals  本地作用域/局部作用域 会随着位置的改变而改变
globals 全局作用域           永远不变 永远是全局

 1 a = 1
 2 b = 2
 3 print(locals())
 4 print(globals())
 5 def func():
 6     c = 3
 7     d = 4
 8     print(locals())
 9 def func2():
10     l1 = []
11     d1 = {}
12     print(locals())     #无论在哪里打印 得到的都是全局作用域中的名字
13 func()
14 func2()
15 结果
16 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2}
17 {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x000001CE3C83A470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'E:/PyPractise/day11.py', '__cached__': None, 'a': 1, 'b': 2}
18 {'d': 4, 'c': 3}
19 {'d1': {}, 'l1': []}

range(起始位置,终止位置,步长)
range(终止位置)
range(起始,终止位置)

1 range(5)        #0,1,2,3,4
2 range(5,0,-1)   #5,4,3,2,1
3 range(1,10,2)   #1,3,5,7,9

iter  创建迭代器和__iter__一样

1 迭代器 = 可迭代的.__iter__()
2 迭代器 = iter(可迭代的)

next    执行迭代器和__next__一样

1 print(net(迭代器))
2 带双下划线的魔术方法一般情况下不直接用
3 带双下划线的所有的方法都可能和内置的函数有千丝万缕的联系

print(要打印的内容1,要打印的内容2,sep = '分隔符',end = '结束符',file=file.txt, flush=False)
file:  默认是输出到屏幕,如果设置为文件句柄,输出到文件
sep:   打印多个值之间的分隔符,默认为空格
end:   每一次打印的结尾,默认为换行符
flush: 立即把内容输出到流文件,不作缓存(默认缓存)
#print的本质,就是写文件,这个文件是pycharm的屏幕

 1 print(123,'abc',sep='|',end='@')
 2 print('www')
 3 结果：
 4 123|abc@www
 5 
 6 事例二
 7 f = open('file','w')
 8 print(123,'abc',file=f,flush=True)
 9 f.close()
10 
11 案例:打印进度条
12 import time   #导入别人写好的代码
13 def func():
14     for i in range(0,101,2):
15         time.sleep(0.1)     #每一次在这个地方阻塞0.1s
16         char_num = i//2     #控制输出长度
17         if i == 100:
18             per_str = '
%s%% : %s
' % (i, '*' * char_num)     # %% 转义%，
换行符
19         else:
20             per_str = '
%s%% : %s' % (i, '*' * char_num)
21         print(per_str,end = '')     #per_str,end = ''格式化输出去除print末尾的默认换行符
,不换行打印
22 func()
23 print('下载完成')

input('字符串数据类型的参数,提醒用户你要输入的内容')

1 python2
2     input() 还原你输入的值的数据类型
3     raw_input = py3.input
4 python3
5     input() 输入的所有内容都是字符串类型
6     阻塞: 等待某件事情发生,如果不发生一直等着
7 input的返回值就是用户输入的内容
8     输入的内容 = input('提示')

hash函数

 1 哈希: 可哈希(不可变数据类型),不可哈希(可变数据类型)
 2 哈希是一个算法,导致了字典的快速寻址
 3 所有的数据要想得到不变的hash值,必须是一个不可变的数据类型
 4 字符串通过hash复杂的算法,得到一个数字
 5 数字算出来就是数字本身
 6 print(id('呵呵'))
 7 print(hash(12345))
 8 结果：
 9 2655670439144
10 12345

id函数
获取到的是内存地址

1 print(id('呵呵'))
2 结果
3 2076687142120

open('文件名')打开一个文件,返回一个文件操作符(文件句柄)

1 操作文件的模式有r,w,a,r+,w+,a+ 共6种
2 每一种方式都可以用二进制的形式操作(rb,wb,ab,rb+,wb+,ab+)
3 encoding指定编码：默认是操作系统的默认编码

dir函数: 特殊的需求/研究或者了解一个新的数据类型/面向对象之后会介绍新的数据类型

1 print(dir(list)) #查看列表内置方法
2 print(dir(123))

help() 帮助你了解python的

1 方式一
2 输入help() 进入帮助页面,输入数据类型,帮助我们打印具体的帮助信息
3 输入q退出帮助
4 
5 方式二
6 print(help(str))
7 print(help('abc'))

callable() 判断某一个变量是否可调用(True/False)

 1 def call(arg):
 2     if callable(arg):
 3         arg()
 4     else:
 5         print('参数不符合规定')
 6 def func():
 7     print('in func')
 8     return 1
 9 func2 = 1234
10 call(func)
11 call(func2)
12 print(callable(func))
13 print(callable(func2))
14 结果
15 in func
16 参数不符合规定
17 True
18 False

bool
int
float
complex 复数

 1 实数 (有理数和无理数) :世界上存在的数
 2 虚数 : j
 3 某一个数的平方是-1 ,那么这个数就是一个虚数的基础单位 j
 4 复数 = 实数+虚数 = a+bj
 5 选择题 :(对你的数学有要求的公司都会考)
 6     复数不能比较大小
 7     共轭复数 : a+bj 和 a-bj是一对共轭复数
 8     a+bj 和 a+bJ都是复数
 9 c = 1+2J
10 print(type(c))
11 结果
12 <class 'complex'>

bin二进制没有2, oct八进制没8, hex十六进制没有16

1 逢二进一是二进制
2 逢八进一是十进制
3 逢十六进一是十六进制
4 0 1 2 3 4 5 6 7 8 9 A B C D E F
5 
6 a=256
7 print(bin(a))     # 0b100000000 0b代表二进制,100000000 = 256
8 print(oct(a))     # 0o400 0o代表八进制,400 = 256
9 print(hex(a))     # 0x100 十六进制

abs 求绝对值,正数的绝对值是正数,负数的绝对值也是正数

1 print(abs(5))
2 print(abs(-5))

sum(可迭代的数字集,start),start从哪个数开始加

 1 print(sum(range(10)))       #1+2+3+……9+10
 2 print(sum((i**2 for i in range(5))))    #1+4+9+16
 3 print(sum((1,2,3,4)))       #1+2+3+4
 4 print(sum([1,2,3,4]))
 5 print(sum((1,2,3,4)))
 6 print(sum((1,2,3,4),10))    #1+2+3+4+10
 7 print(sum((1,2,3,4),30))
 8 结果
 9 45
10 30
11 10
12 10
13 10
14 20
15 40

min/max(iterable/*args,key)
key是一个函数的内存地址,key做的事情就是根据你对每一项数据大小的需求来排序

 1 print(min(1,2,3))
 2 print(min((1,2,3)))
 3 print(min((1,2,3),(4,5,6)))
 4 print(min((7,2,3),(7,5,6)))
 5 结果
 6 1
 7 1
 8 (1, 2, 3)
 9 (7, 2, 3)
10 
11 事例1
12 def func(n):    # n = 2,3,4,7
13     return n%6  # 2,3,4,1
14 ret = min(2,3,4,7,key = func)
15 print(ret)
16 结果
17 7
18 
19 事例2
20 根据每一个元组的和来计算max或者min
21 l = [(7,2,3),(4,5,6),(-1,20,5)]
22 print(max(l,key = sum))   # sum((7,2,3))
23 结果：
24 (-1, 20, 5)
25 
26 案例
27 max函数 找到股价最高的那个字典
28 l中的每一项都会作为参数传给func
29 max和min的求值会根据func的返回值来排序
30 l = [{'name1':10},{'name2':500}]
31 def max(iter,key = None):            # 内置的max   iter = [{'name1':10},{'name2':500}] , key = func
32     ret = 0                          # ret = 0
33     max_value = 0                    # max_value = 0
34     if key:                          # key = func
35         for i in iter:               # iter = [{'name1':10},{'name2':500}]
36             print(key(i),max_value)  # i = {'name1':500}  key(i) = func({'name1':500}) = 500,max_value = 10
37             if key(i) > max_value:   # 500>10
38                 max_value = key(i)   # max_value = 500
39                 ret = i              # ret ={'name1':500}
40     return ret
41 
42 def func(dic):             #  {'name1':10}
43     for k in dic:
44         return dic[k]      # 10
45 print(max(l,key = func))
46 print(min(l,key = func))
47 结果：
48 10 0
49 500 10
50 {'name2': 500}
51 {'name1': 10}

divmod 商余函数(计算商和余数)

1 主要应用: 翻页功能
2 print(divmod(10,3))
3 print(divmod(7,4))
4 print(divmod(8,3))
5 结果
6 (3, 1)
7 (1, 3)
8 (2, 2)

round(小数,保留几位小数)  小数精确
整数是奇数 -> 正常四舍五入
整数是偶数 -> 五舍六入

 1 2.x(完全的四舍五入)和3.x(更精准的计算方式)不同
 2 print(round(2.3258358))
 3 print(round(2.3253358,2))
 4 print(round(2.3254358,3))
 5 print(round(1.5))
 6 print(round(2.5))
 7 print(round(2.6))
 8 结果
 9 2
10 2.33
11 2.325
12 2
13 2
14 3

pow(x,y,z=1) 幂运算/幂余运算 x的y次方%z

 1 print(pow(2,3))
 2 print(pow(3,2))
 3 print(pow(5,3,2))
 4 print(pow(4,2,2))
 5 print(pow(4,3,2))
 6 结果
 7 8
 8 9
 9 1
10 0
11 0

list
tuple

reversed  返回一个迭代器,节省内存
reversed 不修改原基础: 不直接返回列表而返回迭代器,为了不占用更多的内存
reverse 是在原基础上修改: 2000项的列表,不会产生额外的内存占用

 1 l = [1,2]
 2 l.reverse()
 3 print(l)
 4 结果：
 5 [2, 1]
 6 
 7 ret = reversed([1,2,3])  # iterator可迭代的
 8 print(ret)
 9 print(list(ret))
10 结果：
11 <list_reverseiterator object at 0x0000024B9ECEEC88>
12 [3, 2, 1]
13 
14 lst = ["河南", "四川", "东北", "山东", "上海"]
15 r = reversed(lst)
16 print(list(r))
17 结果
18 ['上海', '山东', '东北', '四川', '河南']
19 
20 s= "不是上海自来水来自海上"
21 print(s[::-1])
22 it = reversed(s)
23 s2 = ''
24 for i in it:
25     s2 += i
26 print(s2)
27 结果：
28 上海自来水来自海上是不
29 上海自来水来自海上是不

slice  切片

1 l = [1,2,3,4,5,]
2 ret = slice(1,4)   # [1:4]
3 print(l[ret])
4 等于
5 print(l[1:4])
6 结果：
7 [2, 3, 4]
8 [2, 3, 4]

format(填充)

 1 print(format('test', '<20'),'alex')
 2 print(format('test', '>20'),'alex')
 3 print(format('test', '^20'),'alex')
 4 结果：
 5 test                 alex
 6                 test alex
 7         test         alex
 8 
 9 进制转换
10 print(format(3, 'b'))   # 转换成二进制  binary  0b11
11 print(format(65, 'c'))  # 转换成unicode字符  ascii
12 print(format(11, 'o'))  # 转换成八进制  0o    13
13 print(format(11, 'x'))  # 转换成十六进制(小写字母)
14 print(format(11, 'X'))  # 转换成十六进制(大写字母)
15 print(format(11, 'd'))  # 转换成十进制
16 print(format(11, 'n'))  # 和d一样
17 print(format(11))       # 和d一样
18 结果
19 11
20 A
21 13
22 b
23 B
24 11
25 11
26 11
27 
28 科学计数法
29 print(format(123456789, 'e'))   # 科学计数法,默认保留6位小数,表示大的数据
30 print(format(123456789, '.2e')) # 科学计数法,保留2位小数(小写)
31 print(format(123456789, '0.2E'))# 科学计数法,保留2位小数(大写)
32 结果
33 1.234568e+08
34 1.23e+08
35 1.23E+08
36 
37 浮点计数法
38 print(format(1.23456789, 'f'))    # 浮点数计数法,保留6位小数
39 print(format(1.23456789, '0.2f')) # 小浮点数计数法,保留2位小数
40 print(format(1, '0.10f'))         # 小浮点数计数法,保留10位小数
41 print(format(1.23456789e+10000, 'F')) # 小浮点数计数法
42 结果
43 1.234568
44 1.23
45 1.0000000000
46 INF        #无穷大

bytes 字节
网络上传输的数据: bytes
文件的存储: wb 写字节 rb 读字节 图片视频都是字节
网络 + 文件: wb / rb

 1 str --> bytes
 2     print('abc'.encode('utf-8'))
 3     print('你好'.encode('utf-8'))
 4 bytes --> str
 5     b = b'xe4xbdxa0xe5xa5xbd'
 6     print(b.decode('utf-8'))
 7 结果：
 8 b'abc'
 9 b'xe4xbdxa0xe5xa5xbd'
10 你好

bytearray
把一个字符串编程一个字节数组,较长的字符串的修改节省内存,修改行为必须依靠编码

1 ret = bytearray('abc'*30,encoding='utf-8')  # 字节数组
2 print(ret)
3 ret[0] = 102   # assice码  65A 97a bcdef 你好 您好
4 print(ret)

memoryview 忘记吧

1 print(memoryview(bytes('hello,eva',encoding='utf-8')))
2 结果：
3 <memory at 0x0000026B858B8048>

ord/chr  字符和编码之间的转换

1 print(ord('中'))
2 print(chr(20013))
3 结果
4 20013
5 中
6 
7 查看计算机中所有的字符
8 for i in range(65536):
9     print(chr(i), end= " ")

repr() 还原字符串最官方的效果

 1 转义字符
 2 
 换行
 3 	 tab 制表符
 4 
 回车
 5 "   双引号
 6 '  单引号
 7 \    
 8 print('hello\n world')
 9 结果
10 hello
 world
11 
12 还原字符串最官方的效果
13 print(repr('hello\n world'))
14 结果
15 'hello\n world'
16 
17 原封不动的显示字符串
18 print(r'hello\n wo	rld')
19 结果
20 hello\n wo	rld

len 计算长度

1 print(len('abc'))
2 结果
3 3

enumerate 枚举函数

 1 lst = ['姓名','年龄','职业']
 2 for i in range(len(lst)):
 3     print(i,lst[i])
 4 等于
 5 for k,v in enumerate(lst):
 6     print(k,v)
 7 结果
 8 0 姓名
 9 1 年龄
10 2 职业
11 
12 for i in enumerate(['a','b','c'],9):    #可以指定索引起始位置
13     print(i)
14 结果：
15 (9, 'a')
16 (10, 'b')
17 (11, 'c')
18 
19 案例
20 goods_lst= [
21     {'name':'电脑','price':1999},
22     {'name':'鼠标','price':20},
23     {'name':'美女','price':20},
24 ]
25 
26 for good in goods_lst:
27     print(goods_lst.index(good)+1,good['name'],good['price'])
28 同等
29 for good in enumerate(goods_lst,1):
30     # print(good)
31     index = good[0]
32     dic = good[1]
33     name = dic['name']
34     price = dic['price']
35     print(index,name,price)
36 同等
37 #index,dic = (1, {'name': '电脑', 'price': 1999})  # 解构
38 for index,dic in enumerate(goods_lst,1):
39     print(index,dic['name'],dic['price'])
40 结果：
41 1 电脑 1999
42 2 鼠标 20
43 3 美女 20

all就是bool值(and),参数iterable,只要有一个为假返回False

1 print(all((1,2,3,True)))
2 print(all((1,2,3,0,True)))
3 print(all((1,2,3,True,[])))
4 print(all((1,2,3,True,'')))
5 结果
6 True
7 False
8 False
9 False

any就是bool值(or),参数iterable,只要有一个为真返回True

1 print(any((1,2,3,True)))
2 print(any((1,2,3,0,True)))
3 print(any((1,2,3,True,[])))
4 print(any(({},False,0,[],'')))
5 结果
6 True
7 True
8 True
9 False

zip 拉链函数,返回迭代器-节省内存,水桶效应

 1 a = (1,2,3,4)
 2 b = ('a','b','c')
 3 c = ['111','222']
 4 d = {'k1':'v1','k2':'v2'}
 5 ret = zip(a,b,c,d)
 6 print(ret)
 7 
 8 for i in ret:
 9     print(i)
10 结果：
11 <zip object at 0x0000023ECB077108>
12 (1, 'a', '111', 'k1')
13 (2, 'b', '222', 'k2')

匿名函数
定义
匿名函数的内存地址 = lambda 参数1,参数2 : 返回值/返回值的表达式
调用
接收返回值 = 匿名函数的内存地址(参数)

 1 def定义的函数: 都是有名字的,def后面写的就是函数名
 2 def qqxing():
 3     print('qqxing')
 4 func = qqxing
 5 func2 = qqxing
 6 print(qqxing.__name__)
 7 print(func.__name__)    #内置属性,通过执行的函数名返回定义的函数名
 8 print(func2.__name__)
 9 结果
10 qqxing
11 qqxing
12 qqxing
13 
14 事例2
15 def exe(func):
16     func()
17     print('执行%s函数了'%func.__name__)
18 def qqxing():
19     print('qqxing')
20 def wahaha():
21     print('wahaha')
22 exe(wahaha)
23 exe(qqxing)
24 结果
25 wahaha
26 执行wahaha函数了
27 qqxing
28 执行qqxing函数了
29 
30 
31 匿名函数没有名字,统一的名字是:<lambda>,别称: lambda表达式
32 定义一个很简单的函数,复杂的函数不要用lambda
33 def func(a,b):
34     return a + b
35 ret = func(1,2)
36 print(ret)
37 
38 fn = lambda a,b:a + b
39 ret = fn(5,6)
40 print(ret)
41 print(fn)
42 结果
43 3
44 11
45 <function <lambda> at 0x0000027766AD98C8>
46 使用场景: 配合着sorted,map,filter一起使用
47 
48 事例2
49 qqxing = lambda n:n**2
50 print(qqxing.__name__)
51 ret = qqxing(8)
52 print(ret)
53 结果
54 <lambda>
55 64
56 
57 事例3
58 f = lambda *args:sum(args)
59 ret = f(1,2,3)
60 print(ret)
61 执行结果
62 6
63 
64 事例4
65 dic = {'k1':10,'k2':100,'k3':30}
66 m = max(dic,key=lambda k:dic[k])
67 print(m)
68 同等
69 def func(k):
70     return dic[k]
71 m = max(dic,key=func)
72 print(m)
73 结果
74 k2
75 
76 接收两个参数,返回较大值(不用max内置函数)
77 f1 = lambda a,b : max(a,b)
78 f2 = lambda a,b : a if a>b else b

sorted() 排序,根据key对应的函数的返回值的大小来排序的
由于必须要知道后面的值是谁,才能排出顺序,所以结果就是排序后的结果而不是可迭代的
按照字符串长度排序
执行流程: 把可迭代对象中的每一项拿出来, 作为参数传递给后面key函数,函数返回数字,根据数字进行排序

 1 lst = ['关谷神奇','吕小布','诺兰','山口美惠子','易']
 2 def func(s):
 3     return len(s)
 4 ret = sorted(lst,key=func)
 5 print(ret)
 6 同等
 7 print(sorted(lst,key=lambda s:len(s)))
 8 结果：
 9 ['易', '诺兰', '吕小布', '关谷神奇', '山口美惠子']
10 
11 事例2
12 lst = [
13     {"name":"bob", "shengao":150, "tizhong":250},
14     {"name":"jary", "shengao":158, "tizhong":150},
15     {"name":"jack", "shengao":177, "tizhong":130},
16     {"name":"pique", "shengao":165, "tizhong":130},
17     {"name":"alice", "shengao":160, "tizhong":120},
18     {"name":"athena", "shengao":183, "tizhong":190}
19 ]
20 按照体重进行排序
21 按照身高进行排序
22 print(sorted(lst,key=lambda dic:dic['tizhong']))
23 print(sorted(lst,key=lambda dic:dic['shengao']))
24 
25 
26 事例3
27 l = [-3,1,2]
28 l.sort()
29 print(l)
30 def func(n):
31     return abs(n)
32 l.sort(key = func)
33 print(l)
34 结果
35 [-3, 1, 2]
36 [1, 2, -3]
37 
38 事例4
39 l = [1,-3,2]
40 new_l = sorted(l)   #在不改变原列表的情况下 生成一个新列表
41 print(l)
42 print(new_l)
43 def func(n):
44     return abs(n)
45 ret = sorted(l,key = func)
46 print(ret)
47 结果
48 [1, -3, 2]
49 [-3, 1, 2]
50 [1, 2, -3]
51 
52 事例5
53 按照每一个字典中商品的价格从高到低排列
54 l = [{'name':'电脑','price':1999},{'name':'鼠标','price':2000}]
55 def func(dic):
56     return dic['price']
57 l.sort(key=func,reverse=True)
58 print(l)
59 同等
60 new_l = sorted(l,key = func,reverse= True)
61 print(new_l)
62 结果:
63 [{'name': '鼠标', 'price': 2000}, {'name': '电脑', 'price': 1999}]

filter 筛选

 1 过滤掉名字结尾带刚字的人
 2 把可迭代对象打开,把内部元素一个一个的传递给前面的函数,由这个函数决定此项是否保留
 3 lst = ['旭日阳刚','金毛狮王','李刚','张杰']
 4 f = filter(lambda name:not name.endswith('刚'),lst)
 5 print(f)
 6 print(list(f))
 7 结果：
 8 <filter object at 0x00000206FCB37208>   #可迭代对象
 9 ['金毛狮王', '张杰']
10 
11 事例2
12 lst = [
13     {"name":"bob", "shengao":150, "tizhong":250},
14     {"name":"jary", "shengao":158, "tizhong":150},
15     {"name":"jack", "shengao":177, "tizhong":130},
16     {"name":"pique", "shengao":165, "tizhong":130},
17     {"name":"alice", "shengao":160, "tizhong":120},
18     {"name":"athena", "shengao":183, "tizhong":190}
19 ]
20 ret = filter(lambda a:a['tizhong'] < 180,lst)
21 print(list(ret))
22 结果：
23 [{'name': 'jary', 'shengao': 158, 'tizhong': 150}, {'name': 'jack', 'shengao': 177, 'tizhong': 130}, {'name': 'pique', 'shengao': 165, 'tizhong': 130}, {'name': 'alice', 'shengao': 160, 'tizhong': 120}]
24 
25 事例3
26 ret = filter(None,[1,2,3,0,False])  #只保留真的
27 print(ret)
28 for i in ret:
29     print(i)
30 结果：
31 <filter object at 0x000002BD91BCEBA8>
32 1
33 2
34 3
35 
36 事例4
37 def func(i):
38     if i % 2 != 0:
39         return True
40 l = [1, 4, 6, 7, 9, 12, 17]
41 for i in filter(func,l):  # 迭代l,每一个元素作为参数传给func,如果func的返回值为True,那么l中的这个元素就保留
42     print(i)
43 结果：
44 1
45 7
46 9
47 17
48 
49 事例5
50 def func(i):
51     if type(i) is not dict:     #判断i类型不是dict的就返回True
52         return True
53 同等
54 def func(i):
55     return type(i) is not dict
56 
57 l = ['sjkdhf',[1,2,3],{},()]    #去掉列表中的字典,用filter
58 ret = filter(func,l)
59 print(list(ret))
60 结果：
61     ['sjkdhf', [1, 2, 3], ()]
62 
63 # filter 就像 带着if条件的列表推导式
64     l = ['sjkdhf',[1,2,3],{},()]
65     print([i for i in l if type(i) is not dict])

map 映射函数
一个迭代器中的每一个元素都需要去做同一个操作并返回一个结果组成一个新列表的时候map来处理

 1 lst = ['关谷神奇','吕小布','诺兰','山口美惠子','易']
 2 m = map(lambda s:'姓名:'+s,lst)
 3 print(m)
 4 for i in m:
 5     print(i)
 6 结果：
 7 <map object at 0x000001B76BAA7208>
 8 姓名:关谷神奇
 9 姓名:吕小布
10 姓名:诺兰
11 姓名:山口美惠子
12 姓名:易
13 
14 事例2
15 列表中的每一个值的平方组成的新列表
16 lst = [1,5,78,12,16]
17 m = map(lambda i:i**2,lst)
18 print(list(m))
19 同等
20 print([i**2 for i in lst])
21 同等
22 lst = [1,5,78,12,16]
23 def func(num):
24     return num**2
25 ret = map(func,lst)
26 print(list(ret))
27 结果：
28 [1, 25, 6084, 144, 256]
29 
30 事例3
31 def func(i):
32     return i*'*'
33 ret = map(func,[1,2,3])
34 print(ret)
35 for i in ret:
36     print(i)
37 结果：
38 <map object at 0x0000024AEBB4ECC0>
39 *
40 **
41 ***

eval() 有返回值,可以将字符串数据类型的python代码执行,通过拼接字符串的方式来执行不同的代码--简化代码
evalexec这个函数,不能直接操作文件当中读进来的,从网络上传进来,用户输入的

 1 eval('print(1+2+3+4)')  #返回10
 2 ret = eval('1+2/3*4')
 3 print(ret)              #有返回值
 4 结果：
 5 10
 6 3.6666666666666665
 7 
 8 事例2
 9 code = input("请输入你要执行的代码:")
10 ret = eval(code)
11 print(ret)
12 
13 事例3
14 把字符串类型的代码还原回字典, 列表, 元组
15 s = "{'name':'bob', 'age':18, 'isMan':False}"   #字符串
16 ret = eval(s)   #侧重的有返回值
17 print(ret)
18 print(type(ret))
19 结果：
20 {'name': 'bob', 'age': 18, 'isMan': False}
21 <class 'dict'>
22 
23 事例4
24 with open('测试文件.txt','r',encoding='utf=8')as f:
25     content=f.read()
26     print(content,type(content))
27     print(eval(content),type(eval(content)))
28     print(eval(content)[0])
29 结果：
30 [{'id':1},{'name':'alex'}] <class 'str'>
31 [{'id': 1}, {'name': 'alex'}] <class 'list'>
32 {'id': 1}
33 
34 将普通字符串'<'转换成<小于
35 def func(f):
36     if eval('33 %s 20'%f):
37         print('符合条件')
38     else:
39         print('不符合条件')
40 if '>':
41     func('>')
42 if '<':
43     func('<')

exec() 没有返回值,执行字符串类型的代码,不能太长,不能太乱

 1 code = input("请输入你要执行的代码")
 2 exec(code)  # 没有返回值. 想要返回值用eval
 3 print(a)    # pycharm报错不一定准
 4 结果：
 5 请输入你要执行的代码a=3+4+9
 6 16
 7 
 8 事例2
 9 exec('print(1+2+3+4)')  # 没有返回值,想要返回值用eval
10 ret = exec('1+2/3*4')
11 print(ret)              #没有返回值None
12 exec('for i in range(3):print(i)')
13 执行结果
14 10
15 None
16 0
17 1
18 2

compile编译  
把要执行的代码先预编译,能够节省时间工具,通过exec和eval可以执行我们的代码
参数说明:
resource 要执行的代码,动态代码⽚片段
文件名,代码存放的文件名,当传入了第一个参数的时候,这个参数给空就可以了
模式,取值有3个
    exec: 一般放一些流程语句句的时候
    eval: resource只存放一个求值表达式.
    single: resource存放的代码有交互的时候,mode应为single

 1 先编译 python -编译-> 字节码(bytes) -解释-> 机器码 0101010100101
 2 先整体编译
 3 code1 = 'for i in range(0,3): print (i)'   #这是一个字符串代码
 4 
 5 事例1
 6 流程语句使用exec
 7 compile1 = compile(code1,'','exec')     #预编译 python-> 字节码
 8 exec (compile1)  #解释
 9 exec (compile1)
10 exec(code1)     #编译+解释
11 结果：
12 0
13 1
14 2
15 0
16 1
17 2
18 0
19 1
20 2
21 
22 事例2
23 简单求值表达式用eval
24 code2 = '1 + 2 + 3 + 4'
25 compile2 = compile(code2,'','eval')
26 print(eval(compile2))
27 结果：
28 10
29 
30 事例3
31 交互语句用single
32 code3 = 'name = input("please input your name:")'
33 compile3 = compile(code3,'','single')
34 exec(compile3)
35 print(name)
36 结果：
37 please input your name:linux
38 linux

 练习题

 1 l3 = [{'name':'alex','age':83},{'name':'wusir','age':38}]
 2 # 1.找到年龄大于40的值  filter
 3 def func(dic):
 4     return dic['age']>40
 5 ret = filter(lambda dic:dic['age']>40,l3)
 6 print(list(ret))
 7 结果：
 8 [{'name': 'alex', 'age': 83}]
 9 
10 2.将列表中的项按照年龄从小到大排序 sorted
11 def func(dic):
12     return dic['age']
13 ret = sorted(l3,key=lambda dic:dic['age'])
14 print(ret)
15 结果
16 [{'name': 'wusir', 'age': 38}, {'name': 'alex', 'age': 83}]
17 
18 3.给列表中的每一个人的年龄+1  #lambda 并不能取代函数
19 def func(dic):
20     dic['age'] += 1
21     return dic
22 ret = map(lambda dic:{'name':dic['name'],'age':dic['age']+1},l3)
23 print(list(ret))
24 结果：
25 [{'name': 'alex', 'age': 84}, {'name': 'wusir', 'age': 39}]
26 
27 # 4.给列表中名叫alex的人的年龄+1  三元运算符+字典拼接
28 
29 现有两个元组(('a'),('b')),(('c'),('d'))，
30 请使用python中匿名函数生成列表[{'a':'c'},{'b':'d'}]
31 t1 = (('a'),('b'))
32 t2 = (('c'),('d'))
33 print(t1,t2)
34 ret = zip(t1,t2)
35 def func(tup):
36     return {tup[0]:tup[1]}
37 map(func,ret)
38 iterator1 = map(lambda tup:{tup[0]:tup[1]} ,ret)
39 print(list(iterator1))
40 执行结果：
41 ('a', 'b') ('c', 'd')
42 [{'a': 'c'}, {'b': 'd'}]