函数 装饰器 生成器 列表解析式

# c = a if a>b else b   #三元运算
def func(name,*args,name1=‘name1‘,**kwargs):
    # 如果默认参数的值是一个可变数据类型，那么每一次调用函数且对其进行增删改的时候，如果不传值就公用这个数据类型的资源
    return ‘s‘    # 可以元组方式返回多个值，也可以单独返回字符串列表字典等
func(name,)        # ret = func()多个值之间用逗号隔开，接收的时候可以用一个变量接收（元组），也可以用等量的多个变量接收
func(*[‘a‘,[1,2],‘c‘])    # *打撒 将元素单个传参
#4.函数的参数
    #形参：
        # 位置参数 ： 必须传
        # *args ：可以接收任意多个位置参数
        # 默认参数 ： 可以不传
        # **kwargs ： 可以接收多个关键字参数
    #实参  调用函数的时候
        # 按照位置传参数
        # 按照关键字传参数
            # 可以混用 位置参数必须在关键字传参之前
            # 不能对一个参数重复赋值
# 作用域两种
# 全局作用域 —— 作用在全局 —— 内置和全局名字空间中的名字都属于全局作用域  ——globals()
# 局部作用域 —— 作用在局部 —— 函数（局部名字空间中的名字属于局部作用域） ——locals()
# 如果在一个局部（函数）内声明了一个 global 变量名，那么这个变量在局部的所有操作将对全局的变量有效
# globals 永远打印全局的名字
# locals 输出什么 根据locals所在的位置
# nonlocal 只能用于局部变量 找上层中离当前函数最近一层的局部变量,局部没有则报错,声明了nonlocal的内部函数的变量修改会影响到 离当前函数最近一层的局部变量,对全局无效,对局部 也只是对 最近的 一层 有影响
# func()              # 函数名就是内存地址
# func2 = func      # 函数名可以赋值
# l = [func,func2]    # 函数名可以作为容器类型的元素
# return f          # 函数名可以作为函数的返回值
# qqxing = wahaha(func)   # 函数名可以作为函数的参数
# 闭包 ： 内部函数使用外部函数的变量


# 装饰器函数
# def wrapper(f):    #装饰器函数，f是被装饰的函数
#     def inner(*args,**kwargs):
#         ‘‘‘在被装饰函数之前要做的事‘‘‘
#         ret = f(*args,**kwargs)    #被装饰的函数
#         ‘‘‘在被装饰函数之后要做的事‘‘‘
#         return ret
#     return inner
# @wrapper         #语法糖 @装饰器函数名
# def func(a,b):     #被装饰的函数
#    pass
# import time
# from functools import wraps
# FLAGE = False
# def timmer_out(flag):
#     def timmer(func):
#           @wraps(func) #加在最内层函数正上方
#         def inner(*args,**kwargs):
#             if flag:
#                 start = time.time()
#                 ret = func(*args,**kwargs)
#                 end = time.time()
#                 print(end-start)
#                 return ret
#             else:
#                 ret = func(*args, **kwargs)
#                 return ret
#         return inner
#     return timmer
# @timmer_out(FLAGE) 
# @ def func():
#     pass

# @wrapper3
# @wrapper2
# @wrapper1
# def func():pass

l=[‘a‘,‘b‘]
p = l.__iter__()
print(next(p),p.__next__())
# 迭代器协议 —— 内部含有__next__和__iter__方法的就是迭代器
# 可以被for循环的都是可迭代的
# 可迭代的内部都有__iter__方法
# 只要是迭代器 一定可迭代
# 可迭代的.__iter__()方法就可以得到一个迭代器
# 迭代器中的__next__()方法可以一个一个的获取值
# def func():
#     yield ‘a‘
#     yield ‘b‘
# 只要含有yield关键字的函数都是生成器函数
# 生成器函数：执行之后会得到一个生成器作为返回值，可循环取值for i in 调用的返回值:pass，next()取值
# 迭代器的特点：很方便使用，且只能取所有的数据取一次，节省内存空间
# 生成器函数：
    #含有yield关键字的函数就是生成器函数
    #特点：
        #调用函数的之后函数不执行，返回一个生成器
        #每次调用next方法的时候会取到一个值
        #直到取完最后一个，在执行next会报错
# def func():
#     content = yield ‘a‘
#     yield ‘b‘
# ret = g.__next__()
# ret = g.send(‘hello‘)   
# send获取下一个值的效果和next基本一致，只是在获取下一个值的时候，给上一yield的位置传递一个数据
# 使用send的注意事项：第一次使用生成器的时候 是用next获取下一个值，最后一个yield不能接受外部的值
# 获取移动平均值，预激生成器的装饰器
# def init(func):   #装饰器
#     def inner(*args,**kwargs):
#         g = func(*args,**kwargs)    #g = average()
#         g.__next__()
#         return g
#     return inner
# @init
# def average():
#     sum,count,avg = 0,0,0
#     while True:
#         num = yield avg
#         sum += num    # 10
#         count += 1    # 1
#         avg = sum/count
# avg_g = average()   #===> inner
# ret = avg_g.send(10)
# print(ret)
# ret = avg_g.send(20)
# print(ret)

# [每一个元素或者是和元素相关的操作 for 元素 in 可迭代数据类型]    #遍历之后挨个处理
# [满足条件的元素相关的操作 for 元素 in 可迭代数据类型 if 元素相关的条件]   #筛选功能
l1 = [‘选项%s‘%i for i in range(10)]
# 把列表解析的[]换成()得到的就是生成器表达式
# 列表解析与生成器表达式都是一种便利的编程方式，只不过生成器表达式更节省内存
# l1 = [‘选项%s‘%i for i in range(10) if i%3==0] 理解如下==>
#     for i in range(10):
#        if i%3==0:
#            li.append(‘选项%s‘%i)
# 若还有条件则继续缩进代码取值
# 
# l1 = (‘选项%s‘%i for i in range(10))        # 返回一个生成器对象
# for i in l1:print(i)
# print(li,list(li))
# l1.__next__()        # next(l1)
# l1 = {‘选项%s‘%i for i in range(10)}        # 生成集合
# l1 = {i:‘选项%s‘%i for i in range(10)}    # 生成字典