08 . Python3高阶函数之迭代器、装饰器

a=[0,1,2,3,4,5,6,7,8,9]
b=[]
for i in a:b.append(i+1)
print(b)
print(a)

# 输出结果为
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a=[0,1,2,3,4,5,6,7,8,9]
a = map(lambda x: x + 1, a)
print(a)
for i in a:print(i,end="")

# 输出结果为
<map object at 0x00B78910>
12345678910

a=[0,1,2,3,4,5,6,7,8,9]
a=[i+1 for i in range(10)]
print(a)

# 输出结果为
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
# 这就叫做列表生成式

# 1. 通过生成器函数
# 2. 通过生成器推导式
# 3. Python内置函数或者模块提供(其实1,3)

def gen_func():
    for i in range(1,5001):
        yield f'{i}个包子'

ret = gen_func()
for i in range(200):
    print(next(ret))
    
# yield from
def func1():
    li1 = [1,2,3,4,5]
    yield from li1 # 将li1列表变成迭代器返回
ret = func1()
print(next(ret))
print(next(ret))
print(next(ret))

for x in [1,2,3,4,5]:
	pass

# 首先获得Iterator对象:
it = iter([1, 2, 3, 4, 5])
# 循环:
while True:
    try:
        # 获得下一个值:
        x = next(it)
    except StopIteration:
        # 遇到StopIteration就退出循环
        break

s1 = 'youmen'
print(dir(s1))


# 判断python中的一个对象是不是可迭代对象
print('__iter__' in dir(s1))

True

# 迭代器定义
# 字面意思:  更新迭代,器: 工具，可更新迭代的工具
# 专业角度:  内部含有"__iter__"方法并且含有"__next__"方法的对象就是迭代器
# 可以判断是否是迭代器: "__iter__" and "__next__" 在不在dir(对象)

with open('文件1',encoding='utf-8',mode='w') as f1:
    print('__iter__' and '__next__' in dir(f1))

l1 = [1,2,3,4,5]
obj = iter(l1)  # l1.__iter__()
print(next(obj))  
# 列表迭代器取值, 一个next取对应的一个值，如果迭代器里面的值取完了，还要Next，就会报StopIteration的错误
print(next(obj))
print(obj)

# 1
# 2
# <list_iterator object at 0x000001BA17A2C400>

l2 = [1,2,3,4,5]
obj=iter(l2)

for i in range(5):
    print(next(obj))
    
    
l1 = [1,2,3,4,5]
obj = iter(l1)
while 1:
    # 利用异常处理终止循环
    try:
        print(next(obj))
    except StopIteration:
        break

# 迭代器定义
# 字面意思:  更新迭代,器: 工具，可更新迭代的工具
# 专业角度:  内部含有"__iter__"方法并且含有"__next__"方法的对象就是迭代器
# 可以判断是否是迭代器: "__iter__" and "__next__" 在不在dir(对象)

# 优点
# 1. 节省内存,(迭代器,迭代器在内存中相当于只占一个数据的空间;因为每次取值都上一条数据会在内存释放，加载当前的此条数据, 几百万个对象,8G内存可以承受的)
# 2. 惰性机制,(next一次就取一个值,绝不过多取值)
		# 有一个迭代器模式可以很好的解释上面这两条:  迭代是数据处理的基石,扫描内存中放不下的数据时,我们要找到一种惰性获取数据的方式,即按需获取一个数据项，这就是迭代器模式.

# 缺点
# 1. 速度慢，不能直观的查看里面的数据
# 2. 不走回头路，只有全部取完才能取原来的值

# 可迭代对象是一个操作方法比较多(比如列表,字典的增删改查,字符串的常用方法等), 比较直观,但是占用内存,而且不能直接通过循环迭代取值的一个数据集.

# 应用:  
# 当你侧重于数据可以灵活处理，并且内存空间足够,将数据设置为可迭代对象是明确的选择.

# 当你侧重于对于数据可以灵活处理，并且内存空间足够,将数据集设置为可迭代对象是明确的选择

