1. 协程函数
1.1 yield基本用法
yield作用
1.把函数的执行结果封装好，即封装__iter__和__next__，即得到一个迭代器
2.与return功能类似，都可以返回值，但不同的是，return只能返回一次值，而yield可以返回多次值
3.函数暂停与继续运行的状态是由yield保存
示例
def func(count):
print("start")
while True:
yield count
count += 1 g = 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 os def init(func):
def wrapper(*args, **kwargs):
g = func(*args, **kwargs)
next(g)
return g
return wrapper # 第一阶段：找到所有文件的绝对路径
@init
def 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) # 第二阶段：打开文件
@init
def opener(target):
while True:
abspath = yield
with open(abspath,"r",encoding="utf-8") as read_f:
target.send((abspath,read_f)) # 第三阶段：循环读出每一行内容
@init
def cat(target):
while True:
abspath,file = yield
for line in file:
tag = target.send((abspath,line))
if tag:
break # 第四阶段：过滤
@init
def grep(target,pattern):
tag = False
while True:
abspath,line = yield tag
tag = False
if pattern in line:
tag = True
target.send(abspath) # 第五阶段：打印该行属于的文件名
@init
def 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) = 18
def age(n):
if n == 1:
return 18
return age(n-1)+2 print(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.py
print('from the spam.py')
money=1000 def read1():
print('spam->read1->money',money) def read2():
print('spam->read2 calling read')
read1() def change():
global money
money=0 # test_import.py import spam spam.read1()
spam.read2()
spam.change()
spam.read2()
运行结果
from the spam.py
spam->read1->money 1000
spam->read2 calling read
spam->read1->money 1000
spam->read2 calling read
spam->read1->money 0
利用import导入，可以利用as设置别名
示例：模拟sql模块
#mysql.py
def sqlparse():
print('mysql sqlparse') #oracle.py
def sqlparse():
print('orale sqlparse')
在sql_test.py中进行测试
sql_type = input("sql_type>>:")
if sql_type == "mysql":
import mysql as sql
if sql_type == "oracle":
import oracle as sql
sql.sqlparse()
5.3 from…import导入模块
优点：使用源文件内的名字时无需加前缀，使用方便
缺点：容易与当前文件的名称空间的名字混淆
示例
from spam import money
print(money) # 使用spam模块变量money
导入spam模块的所有内容，需要利用*进行导入模块
from spam import *
这种方法需要慎重使用
5.4 查看模块加载到内存
模块只有在第一次导入时才会执行，之后的导入都是直接引用内存已经存在的结果；利用sys模块的方法modules进行查看
import sys
print("spam" in sys.modules) #存放的是已经加载到内的模块 import spam
print("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.py
def func1():
print('from m1')
def func2():
print('from m2')
def func3():
print('from m3')
if __name__ == '__main__':
#当做脚本使用
func1()
func2()
func3() # run.py
import m1
m1.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.py
def get():
print('from policy.py') #manage.py
def main():
print('from manage.py')
绝对导入：以glance作为起始
相对导入：用.或者..的方式作为起始
# 绝对导入，以glance作为起始
from glance.api.policy import get
from glance.cmd.manage import main # 相对导入，以.或者..作为起始
from .api.policy import get
from .cmd.manage import main
8. 软件开发规范
#=============>bin目录：存放执行脚本
#start.py
import sys,os BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(BASE_DIR) from core import core
from conf import my_log_settings if __name__ == '__main__':
my_log_settings.load_my_logging_cfg()
core.run() #=============>conf目录：存放配置文件
#config.ini
[DEFAULT]
user_timeout = 1000 [egon]
password = 123
money = 10000000 [alex]
password = alex3714
money=10000000000 [yuanhao]
password = ysb123
money=10 #settings.py
import os
config_path=r'%s\%s' %(os.path.dirname(os.path.abspath(__file__)),'config.ini')
user_timeout=10
user_db_path=r'%s\%s' %(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),\
'db') #my_log_settings.py
"""
logging配置
""" import os
import 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.py
import logging
import time
from conf import settings
from lib import read_ini config=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 @auth
def buy():
print('buy...') @auth
def run():
print('''
购物
查看余额
转账
''')
while True:
choice = input('>>: ').strip()
if not choice:continue
if choice == '':
buy() if __name__ == '__main__':
run() #=============>db目录：存放数据库文件
#alex_json
#egon_json #=============>lib目录：存放自定义的模块与包
#read_ini.py
import configparser
def read(config_file):
config=configparser.ConfigParser()
config.read(config_file)
return config
9. 日志模块
import logging
formatter1 = 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")