python-内置函数、装饰器

本节内容：

一之前课程回顾：


在书写代码的时候，先写简单的逻辑在写复杂的逻辑。
概念梳理：
1、函数在传递实参的时候是传递的是引用而不是从内存中重新赋相同值给形参。
比如：

 def test(x):
     x.append()

 list_1=[,,,,]
 test(list_1)
 print(list_1)
 [, , , , ]

2、函数名带圆括号和不带圆括号。

 def test(x):
     x.append()

 list_1=[,,,,]
 a=test(list_1)
 b=test
 print(list_1)
 print(b,a)

 [, , , , ]
 <function test at 0x027117C8> None

函数名带圆括号是函数的调用，由于函数test没有返回值，所以输出None，而函数名代表的是函数体，上面是把函数体test赋值给b。
所以可以直接执行b函数和执行test函数是一样的。

 def test(x):
     x.append()
     return 'b'

 list_1=[,,,,]
 a=test(list_1)
 b=test
 print(list_1)
 print(b,a)
 res=b(list_1)
 print('this is b '+res)

 [, , , , ]
 <function test at 0x027017C8> b
 this is b b

3、函数返回值

 def test2(x):
     x.append()
 lz=[,,,]
 lz=test2(lz)
 print(lz)

 None

在函数没有返回值的时候默认是None。
4、python 中的为False：0、False、[]、{}、()、''、""。空列表、空字典、空字符创、空元组都是False.
二：内置函数
1：callable()该函数检测对象是否可以被调用。不常用这个函数。

 def test2(x):
     x.append()
 res=callable(test2)
 print(res)
 TEST=
 res_1=callable(TEST)
 print(res_1)

 True
 False

2：chr()、odr()
字母在ASCII数字表示范围，大写字母在(65-90)小写字母在（97-122）

chr()是把数字转换成对应的字母。

 a=chr()
 print(a)
 N

ord()是把对应的字母转成数字。

 b=ord('a')
 print(b)
 

应用：
我们经常在网站登录时候或者购买商品提交的时候，会有验证码的填写。那用python 如何产生随机的验证码？

 import random
 num=random.randint(,)
 num_1=random.randint(,)
 st_1=chr(num_1)
 sj=[]
 for i in range():
     m=random.randint(0,7)############需要注意的是这个，这个保证产生的验证码是随机的。如果指定的位置为数字或者字母，那就不是随机验证码。
     if m== or m==:
         sj.append(num)
     else:
         sj.append(st_1)
 print('%s%s%s%s%s%s%s'%(sj[],sj[],sj[],sj[],sj[],sj[],sj[]))

 SS6SSSS

3、python代码是如何执行呢？

模拟这个过程：

 s='print([1,2,3,])'
 t=compile(s,'','exec')##s是指可读取字符串的文件或者变量.内置函数compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)，
 exec(t)###其中‘’表示字符串（或用""），可以在引号内填写任意内容。'exec'表示执行以哪种方式执行，exec表示一系列python语句，eval表示的是表达式可以进行求值。single表示单一的语句。  [, , ]

eval():通常用在表达式上，他有返回值。返回值是该表达是的值。表达式为字符串、后者是python表达式或者经过函数compile()编译过的代码。
其中表示：The source may be a string representing a Python expression or a code object as returned by compile().

 t=eval('2+2')
 print(t)
 

 t='2*2+3'
 s=compile(t,'','eval')
 h=eval(s)
 print(h)
 

eval()可以直接接受字符串表达式。
exec()，也可以处理字符串，但是没有返回值。也可以接受经过函数compile()编译过的代码。

 t='print(2*2+3)'
 print(exec(t))

 None

以后再模板引用的时候会用到把字符串格式的代码编译执行。

上述就是html格式的转换成一个函数，并为该函数提供全局变量，然后执行该函数。
将字符串格式转换成代码格式，并执行。
dir()和help()函数，他两个都是查看函数或者类的帮助文档。只是help()查看内容更为详细。而dir只是列出有什么方法和函数。

help()

 dimovd(x,y)求商和余数。x是被除数，y是余数。返回值是商和余数的元组。常用于分页计算。

 t=divmod(,)
 print(t)
 (, )

 实例是类的具体对象，他继承了类的所有特性（函数方法等。）比如如下字符串'abc'继承str所有的方法和函数。

isinstance(object，class or type)就是判断一个对象是否一个类的的实例，返回值是True或者False.

 a='abc'
 t=isinstance(a,str)
 print(t)
 True

和type()区别：instance() 和type（） instance() 中后面是基类或者父类 返回的也是TRUE 而 type()  只是返回一个当前一个类。

filter(x,y)函数，把符合的条件可以迭代的元素 生成一个生成器，然后用相应的函数进行转换。一般做筛选使用。

 def test(x):
     if x>:
         return True
 x=[,,,,,]
 t=filter(test,x)
 print(list(t))

 [, ]

整个过程：

 def test(x):
     if x>:
         return False
     else:
         return True
 x=[,,,,,]
 t=filter(test,x)
 print(list(t))

 [, , ]

 lambda()，返回值是布尔值，可以用lambda和filter结合使用。

 x=
 test=lambda a:a>
 print(test(x))

 False

