Python Built-in Function 學習筆記

1. 匿名函數
    1.1 什么是匿名函數
        python允許使用lambda來創建一個匿名函數，匿名是因為他不需要以標准的方式來聲明，比如def語句

    1.2 匿名函數優點
        節省內存：如果不把它賦值給一個變量的話，由於是匿名的，不用分配棧空間
        不會重名
        可以嵌在推導式中，代碼更簡練
    1.3 舉例
        lambda 參數列表:返回值
        a = lambda x,y=2:x+y
        a(5)  ==>  7
        a(2,3)==>  5


2. 內置函數
   2.1 abs():返回一個數值的絕對值，參數接受整數或浮點數，如果參數是復數，返回復數的模
   2.2 all(iterable): 可迭代對象為空或者元素全為True,返回True。 類似與and
   2.3 any(iterable): 可迭代對象中有一個元素為True返回True,否則返回False
   2.4 ascii():類似repr()
            print(ascii("abc\n"))  #'abc\n'

   2.5 bin(int):
            print(bin(100)) #0b1100100
            a = bin(100)
            print(type(a)) <class 'str'> 返回值是一個字符串
            將整數轉換為二進制字符串，結果是一個有效的python表達式。
   2.6 bool(x):
            bool類型是int的子類，返回布爾True或False，使用真值測試標准對x進行轉換。
            print(bool("123"))  --> True
   2.7 bytearray():返回一個字節數組
         source:
            如果是一個字符串，需要指定編碼，以及可選的參數errors
            如果是一個可迭代對象，其整數元素取值范圍0 <= x < 256
         a = bytearray("abc",encoding='utf-8',errors="失敗")
         print(a,type(a)) # bytearray(b'abc') <class 'bytearray'>
         print(a[0]) # 97
         print(a[1]) # 98
         print(a[2]) # 99

   2.8 bytes(): 返回一個新的字節對象，是一個0 <= x < 256不可變的整數序列，是bytearray()不可變版本
   2.9 callable(object):
        如果object是可調用的，返回True。
        注：類是可以調用的，調用一個類會返回一個新的實例
   2.10 chr():
        ord()的逆操作,通過字符返回Unicode碼值.
        print(chr(98)) #b
   2.11 classmethod():
        將函數包裝成類方法。
        類方法隱式的將類作為第一個參數接收，就像實例方法接收實例一樣
   2.12 compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1):
        將source編譯成代碼或AST對象。代碼對象可以被exec()或eval()執行
   2.13 complex():
        返回復數
   2.14 delattr(object,name):
        參數:對象,字符串(必須是對象屬性之一的名稱),該函數實現刪除對象指定屬性的操作，只要改對象允許
        delattr(x,'name')  ===>   del x.name

   2.15 dict(): 創建一個字典。dict對象是一個字典類，可以是實例化一個字典對象
        d = dict({'a':96})
   2.16 dir([object]):
        打印：
            --> 內置方法
            --> 內置屬性
            --> 對象屬性
            --> 對象方法
            --> 類屬性
            --> 類方法

        1. 不帶參數的時候：返回當前作用域的名稱列表
        2. 帶參數時：返回object有效屬性列表
        3. 如果對象具有__dir__()方法，將會調用此方法，並且必須返回屬性列表

        I.   如果對象是模塊對象：列表包含模塊的屬性名
        II.  如果對象是類型或者類對象，列表包含其屬性名稱，並顯示其父類的屬性的遞歸。
        III. 否則列表包含對象的屬性名稱，其類屬性的名稱以及其類的基類的屬性的遞歸。

   2.17 divmod(a,b):兩個整數作為參數，返回商和余組成的元組。使用的整除(商,余數)
        print(divmod(1,2)) # (0,1)
        print(divmod(4,2)) # (2,0)
        print(divmod(10,3),type(divmod(10,3))) # (3,1)<class 'tuple'>

   2.18 enumerate(iterable,start=0):
        1. 返回一個enumerate object對象,索引默認從0開始
        2. 調用enumrate object的__next__()方法，返回一個元組
        3. 該元組包含一個計數,從start開始和iterable迭代的值

        for i in enumerate([1,2,3,4],start=0):
            print(i)

        (0, 1)   (start,iterable)
        (1, 2)
        (2, 3)
        (3, 4)

   2.19 eval(expression, globals=None, locals=None):
        參數是一個字符串和可選的全局變量和局部變量。
        也用於執行任意代碼對象,支持語句的動態執行
        eval("print('Hello')")   --->   console打印：  Hello

   2.20 exec(object[, globals[, locals]):
        這個函數支持動態執行Python代碼。object必須是一個字符串或代碼對象。
        如果它是一個字符串，則將該字符串解析為一組Python語句，然后執行該語句（除非發生語法錯誤）。
        如果它是一個代碼對象，只是簡單地執行它。
        exec("print('Hello')")   --->   console打印：  Hello

        eval()和exec()區別:
            1. 如果是簡單的表達是求值，eval()和exec()都可以
            2. exec()支持字符串、代碼對象、復雜的Python代碼
            3. eval()僅支持有效的表達式求值並返回計算結果

   2.21 filter(function, iterable):  類似表達式的過濾。比列表推導式省內存
            1. 如果function不是None，等效於生成器表達式，比列表推導式省內存
            2. 如果function是None,等效於列表推導式

            f = filter(None,shares)  # 函數為None,類似列表推導式，循環打印出每一個值
            print(f,type(f)) #<filter object at 0x00000242A5C585C0> <class 'filter'>
            for i in f:
                print(i)
                '''
                IBM
                Lenovo
                ocean
                '''

            # 類似可迭代對象的過濾工具：把每一項拿出來處理
            f = filter(lambda x:shares[x]>20,shares)  # 他會把每個元素拿出來，放到函數中，然后根據函數的返回值。返回一個filter對象
            print(f,type(f)) #<filter object at 0x00000242A5C585C0> <class 'filter'>
            for i in f:
                print(i)
            '''
            IBM
            Lenovo
            '''


   2.22 float():返回一個由數字或字符串x構造的浮點數。
   2.23 format():  字符串格式化
        I.
            print("{},{},{}".format(name,age,name)) # 不可以重復，有序
        II.
            print("{0},{1},{0}".format(name,age))  # 可以重復
        III.
            print("{name},{age},{name}".format(name=name,age=age))  # 可以重復，無序
   2.24 frozenset():返回一個新的frozenset對象，可選地使用iterable中的元素。
            set(可變集合)與frozenset(不可變集合)的區別：
            set無序排序且不重復，是可變的,有add（），remove（）等方法。既然是可變的，所以它不存在哈希值。基本功能包括關系測試和消除重復元素.
            frozenset是凍結的集合，它是不可變的，存在哈希值，好處是它可以作為字典的key，也可以作為其它集合的元素。缺點是一旦創建便不能更改，沒有add，remove方法。
   2.25 getattr(object,name[, default]):
            返回對象命名屬性的值，name必須是字符串
            如果name是對象屬性之一，則該結果是該屬性的值。
                getattr(x,"name") ===>  x.name
            如果name不存在,則返回提供default值，否則引發AttributeError

   2.26 globals():
            返回當前全局變量名的字典
   2.27 hasattr(object,name):
            參數是一個對象和一個字符串。如果字符串是對象的一個屬性，則返回True，否則返回False。
            它的實現是通過調用getattr(object, name)並查看它是否引發一個AttributeError。
            在getattr()之前判斷object是否含有某個屬性
   2.28 hash():
        返回該對象的哈希值（如果有的話）. 哈希值應該是一個整數。
        哈希值用於在查找字典時快速地比較字典的鍵。
        相等數值的哈希值相同（即使它們的類型不同，比如1和1.0）.

   2.29 help():調用內置的幫助系統。
   2.30 hex():將整數轉換為以“0x”為前綴的小寫十六進制字符串
   2.31 id(): 返回對象的內存地址
            返回一個對象的“身份”。
            這是一個整數，它保證在該對象的生命周期內是唯一的和恆定的。
            具有不重疊壽命的兩個對象可以具有相同的id()值。
   2.32 input([prompt]):
            如果存在提示符參數，則將其寫入標准輸出而不帶結尾換行符。
            然后該函數從輸入中讀取一行，將其轉換為一個字符串（剝離尾隨的換行符），然后返回該行。
            當讀取到EOF時，會產生EOFError。
                input("Hello")  ---> console：Hello

   2.33 int():
            從數字或字符串（x）構造並返回一個整數對象
            如果沒有給出參數，則返回0。
            如果 x 是一個數字，返回 x.__int__()。對於浮點數，這將截斷為零。

   2.34 isinstance(object, classinfo):
            instance(實例,類型)
            如果object是clsaainfo的一個實例（或者是classinfo的直接、間接或虛擬子類的實例），那么則返回true。
            如果object不是給定類型的對象，則該函數始終返回false。

            如果classinfo是類型對象的元組（或者其他這樣的元組），如果object是任何類型的實例，則返回true。
            如果classinfo不是類型或類型組成的元祖和此類元組，則會引發TypeError異常。

   2.35 issubclass(class, classinfo):
            issubclass(類,或父類)
            如果 class 是classinfo的子類(直接、 間接或 虛擬) 則返回 true 。
            一個類被認為是它自己的一個子類。

            任何其他情況下，會引發TypeError異常。

   2.36 iter(object[, sentinel]):
            1. 返回一個迭代器對象。
            2. 根據第二個參數:
                    沒有第二個參數，object必須是一個支持迭代協議（__iter__()方法）的容器對象，或者它必須支持序列協議
                    第二個參數sentinel，那么object必須是一個可調用的對象。  object.__next__()

   2.37 len():返回對象的長度（項目數量）。
   2.38 list():list不是一個函數，它實際上是一個可變的序列類型
   2.39 locals():更新和返回表示當前局部符號表的字典。當locals()在函數代碼塊中調用時會返回自由變量，但是在類代碼塊中不會。
   2.40 map(function, iterable, ...):
            1. 返回一個迭代器
            2. 對iterable的每個項應用function，並yield結果。
   2.41 max():
            返回iterable中的最大項或兩個或更多個參數中最大的項。
            max(iterable, *[, key, default])
            max(arg1, arg2, *args[, key])
   2.42 memoryview(obj):
            返回從給定參數創建的“內存視圖”對象。
   2.43 min():
            返回可迭代中的最小項或兩個或更多個參數中的最小項。
   2.44 next(iterator[, default]):
            通過調用__next__()方法從迭代器中檢索下一個項目。如果給出default，則在迭代器耗盡時返回，否則引發StopIteration。
   2.45 object():
            返回一個新的無特征的對象。
            該函數不接受任何的參數。
   2.46 oct():將整數轉換為八進制字符串。
   2.47 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None):
            打開 file 並返回一個相應的 文件對象.如果文件不能被打開, 拋出 OSError 異常.

   2.48 ord():
            給定一個表示一個Unicode字符的字符串，返回一個表示該字符的Unicode代碼點的整數。

   2.49 pow():返回x的y次方; 如果提供z參數， 返回x 的y次方再除以z的余數
   2.50 print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False):
                1. 將object打印到文本流file，由sep分隔，尾部接end。
                2. sep, end 和 file 如果提供這三個參數的話，必須以關鍵參數的形式。
   2.51 property():返回一個property 屬性。
            class Person(object):
                def __init__(self,name,age):
                    self.name = name
                    self.age = age

                def gettx(self):
                    return self.name

                def setx(self,name):
                    self.name=name

                def delx(self):
                    del self.name
                x = property(gettx, setx, delx, "I'm the 'x' property.")

            p = Person(name,age)

            # 和@property一樣。自定義托管屬性
            print(p.x)
            p.x="haha"
            del p.x
   2.52 range():
            range(stop)
            range(start, stop[, step])
                range實際上是一個不可變的序列類型
   2.53 repr():
            返回一個包含對象可打印表示的字符串。
            一個類可以通過定義一個__repr__()方法來控制該函數為其實例返回的內容。
   2.54 reversed(seq):
            返回一個反向iterator。seq必須是具有__reversed__()方法或支持序列協議（__len__()方法和__getitem__()方法，整數參數從0開始）。
   2.55 round(number[, ndigits]):
            四舍五入
            返回number舍入到小數點后ndigits位的浮點值。如果省略ndigits，將返回最接近輸入的整數。
   2.56 set():
            返回一個新的set對象，可選地使用iterable中的元素。
   2.57 setattr():
            它與getattr()相對應。參數是一個對象、一個字符串和一個任意值。
            該字符串可以命名現有的屬性或新的屬性。
            如果該對象允許，該函數將該值分配給該屬性。
            setattr(x, 'foobar', 123)等同於x.foobar = 123

   2.58 slice():
            class slice(stop)
            class slice(start, stop[, step])
            返回表示由范圍（start， stop， step）指定的一組索引的slice對象 T2>。


   2.59 sorted(iterable[, key][, reverse]):依據iterable中的元素返回一個新的排好序的列表。
            iterable[, key][, reverse]
            key指示一個帶有一個參數的函數，它用於從列表的每個元素中提取比較的關鍵字：key=str.lower
            reverse是一個布爾值。如果設置為True，那么列表中元素反過來比較來排序。


   2.60 staticmethod():
            為函數返回一個靜態方法。
   2.61 str()：
            返回一個object的str版本
            repr:對象以str形式表現出來，以便辨認
   2.62 sum(iterable[, start])：
            從左至右項目返回總數
            連接字符串序列的首選方法是通過調用''.join(sequence)的方式
   2.63 super(type[, object-or-type])：
            返回一個調用父類或者type同級類的委托方法
            訪問類中被覆蓋的繼承方法時很有用
            1. 在單繼承中，super()和其他編程語言類似，使用super()來引用父類，而不必明確命名它們
            2. 動態執行環境中，支持協同多繼承。


   2.64 tuple([iterable]):
            tuple實際上是一個不可變的序列類型，而不是一個函數
   2.65 type():
            class type(object)
            class type(name, bases, dict)

            使用一個參數，返回對象的類型。
            返回值是一個類型對象，並且通常與object.__class__返回的對象相同。
            建議使用isinstance()內置函數來測試對象的類型，因為它考慮了子類。
            有三個參數，返回一個新的類型對象。這本質上是class語句的動態形式。

   2.66 vars([object]):
            返回一個模塊、字典、類、實例或者其它任何一個具有__dict__屬性的對象的__dict__屬性。
   2.67 zip(*iterables):
            創建一個迭代器，聚合來自每個迭代器的元素。
            返回一個由元組構成的迭代器
            當最短的輸入迭代耗盡時，迭代器停止。  以短的為標准

            zip()當迭代器元素不一致時，循環停止在較短的迭代器元素，較長的迭代器元素會被舍棄。
            zip()結合*運算符可用於解壓縮列表

   2.68 __import__():
            通過 import 語句調用此函數。