python之装饰器、生成器、内置函数、JSON

一、装饰器：

装饰器，器在这里的意思是函数，也就是装饰函数。作用是给其他函数添加新功能，它可以不改变原有的函数，原来的函数和原来一模一样，什么都不需要改变，只需要在函数外部加上调用哪个装饰器就可以了，装饰器的作用就是不改变原来函数的调用方式，不改变原来函数的代码，给它增加了一个新功能。但是不改变函数，给它增加新功能，那是不可能的，装饰器只不过是偷偷改变了原来的函数而已，而原来的函数不知不觉。

学习装饰器前的知识储备：

1、函数即变量，在python里面函数就是一个变量，函数名就是变量名，函数名里存着函数内存地址。它把函数体存在内存里，在调用的时候从函数名里面的内存地址来函数体运行这个函数。函数名后面加上小括号就是调用，只有函数名就是打印函数的内存地址。

def test():
    int(input('please enter you age:'))

test()
print(test)

运行结果：

please enter you age:20
<function test at 0x02A84270>

2、高阶函数，如果函数的入参为函数的话，那么这个函数就是一个高阶函数。

3、函数嵌套，函数嵌套就是在函数里再定义一个函数，而不是调用一个函数。

def A(a):

    print("I am A")

    def B(b):

        print("a+b=", a+b)

        print("I am B")

    B(2)

    print("Over!!!")

A(3)

了解以上知识后，我们来写一个简单的装饰器，用来统计函数运行时间。

import time

def fun():
    time.sleep(3)
    print('in the fun')

def test(func):
    start_time = time.time()
    func()
    stop_time = time.time()
    print('the func run time is %s' % (stop_time - start_time))

test(fun)

运行结果：

 in the fun
 the func run time is 3.007230520248413

但是这样的话，我们每次都要将一个函数作为参数传递给test1函数。改变了函数调用方式，之前执行业务逻辑时，执行运行bar()，但是现在不得不改成test1(bar)。此时就要用到装饰器。我们就来想想办法不修改调用的代码；如果不修改调用代码，也就意味着调用bar()需要产生调用test1(bar)的效果。我们可以想到将test1赋值给bar，但是test1似乎带有一个参数……想办法把参数统一吧！如果test1(bar)不是直接产生调用效果，而是返回一个与foo参数列表一致的函数的话……就很好办了，将test1(bar)的返回值赋值给bar，然后，调用bar()的代码完全不用修改！

import time

def Time(fun):

    def deco():

        start_time = time.time()

        fun()

        stop_time = time.time()

        print('the func run time is :%s'%(stop_time - start_time))

    return deco
@Time
def dos():

    time.sleep(2)

    print('in the dos')

dos()

运行结果：

in the dos
the func run time is :2.0002448558807373

这样，我们就提高了程序的可重复利用性，当其他函数需要调用装饰器时，可以直接调用。装饰器在Python使用如此方便都要归因于Python的函数能像普通的对象一样能作为参数传递给其他函数，可以被赋值给其他变量，可以作为返回值，可以被定义在另外一个函数内。

 import time

 def Timing(fun):

     def deco(*arg, **kwarg):

         start_time = time.time()

         fun(*arg, **kwarg)

         stop_time = time.time()

         print('the func run time is :%s'%(stop_time - start_time))

     return deco

 @Timing
 def tar(name, age):

     time.sleep(2)

     print('in the tar :', name, age)

 tar('hk', 18)

运行结果：

 in the tar : hk 18
 the func run time is :2.000657081604004

下面是用装饰器写的一个实例，逻辑是运行程序，打印菜单，如果选择后台管理和添加商品就判断是否登录，如果用户为登录就让用户登录；查看商品就不需要判断是否登录。

 import os
 def login():
     '''
     如果成功登录，就写入到user文件中
     :return:
     '''
     print('login')
     username = input('请输入账号：')
     password = input('请输入密码：')
     if username == 'admin' and password == '':
         print('登录成功！')
         with open('user', 'a+') as fw:
             fw.write(username)
     else:
         print('账号密码错误')

 def auth(func):
     def check(*args, **kwargs):
         if os.path.exists('user'):
             func(*args, **kwargs)
         else:
             print('未登录')
             login()
     return check
 @auth
 def admin():
     print('welcome!')

 def show():
     print('show!')

 @auth
 def add():
     print('add product')

 def menu():
     msg = '''
     1 : 后台管理
     2 : 查看商品
     3 : 添加商品
     '''
     print(msg)
     m = {
         "": admin,
         "": show,
         "": add
     }
     choice = input('请输入你的选择：').strip()
     if choice in m:
         m[choice]()
     else:
         print('输入错误！')
         menu()
 if __name__ == '__main__':
     menu()

二、生成器

生成器是个什么东东？大概可以理解为一个迭代的对象，和list类似，不过生成器是用到这个里面的数据时它才会生成。生成器是按照某种规则生成的一个列表。所以不能像list那样，直接索引取值，必须知道前一个值，才能知道后面一个值。

1、列表生成式

 list = [x*x for x in range(1,11)]

 print(list) 
 [1, 4, 6, 9, 25, 36, 49, 64, 81, 100]

