摘要：裝飾器的應用場景比如插入日志，性能測試，事務處理，緩存等等場景。裝飾器完美的遵循了這個開放封閉原則。迭代器迭代器遵循迭代器協議必須擁有方法和方法。直到函數執行結束。調用相關函數用于檢查一個對象是否是可調用的。

1.裝飾器本質上就是一個python函數，他可以讓其他函數在不需要做任何代碼變動的前提下，增加額外的功能，裝飾器的返回值也是一個函數對象。
2.裝飾器的應用場景：比如插入日志，性能測試，事務處理，緩存等等場景。

1.現在我有一個需求，我想讓你測試這個函數的執行時間，在不改變這個函數代碼的情況下：

import time
def func1():
    time.sleep(0.3)
    print("in func1")
def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner
func1 = timer(func1)
func1()
裝飾器---簡單版

2.但是如果有多個函數，我都想讓你測試他們的執行時間，你每次是不是都得func1 = timer(func1)?這樣還是有點麻煩，因為這些函數的函數名可能是不相同，有func1，func2,graph,等等，所以更簡單的方法，python給你提供了，那就是語法糖。

import time
def timer(func):
    def inner():
        start = time.time()
        func()
        print(time.time() - start)
    return inner
@timer   #==> func1 = timer(func1)
def func1():
    time.sleep(0.3)
    print("in func1")
func1()

3.剛剛我們討論的裝飾器都是裝飾不帶參數的函數，現在要裝飾一個帶參數的函數怎么辦呢？

import  time
def timer(func):
    def inner(a):
        start = time.time()
        func(a)
        print(time.time() - start)
    return inner
@timer
def func1(a):
    time.sleep(0.3)
    print(a)
func1(1)

4.裝飾器通用模板實例：

import time
def timer(func):
    def inner(*args,**kwargs):
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner
@timer   #==> func1 = timer(func1)
def func1(a,b):
    print("in func1")
@timer   #==> func2 = timer(func2)
def func2(a):
    print("in func2 and get a:%s"%(a))
    return "fun2 over"
func1("aaaaaa","bbbbbb")
print(func2("aaaaaa"))

5.上面的裝飾器已經非常完美了，但是有我們正常情況下查看函數信息的方法在此處都會失效。

import time
def timer(func):
    def inner(*args,**kwargs):
        """this is inner"""
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner
@timer   #==> func1 = timer(func1)
def func1(a,b):
    """
    this is func1
    """
    print("in func1")
print(func1.__doc__)   #查看函數的注釋 
print(func1.__name__)  #查看函數的名字

查看func1的函數注釋變成了this is inner
函數的名字變成了inner
解決方法：

from functools import wraps
import time
def timer(func):
    @wraps(func)  # 加在最內層函數正上方
    def inner(*args,**kwargs):
        """this is inner"""
        start = time.time()
        re = func(*args,**kwargs)
        print(time.time() - start)
        return re
    return inner
@timer   #==> func1 = timer(func1)
def func1(a,b):
    """
    this is func1
    """
    print("in func1")
print(func1.__doc__)   #查看函數的注釋
print(func1.__name__)  #查看函數的名字

1.對擴展是開放的
　　　　為什么要對擴展開放呢？
　　　　我們說，任何一個程序，不可能在設計之初就已經想好了所有的功能并且未來不做任何更新和修改。所以我們必須允許代碼擴展、添加新功能。
2.對修改是封閉的
　　　　為什么要對修改封閉呢？
　　　　就像我們剛剛提到的，因為我們寫的一個函數，很有可能已經交付給其他人使用了，如果這個時候我們對其進行了修改，很有可能影響其他已經在使用該函數的用戶。
裝飾器完美的遵循了這個開放封閉原則。

1.裝飾器的固定格式：

def timer(func):
    def inner(*args,**kwargs):
        """執行函數之前要做的"""
        re = func(*args,**kwargs)
        """執行函數之后要做的"""
        return re
    return inner

2.裝飾器的固定格式wraps版：

from functools import wraps

def deco(func):
    @wraps(func) #加在最內層函數正上方
    def wrapper(*args,**kwargs):
        return func(*args,**kwargs)
    return wrapper

