python_way,day4 内置函数（callable，chr，随机验证码，ord），装饰器
python_way,day4
1、内置函数 - 下
制作一个随机验证码
2、装饰器
1、内置函数 - 下
1 callable() #对象能否被调用 2 chr() #10进制数字对应的ascii码表中的内容 3 ord() #查询对应的ascii码表中的元素的位置
chr(65) A ord(A) 65
使用random这个模块和chr（）写一个生成验证码的功能。
import random li = [] def num(): """ 生成一个随机的元素，这个元素可能是大写字母，小写字母还有数字。 :return: 随机的英文或者数字 """ b=random.randrange(0,5) #生成一个数字 if b == 2 or b == 5: #这个随机的数字如果等于2 或者 5 的时候 a = random.randrange(97,122) #a 等于 97 -- 122 之间的一个数字 small = chr(a) # 这个数字在ascii码中对应的位置是小写字母的位置 return small #返回出来 elif b == 1 or b == 6: a = random.randrange(65,90) big = chr(a) #同理，这个范围是大写字母的范围 return big else: a = random.randrange(1,10) #都不是则返回的是1-9的数字 return str(a) def auth_num(): l = [] for i in range(6): #循环6次 l.append(num()) #每次将上面生成的随机数插入到l这个 空列表中，6次后则生成了一个6位的随机数 s = "".join(l) #将列表转成字符串 return s a = auth_num() print(a)
4 compile() #编译代码
python解释器读取python文件的过程：
读取文件内容 open（） 转成str放到内存
- python如何能能知道这些str是什么语法？
python内部把字符串 -----> 编译成python认识的特殊代码 ----> 执行代码
s = "print(123)"
r = compile(s,"<string>","exec") 用来编译代码
- 如果第二位不加 <string> 前面的s就要传一个文件
print(r)
<code object <module> at 0x0000005A65327C00, file "<string>", line 1>
这个就是将s编译成为了python认识的代码
然后python再用exec（）去执行这段代码
s 这个位置也可以是一个文件
5 exec()
- exec能执行python任意的代码
- exec可以直接接受一个没有被编译的字符串直接执行。也可以接收一个编译好的对象。
exec（r）
123 # 就得到了 s 这个字符串 print 这个执行的结果了
#exec() 是能执行代码但是没有返回结果
6 eval()
- eval是只能执行一个表达式，但是他有返回结果
a = eval("1+2+3")
print(a)
6
7 dir() #获得一个类提供了那些功能
8 help() #查看帮助
9 divmode() #计算数字取余数和商数
a = divmod(100,7)
print(a)
获得一个元组（14,2）
10 isinstence() #查看一个对象是否属于某个类
s = "123"
a = isinstance(s,str)
print(a)
True
11 filter() & map()
首先先做一个需求
1 li = [11,22,33,44,55] 2 #写一个函数，只要大于33的元素 3 def f1(arg): 4 min_list = [] 5 for i in arg: 6 if i > 22: 7 min_list.append(i) 8 return min_list 9 10 a = f1(li) 11 print(a) 12 [33,44,55]
filter（）就可以实现上面的功能
- fileter（函数，可迭代对象）
li = [11,22,33,44,55]
ret = fileter(None,li)
print(list(ret)) #在python2中filter返回的模式是个list，python3中ret返回的是个对象，我们需要制定他的类型
[11,22,33,44,55]
- 由于第一个参数我们传递的是None，所以得到的结果就是传入的那个值
这是我们在None这里定义一个函数
def f1(arg):
if f1 > 22:return True
把这个函数放到 filter中
ret = filter(f2,li)
print(list(ret))
[33,44,55]
这样就能看出来：
filter是具有过滤功能的，他把第二个参数放到第一个参数中做匹配，如果是True则自定的加到ret中
这是我们就可以用lambda来写这个函数，更简便
ret = filter（lambda a:a>22,li）
print(list(ret))
[33, 44, 55]
原理：
在filter内部会循环第二个参数，然后每次循环的内部会执行第一个参数，把为真的结果的元素添加到filter的返回值中。
简单的说：函数返回True,将元素添加到结果中。
- map（）
需求：
li = [11,22,33,44,55] 每个列表中的元素 + 100
def f1(arg):
l = []
for i in arg:
i = i + 100
l.append(i)
return l
print(f1(li))
[111,122,133,144,155]
map（）就是来实现上面的功能的
map（函数，可迭代的对象）
li = [11,22,33,44,55]
ret = map(lambda:a+100,li)
print(list(ret))
[111, 122, 133, 144, 155]
原理：
map先遍历li列表中的内一个每元素，然后将这个元素放到前面的函数中去执行，并将执行结果返回出来。
简单的说：将函数的返回值添加到结果中
12 frozenset() #将一个对象编程不能变的集合。
s = {11,22,33}
ret = frozenset(s)
print(ret)
frozenset({33, 11, 22})
t = (11,11,22,33)
ret = frozenset(t)
print(ret)
frozenset({33, 11, 22})
13globals() & locals()
globals() 代表着所有的全局变量
locals（）代表着所有的局部变量
def f1():
a = 123
print(globals())
print(locals())
这样就会找出所有的全局变量和局部变量。
全局变量中包括：自定义的全局变量和内置的全局变量
2、装饰器：
def outer(func): def inner(): print("log") return func() return inner
@outer
def f1()
print("F1")
装饰器原理1：
def f1(): print(123) def f1(): print(456) f1() 当执行f1的时候我们得到的结果是 456 因为函数执行有先后顺序，最后一次执行的456把之前执行的123覆盖了。
装饰器原理2
def f1(): print(123) def f2(arg): arg() f2(f1) 结果是把f1当做整体传给了f2，f2的内部则是对这个传入的对象进行调用 结果就是执行了f1()
先说说装饰器的功能：
1、自动执行outer函数：相当于@outer是 自动执行outer()
2、将下面的函数名f1当做参数传递给outer（f1）
3、将outer函数的返回值重新赋值给f1
此时如果outer（）内部是这样的 def outer(func) pirnt(123,func)
return “111” @outer def f1(): print(123)
结果就是 123， <function f1 at 0x00000345332>
执行outer，f1函数对象被当成参数传给了func这个形参
所以就证明了上面的1、2结论
第三结论就是
当执行@outer的时候，就会把outer（）返回值重新赋值给f1
就相当于 f1=“111”
所以此时即便上面我们定义了f1的函数，但是又相当于给f1重新赋值了111，所以上面定义的就没有效果了。
在用装饰器之前 f1对象内存为
<function f1 at 0x000000CE29CEF158>
执行装饰器后f1的地址则发生了改变，就证明了第3个功能
<function f1 at 0x00000014EDB80268>
上面我们的outer 返回值时111，那么我们也可以给他返回一个函数：
def outer（func） def inner() print('before') return inner
@outer
def f1():
print('F1')
def f1(): print("123") def f2(): print(666) f1=f2 print(f1())
666 (print内容)
None (由于f2没有指定return，所以返回值为None)
一个函数体f2赋值给另一个函数体f1，执行后就相当于赋值后的函数体f2：
但是此时我们只是简单的把inner的功能赋值给了f1，我们是要把f1的功能保留并且新增加一个inner中的功能
那么我们应该怎么办？？
我们只要把返回给f1的inner中加一条引用刚刚传进outer时的f1，就可以把f1功能加进来了。
def outer(func): def inner(): print("before") func() return inner
# func就是刚刚传入的f1
#此时我们发现我们成功的将f1函数改变了。但是我们的初衷是不改变原函数，并对其效果增加功def outer(func)
def outer(func):
def inner(arg):
print("before")
r = func(arg) #(arg) 就是原函数f1传过去的值
print("after")
return f
return inner
@outer
def f1(arg):
print(arg)
return arg
f1('F1')
before
F1
after
