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]

• 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())

这样就会找出所有的全局变量和局部变量。
全局变量中包括：自定义的全局变量和内置的全局变量

def outer(func):
    def inner():
        print("log")
        return func()
    return inner

@outer
def f1()
　　print("F1")

def f1():
    print(123)

def f1():
    print(456)

f1()

当执行f1的时候我们得到的结果是 456

因为函数执行有先后顺序，最后一次执行的456把之前执行的123覆盖了。

def f1():
    print(123)

def f2(arg):
    arg()

f2(f1)
结果是把f1当做整体传给了f2，f2的内部则是对这个传入的对象进行调用

结果就是执行了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=“666”

所以此时几遍上面我们定义了f1的函数，但是此时有相当于给f1重新赋值了666，所以上面定义的就没有效果了。

在用装饰器之前 f1对象内存为
<function f1 at 0x000000CE29CEF158>
执行装饰器后f1的地址则发生了改变，就证明了第3个功能
<function f1 at 0x00000014EDB80268>

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：

def outer(func):
    def inner():
        print("before")
        func()
     return inner

def outer(func):
　　def inner(arg):
　　　print("before")
　　　r = func(arg)　　　　　　　　#(arg) 就是原函数f1传过去的值
　　　print("after")
　　　return func(arg)　　　　　　　　　　　　
return outer 
　　　
@outer　　　　　　　　　　　　　
def f1(arg):
　　print(arg)
　　return arg

f1(‘F1‘)

before 
F1
after