# 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)}    # 生成字典

函數 裝飾器 生成器 列表解析式