1. 协程函数

1.1 yield基本用法

　　yield作用

　　　　1.把函数的执行结果封装好，即封装__iter__和__next__，即得到一个迭代器

　　　　2.与return功能类似，都可以返回值，但不同的是，return只能返回一次值，而yield可以返回多次值

　　　　3.函数暂停与继续运行的状态是由yield保存

　　示例

def func(count):    print("start")    while True:        yield count        count += 1g = func(10)print(next(g))print(next(g))

 

1.2 通过yield向函数传参数

　　通过yield方法send，向yield暂停的位置进行传值

　　表达式形式的yield应用：例如food = yield food_list；需要分为两个阶段

　　　　1.初始化        next(jack_g) 等价于jack_g.send(None)

　　　　2.给yield传值   jack_g.send('骨头')

def eater(name):    print('%s 说：我开动啦' %name)    food_list = []    while True:        food = yield food_list        food_list.append(food) #['骨头'，'菜汤']        print('%s eat %s' %(name,food))jack_g = eater('jack')# 第一阶段：初始化next(jack_g) # jack_g.send(None)# 第二阶段：给yield传值print(jack_g.send('骨头'))#1 先给当前暂停位置的yield传骨头 #2 继续往下执行，直到再次碰到yield，然后暂停并且把yield后的返回值当做本次调用的返回值print(jack_g.send('菜汤'))print(jack_g.send('狗肉包子'))

 

1.3 生产者、消费者

　　生产者

def consumer(name):    print('%s 说：我开动啦' %name)    food_list = []    while True:        food = yield food_list        food_list.append(food) #['骨头'，'菜汤']        print('%s eat %s' %(name,food))

　　消费者

def producer():    jack_g = consumer('jack')    # 第一阶段：初始化    next(jack_g)    # 第二阶段：给yield传值    while True:        food = input('>>: ').strip()        if not food:continue        print(jack_g.send(food))

　　执行

producer()

　　运行结果

jack 说：我开动啦>>: 骨头jack eat 骨头['骨头']>>: 菜汤jack eat 菜汤['骨头', '菜汤']>>: 包子jack eat 包子['骨头', '菜汤', '包子']

 

1.4 解决初始化问题

　　利用装饰器，解决迭代器的初始化问题

# 装饰器，初始化yield形成的迭代器def init(func):    def wrapper(*args, **kwargs):        g = func(*args, **kwargs)        next(g)        return g    return wrapper@init  # 初始化eater的next方法的初始化def eater(name):    print('%s 说：我开动啦' %name)    food_list = []    while True:        food = yield food_list        food_list.append(food) #['骨头'，'菜汤']        print('%s eat %s' %(name,food))jack_g = eater('jack')print(jack_g.send('骨头'))print(jack_g.send('菜汤'))

 

2. 面向过程

　　面向过程：核心是过程二字，过程即解决问题的步骤，基于面向过程去设计程序就像是在设计一条工业流水线，是一种机械式的思维方式

　　优点：程序结构清晰，可以把复杂的问题简单化，流程化

　　缺点：可扩展性差，一条流线只是用来解决一个问题

　　应用场景：linux内核，git，httpd，shell脚本

 

　　示例：模拟linux命令grep，进行过滤，打印符合条件的文件名

#grep -rl "error" /dir/import osdef init(func):    def wrapper(*args, **kwargs):        g = func(*args, **kwargs)        next(g)        return g    return wrapper# 第一阶段：找到所有文件的绝对路径@initdef search(target):    while True:        filepath = yield        g = os.walk(filepath)        for pardir,_,files in g:            for file in files:                abspath = r"%s\%s" %(pardir,file)                target.send(abspath)# 第二阶段：打开文件@initdef opener(target):    while True:        abspath = yield        with open(abspath,"r",encoding="utf-8") as read_f:            target.send((abspath,read_f))# 第三阶段：循环读出每一行内容@initdef cat(target):    while True:        abspath,file = yield        for line in file:            tag = target.send((abspath,line))            if tag:                break# 第四阶段：过滤@initdef grep(target,pattern):    tag = False    while True:        abspath,line = yield tag        tag = False        if pattern in line:            tag = True            target.send(abspath)# 第五阶段：打印该行属于的文件名@initdef printer():    while True:        abspath = yield        print(abspath)g = search(opener(cat(grep(printer(),"error"))))g.send(r"D:\python\code\Learning\day05\a")

 

3. 递归

3.1 介绍

　　递归：即递归调用，函数在调用时，直接或间接调用了自身。

　　递归的执行分为两个阶段：

　　　　1．递推

　　　　2．回溯

　　递归的特点：

　　　　1.必须有一个明确的结束条件

　　　　2.每次进入更深一层时，问题规模相比上次递归都应有所减少

　　　　3.递归效率不高，递归层次过多会导致栈溢出

 

3.2 直接调用

def func():    print("from in func.")    func()func()

 

3.3 间接调用

def foo():    print("from foo.")    bar()def bar():    print("from bar.")    foo()foo()

 

