Python之路【第3天】-CSDN博客

迭代器

从第一个元素开始访问
只能往前不能后退
不需要准备整个文件
便于遍历几个G的文件

names=iter(["aa","bb","cc"])  #创建一个迭代器
print(names)
print(names.__next__())
print(names.__next__())
print(names.__next__())
#结果为：
<list_iterator object at 0x00000238C543DDD8>
aa
bb
cc
#ps:每次只能取一个数

生成器generator

一个函数调用时返回一个迭代器

取钱案例

def cash_money(amount):
    while amount>0:
        amount-=100
        yield 100   #返回值和接受值
        print("又来取钱了！")

atm=cash_money(300)  #调用函数
print(type(atm))  #查看函数类型
print(atm.__next__())  #打印结果
print(atm.__next__())
print("中断做其他事")   #迭代器异步操作，其他的函数不能中断，中断了不能继续执行
print(atm.__next__())
#结果为：
<class 'generator'>
100
又来取钱了！
100
中断做其他事
又来取钱了！
100

装饰器

# 单独print(login)是打印出login的地址
def login(func):    #这里func=f1 是一个参数地址
    def inner():   #再定义一个函数
        #验证
       print("验证了")
       return func()  #这里相当于 f1()
    return inner()
@login       #装饰器
def f1():
    print("f1")
#结果为：
验证了
f1

对比下面的例子

#进入前，先验证，不改变原来 tv 的函数
def login(func):  #这里传进了参数就是 tv的地址
    print("验证了")
    return func  #返回f1的地址
def tv(name):
    print("tv")

tv=login(tv)  #这里用装饰器 @login替换，就是产生了一个新的函数
tv("aa")
#结果为：
验证了
tv

装饰器，与参数

def login(func): #func=tv
    def inner(arg):  #内置函数第一次只扫描，返回inner
        print("验证了")   #未执行不打印
        return func(arg)  #执行tv(arg)
    return inner
@login
def tv(name):
    print("tv")

tv("aa")   #相当于login(tv)
#结果为：
验证了
tv

装饰器框架

def before(*arg,**kargs):
    print("before")
def after(*arg,**kargs):
    print("after")
def fiter(before_func,after_func):  #before,after
    def outer (main_func):  #index
        def inner(*arg,**kargs):
            before_func(*arg,**kargs)
            main_func(*arg,**kargs)
            after_func(*arg,**kargs)
        return inner
    return outer
@fiter(before,after)   #产生新的 index
def index(*arg,**kargs):
    print("index")
index("aa","bb")
#结果为：
before
index
after

单线程实现并发运算

import time  #导入类库
def consumer(name):
    print("%s 准备吃包子啦！"%name)
    while True:
        baozi=yield  #返回参数，接收send传过来的参数，yield捕获的意思
        print("包子[%s]来了，被[%s]吃了"%(baozi,name))
def producer(name):
    c=consumer("A")
    c2=consumer("B")
    c.__next__()
    c2.__next__()
    print("开始准备做包子了")
    for i in range(1,5):  #循环4次
          time.sleep(1)  #间隔1秒
          print("做了两个包子")
          c.send(i)   #将数值传给 yeild
          c2.send(i)
producer("aa")
#结果为：
A 准备吃包子啦！
B 准备吃包子啦！
开始准备做包子了
做了两个包子
包子[1]来了，被[A]吃了
包子[1]来了，被[B]吃了
。。。。。。

递归

递归算法是一种直接或者是间接调用自身算法的过程

递归就是在过程中或函数里调用自身
在使用过程中必须有一个递归结束条件，递归出口
递归算法简洁，但是效率低，不提倡设计程序
递归次数过多，会造成内存溢出
要求
每次调用在规模上都缩小（通常是减半）
两次相邻的递归须有紧密联系
每次递归须有条件

递归算法从数列中找出一个数


#递归算法从数列中找一个数
def binary_search(data_source,find_n):
    mid=int(len(data_source)/2)  #得到中间数的下标
    if len(data_source)>=1:
        if data_source[mid]>find_n:
            print("在[%s]左边"%data_source[mid])
            binary_search(data_source[:mid],find_n) #切片，调用自身函数递归
        elif data_source[mid]<find_n:
            print("在[%s]右边"%data_source[mid])
            binary_search(data_source[mid:],find_n)
        else:
            print("找到了[%s]"%data_source[mid])
    else:
        print("找不到")
if __name__=="__main__":
   # data=list(range(1,600,3))  #转化成列表
    data = list(range(1,10))  # 转化成列表
   # print(data)
binary_search(data,4)    #执行函数，找到数值4
#结果为：
在[5]左边
在[3]右边
找到了[4]

自动创建空列表

a=[i for i in range(4)]
print (a)
#上面是简写
a=[]
for i in range(4):
    print(i)
    a+=[i]
    print(a)
#结果为：
[0, 1, 2, 3]
--------------
0
[0]
1
[0, 1]
2
[0, 1, 2]
3
[0, 1, 2, 3]

需求打印一个二维数组

a=[[i for i in range(4)] for j in range(4)]
print(a)
for row in a:
    print(row)
#结果为：
[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]
[0, 1, 2, 3]

需求将上面的二维列表转90度

data=[[i for i in range(4)] for j in range(4)]
for r_index,row in enumerate(data):
    print(row)
    for c_index in range(r_index,len(row)):
        tmp=data[c_index][r_index]
        data[c_index][r_index]=row[c_index]
        data[r_index][c_index]=tmp
        print("-----------")
        for r in data:
            print(r)
print("**************************")
#重新构造
for i in range (len(data)):
    data2=[data[i][i] for row in range(4)]
    print(data2)

print("**************************")
for i in range (len(data)):
    #data3=[data[i][i] for row in range(4)]
    data3=[data[i][i]]
    print(data3)
#结果为：
[0, 0, 0, 0]
[1, 1, 1, 1]
[2, 2, 2, 3]
[3, 3, 2, 3]

斐波那契数列

a=[]
def func(arg1,arg2,stop):
    if arg1==0:
        pass
    arg3=arg1+arg2
    a.append(arg3)
#    print(arg3)
    if arg3<stop:
        func(arg2,arg3,stop)  #调用自身程序
    else:
        print(a)

func(0,1,30)
#结果为：
[1, 2, 3, 5, 8, 13, 21, 34]