# 是一个非常节省内存,可以记录值位置，可以直接通过循环+next方法取值,但是不直观,操作方法比较单一的数据集.

# 应用:

# 当你的数据量过大,大到足以撑爆你的内存或者你节省内存的首选因素时,将数据集设置为迭代器是一个不错的选择.

# 闭包定义
# 内层函数对外层函数非全局变量的引用(使用)，就会形成闭包

# 闭包现象
# 被引用的非全局变量也称作自由变量，这个自由变量会与内层函数产生一个绑定关系.
# 自由变量不会再内存中消失


# 闭包的作用:
# 	保存局部信息不被销毁，保证数据的安全性

# 闭包的应用
# 1. 可以保存一些非全局变量但是不易被销毁,改变的数据
# 2. 装饰器

def make_averager():
    series = []
    def averager(new_value):
        series.append(new_value)
        total = sum(series)
        return total/len(series)
    return averager

avg = make_averager()
print(avg(100))
print(avg(110))
print(avg(120))

# 装饰器定义：
# 再不改变原被装饰的函数的源代码以及调用方式下，为其添加额外的功能.

def index():
    print("欢饮访问博客园主页")

import time
print(time.time())
# 此方法返回的是格林尼治时间，是此时此刻距离1970年1月1日0点0分0秒的时间秒数。也叫时间戳，他是一直变化的。所以要是计算shopping_car的执行效率就是在执行前后计算这个时间戳的时间，然后求差值即可。

def index():
    time.sleep(1)  # 模拟一下网络延迟以及代码的效率
    print("欢饮访问博客园主页")

start_time = time.time()
index()
end_tiem = time.time()
print(f'此函数的执行效率是{end_tiem-start_time}')

# 虽然完成了需求，但是完成的是一个测试其他函数的执行效率的功能，如果让你测试一下其他人员的函数效率?我还全得复制，重复代码太多，我们可以用函数,函数就是以功能为导向，减少重复代码，好我们继续整改.

def index():
    time.sleep(1)
    print("欢饮访问博客园主页")

def home(name):
    time.sleep(2)
    print(f'欢迎访问{name}主页')

def inner(func):
    start_time = time.time()
    func()
    end_tiem = time.time()
    print(f'此函数的执行效率是{end_tiem - start_time}')
inner(index)

# 这样我将index函数的函数名作为参数传递给inner函数，然后再inner函数里面执行index函数，这样就动态传参了,但是执行方式改变了，不符合封闭原则

# 将原函数的调用方式不改变
def index():
    time.sleep(1)
    print("欢饮访问博客园主页")

def home(name):
    time.sleep(2)
    print(f'欢迎访问{name}主页')

def timmer(func):
    def inner():
        start_time = time.time()
        func()
        end_tiem = time.time()
        print(f'此函数的执行效率是{end_tiem - start_time}')
    return inner
index = timmer(index)
index()

# 版本三就是最简单的一个装饰器,在不改变原函数的源码以及调用方式的前提下，为其增加额外的功能，测试执行效率
# 装饰器一定要在代码的最上面


def timmer(func):
    def inner():
        start_time = time.time()
        func()
        end_tiem = time.time()
        print(f'此函数的执行效率是{end_tiem - start_time}')
    return inner

# 为了省略每次我们调用函数时候写index = timmer(index)可以使用下面这种方式
# @装饰器名, 语法糖
# @timmer = index = timer(index)

@timmer
def index():
    time.sleep(1)
    print("欢饮访问博客园主页")

@timmer
def home(name):
    time.sleep(2)
    print(f'欢迎访问{name}主页')

index()

def timmer(func):
    def inner():
        start_time = time.time()
        result = func()
        func()
        end_tiem = time.time()
        print(f'此函数的执行效率是{end_tiem - start_time}')
        return result
    return inner

@timmer
def index():
    time.sleep(1)
    return 6666
    print("欢饮访问博客园主页")