3.4 示例

# age(5) = age(4) + 2# age(4) = age(3) + 2# age(3) = age(2) + 2# age(2) = age(1) + 2# age(1) = 18# 也就是# age(n) = age(n-1) + 2# age(1) = 18def age(n):    if n == 1:        return 18    return age(n-1)+2print(age(5))

　　循环打印列表的内容

l =[1, 2, [3, [4, 5, 6, [7, 8, [9, 10, [11, 12, 13, [14, 15,[16,[17,]],19]]]]]]]def search(l):    for item in l:        if type(item) is list:            search(item)        else:            print(item)search(l)

 

3.5 二分查找

l = [1,2,5,7,10,31,44,47,56,99,102,130,240]def binary_search(l,num):    if len(l) == 1:        if num == l[0]:            print("find it")        else:            print("not exist")        return    mid_index = len(l)//2    if num > l[mid_index]:        # in the right        l = l[mid_index+1:]        binary_search(l,num)    elif num < l[mid_index]:        # in the left        l = l[:mid_index]        binary_search(l,num)    else:        print("find it")binary_search(l,99)

　　更加实用版本二分查找

l = [1,2,5,7,10,31,44,47,56,99,102,130,240]def binart_search(l,num):    # 判断l是否为列表    if not isinstance(l,list):        print("l is not list")        return    # 判断列表是否为空    if len(l) ==  0:        print("not exists")        return    # 判断列表是否只有一个值    if len(l) == 1:        if l[0] == num:            print("find it")        else:            print("not exists")        return    mid_index = len(l) // 2    mid_value = l[mid_index]    if num == mid_value:        print("find it")        return    if num > mid_value:        l = l[mid_index:]    if num < mid_value:        l = l[:mid_index]    binart_search(l,num)binart_search([],40)

 

5. 模块

5.1 导入模块干了哪些事

　　1.执行源文件

　　2.以一个源文件的全局名称空间

　　3.在当前位置拿到一个模块名，指向2创建的名称空间

5.1 import导入模块

　　示例：在test_import.py中导入spam.py

# spam.pyprint('from the spam.py')money=1000def read1():    print('spam->read1->money',money)def read2():    print('spam->read2 calling read')    read1()def change():    global money    money=0# test_import.pyimport spamspam.read1()spam.read2()spam.change()spam.read2()

　　运行结果

from the spam.pyspam->read1->money 1000spam->read2 calling readspam->read1->money 1000spam->read2 calling readspam->read1->money 0

 

　　利用import导入，可以利用as设置别名

　　示例：模拟sql模块

#mysql.pydef sqlparse():    print('mysql sqlparse')#oracle.pydef sqlparse():    print('orale sqlparse')

 

　　在sql_test.py中进行测试

sql_type = input("sql_type>>:")if sql_type == "mysql":    import mysql as sqlif sql_type == "oracle":    import  oracle as sqlsql.sqlparse()

 

5.3 from…import导入模块

　　优点：使用源文件内的名字时无需加前缀，使用方便

　　缺点：容易与当前文件的名称空间的名字混淆

　　示例

from spam import moneyprint(money)  # 使用spam模块变量money

 

　　导入spam模块的所有内容，需要利用*进行导入模块

from spam import *

　　这种方法需要慎重使用

 

5.4 查看模块加载到内存

　　模块只有在第一次导入时才会执行，之后的导入都是直接引用内存已经存在的结果；利用sys模块的方法modules进行查看

import sysprint("spam" in sys.modules)  #存放的是已经加载到内的模块import spamprint("spam" in sys.modules)

 

5.5 模块的搜索路径

　　模块搜索，优先从内存中查找，然后从内置模块中查找，最后从当前目录中查找。

　　结论：

　　　　1.自定义的模块名一定不要与python自带的模块名重名

　　　　2.模块搜索路径：内存中-->内置模块路径-->sys.path

　　sys.path路径的初始化：

　　　　1.执行文件所在的当前路径

　　　　2.PYTHONPATH

　　　　3.依赖安装时默认指定的

 

5.6 区分模块的两种用法

　　模块的两种用法：

　　　　1.文件当做脚本运行时__name__等价于__main__

　　　　2.文件当做模块被加载运行时__name__等于模块名

# m1.pydef func1():    print('from m1')def func2():    print('from m2')def func3():    print('from m3')if __name__ == '__main__':    #当做脚本使用    func1()    func2()    func3()# run.pyimport m1m1.func1()

 

7. 包

7.1 说明

　　1.无论是import形式还是from…import形式，凡是在导入语句中(而不是在使用时)遇到带点的，都要第一时间提高警觉：这是关于包才有的导入语法。点的左边是包

　　2.包的目录级的(文件夹级)，文件夹是用来组成py文件(包的本质就是一个包含__init__.py文件的目录)

　　3.import导入文件时，产生名称空间中的名字来源于文件，import包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件。

　　强调：

