携程函数 与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(g)
print(next(g))
print(next(g))
yield的表达式形式的应用
def eater(name):
print(‘%s 说：我开动啦‘ %name)
while True:
food=yield print(‘%s eat %s‘ %(name,food))
alex_g=eater(‘alex‘)
print(alex_g)
print(next(alex_g))
print(‘==============>‘)
print(next(alex_g))
print(‘==============>‘)
print(next(alex_g))
用法： def eater(name):
print(‘%s 说：我开动啦‘ %name) f
ood_list=[]
while True:
food=yield food_list
food_list.append(food) #[‘骨头‘，‘菜汤‘]
print(‘%s eat %s‘ %(name,food))
alex_g=eater(‘alex‘)
第一阶段：初始化 next(alex_g) #等同于alex_g.send(None) print(‘===========>‘)
第二阶段：给yield传值 print(alex_g.send(‘骨头‘))
#1 先给当前暂停位置的yield传骨头
2 继续往下执行，直到再次碰到yield，然后暂停并且把yield后的返回值当做本次调用的返回值
def eater(name): print(‘%s 说：我开动啦‘ %name) food_list=[] while True: food=yield food_list food_list.append(food) #[‘骨头‘，‘菜汤‘] print(‘%s eat %s‘ %(name,food))
def producer(): alex_g=eater(‘alex‘)
#第一阶段：初始化 next(alex_g)
#第二阶段：给yield传值
while True:
food=input(‘>>: ‘).strip()
if not food:continue
print(alex_g.send(food))
producer()
print(‘===========>‘)
print(alex_g.send(‘菜汤‘))
print(alex_g.send(‘狗肉包子‘))
#解决初始化问题
def init(func):
def wrapper(*args,**kwargs):
g=func(*args,**kwargs)
next(g)
return g
return wrapper
@init def eater(name):
print(‘%s 说：我开动啦‘ %name)
food_list=[]
while True:
food=yield food_list
food_list.append(food) #[‘骨头‘，‘菜汤‘]
print(‘%s eat %s‘ %(name,food))
alex_g=eater(‘alex‘) 第二阶段：给yield传值 print(alex_g.send(‘骨头‘))
#1 先给当前暂停位置的yield传骨头
2 继续往下执行，直到再次碰到yield，然后暂停并且把yield后的返回值当做本次调用的返回值 print(‘===========>‘)
面向过程编程
--------------------------------------------------------
面向过程：核心是过程二字，过程即解决问题的步骤，像一条工业流水线，是一种机器式的思维方式 优点：程序结构清晰，可以把负载的问题简单化，流程化 缺点：可扩展性差，一条线只是用来解决一个问题 应用场景：linux内核，git，httpd，shell脚本 grep -rl ‘error‘ /dir/ 第一阶段：找到所有文件的绝对路径 第二阶段：打开文件 第三阶段：循环读出每一行内容 第四阶段：过滤 第五阶段：打印该行属于的文件名
--------------------------------------------------------------------
递归与二分法
递归调用：在调用一个函数的过程中，直接或间接地调用了函数本身 直接
def func():
print(‘from func‘)
func()
func()
间接 def foo():
print(‘from foo‘)
bar()
def bar():
print(‘from bar‘)
foo()
foo()
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 #n>1 age(1)=18 #n=1
def age(n): if n == 1: return 18 return age(n-1)+2
print(age(5))
递归的执行分为两个阶段： 1 递推 2 回溯
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)
二分法
l = [1,2,5,7,10,31,44,47,56,99,102,130,240]
def binary_search(l,num):
print(l) #[10, 31]
if len(l) > 1:
mid_index=len(l)//2 #1
if num > l[mid_index]:
#in the right
l=l[mid_index:] #l=[31]
binary_search(l,num)
elif num < l[mid_index]:
#in the left
l=l[:mid_index]
binary_search(l,num)
else:
print(‘find it‘)
else:
if l[0] == num:
print(‘find it‘)
else:
print(‘not exist‘)
return
binary_search(l,32)
======================================================================
软件开发规范： 把一个程序分成各个包并且来互相调用功能： bin、conf、core、log、lib、db
======================================================================
模块与包的使用 import from。。。import
---------------------------------------
导入模块干了哪些事： 1、执行源文件 2、以一个源文件的全局名称空间 3、在当前位置拿到一个模块名，指向2创建的名称空间
from。。。improt 优点：使用源文件内的名字是无需加前缀，使用方便 缺点：容易与当前文件的名字混淆
模块只会在第一次执行时才会导入，之后导入都是直接引用内存里的东西
模块搜索路径： 注意：自定义的模块名一定不要与python自带的模块重名 内存》内置模块》硬盘中