假如你有成千上萬個函數使用了一個裝飾器，現在你想把這些裝飾器都取消掉，你要怎么做？
一個一個的取消掉？ 沒日沒夜忙活3天。。。
過兩天你領導想通了，再讓你加上。。。

def outer(flag):
    def timer(func):
        def inner(*args,**kwargs):
            if flag:
                print("""執行函數之前要做的""")
            re = func(*args,**kwargs)
            if flag:
                print("""執行函數之后要做的""")
            return re
        return inner
    return timer
@outer(False)
def func():
    print(111)
func()

def wrapper1(func):   #f = warpper1(f)  里面的f函數名 外面的f 是inner1
    def inner1():
        print("wrapper1 ,before func")
        func()
        print("wrapper1 ,after func")
    return inner

def wrapper2(func):    #f = warpper2(f)  里面的f是inner1 外面的f是inner2
    def inner2():
        print("wrapper2 ,before func")
        func()
        print("wrapper2 ,after func")
    return inner

@wrapper2
@wrapper1
def f():
    print("in f")
f()

輸出為：
wrapper2 ,before func
wrapper1 ,before func
in f
wrapper1 ,after func
wrapper2 ,after func

字符串、列表、元組、字典、集合都可以被for循環，說明他們都是可迭代的。

from collections import Iterable
s_str = "1234"
l = [1,2,3,4]
t = (1, 2, 3,4)
d = {1:2,3:4}
s_set = {1,2,3,4}
print(isinstance(s_str, Iterable))
print(isinstance(l, Iterable))
print(isinstance(t, Iterable))
print(isinstance(d, Iterable))
print(isinstance(s_set,Iterable))

我們現在是從結果分析原因，能被for循環的就是“可迭代的”，但是如果正著想，for怎么知道誰是可迭代的呢？
假如我們自己寫了一個數據類型，希望這個數據類型里的東西也可以使用for被一個一個的取出來，那我們就必須滿足for的要求。這個要求就叫做“協議”。
可以被迭代要滿足的要求就叫做可迭代協議。可迭代協議的定義非常簡單，就是內部實現了__iter__方法。

