NO.4：自学python之路------内置方法装饰器迭代器

Posted 2020-11-06 猛男落泪

引言

　　是时候开始新的Python学习了，最近要靠英语，可能不会周更，但是尽量吧。

正文

内置方法

　　Python提供给了使用者很多内置方法，可以便于编程使用。这里就来挑选其中大部分的内置方法进行解释其用途。

　　abs() #求取绝对值，例子。

a = -5
abs(a)#求绝对值

　　all() #迭代对象全为真，则返回Ture，否则返回False，例子。

all([1,5,6])#True
all([5,0,6])#False

　　any() #与all类似，但是有真则返回Ture，全假返回False，例子。

any([0,0,-1])#True
any([0,0,0])#False

　　ascii() #将格式转换为字符串，例子。

ascii(‘你好‘)

　　bin() #十进制数转换为二进制，例子。

bin(15)

　　bool() #与all类似，判断单个真假，例子。

bool(0)#False
bool(other)#True

　　bytes() #转换为byte型，转换后的字符不可修改，例子。

a = bytes(‘abcdd‘,encoding=‘utf-8‘)
print(a[0])#97

　　bytearray() #与bytes类似，但可以修改，例子。

a = bytearray(‘abcdd‘,encoding=‘utf-8‘)
a[0] = 66

　　callable() #判断函数能否调用，例子。

callable(abs)#True
callable(tensorflow.rnn)#False

　　chr() #返回ascii码对应的字符，同理ord()可以返回字符对应的ascii码，例子。

chr(97)#a
ord(‘a‘)#97

　　compile() #字符串编译为可执行代码，source:字符串或者AST对象，filename:代码文件名称,mode:指定编译代码的种类。exec类型，表示这是一个序列语句，可以进行运行；eval类型，表示这是一个单一的表达式语句，可以用来计算相应的值；single类型，表示这是一个单一语句，采用交互模式执行，例子。

code = ‘1+2+3+4‘
a = compile(code,‘‘,‘eval‘)
eval(a)

　　dir() #查看有什么方法，例子。

a = 5
dir(a)

　　divmod() #返回商和余数，(c,d) = divmod(a,b)表示a/b=c余d，例子。

divmod(5,2)#(2,1)

　　filter() #与匿名函数结合，实现过滤，例子。

a = filter(lambda n:n>5,range(10))
for i in a:
    print(i)

　　map() #与filter不同，是将所有值传入匿名函数，例子。

a = map(lambda n:n,range(10))
for i in a:
    print(i)

　　题外 reduce() #可以实现累加，累乘，例子。

import functools
a = functools.reduce(lambda x,y:x+y,range(10))#45

　　frozenset() #不可变集合，例子。

frozenset(‘123abc‘)

　　globals() #打印返回当前运行环境下的全局符号表字典，例子。

globals()

　　hash() #字符串与数字的映射关系，即哈希值，例子。

hash(‘蛤蛤‘)#6313981968308522494

　　help() #查看帮助，例子。

help(hash)

　　hex() #10进制转16进制，例子。

hex(35)

　　max() #返回列表中的最大值，相反也有min()，例子。

max([1,2,3,4])#4
min([1,2,3,4])#1

　　oct() #10进制转8进制，例子。

oct(17)

　　pow() #求次方，a = pow(b,c)即 a = b^(c)，例子。

pow(2,3)#8

　　round() #保留某位小数，例子。

round(1.2345,2)#1.23

　　slice() #切片，用途与‘:’重叠，例子。

a = range(10)
a[slice(2,5)]

　　sorted() #将字典转换为列表，并排序，例子。

a = {6:‘a‘,7:‘b‘,10:‘c‘,2:‘d‘}
sorted(a.items())#按Key排序
sorted(a.items(),key = lambda x:x[1])#按value排序

　　zip() #组合列表为新的元组，例子。

a = [1,2,3,4]
b = [‘a‘,‘b‘,‘c‘,‘d‘]
for i in zip(a,b):
    print(i)

　　__import__() #import字符方法，例子。

__import__(‘os‘)

装饰器

　　装饰器的本质是一个函数，功能为装饰其他函数。它可以在不修改被装饰函数源代码以及被装饰函数的调用方式的前提条件下，为被装饰函数增加其他功能。

　　装饰器的实现主要依靠：1.函数也是一种变量；2.高阶函数；3.嵌套函数。

函数即变量

　　函数也是一种变量，可以靠赋值的方法赋给其他变量名，例子。

def a():
    print(‘hello‘)
b = a
print(b)#内存地址
b()#函数a执行

　　这个特性，为不改变函数名调用被装饰函数提供了条件。

高阶函数

　　高阶函数在之前已经介绍过了，这里再介绍一次。

　　高阶函数是指把函数名作为参数，传递给另外一个函数。这样就可以实现为函数添加功能。例子。

def a(func):
     print(‘函数运行‘)
     func()
     print(‘运行结束‘)
 def b():
     print(‘另一个函数‘)

