摘要：裝飾器的應(yīng)用場景比如插入日志，性能測試，事務(wù)處理，緩存等等場景。裝飾器完美的遵循了這個開放封閉原則。迭代器迭代器遵循迭代器協(xié)議必須擁有方法和方法。直到函數(shù)執(zhí)行結(jié)束。調(diào)用相關(guān)函數(shù)用于檢查一個對象是否是可調(diào)用的。

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

1.現(xiàn)在我有一個需求，我想讓你測試這個函數(shù)的執(zhí)行時間，在不改變這個函數(shù)代碼的情況下：

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.但是如果有多個函數(shù)，我都想讓你測試他們的執(zhí)行時間，你每次是不是都得func1 = timer(func1)?這樣還是有點麻煩，因為這些函數(shù)的函數(shù)名可能是不相同，有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.剛剛我們討論的裝飾器都是裝飾不帶參數(shù)的函數(shù)，現(xiàn)在要裝飾一個帶參數(shù)的函數(shù)怎么辦呢？

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.上面的裝飾器已經(jīng)非常完美了，但是有我們正常情況下查看函數(shù)信息的方法在此處都會失效。

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__)   #查看函數(shù)的注釋 
print(func1.__name__)  #查看函數(shù)的名字

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

from functools import wraps
import time
def timer(func):
    @wraps(func)  # 加在最內(nèi)層函數(shù)正上方
    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__)   #查看函數(shù)的注釋
print(func1.__name__)  #查看函數(shù)的名字

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

1.裝飾器的固定格式：

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

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

from functools import wraps

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

假如你有成千上萬個函數(shù)使用了一個裝飾器，現(xiàn)在你想把這些裝飾器都取消掉，你要怎么做？
一個一個的取消掉？ 沒日沒夜忙活3天。。。
過兩天你領(lǐng)導(dǎo)想通了，再讓你加上。。。

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

def wrapper1(func):   #f = warpper1(f)  里面的f函數(shù)名 外面的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循環(huán)，說明他們都是可迭代的。

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))

我們現(xiàn)在是從結(jié)果分析原因，能被for循環(huán)的就是“可迭代的”，但是如果正著想，for怎么知道誰是可迭代的呢？
假如我們自己寫了一個數(shù)據(jù)類型，希望這個數(shù)據(jù)類型里的東西也可以使用for被一個一個的取出來，那我們就必須滿足for的要求。這個要求就叫做“協(xié)議”。
可以被迭代要滿足的要求就叫做可迭代協(xié)議?？傻鷧f(xié)議的定義非常簡單，就是內(nèi)部實現(xiàn)了__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"]

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

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

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

可迭代對象：

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

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

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

判斷該是否可迭代對象

迭代器含義：

內(nèi)部含有__iter__且含有__next__方法的對象就是迭代器，遵循迭代器協(xié)議

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

判斷該對象是不是迭代器

迭代器的好處:

減少內(nèi)存

惰性機制

單向執(zhí)行，不可逆

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

構(gòu)建方式：
1.函數(shù)方式

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

2.列表推導(dǎo)式

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

3.區(qū)別：

1.列表推導(dǎo)式直觀可以看出，但是占內(nèi)存
2.生成器表達式不易看出，但是節(jié)省內(nèi)存      

生成器Generator：

　　1.本質(zhì)：迭代器(所以自帶了__iter__方法和__next__方法，不需要我們?nèi)崿F(xiàn))
　　2.特點：惰性運算,開發(fā)者自定義

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

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

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

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)

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

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

1.locals ：函數(shù)會以字典的類型返回當(dāng)前位置的全部局部變量。
2.globals：函數(shù)以字典的類型返回全部全局變量

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

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

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/.../內(nèi)置函數(shù).py", "func": , "__name__": "__main__", "__package__": None}

1.字符串類型代碼的執(zhí)行 eval,exec

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

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

exec

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

2.輸入輸出相關(guān) 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:  默認(rèn)是輸出到屏幕，如果設(shè)置為文件句柄，輸出到文件
    sep:   打印多個值之間的分隔符，默認(rèn)為空格
    end:   每一次打印的結(jié)尾，默認(rèn)為換行符
    flush: 立即把內(nèi)容輸出到流文件，不作緩存
    """
"""

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

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

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

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

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

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