2、生成器（generator）：要创建一个generator，只要把一个列表生成式的[]改成()，就创建了一个generator。

g=(x*x for x in range(1,11))

print(g)

<generator object fib at 0x033FFE10>

创建list和generator的区别就是外层的[]和(),打印generator需要使用next方法。

g = (x*x for x in range(1,11))

print(next(g))
print(next(g))
print(next(g))
print(next(g))

运行结果：

1
4
9
16

generator保存的是算法，每次调用next(g)，就计算出g的下一个元素的值，直到计算到最后一个元素，没有更多的元素时，抛出StopIteration的错误。可以使用for循环来迭代。而且不会担心Stopiteration错误。

g = (x*x for x in rang(1, 11))

for i in g:

    print(i)

运行结果：

1
4
9
16
25
36
49
64
81
100

对于比较复杂的算法，用类似列表生成式的for循环无法完成，这个时候可以使用函数来实现。

def fib(num):

    n, a, b = 0, 0, 1

    while n < num:

        print(b)

        a, b = b, a+b

        n = n+1

    return 'done'

f = fib(8)

运行结果：

1
1
2
3
5
8
13
21

上面函数和generator仅有的区别就是把print(b)变成yield b。

def fib(num):

    n, a, b = 0, 0, 1

    while n < num:

        yield b

        a, b = b, a+b

        n = n+1

    return 'done'

f = fib(8)

for i in f:

    print(i)

三、内置函数

print(any([1, 'n', 3, 4, 0]))  # 判断可迭代的对象里面是否有一个为真
print(all([1, 2, 3]))  # 判断可迭代对象里面的值知否都为真
print(bin(108))  # 十进制转为二进制
print(bool(0))  # 把一个对象转为布尔类型
print(bool(1))   # 把一个对象转为布尔类型
print(bytearray('ade', encoding='utf-8'))  # 把字符串变成一个可修改的bytes
print(callable('s'))  # 判断传入的对象是否可调用
print(chr(2))  # 数字对应的ASCII码
print(ord('A'))  # 字符串对应的ASCII码
print(dict(a=1, b=2))  # 转为字典
print(dir(2))  # 打印传入对象的调用方法
print(eval('[]'))
print(exec('def a():pass'))
print(filter(lambda x: x > 5, [12, 3, 12, 2, 1, 2, 25]))  # list里面迭代对象筛选方法为 x > 5
print(map(lambda x: x > 5, [1, 2, 3, 4, 5, 6]))
print(frozenset({1, 2, 3, 4}))  # 定义一个不可修改的集合
print(globals())  # 返回程序内的全局变量
print(locals())  # 返回程序的局部变量
print(hash('abc'))  # 把一个字符串哈希成数字
print(hex(123))  # 数字装换成16进制
print(max(111, 222))  # 取最大值
print(oct(12))  # 转换成8进制
print(round(12.345, 2))   # 取2位小数
print(sorted([1, 3, 4, 5, 2, 2, 10, 0, 23, 15]))  # 排序
dic = {1: 2, 3: 5, 4: 4, 8: 3, 6: 2}
print(sorted(dic.items()))  # 按字典key排序
print(sorted(dic.items(), key=lambda x: x[1]))  # 按字典value排序
__import__('os')

运行结果：

True
True
0b1101100
False
True
bytearray(b'ade')
False

65
{'a': 1, 'b': 2}
['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__init__', '__init_subclass__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__round__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
[]
None
<filter object at 0x008028B0>
<map object at 0x00802910>
frozenset({1, 2, 3, 4})
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x006FA470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/wgx/PycharmProjects/titled/group.py', '__cached__': None, 'a': <function a at 0x008042B8>}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x006FA470>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/wgx/PycharmProjects/titled/group.py', '__cached__': None, 'a': <function a at 0x008042B8>}
9703036
0x7b
222
0o14
12.35
[0, 1, 2, 2, 3, 4, 5, 10, 15, 23]
[(1, 2), (3, 5), (4, 4), (6, 2), (8, 3)]
[(1, 2), (6, 2), (8, 3), (4, 4), (3, 5)]

四、匿名函数

匿名函数只可以执行一次，匿名函数只能处理简单的逻辑，不能写循环判断。匿名函数定义使用lambda关键字

d = lambda x,y:x+y
print(s(1,3)

五、Json处理

import json

dic = {'name': '白夜行', 'author': '东野圭吾'}

print(json.dumps(dic))  # 将字典转换成json串

fw = open('a.json', 'w')

json.dump(dic, fw)  # 将字典转换成json串病写到一个文件里

s_json = '{"name": "hk", "age": 20, "status": true}'

print(json.loads(s_json))  # 将json串转换成字典

fr = open('b.json', 'r')

print(json.load(fr))  # 从文件中读取json串并转换成字典

运行结果：

{"name": "\u767d\u591c\u884c", "author": "\u4e1c\u91ce\u572d\u543e"}
{'name': 'hk', 'age': 20, 'status': True}
{'name': '白夜行', 'author': '东野圭吾'}