print( "__iter__" in dir(str))
True
print(dir(str))
["__add__", "__class__", "__contains__", "__delattr__", "__dir__", "__doc__", "__eq__", "__format__", "__ge__", "__getattribute__", "__getitem__", "__getnewargs__", "__gt__", "__hash__", "__init__", "__init_subclass__", "__iter__", "__le__", "__len__", "__lt__", "__mod__", "__mul__", "__ne__", "__new__", "__reduce__", "__reduce_ex__", "__repr__", "__rmod__", "__rmul__", "__setattr__", "__sizeof__", "__str__", "__subclasshook__", "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalnum", "isalpha", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "maketrans", "partition", "replace", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill"]

總結一下我們現在所知道的：可以被for循環的都是可迭代的，要想可迭代，內部必須有一個__iter__方法。
接著分析，__iter__方法做了什么事情呢？
可迭代的：內部必須含有一個__iter__方法。

s = "1234"
s_obj = s.__iter__()
while True:
    try:
        print(s_obj.__next__())
    except:
        break

迭代器遵循迭代器協議：必須擁有__iter__方法和__next__方法。
for循環，能遍歷一個可迭代對象，他的內部到底進行了什么？
將可迭代對象轉化成迭代器。（可迭代對象.__iter__()）
內部使用__next__方法，一個一個取值。
加了異常處理功能，取值到底后自動停止。
總結：
迭代器

可迭代對象：

凡是可以用for可以遍歷的基本都是可迭代的

str，list，tuple，dict，set，文件句柄，range中

對象中含有__iter__方法的就是可迭代對象，遵循可迭代協議

判斷該是否可迭代對象

迭代器含義：

內部含有__iter__且含有__next__方法的對象就是迭代器，遵循迭代器協議

迭代器可以取值，必須通過__next__取值

判斷該對象是不是迭代器

迭代器的好處:

減少內存

惰性機制

單向執行，不可逆

生成器本質就是迭代器，是自己定義的迭代器，單向執行，不可逆

構建方式：
1.函數方式

    1.在函數中看到yield，就不是函數了，他就是生成器
    2.__next__和yield一一對應
    3.--next__和send都可以取值，send會給上一個yield會發送一個值
    4.send不能用作第一次取值，最后一個yiled不能取到值

2.列表推導式

    1.[變量（加工后的變量）for 變量 in iterable(可迭代對象)]  遍歷模式;
    2.[變量（加工后的變量）for 變量 in iterable(可迭代對象) if 條件] 篩選模式；
    3.特別復雜的無法用列表推導式

3.區別：

1.列表推導式直觀可以看出，但是占內存
2.生成器表達式不易看出，但是節省內存      

生成器Generator：

　　1.本質：迭代器(所以自帶了__iter__方法和__next__方法，不需要我們去實現)
　　2.特點：惰性運算,開發者自定義

一個包含yield關鍵字的函數就是一個生成器函數。yield可以為我們從函數中返回值，但是yield又不同于return，return的執行意味著程序的結束，調用生成器函數不會得到返回的具體的值，而是得到一個可迭代的對象。每一次獲取這個可迭代對象的值，就能推動函數的執行，獲取新的返回值。直到函數執行結束。

    with open("info",encoding="utf-8",mode="r") as f_read:
        for line in f_read:
            yield line.strip().split(",")

[變量（加工后的變量）for 變量 in iterable(可迭代對象)
1.列表推導式

l = [i for i in range(10)]
print(l)
l1 = ["選項%s"%i for i in range(10)]
print(l1)

2.把列表解析的[]換成()得到的就是生成器表達式

l = (x for x in range(1,5))
for i in l:
    print(i)

列表解析與生成器表達式都是一種便利的編程方式，只不過生成器表達式更節省內存
過濾掉長度小于3的字符串列表，并將剩下的轉換成大寫字母

l = ["abc","ac","accd"]
l1 = [i.upper() for i in l if len(i) >=3]
print(l1)

1.locals ：函數會以字典的類型返回當前位置的全部局部變量。
2.globals：函數以字典的類型返回全部全局變量

a = 1
b = 2
print(locals())
print(globals())
# 這兩個一樣，因為是在全局執行的。

##########################

def func(argv):
    c = 2
    print(locals())
    print(globals())
func(3)

#這兩個不一樣，locals() {"argv": 3, "c": 2}
#globals() {"__doc__": None, "__builtins__": , "__cached__": None, "__loader__": <_frozen_importlib_external.SourceFileLoader object at 0x0000024409148978>, "__spec__": None, "__file__": "D:/lnh.python/.../內置函數.py", "func": , "__name__": "__main__", "__package__": None}

1.字符串類型代碼的執行 eval,exec

eval的含義就是去掉字符串兩邊的引號，里邊該是什么類型就是什么類型

a =  ""123""
print(eval(a))
#打印結果為：123

exec

s = """
for i in [1,2,3]:
    print(i)
"""
exec(s)
打印結果為：
1
2
3

2.輸入輸出相關 input,print

def print(self, *args, sep=" ", end="
", file=None): # known special case of print
    """
    print(value, ..., sep=" ", end="
", file=sys.stdout, flush=False)
    file:  默認是輸出到屏幕，如果設置為文件句柄，輸出到文件
    sep:   打印多個值之間的分隔符，默認為空格
    end:   每一次打印的結尾，默認為換行符
    flush: 立即把內容輸出到流文件，不作緩存
    """
"""

print(111,222,333,sep="*")  # 111*222*333

print(111,end="")
print(222)  #兩行的結果 111222

f = open("log","w",encoding="utf-8")
print("寫入文件",file=f,flush=True)

3.內存相關 hash id
hash：獲取一個對象（可哈希對象：int,str,Bool，tuple）的哈希值。
4.文件操作相關
open：函數用于打開一個文件，創建一個 file 對象，相關的方法才可以調用它進行讀寫。
5.調用相關
callable：函數用于檢查一個對象是否是可調用的。如果返回True，object仍然可能調用失敗；但如果返回False，調用對象ojbect絕對不會成功。

def add(a,b):
    return a+b
print(callable(add))

6.查看內置屬性
dir：函數不帶參數時，返回當前范圍內的變量、方法和定義的類型列表；帶參數時，返回參數的屬性、方法列表。如果參數包含方法__dir__()，該方法將被調用。如果參數不包含__dir__()，該方法將最大限度地收集參數信息。

print(dir())   #查看當前模塊的屬性列表 
["__annotations__", "__builtins__", "__cached__", "__doc__", "__file__", "__loader__", "__name__", "__package__", "__spec__", "s"]獲得當前模塊的屬性列表
print(dir("a")) #查看字符串的屬性列表
["__add__", "__class__", "__contains__", "__delattr__", "__dir__", "__doc__", "__eq__", "__format__", "__ge__", "__getattribute__", "__getitem__", "__getnewargs__", "__gt__", "__hash__", "__init__", "__init_subclass__", "__iter__", "__le__", "__len__", "__lt__", "__mod__", "__mul__", "__ne__", "__new__", "__reduce__", "__reduce_ex__", "__repr__", "__rmod__", "__rmul__", "__setattr__", "__sizeof__", "__str__", "__subclasshook__", "capitalize", "casefold", "center", "count", "encode", "endswith", "expandtabs", "find", "format", "format_map", "index", "isalnum", "isalpha", "isdecimal", "isdigit", "isidentifier", "islower", "isnumeric", "isprintable", "isspace", "istitle", "isupper", "join", "ljust", "lower", "lstrip", "maketrans", "partition", "replace", "rfind", "rindex", "rjust", "rpartition", "rsplit", "rstrip", "split", "splitlines", "startswith", "strip", "swapcase", "title", "translate", "upper", "zfill"]

range：函數可創建一個整數對象，一般用在 for 循環中。
next：內部實際使用了__next__方法，返回迭代器的下一個項目。

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

iter：函數用來生成迭代器（講一個可迭代對象，生成迭代器）

from collections import Iterable
from collections import Iterator
l = [1,2,3]
print(isinstance(l,Iterable))  # True
print(isinstance(l,Iterator))  # False

l1 = iter(l)
print(isinstance(l1,Iterable))  # True
print(isinstance(l1,Iterator))

1.數字相關
數據類型：
　　　　bool ：用于將給定參數轉換為布爾類型，如果沒有參數，返回 False。
　　　　int：函數用于將一個字符串或數字轉換為整型。

print(int())  # 0

print(int("12"))  # 12

print(int(3.6))  # 3

print(int("0100",base=2))  # 將2進制的 0100 轉化成十進制。結果為 4

2.float：函數用于將整數和字符串轉換成浮點數。

a = "1.2"
print(float(a))   #1.2
b = 1
print(float(b))   #1.0

3.進制轉換：
　　　　bin：將十進制轉換成二進制并返回。
　　　　oct：將十進制轉化成八進制字符串并返回。
　　　　hex：將十進制轉化成十六進制字符串并返回。

print(bin(10),type(bin(10)))  # 0b1010 
print(oct(10),type(oct(10)))  # 0o12 
print(hex(10),type(hex(10)))  # 0xa 

4.數學運算：
　　　　abs：函數返回數字的絕對值。
　　　　divmod：計算除數與被除數的結果，返回一個包含商和余數的元組(a // b, a % b)。
　　　　round：保留浮點數的小數位數，默認保留整數。
　　　　pow：求xy次冪。（三個參數為xy的結果對z取余）

print(abs(-5))  # 5

print(divmod(7,2))  # (3, 1)

print(round(7/3,2))  # 2.33
print(round(7/3))  # 2
print(round(3.32567,3))  # 3.326

print(pow(2,3))  # 兩個參數為2**3次冪
print(pow(2,3,3))  # 三個參數為2**3次冪，對3取余。

5.sum：對可迭代對象進行求和計算（可設置初始值）。

print(sum([1,2,3]))  #6
print(sum((1,2,3),100)) #106

min：返回可迭代對象的最小值（可加key，key為函數名，通過函數的規則，返回最小值）。

print(min([1,2,3]))  # 返回此序列最小值
ret = min([1,2,-5,],key=abs)  # 按照絕對值的大小，返回此序列最小值
print(ret)
dic = {"a":3,"b":2,"c":1}
print(min(dic,key=lambda x:dic[x]))
# x為dic的key，lambda的返回值（即dic的值進行比較）返回最小的值對應的鍵

　max：返回可迭代對象的最大值（可加key，key為函數名，通過函數的規則，返回最大值）。

print(max([1,2,3]))  # 返回此序列最大值
ret = max([1,2,-5,],key=abs)  # 按照絕對值的大小，返回此序列最大值
print(ret)
dic = {"a":3,"b":2,"c":1}
print(max(dic,key=lambda x:dic[x]))
# x為dic的key，lambda的返回值（即dic的值進行比較）返回最大的值對應的鍵

列表和元祖（2）
　　　　list：將一個可迭代對象轉化成列表（如果是字典，默認將key作為列表的元素）
　　　　tuple：將一個可迭代對象轉化成元祖（如果是字典，默認將key作為元祖的元素）

l = list((1,2,3))
print(l)

l = list({1,2,3})
print(l)

l = list({"k1":1,"k2":2})
print(l)

tu = tuple((1,2,3))
print(tu)

tu = tuple([1,2,3])
print(tu)

tu = tuple({"k1":1,"k2":2})
print(tu)

相關內置函數 :
　　　　reversed：將一個序列翻轉，并返回此翻轉序列的迭代器。
　　　　slice：構造一個切片對象，用于列表的切片。

ite = reversed(["a",2,3,"c",4,2])
for i in ite:
    print(i)

li = ["a","b","c","d","e","f","g"]
sli_obj = slice(3)
print(li[sli_obj])

sli_obj = slice(0,7,2)
print(li[sli_obj])

字符串相關
　　　　str：將數據轉化成字符串。
　　　　format:與具體數據相關，用于計算各種小數，精算等。

#字符串可以提供的參數,指定對齊方式，<是左對齊， >是右對齊，^是居中對齊
print(format("test", "<20"))
print(format("test", ">20"))
print(format("test", "^20"))

#整形數值可以提供的參數有 "b" "c" "d" "o" "x" "X" "n" None
>>> format(3,"b") #轉換成二進制
"11"
>>> format(97,"c") #轉換unicode成字符
"a"
>>> format(11,"d") #轉換成10進制
"11"
>>> format(11,"o") #轉換成8進制
"13"
>>> format(11,"x") #轉換成16進制 小寫字母表示
"b"
>>> format(11,"X") #轉換成16進制 大寫字母表示
"B"
>>> format(11,"n") #和d一樣
"11"
>>> format(11) #默認和d一樣
"11"

#浮點數可以提供的參數有 "e" "E" "f" "F" "g" "G" "n" "%" None
>>> format(314159267,"e") #科學計數法，默認保留6位小數
"3.141593e+08"
>>> format(314159267,"0.2e") #科學計數法，指定保留2位小數
"3.14e+08"
>>> format(314159267,"0.2E") #科學計數法，指定保留2位小數，采用大寫E表示
"3.14E+08"
>>> format(314159267,"f") #小數點計數法，默認保留6位小數
"314159267.000000"
>>> format(3.14159267000,"f") #小數點計數法，默認保留6位小數
"3.141593"
>>> format(3.14159267000,"0.8f") #小數點計數法，指定保留8位小數
"3.14159267"
>>> format(3.14159267000,"0.10f") #小數點計數法，指定保留10位小數
"3.1415926700"
>>> format(3.14e+1000000,"F")  #小數點計數法，無窮大轉換成大小字母
"INF"

#g的格式化比較特殊，假設p為格式中指定的保留小數位數，先嘗試采用科學計數法格式化，得到冪指數exp，如果-4<=exp>> format(0.00003141566,".1g") #p=1,exp=-5 ==》 -4<=exp>> format(0.00003141566,".2g") #p=1,exp=-5 ==》 -4<=exp>> format(0.00003141566,".3g") #p=1,exp=-5 ==》 -4<=exp>> format(0.00003141566,".3G") #p=1,exp=-5 ==》 -4<=exp>> format(3.1415926777,".1g") #p=1,exp=0 ==》 -4<=exp>> format(3.1415926777,".2g") #p=1,exp=0 ==》 -4<=exp>> format(3.1415926777,".3g") #p=1,exp=0 ==》 -4<=exp>> format(0.00003141566,".1n") #和g相同
"3e-05"
>>> format(0.00003141566,".3n") #和g相同
"3.14e-05"
>>> format(0.00003141566) #和g相同
"3.141566e-05"

bytes：用于不同編碼之間的轉化

s = "中國"
s1 = s.encode("utf-8")
print(s1.decode("utf-8"))

#將s1的gbk的bytes類型轉成utf-8的bytes類型
s = "中國"
s1 = s.encode("gbk")
print(s1.decode("gbk").encode("utf-8"))

bytearry：返回一個新字節數組。這個數組里的元素是可變的，并且每個元素的值范圍: 0 <= x < 256。

ret = bytearray("alex",encoding="utf-8")
print(id(ret))
print(ret)
print(ret[0])
ret[0] = 65
print(ret)
print(id(ret))

repr:返回一個對象的string形式（原形畢露）。

# %r  原封不動的寫出來
# name = "taibai"
# print("我叫%r"%name)

# repr 原形畢露
print(repr("{"name":"alex"}"))
print("{"name":"alex"}")

數據集合
　　　　dict：創建一個字典。
　　　　set：創建一個集合。
　　　　frozenset：返回一個凍結的集合，凍結后集合不能再添加或刪除任何元素。
相關內置函數
　　　　len:返回一個對象中元素的個數。
　　　　sorted：對所有可迭代的對象進行排序操作。

L = [("a", 1), ("c", 3), ("d", 4),("b", 2), ]
sorted(L, key=lambda x:x[1])               # 利用key
[("a", 1), ("b", 2), ("c", 3), ("d", 4)]
 
 
students = [("john", "A", 15), ("jane", "B", 12), ("dave", "B", 10)]
sorted(students, key=lambda s: s[2])            # 按年齡排序
[("dave", "B", 10), ("jane", "B", 12), ("john", "A", 15)]
 
sorted(students, key=lambda s: s[2], reverse=True)    # 按降序
[("john", "A", 15), ("jane", "B", 12), ("dave", "B", 10)]

　enumerate:枚舉，返回一個枚舉對象。

    print(enumerate([1,2,3]))
for i in enumerate([1,2,3]):
    print(i)
for i in enumerate([1,2,3],100):
    print(i)

all：可迭代對象中，全都是True才是True
any：可迭代對象中，有一個True 就是True

# all  可迭代對象中，全都是True才是True
# any  可迭代對象中，有一個True 就是True
# print(all([1,2,True,0]))
# print(any([1,"",0]))

zip：函數用于將可迭代的對象作為參數，將對象中對應的元素打包成一個個元組，然后返回由這些元組組成的列表。如果各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同。

l1 = [1,2,3,]
l2 = ["a","b","c",5]
l3 = ("*","**",(1,2,3))
for i in zip(l1,l2,l3):
    print(i)
 #
(1, "a", "*")
(2, "b", "**")
(3, "c", (1, 2, 3))

filter：過濾

def func(x):return x%2 == 0
ret = filter(func,[1,2,3,4,5,6,7])
print(ret)   
for i in ret:
    print(i)

map:會根據提供的函數對指定序列做映射，返回的是一個迭代器。

>>>def square(x) :            # 計算平方數
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 計算列表各個元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函數
[1, 4, 9, 16, 25]
 
# 提供了兩個列表，對相同位置的列表數據進行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

#map返回的是一個生成器，，取值要用for循環
for i in  map(lambda n:n+"_sb",["oldboy","alex","wusir"]):
    print(i)

匿名函數：為了解決那些功能很簡單的需求而設計的一句話函數。

def calc(n):
    return n**n
print(calc(10))
 
#換成匿名函數
calc = lambda n:n**n
print(calc(10))

上面是我們對calc這個匿名函數的分析，下面給出了一個關于匿名函數格式的說明
函數名 = lambda 參數 ：返回值

- 參數可以有多個，用逗號隔開
- 匿名函數不管邏輯多復雜，只能寫一行，且邏輯執行結束后的內容就是返回值
- 返回值和正常的函數一樣可以是任意數據類型