@timmer
def home(name):
    time.sleep(2)
    print(f'欢迎访问{name}主页')

ret = index()
print(ret)

# 1588496241.6084275
# 此函数的执行效率是2.0007846355438232
# 6666

def timmer(func):
    def inner(*args,**kwargs):
        start_time = time.time()
        result = func(*args,**kwargs)
        end_tiem = time.time()
        print(f'此函数的执行效率是{end_tiem - start_time}')
        return result
    return inner

@timmer
def index(name):
    time.sleep(1)
    return 6666
    print("欢饮访问博客园主页")

@timmer
def home(name):
    time.sleep(2)
    print(f'欢迎访问{name}主页')

# ret = index('幽梦')
# print(ret)

@timmer
def demo1(name,age):
    time.sleep(0.5)
    print(f'欢迎{age}岁{name}登录日记页面')
demo1('幽梦',18)

def home():
    print("---首页----")
    
def america():
    print("----欧美专区----")
    
def japan():
    print("----日韩专区----")
    
def henan():
    print("----河南专区----")

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

user_status = False  # 用户登录了就把这个改成True

def login():
    _username = "alice"  # 假装这是DB里存的用户信息
    _password = "123"  # 假装这是DB里存的用户信息
    global user_status

    if user_status == False:
        username = input("user:")
        password = input("pasword:")

        if username == _username and password == _password:
            print("welcome login....")
            user_status = True
        else:
            print("wrong username or password!")
    else:
        print("用户已登录，验证通过...")

def home():
    print("---首页----")

def america():
    login()  # 执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

def henan():
    login()  # 执行前加上验证
    print("----河南专区----")

home()
america()
henan()

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

user_status = False  # 用户登录了就把这个改成True

def login(func):  # 把要执行的模块从这里传进来
    _username = "alex"  # 假装这是DB里存的用户信息
    _password = "abc!23"  # 假装这是DB里存的用户信息
    global user_status

    if user_status == False:
        username = input("user:")
        password = input("pasword:")

        if username == _username and password == _password:
            print("welcome login....")
            user_status = True
        else:
            print("wrong username or password!")

    if user_status == True:
        func()  # 看这里看这里，只要验证通过了，就调用相应功能

def home():
    print("---首页----")

def america():
    # login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

def henan():
    # login() #执行前加上验证
    print("----河南专区----")

home()
login(america) #需要验证就调用 login，把需要验证的功能 当做一个参数传给login
# home()
# america()
login(henan)

def plus(n):
    return n + 1

plus2 = lambda x: x + 1

calc = plus
calc(n)

home()
login(america) #需要验证就调用 login，把需要验证的功能 当做一个参数传给login
# home()
# america()
login(henan)

home()
america = login(america)
henan = login(henan)

home()
america = login(america)  # 你在这里相当于把america这个函数替换了
henan = login(henan)

# 那用户调用时依然写
america()

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

def login(func):  # 把要执行的模块从这里传进来

    def inner():  # 再定义一层函数
        _username = "youmen"  # 假装这是DB里存的用户信息
        _password = "123"  # 假装这是DB里存的用户信息
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("pasword:")

            if username == _username and password == _password:
                print("welcome login....")
                user_status = True
            else:
                print("wrong username or password!")

        if user_status == True:
            func()  # 看这里看这里，只要验证通过了，就调用相应功能

    return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数

@login
def america():
    # login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

@login
def henan():
    # login() #执行前加上验证
    print("----河南专区----")

#!/usr/bin/env python3
# -*- coding:utf-8 -*-

user_status = False  # 用户登录了就把这个改成True

def login(func):  # 把要执行的模块从这里传进来

    def inner(*args, **kwargs):  # 再定义一层函数
        _username = "youmen"  # 假装这是DB里存的用户信息
        _password = "!23"  # 假装这是DB里存的用户信息
        global user_status

        if user_status == False:
            username = input("user:")
            password = input("pasword:")

            if username == _username and password == _password:
                print("welcome login....")
                user_status = True
            else:
                print("wrong username or password!")

        if user_status == True:
            func(*args, **kwargs)  # 看这里看这里，只要验证通过了，就调用相应功能

    return inner  # 用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数

