Python开发之路——7

Posted 2020-11-04 hechengwei

一、迭代器

1.迭代器协议

（1）迭代器协议是指：对象必须提供一个next方法，执行该方法要么返回迭代中的下一项，要么引起一个StopIteration移除异常以中止迭代。

（2）可迭代对象：实现了迭代器协议的对象（实现方法：在对象内部定义一个__iter__()方法）

（3）协议是一种约定，可迭代对象实现了迭代器协议，Python的内部工具如：for循环，sum，min，max等使用迭代器协议访问对象

2.for循环

（1）for 循环的本质：使用迭代器协议循环所有对象

（2）字符串、列表、元组、字典、集合、文件对象都不是可迭代对象，在for循环时，调用了内部的__iter__()方法，把它们变成了可迭代对象

（3）for循环调用可迭代对象的__next__()方法，并捕捉StopIteration异常来中止迭代

l = [1,2,3]
iter_l = l.__iter__()
print(iter_l.__next__())
print(iter_l.__next__())
print(next(iter_l))#python内置的next
print(iter_l.__next__())

View Code

（4）for循环就是基于可迭代协议提供了一个统一的可以迭代所有对象的方法，即在遍历之前，先调用对象内部的__iter__()方法，将对象转化成迭代器，然后利用迭代器协议去循环访问。

# while模拟for循环
l = [1,2,3,4,5]
diedai_l=l.__iter__()
while True:
    try:
        print(diedai_l.__next__())
    except StopIteration:
        print("迭代结束")
        break

View Code

二、生成器

1.三元表达式

name = "Kobe"
res = "Lakers" if name=="Kobe" else "Other Team"
print(res)

View Code

2.列表解析

l = [x*x for x in range(20) if x%2==0]
print(l)

l=[]
for x in range(20):
    if x%2==0:
        l.append(x*x)
print(l)

View Code

3.生成器

（1）生成器是一种自动实现可迭代协议的数据类型，不需要调用__iter__方法，所以生成器就是一种可迭代对象

（2）生成器在Python中有两种产生形式

a.生成器函数：与常规函数类似，但返回值不用return而是用yield。yield每次返回一个结果，返回后函数状态挂起，下次执行从挂起的状态继续执行

b.生成器表达式：与列表解析类似，把列表解析式的[]改为()就创建了一个生成器，生成器是按照需要每次产生一个结果，而不是直接构建完整的结果

（3）生成器的优点：a.可以延迟操作，即在需要的时候产生结果，可以节省内存；b.可以提高代码可读性

人口普查

def population_get():
    with open("人口普查.txt","r",encoding="utf-8") as f:
        for i in f:
            yield i

g = population_get()

all_pop = sum(int(eval(i)["population"]) for i in g )

print(all_pop)
for p in g:
    print("%s %%"%int(eval(i)["population"])/all_pop)#因为生产器已经迭代了一遍，所以不会有输出结果

View Code

生产者消费者模型

def produce_baozi():
    ret = []
    for i in range(100):
        ret.append("包子%s"%i)
    return ret
def consumer(res):
    for index,baozi in enumerate(res):
        print("第%s人吃掉了第%s个包子"%(index,baozi))
a = produce_baozi()
consumer(a)

View Code

三、装饰器

1.装饰器：

本质就是函数，为其他函数添加附加功能，装饰器功能的实现需要用到高阶函数+函数嵌套+闭包

2.原则：

（1）不改变被修饰函数的源代码

（2）不改变被修饰函数的调用方式

3.高阶函数

满足下面任意一条的函数即是高阶函数

（1）函数接收的参数是一个函数名

（2）函数的返回值是一个函数名

高阶函数在装饰器中的作用：

（1）函数的接收值是一个函数名

可以在不修改源代码的前提下，为函数添加新功能，但是会改变函数的调用方式

（2）函数的返回值是一个函数名

不会改变函数的调用方式，但是不能为函数添加新功能

import time
def foo():
    time.sleep(3)
    print("hello,贺丑子")
def timer(func):
    start_time=time.time()
    func()
    end_time=time.time()
    print("程序运行时间 %s" %(end_time-start_time))
    return func