可以用2者结合。

 x=[,,,,]
 test=filter(lambda a:a>,x)
 print(list(test))
 [, ]

 map()函数是对批量的对象进行相同的操作。同样也可以和lambda结合使用。

 x=[,,,,]
 t=map(lambda a:a+,x)
 print(list(t))
 [, , , ]

len()函数计算字符长度。在不通的版本计算的方法不通，在python3中计算的是字符个数，如果在3中想计算字节的个数可以用bytes()函数转换成字节在用len()函数计算，是把字符转换成字节。在python2中计算字节的个数。

 print(len('生活'))
 print(len(bytes('生活',encoding='gbk')))
 print(len(bytes('生活',encoding='utf-8')))

max(),min(),sum函数。分别的是求最大值、最小值、求和。

 test_list=[,,,,]
 print(max(test_list))
 print(min(test_list))
 print(sum(test_list))

hash()函数将字符或者其他对象求hash值。我们接触字典的key值就是hash值存储到磁盘。而且键值是可hash的。

 print(hash('a'))
 

pow()函数是求平方。等同于**

 a=pow(,)
 print(a)
 b=**
 print(b)

 reversed()函数是反转的意思  但是并不操作原先的对象，而是生成新生成器对象，可以进行遍历的。

 test_list=[,,]
 t=reversed(test_list)
 print(t)
 print(test_list)
 for i in t:
     print(i)
 <list_reverseiterator object at 0x026701D0>
 [, , ]

而字典的reserse()函数是直接操作原先的对象，进行反转。

 test_list=[,,]
 test_list.reverse()
 print(test_list)
 [, , ]

 round()四舍五入。

 print(round(1.2))
 print(round(1.5))

sorted() 排序从小打到。之前用过排序字典的key值，来保证有序输出

 test_list=[,,,,]
 print(sorted(test_list))
 [, , , ]

 zip()函数显示2个对象的都拥有的元素元组的列列表。

 list_1=[,,,]
 list_2=[,,,]
 list_3=[,,]
 print(list(zip(list_1,list_2,list_3)))

 [(, , ), (, , )]

三：装饰器，功能在不修改类和函数的代码基础上加的额外功能。（函数可以做为实参赋值给形参。）

 USER_INFO={'evil':''}
 AUTH_DIC={
     'AUTH_FLAG':False
 }
 pre='''
 :login
 :change password'''
 def test(func):
     def prvi():
         if AUTH_DIC['AUTH_FLAG']==False:
             print('login first!')
         else:
             func()
     return prvi

 def login(username,password):
     if username=='evil'and password=='':
         print('login successful!')
         return True
     else:
         print('login fail')
 @test
 def chpass():
     new_password=input('entre new password:')
     USER_INFO['evil']=new_password
 def login_main():
     while True:
         print(pre)
         choice=input('entre your choice:')
         if choice=='':
             username=input('entre your login username:')
             password=input('entre your login password:')
             res=login(username,password)
             if res:
                 AUTH_DIC['AUTH_FLAG']=True
                 continue
             else:
                 AUTH_DIC['AUTH_FLAG']=False
                 continue
         elif choice=='':
             chpass()
             print(USER_INFO)
 login_main()

 :login
 :change password
 entre your choice:
 login first!

 :login
 :change password
 entre your choice:
 entre your login username:evil
 entre your login password:
 login successful!

 :login
 :change password
 entre your choice:
 entre new password:

上面是简单的验证权限问题，在用户没登陆之前不能做修改密码的操作，在登陆之后可以进行修改密码的操作。
装饰器的语法：

 def outer(func):            ##定义装饰器函数outer并且参数为被装饰的函数整体。
     def inner():            ##定义inner函数并做为outer函数的返回值，赋予func函数。
         print('do before')
         func()
         print('do afer')
         return True
     return inner
 @outer
 def f1():
     print(+)

 f1()

 do before

 do afer

语法:@函数名
1：自动执行outer()函数并且将下面的函数f1当做参数传递。
2：将outer函数的返回值，重新赋值给f1。
执行顺序：
aaarticlea/png;base64,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" alt="" />
python执行顺序是，从上到下，先将outer函数加载到内存，然后把函数f1加载到内存。在执行f1的时候，由于f1被outer装饰，f1作为实参赋值给outer函数的形参func,然后将outer函数的返回函数inner赋值给f1,
所以执行inner函数，因为到func()的调用时候，执行f1的旧函数的函数体，也就是7，执行完在执行第8步，如果f1有返回值，那么inner函数将返回相同的返回值。

如果函数有参数的时候，参数的对应是一一对应。
为了解决不同的被装饰的函数的参数个数问题，避免出现参数个数报错。可以用万能参数，来避免这个错误。

 def outer(func):
     def inner(*args,**kwargs):
         print('do before')
         func(*args,**kwargs)
         print('do afer')
     return inner
 @outer
 def f1():
     print(+)
 @outer
 def f2(x,y):
     print(x*y)

 f1()
 f2(,)
 do before

 do afer
 do before

 do afer

装饰器应用场景：大部分都是用来权限的验证。