a(b)#为函数b添加了功能

嵌套函数

　　嵌套函数，就是再函数体内再定义一个函数。通过函数的嵌套，可以实现不改变调用方式调用函数。例子。

def a():
     def b():
         print(‘hello‘)
     return b

b = a()#这里b也就相当于嵌套函数内的b，这里a需要带‘()‘
b() #运行嵌套的函数

综合

　　综合上面的内容，可以完成一个简单的装饰器函数，例子。

def a(func):
    def wrapper():
        print(‘装饰内容‘)
        func()
    return wrapper
@a#b = a(b)
def b():
    print(‘被装饰内容‘)

b()

　　当被装饰函数拥有输入值，返回值时，输入值可以依靠不定变量完成，例子。

def a(func):
    def wrapper(*args,**kwargs):
        print(‘装饰内容‘)
        res = func(*args,**kwargs)
        return res 
    return wrapper
@a
def b(name,age):
    print(‘%s,%s‘%(name,age))
    return ‘返回‘

b(‘蛤蛤‘,120) 

　　当需要给装饰器输入参数时，例子。

def a(type):
    def out_wrapper(func):
        def wrapper(*args,**kwargs):
            if type == 1:
                print(‘装饰内容1‘)
            elif type == 2:
                print(‘装饰内容2‘)
            res = func(*args,**kwargs)
            return res 
        return wrapper
    return out_wrapper
@a(1)
def b(name,age):
    print(‘%s,%s‘%(name,age))
    return ‘返回‘

b(‘蛤蛤‘,120) 

迭代器

　　可直接用于for循环的数据类型：1.集合数据类型，list,tuple,dict,set,str;2.generator,包括生成器和带yield的generator function。

生成器

　　避免列表过大占用内存，可以靠推测时可以依靠迭代推测即时生成。1.只有在调用时才会生成相应的数据 2.无法回到上一次。例子。

a = (i*2 for i in range(10))
#方法1
a.__next__()
#方法2
for i in a:
    print(i)

 　　改写上面的式子为生成器，可以用yield来完成，例子。

def a(max):
    i = 0
    while i<max:
        yield i*i
        i = i+1
b = a(10)
b.__next__()

　　当next过多时，会报错，所以可以用抓异常的方法来防止出错。例子。

def a(max):
    i = 0
    while i<max:
        yield i*i
        i = i+1
b = a(10)
while True:
     try:
         next(b)
     except StopIteration as e:
         print(‘已达上限：‘,e.value)
         break

　　生成器并行。send()函数可以唤醒yield并传入值；next()只能唤醒yield；所以可以依靠yield实现单线程下程序的并行运行。例子。

def income(name):
    print(‘%s已登陆‘%(name))
    money = 0
    while True:
        new_money = yield
        money = money+new_money
        print(‘%s收入%d元,现有%d元‘%(name,new_money,money))

def outlet(name):
    print(‘%s已登陆‘%(name))
    a = income(‘凯凯王‘)
    a.__next__()#唤醒yeild
    print(‘开始转账！‘)
    flag = True
    while flag:
        money = int(input(‘转账金额：‘))
        a.send(money)
        select = input(‘是否继续？[Y:yes]：‘)
        if select == ‘y‘ or select == ‘Y‘:
            pass
        else:
            break

outlet(‘卖力头‘)

View Code

迭代器

　　可迭代对象Iterable，可以使用 isinstance()判断。例子。

from collections import Iterable
isinstance([],Iterable)

JSON序列化

　　json可以将运行中的内存中的对象存储为文件，供其他程序或软件使用，目前json正在逐渐取代xml

　　存取过程，例子。

import json
info = {
    ‘name‘:‘cdd‘,
    ‘age‘:23,
    }
f = open(‘test.txt‘,‘w‘)
f.write(json.dumps(info))#存
f.colse
g = open(‘test.txt‘,‘r‘)
data = json.loads(f.read())#读
f.close()
print(data)

软件目录结构

　　合理的软件目录结构可以提高项目的可读性，可维护性。一个合理的软件目录结构，例子。

Projectname/
    -bin/                 #可执行文件
        -function.py
    -projectname/   #项目所有源代码
        -test/            #测试文件
            -__init__.py
            -test_main.py
        -__init__.py
        -main.py
    -docs/               #文档文件
        -conf.py
    -setup.py           #安装部署打包脚本
    -requirements.txt#依赖关系
    -readme             #1.软件功能，2.安装环境，3.简要说明，4.代码目录，5.常见问题

查看

作业

实现一个银行+商城程序，目的在于练习装饰器与生成器并行

银行：1.还款，2.充值，3.提现，4.多用户转账(并行)

商城：1.购物车，2.银行接口结账

管理：1.添加账户，2.额度修改，3.冻结账户

 

实现：

由于转账已在例子中完成，不再添加，冻结功能由于编程时遗忘了，所以也不添加了。作业链接。密码: 4gwm