def home():
    print("---首页----")

@login
def america():
    # login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

# @login
def henan(style):
    '''
    :param style: 喜欢看什么类型的，就传进来
    :return:
    '''
    # login() #执行前加上验证
    print("----河南专区----")


home()
# america = login(america) #你在这里相当于把america这个函数替换了
henan = login(henan)

# #那用户调用时依然写
america()

henan("3p")

user_status = False #用户登录了就把这个改成True

def login(auth_type): #把要执行的模块从这里传进来
    def auth(func):
        def inner(*args,**kwargs):#再定义一层函数
            if auth_type == "qq":
                _username = "youmen" #假装这是DB里存的用户信息
                _password = "!23" #假装这是DB里存的用户信息
                global user_status

                if user_status == False:
                    username = input("user:")
                    password = input("pasword:")

                    if username == _username and password == _password:
                        print("welcome login....")
                        user_status = True
                    else:
                        print("wrong username or password!")

                if user_status == True:
                    return func(*args,**kwargs) # 看这里看这里，只要验证通过了，就调用相应功能
            else:
                print("only support qq ")
        return inner #用户调用login时，只会返回inner的内存地址，下次再调用时加上()才会执行inner函数

    return auth

def home():
    print("---首页----")

@login('qq')
def america():
    #login() #执行前加上验证
    print("----欧美专区----")

def japan():
    print("----日韩专区----")

@login('weibo')
def henan(style):
    '''
    :param style: 喜欢看什么类型的，就传进来
    :return:
    '''
    #login() #执行前加上验证
    print("----河南专区----")

home()
# america = login(america) #你在这里相当于把america这个函数替换了
#henan = login(henan)

# #那用户调用时依然写
america()

# henan("3p")

# 装饰器应用:  登录认证

# sep输出信息以什么为分割
print(1,2,3,4,sep='^')

# end下一行输出不换行
print(1,end='  ')
print(2)
print(3)


# 1  2
# 3

# abs()  返回绝对值
print(abs(-1234))

# 1234

# sum:   求出可迭代对象所有对象的和
print(sum([1,23,4,5]))

# min:   求最小值
print(min([1,2,3]))  # 返回此序列最小值

ret = min([1,2,-5,],key=abs)  # 按照绝对值的大小，返回此序列最小值
print(ret)

# reversed()将一个序列翻转, 返回翻转序列的迭代器
ret = reversed([4,2,3423,1234,234])
print(list(ret))

# [234, 1234, 3423, 2, 4]

# zip()拉链方法:   函数用于将可迭代对象作为参数，将对象中对应的元素打包成一个个元组
# 然后将这些元组组成的内容,如果各个迭代器的元素个数不一致，则按照长度最短的返回.

list1 = [1,2,3]
list2 = ['a','b','c']
list3 = [11,22,33]
for i in zip(list1,list2,list3):
    print(i)
    
(1, 'a', 11)
(2, 'b', 22)
(3, 'c', 33)

# sorted排序算法
# 语法: sorted(iterable,key=None,reverse=False)
# iterable:  可迭代对象
# key:  排序规则(排序函数),在sotted内部会将可迭代对象的每一个元素传递给这个函数的参数，根据函数运算结果进行排序
# reverse:  是否是倒序,True倒叙，False正序

list1 = [1,6,5,4,5]
list2 = sorted(list1)
print(list2)

list3 = sorted(list1,reverse=True)
print(list3)

# [1, 4, 5, 5, 6]
# [6, 5, 5, 4, 1]

# 按照年龄对学生信息进行排序
lst = [{'id':1,'name':'alex','age':18},
    {'id':2,'name':'wusir','age':17},
    {'id':3,'name':'taibai','age':16},]

print(sorted(lst,key=lambda e:e['age']))

# 语法: filter(function,iterable)
# function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回的True或False来判断是否保留此项数据