　　1.在python3中，即使包下没有__init__.py文件，import包仍然不会报错，而在python2中，包下一定要有该文件，否则import包报错

　　2.创建包的目的不是为了运行，而是被导入使用，记住：包只是模块的一种形式而已，包即模块。

 

7.2 绝对导入与相对导入

glance/                   #Top-level package├── __init__.py           #Initialize the glance package├── api                   #Subpackage for api│   ├── __init__.py│   ├── versions.py├── cmd                   #Subpackage for cmd    ├── __init__.py    └── manage.py#文件内容#policy.pydef get():    print('from policy.py')#manage.pydef main():    print('from manage.py')

 

　　绝对导入：以glance作为起始

　　相对导入：用.或者..的方式作为起始

# 绝对导入，以glance作为起始from glance.api.policy import getfrom glance.cmd.manage import main# 相对导入，以.或者..作为起始from .api.policy import getfrom .cmd.manage import main

 

8. 软件开发规范

　　 

#=============>bin目录：存放执行脚本#start.pyimport sys,osBASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))sys.path.append(BASE_DIR)from core import corefrom conf import my_log_settingsif __name__ == '__main__':    my_log_settings.load_my_logging_cfg()    core.run() #=============>conf目录：存放配置文件#config.ini[DEFAULT]user_timeout = 1000[egon]password = 123money = 10000000[alex]password = alex3714money=10000000000[yuanhao]password = ysb123money=10 #settings.pyimport osconfig_path=r'%s\%s' %(os.path.dirname(os.path.abspath(__file__)),'config.ini')user_timeout=10user_db_path=r'%s\%s' %(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),\                     'db')#my_log_settings.py"""logging配置"""import osimport logging.config# 定义三种日志输出格式 开始standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \                  '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字 simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'# 定义日志输出格式 结束logfile_dir = r'%s\log' %os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log文件的目录logfile_name = 'all2.log'  # log文件名# 如果不存在定义的日志目录就创建一个if not os.path.isdir(logfile_dir):    os.mkdir(logfile_dir) # log文件的全路径logfile_path = os.path.join(logfile_dir, logfile_name)# log配置字典LOGGING_DIC = {    'version': 1,    'disable_existing_loggers': False,    'formatters': {        'standard': {            'format': standard_format        },        'simple': {            'format': simple_format        },    },    'filters': {},    'handlers': {        #打印到终端的日志        'console': {            'level': 'DEBUG',            'class': 'logging.StreamHandler',  # 打印到屏幕            'formatter': 'simple'        },        #打印到文件的日志,收集info及以上的日志        'default': {            'level': 'DEBUG',            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件            'formatter': 'standard',            'filename': logfile_path,  # 日志文件            'maxBytes': 1024*1024*5,  # 日志大小 5M            'backupCount': 5,            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了        },    },    'loggers': {        #logging.getLogger(__name__)拿到的logger配置        '': {            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕            'level': 'DEBUG',            'propagate': True,  # 向上（更高level的logger）传递        },    },} def load_my_logging_cfg():    logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置    logger = logging.getLogger(__name__)  # 生成一个log实例    logger.info('It works!')  # 记录该文件的运行状态if __name__ == '__main__':    load_my_logging_cfg()#=============>core目录：存放核心逻辑#core.pyimport loggingimport timefrom conf import settingsfrom lib import read_iniconfig=read_ini.read(settings.config_path)logger=logging.getLogger(__name__)current_user={
     'user':None,'login_time':None,'timeout':int(settings.user_timeout)}def auth(func):    def wrapper(*args,**kwargs):        if current_user['user']:            interval=time.time()-current_user['login_time']            if interval < current_user['timeout']:                return func(*args,**kwargs)        name = input('name>>: ')        password = input('password>>: ')        if config.has_section(name):            if password == config.get(name,'password'):                logger.info('登录成功')                current_user['user']=name                current_user['login_time']=time.time()                return func(*args,**kwargs)        else:            logger.error('用户名不存在')    return wrapper@authdef buy():    print('buy...') @authdef run():    print('''购物查看余额转账    ''')    while True:        choice = input('>>: ').strip()        if not choice:continue        if choice == '1':            buy() if __name__ == '__main__':    run() #=============>db目录：存放数据库文件#alex_json#egon_json#=============>lib目录：存放自定义的模块与包#read_ini.pyimport configparserdef read(config_file):    config=configparser.ConfigParser()    config.read(config_file)    return config

 

 

9. 日志模块

import loggingformatter1 = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s",                     datefmt="[%Y-%m-%d %H:%M:%S %p]",)fh1 = logging.FileHandler("test1.log")fh2 = logging.FileHandler("test2.log")ch = logging.StreamHandler()fh1.setFormatter(formatter1)fh2.setFormatter(formatter1)ch.setFormatter(formatter1)logger1 = logging.getLogger("jack")logger1.setLevel(10)logger1.addHandler(fh1)logger1.addHandler(fh2)logger1.addHandler(ch)logger1.debug("debug")logger1.info("info")logger1.error("error")