foo = timer(foo)
foo()

View Code

4.最后实现

import time
def timmer(func):
    def wrapper(*args,**kwargs):
        start_time=time.time()
        res=func(*args,**kwargs)
        stop_time=time.time()
        print("程序运行时间%s" %(stop_time-start_time))
        return res
    return wrapper

@timmer
def test1(name,age):
    time.sleep(3)
    print("hello,world,,名字是%s,年龄是%s"%(name,age))
    return "这是test1的返回值"

res=test1("hehcouzi",17)
print(res)

View Code

四、一个文件操作系统

# 实现功能：1.函数操作 2.文件处理 3.tag的用法 4.文件的解耦
import os
def file_handler(backend_data,res=None,type="fetch"):#文件的解耦
    if type == "fetch":
        with open("haproxy.conf","r") as read_f:
            tag = False#tag用法
            ret= []
            for read_line in read_f:
                if read_line.strip()==backend_data:
                    tag =True
                    continue
                if tag and read_line.startswith("backend"):
                    break
                if tag:
                    print(read_line,end="")
                    ret.append(read_line)
        return ret
    elif type == "change":
        with open("haproxy.conf", "r") as read_f, open("haproxy.conf_new", "w") as write_f:
            tag = False
            has_write = False
            for read_line in read_f:
                if read_line.strip() == backend_data:
                    tag = True
                    continue
                if tag and read_line.startswith("backend"):
                    tag = False
                if not tag:
                    write_f.write(read_line)
                else:
                    if not has_write:
                        for record in res:
                            write_f.write(record)
                        has_write = True
        os.rename("haproxy.conf", "haproxy.conf.bak")
        os.rename("haproxy.conf_new", "haproxy.conf")
        os.remove("haproxy.conf.bak")
def fetch(data):
    print("这是查询功能")
    print("用户数据是",data)
    backend_dat= "backend %s" %data
    return (file_handler(backend_dat))

def add():
    pass

def change(data):
    backend=data[0]["backend"]
    backend_data="backend %s" %backend
    old_server_record="%sserver %s %s weight %s maxconn %s\n" %(" "*8,data[0]["record"]["server"],
                                                              data[0]["record"]["server"],
                                                              data[0]["record"]["weight"],
                                                              data[0]["record"]["maxconn"])
    new_server_record="%sserver %s %s weight %s maxconn %s\n" %(" "*8,data[1]["record"]["server"],
                                                              data[1]["record"]["server"],
                                                              data[1]["record"]["weight"],
                                                              data[1]["record"]["maxconn"])
    print("用户想要修改的记录是:",old_server_record)
    res = fetch(backend)
    print("来自change函数读取的内容：",res)
    if not res or old_server_record not in res:
        print("没有找到要修改的内容")
    else:
        index = res.index(old_server_record)
        res[index]=new_server_record
    res.insert(0,"%s\n" %backend_data)
    file_handler(backend_data,res=res,type="change")
    return res

def delete():
    pass

if __name__ == "__main__":#判断功能
    msg=‘‘‘
    1:查询
    2:增加
    3:修改
    4:删除
    5:退出
    ‘‘‘
    msg_dic={
        "1":fetch,
        "2":add,
        "3":change,
        "4":delete,
    }
    while True:
        print(msg)
        choice = input("请输入你的选项： ").strip()
        if not choice:continue
        if choice == "5": break

        data = input("请输入你的数据:").strip()
        if choice != "1":
            data = eval(data)

        res = msg_dic[choice](data)
        print(res)
# [{"backend":"www.oldboy1.org","record":{"server":"2.2.2.4","weight":"20","maxconn":"3000"}},{"backend":"www.oldboy1.org","record":{"server":"2.2.2.5","weight":"20","maxconn":"3000"}}]

View Code

 

一些小的补充：

#一一对应
a,b,c = (1,2,3)
print(a,b,c)
#只取头尾
l = [11,22,33,44,55,66,77]
a,*_,c = l
print(a,c)
#交换位置
f1 = 1
f2 = 2
f1,f2 = f2,f1
print(f1,f2)

View Code