print(dir())   #查看當(dāng)前模塊的屬性列表 
["__annotations__", "__builtins__", "__cached__", "__doc__", "__file__", "__loader__", "__name__", "__package__", "__spec__", "s"]獲得當(dāng)前模塊的屬性列表
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：函數(shù)可創(chuàng)建一個整數(shù)對象，一般用在 for 循環(huán)中。
next：內(nèi)部實際使用了__next__方法，返回迭代器的下一個項目。

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

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

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.數(shù)字相關(guān)
數(shù)據(jù)類型：
　　　　bool ：用于將給定參數(shù)轉(zhuǎn)換為布爾類型，如果沒有參數(shù)，返回 False。
　　　　int：函數(shù)用于將一個字符串或數(shù)字轉(zhuǎn)換為整型。

print(int())  # 0

print(int("12"))  # 12

print(int(3.6))  # 3

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

2.float：函數(shù)用于將整數(shù)和字符串轉(zhuǎn)換成浮點數(shù)。

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

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

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

4.數(shù)學(xué)運算：
　　　　abs：函數(shù)返回數(shù)字的絕對值。
　　　　divmod：計算除數(shù)與被除數(shù)的結(jié)果，返回一個包含商和余數(shù)的元組(a // b, a % b)。
　　　　round：保留浮點數(shù)的小數(shù)位數(shù)，默認(rèn)保留整數(shù)。
　　　　pow：求xy次冪。（三個參數(shù)為xy的結(jié)果對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))  # 兩個參數(shù)為2**3次冪
print(pow(2,3,3))  # 三個參數(shù)為2**3次冪，對3取余。

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

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

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

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的值進行比較）返回最小的值對應(yīng)的鍵

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

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的值進行比較）返回最大的值對應(yīng)的鍵

列表和元祖（2）
　　　　list：將一個可迭代對象轉(zhuǎn)化成列表（如果是字典，默認(rèn)將key作為列表的元素）
　　　　tuple：將一個可迭代對象轉(zhuǎn)化成元祖（如果是字典，默認(rèn)將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)

相關(guān)內(nèi)置函數(shù) :
　　　　reversed：將一個序列翻轉(zhuǎn)，并返回此翻轉(zhuǎn)序列的迭代器。
　　　　slice：構(gòu)造一個切片對象，用于列表的切片。

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])

字符串相關(guān)
　　　　str：將數(shù)據(jù)轉(zhuǎn)化成字符串。
　　　　format:與具體數(shù)據(jù)相關(guān)，用于計算各種小數(shù)，精算等。

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

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

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

#g的格式化比較特殊，假設(shè)p為格式中指定的保留小數(shù)位數(shù)，先嘗試采用科學(xué)計數(shù)法格式化，得到冪指數(shù)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：用于不同編碼之間的轉(zhuǎn)化

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

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

bytearry：返回一個新字節(jié)數(shù)組。這個數(shù)組里的元素是可變的，并且每個元素的值范圍: 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"}")

數(shù)據(jù)集合
　　　　dict：創(chuàng)建一個字典。
　　　　set：創(chuàng)建一個集合。
　　　　frozenset：返回一個凍結(jié)的集合，凍結(jié)后集合不能再添加或刪除任何元素。
相關(guān)內(nèi)置函數(shù)
　　　　len:返回一個對象中元素的個數(shù)。
　　　　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：函數(shù)用于將可迭代的對象作為參數(shù)，將對象中對應(yīng)的元素打包成一個個元組，然后返回由這些元組組成的列表。如果各個迭代器的元素個數(shù)不一致，則返回列表長度與最短的對象相同。

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:會根據(jù)提供的函數(shù)對指定序列做映射，返回的是一個迭代器。

>>>def square(x) :            # 計算平方數(shù)
...     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 匿名函數(shù)
[1, 4, 9, 16, 25]
 
# 提供了兩個列表，對相同位置的列表數(shù)據(jù)進行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

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

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

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

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

- 參數(shù)可以有多個，用逗號隔開
- 匿名函數(shù)不管邏輯多復(fù)雜，只能寫一行，且邏輯執(zhí)行結(jié)束后的內(nèi)容就是返回值
- 返回值和正常的函數(shù)一樣可以是任意數(shù)據(jù)類型