# iterable:  可迭代对象
lst = [{'id':1,'name':'alex','age':18},
    {'id':2,'name':'wusir','age':17},
    {'id':3,'name':'taibai','age':16},]

ls = filter(lambda e:e['age'] > 17,lst)
print(list(ls))

# 映射函数
# 语法: map(function,iterable)可以对可迭代对象中的每一个元素映射，分别取执行function
# 计算列表中每个元素的平方，返回新列表

list1 = [1,2,3,4,5]
def func(s):
    return s*s
mp = map(func,list1)
print(list(mp))
print(list(map(lambda s:s*s,list1)))

# [1, 4, 9, 16, 25]

# 计算两个列表相同位置元素的和
list1 = [1,2,3,4,5]
list2 = [1,2,3,4,5]
print(list(map(lambda x,y:x+y,list1,list2)))

# [2, 4, 6, 8, 10]

# reduce在python2是内置函数，python3编程模块
# reduce的使用方式
# reduce(函数名,可迭代对象)

from functools import reduce
def func(x,y):
    return x*y

ret = reduce(func,[3,4,5,6])
print(ret)

# 匿名函数版
result = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(result)

# reduce的作用是先把列表中前两个元素取出计算一个值后临时保存着, 接下来用这个临时保存的值和列表第三个元素进行计算，求出新的值将最开始临时保存的值覆盖，然后用这个新的临时值和列表的第四个元素计算，依此类推.

# eval 剥去字符串的外表运算里面的代码,公司一般不用,容易被黑客劫持替换成危险的脚本
s1 = '1+3'
print(s1)
print(eval(s1))

# 执行字符串里面的代码
msg = '''
for i in range(10):
    print(i)
'''
print(exec(msg))

# hash: 获取一个对象(可哈希对象: int,str,bool,tuple)的哈希值
print(hash('1234'))

# -5939173262231693622

# help: 函数用于查看函数或模块用途的详细说明
print(help(list))

# callable:  判断一个对象是否能调用,如果返回True,object仍然可能调用失败, 但如果返回False,调用对象object绝对不会成功
name = 'youmen'
def func():
    pass
print(callable(name))
print(callable(func))

print(round(7/2))
print(round(3.14152))

# bytes: 用于不同编码之间的转化
s = 'youmen'
name = s.encode('utf-8')
print(name)

name2 = bytes(s,encoding='utf-8')
print(name2)

# b'youmen'
# b'youmen'

# ord: 输入字符找该字符编码的位置
print(ord('a'))

# chr 输入位置数字找到对应的字符
print(chr(97))

# repr:  返回一个对象的string形式(原形毕露)

# %r 原封不动的写出来
name = 'zhou'
print('我叫%r'%name)

# repr:  返回一个对象的string形式
print(repr('{"name":"youmen"}'))
print('{"name":"youmen"}')

# all:  可迭代对象中,全都是True才是True
# any:  可迭代对象中，有一个True就是True
print(all([1,2,True,0,True]))
print(any([1,'',0]))

Foo/
|-- bin/
|   |-- foo
|
|-- foo/
|   |-- tests/
|   |   |-- __init__.py
|   |   |-- test_main.py
|   |
|   |-- __init__.py
|   |-- main.py
|
|-- docs/
|   |-- conf.py
|   |-- abc.rst
|
|-- setup.py
|-- requirements.txt
|-- README

# 1. bin/`: 存放项目的一些可执行文件，当然你可以起名`script/`之类的也行。
# 2. `foo/`: 存放项目的所有源代码。(1) 源代码中的所有模块、包都应该放在此目录。不要置于顶层目录。(2) 其子目录`tests/`存放单元测试代码； (3) 程序的入口最好命名为`main.py`。
# 3. `docs/`: 存放一些文档。
# 4. `setup.py`: 安装、部署、打包的脚本。
# 5. `requirements.txt`: 存放软件依赖的外部Python包列表。
# 6. `README`: 项目说明文件。