內建函式

內建函式
一、內建函式定義及總數
    python裡的內建函式。截止到python版本3.6.2，現在python一共為我們提供了68個內建函式。

            Built-in Functions
    abs()	    dict()	help()	min()	setattr()
    all()	    dir()	hex()	next()	slice()
    any()	    divmod()	id()	object()	sorted()
    ascii()	    enumerate()	input()	oct()	staticmethod()
    bin()	    eval()	int()	open()	str()
    bool()	    exec()	isinstance()	ord()	sum()
    bytearray()	filter()	issubclass()	pow()	super()
    bytes()	    float()	iter()	print()	tuple()
    callable()	format()	len()	property()	type()
    chr()	    frozenset()	list()	range()	vars()
    classmethod()	getattr()	locals()	repr()	zip()
    compile()	globals()	map()	reversed()	__import__()
    complex()	hasattr()	max()	round()
    delattr()	hash()	memoryview()	set()

二、分類

(1)作用域相關

    1.locals()    #返回本地作用域中的所有名字  函式會以字典型別返回當前位置的全部區域性變數。

    2.globals()   #返回全域性作用域中的所有名字  函式會以字典型別返回當前位置的全部全域性變數。

    與local、global不同
    local 變數  #宣告變數作用域
    global 變數 #宣告變數作用域

(2)迭代器

    1.next(iterator[, default])  返回迭代器的下一個專案
        迭代器.__next__()  效果都一樣，實際執行迭代器.__next__()

    2.iter(可迭代的) 函式用來生成迭代器。
        可迭代的.__iter__()

    3.range(start, stop[, step]) 函式可建立一個整數列表，一般用在 for 迴圈中。
        是一個可迭代的，不是一個迭代器
        range(10),range(1,10),range(1,10,2)

        print(dir(range(10)) )
        print( '__next__' in dir(range(10)) )   #False
        print( '__next__' in dir(iter(range(10))) )    #False  將可迭代的轉化成迭代器

(3)其他：

    1.dir() 不帶引數時，返回當前範圍內的變數、方法和定義的型別列表；帶引數時，返回引數的屬性、方法列表。
            如果引數包含方法__dir__()，該方法將被呼叫。如果引數不包含__dir__()，該方法將最大限度地收集引數資訊。
        print(dir(1))

    2.callable()  用於檢查一個物件是否是可呼叫的。如果返回True，object仍然可能呼叫失敗；但如果返回False，呼叫物件ojbect絕對不會成功。
                對於函式, 方法, lambda 函式, 類, 以及實現了 __call__ 方法的類例項, 它都返回 True。
        print(callable('alina')) -> False

        def func():pass
        print(callable(func))    ->   True

    3.help()  用於檢視函式或模組用途的詳細說明。
        help(list)

    4.import 模組名稱    呼叫__import__()  函式
        __import__()  一般不用
        # import datetime
        test_time = __import__('datetime')
        print(test_time.datetime.now())
            2018-09-27 14:28:46.529354

    5.open() 開啟檔案

    6.id() 檢視記憶體地址

    7.hash()
        print(hash(1234))
            1234
        print(hash('felix'))
            6020047598959426572
        字典的定址方式

    某個方法屬於某個資料型別的變數，就用 .呼叫
    如果某個方法不依賴於任何資料型別，就直接呼叫 ----內建函式 和 自定義函式

    8.input()  輸入，字串接受

    9.print()  輸出

        end=  指定輸出的結束符
            print('test',end='\t')

        sep=  指定輸出的分隔符
           print('test',sep='|')

        file=  指定輸出位置檔案   預設輸出到螢幕
            with open('file','w',encoding='utf-8') as f:
                print('測試print函式輸出位置',file=f)
        flush:立即把內容輸出到流檔案，不作快取


        #列印進度條
        import time
        for i in range(0,100000,2):
             time.sleep(0.1)
             char_num = i//2      #列印多少個'*'
             per_str = '\r%s%% : %s\n' % (i, '*' * char_num) if i == 100 else '\r%s%% : %s'%(i,'*'*char_num)
             print(per_str,end='', flush=True)
        #小越越  ： \r 可以把游標移動到行首但不換行
        列印進度條模組  progress Bar

    10.exec()
    11.eval() 用來執行一個字串表示式，並返回表示式的值。
        exec和eval都可以執行 字串型別的程式碼
        eval() 有返回值 ---有結果的簡單運算
        exec() 無返回值 ----簡單的流程控制
        eval()只能用在你明確知道你要執行的程式碼是什麼

        exec('print(123)')
        eval('print(123)')
        print(exec('print(123)'))  #沒有返回值
        print(eval('print(123)'))   #有返回值

        code = """[(print(i*'*')) for i in range(10)]"""
        exec(code)
        123
        123
        123
        None
        123
        None

        *
        **
        ***
        ****
        *****
        ******
        *******
        ********
        *********

    12.compile(source, filename, mode[, flags[, dont_inherit]]) 將一個字串編譯為位元組程式碼。
        code3 = """name = input('請輸入你的名字：')"""
        compile3 = compile(code3,'','single')

        exec(compile3)
        print(name)

(4)資料型別相關

    1.complex([real[, imag]]) 用於建立一個值為 real + imag * j 的複數或者轉化一個字串或數為複數。如果第一個引數為字串，則不需要指定第二個引數。。
        複數 —— complex
        實數 ： 有理數
                無理數
        虛數 ：虛無縹緲的數
        5 + 12j  === 複合的數 === 複數
        6 + 15j

    2.float() 用於將整數和字串轉換成浮點數。
        浮點數（有限迴圈小數，無限迴圈小數）  != 小數 ：有限迴圈小數，無限迴圈小數，無限不迴圈小數
        浮點數
            354.123 = 3.54123*10**2 = 35.4123 * 10
        f = 1.781326913750135970
        print(f)

    3.bin()  返回一個整數 int 或者長整數 long int 的二進位制表示
    4.oct()  將一個整數轉換成8進位制字串。
    5.hex()  函式用於將10進位制整數轉換成16進位制，以字串形式表示。

        print(bin(10))    0b1010
        print(oct(10))    0o12
        print(hex(10))    0xa

    6.abs()  求絕對值

    7.divmod(x,y)   把除數和餘數運算結果結合起來，返回一個包含商和餘數的元組(a // b, a % b)。
        Return the tuple (x//y, x%y)
        print(divmod(100,15))
            (6, 10)
        實際應為舉例：100條新聞，每15條方1頁，可以放多少頁


    8.round()  四捨五入

    9.pow(x,y[,z])  方法返回 xy（x的y次方） 的值。
        當有2個引數時候，為x的y次方，等價於 x**y
            print(pow(9,2))     ->  81
        當有3個引數是，為x的y次方，再對z取餘
            print(pow(9,2,4))  ->  1

    10.sum(iterable[, start])  求和

    11.max(iterable, *[, default=obj, key=func]) -> value
       max(arg1, arg2, *args, *[, key=func]) -> value
        print(max([1,22,9],[2,11,23]))
            [2, 11, 23]
        print(max(1,22,-100,key=abs))
            -100
    12.min(iterable, *[, default=obj, key=func]) -> value
       min(arg1, arg2, *args, *[, key=func]) -> value


    13.reversed()  保留原列表，反轉資料，返回一個可迭代的

        lst = [1,5,9,2,7,3]
        lst.reverse()
        print(lst)

        lst1 = []
        for i in reversed(lst):
            lst1.append(i)
        print(lst1)

    14.slice(start, stop[, step]) 實現切片物件，主要用在切片操作函式裡的引數傳遞。
        exp:
        lst = [1,5,9,2,7,3]
        slst = slice(0,4,2)
        print(lst[slst])
            [1, 9]


    15.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<p，則採用小數計數法，並保留p-1-exp位小數，否則按小數計數法計數，並按p-1保留小數位數
            >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點
            '3e-05'
            >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留1位小數點
            '3.1e-05'
            >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留2位小數點
            '3.14e-05'
            >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科學計數法計數，保留0位小數點，E使用大寫
            '3.14E-05'
            >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留0位小數點
            '3'
            >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留1位小數點
            '3.1'
            >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小數計數法計數，保留2位小數點
            '3.14'
            >>> format(0.00003141566,'.1n') #和g相同
            '3e-05'
            >>> format(0.00003141566,'.3n') #和g相同
            '3.14e-05'
            >>> format(0.00003141566) #和g相同
            '3.141566e-05'


    16.bytes()  轉換成bytes型別（轉換成二進位制型別）
        s = '王秋華'
        print(bytes('王秋華',encoding='utf-8')) #unicode轉換成utf-8的bytes
        print(bytes('王秋華',encoding='gbk'))   #unicode轉換成gbk的bytes
        print(s.encode('utf-8'))   #unicode轉換成utf-8的bytes
        print(s.encode('gbk'))     #unicode轉換成gbk的bytes

        網路程式設計：只能傳二進位制
        照片和視訊也是以二進位制儲存
        html網頁爬取到的也是編碼


    17.bytearray([source[, encoding[, errors]]]) 返回一個bytes陣列,對陣列進行取值，得到轉化為十進位制的數
                                    返回一個新位元組陣列。這個數組裡的元素是可變的，並且每個元素的值範圍: 0 <= x < 256。
        bytearray('王王王',encoding='utf')
            bytearray(b'\xe7\x8e\x8b\xe7\xa7\x8b\xe5\x8d\x8e')

        new_s = bytearray('王王王',encoding='utf')
        new_s_lst = []
        for i in new_s:
            new_s_lst.append(i)
        print(new_s_lst)
            [231, 142, 139, 231, 167, 139, 229, 141, 142]

    18.memoryview(bytes('hello,eva',encoding='utf-8'))  返回給定引數的記憶體檢視物件(Momory view)。
                        所謂記憶體檢視物件，是指對支援緩衝區協議的資料進行包裝，在不需要複製物件基礎上允許Python程式碼訪問。
                        針對bytes型別進行位元組型別的切片
        切片  ---- 位元組型別的切片 不佔記憶體

        s = memoryview(bytes('王王王',encoding='utf-8'))
        print(s[1])


    19.ord()  將unicode的1個字元轉換成unicode的1個數字
        chr() 函式（對於8位的ASCII字串）或 unichr() 函式（對於Unicode物件）的配對函式，它以一個字元（長度為1的字串）
        作為引數，返回對應的 ASCII 數值，或者 Unicode 數值，如果所給的 Unicode 字元超出了你的 Python 定義範圍，則會引發一個 TypeError 的異常。
        print(ord('f'))
            102
        print(ord('王'))
            29579
    20.chr()  將unicode的1個數字轉換成unicode的1個字元
              用一個範圍在 range（256）內的（就是0～255）整數作引數，返回一個對應的字元。
        print(chr(97))
            a

    21.ascii() 只要是ascii碼中的內容，就打印出來，不是就轉換成\u

    22.repr()  用於%r格式化輸出
        print(repr('1'))    '1'
        print(repr(1))      1

    23.diet() 字典

    24.set()集合

    25.frozenset([iterable])  返回一個凍結的集合，凍結後集合不能再新增或刪除任何元素。

        >>>a = frozenset(range(10))     # 生成一個新的不可變集合
        >>> a
        frozenset([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
        >>> b = frozenset('runoob')
        >>> b
        frozenset(['b', 'r', 'u', 'o', 'n'])   # 建立不可變集合
        >>>

相關內建函式

    1.len()  長度

    2.enumerate(object)  函式用於將一個可遍歷的資料物件(如列表、元組或字串)組合為一個索引序列，
                         同時列出資料和資料下標，一般用在 for 迴圈當中

        >>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
        >>>list(enumerate(seasons))
        [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
        >>>list(enumerate(seasons, start=1))       # 小標從 1 開始
        [(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

        普通的 for 迴圈
            >>>i = 0
            >>>seq = ['one', 'two', 'three']
            >>>for element in seq:
            ...    print(i, seq[i])
            ...    i += 1
            ...
            0 one
            1 two
            2 three

        for 迴圈使用 enumerate
            >>>seq = ['one', 'two', 'three']
            >>>for i, element in enumerate(seq):
            ...    print(i, seq[i])
            ...
            0 one
            1 two
            2 three

    3.all(iterable)  如果iterable的所有元素不為0、''、False或者iterable為空，all(iterable)返回True，否則返回False；
                     注意：空元組、空列表返回值為True，這裡要特別注意。
                     有一個False就為False

    4.any(iterable) 如果都為空、0、false，則返回false，如果不都為空、0、false，則返回true
                    有1個為true就為true
        >>>any(['a', 'b', 'c', 'd'])  # 列表list，元素都不為空或0   True
        >>> any(['a', 'b', '', 'd'])   # 列表list，存在一個為空的元素   True
        >>> any([0, '', False])        # 列表list,元素全為0,'',false  False
        >>> any(('a', 'b', 'c', 'd'))  # 元組tuple，元素都不為空或0  True
        >>> any(('a', 'b', '', 'd'))   # 元組tuple，存在一個為空的元素  True
        >>> any((0, '', False))        # 元組tuple，元素全為0,'',false   False
        >>> any([]) # 空列表    False
        >>> any(()) # 空元組  False

    5.zip([iterable, ...]) 拉鍊方法：
        函式用於將可迭代的物件作為引數，將物件中對應的元素打包成一個個元組，然後返回由這些元組組成的物件，
        這樣做的好處是節約了不少的記憶體。我們可以使用 list() 轉換來輸出列表。
        如果各個迭代器的元素個數不一致，則返回列表長度與最短的物件相同，利用 * 號操作符，可以將元組解壓為列表。
        >>>a = [1,2,3]
        >>> b = [4,5,6]
        >>> c = [4,5,6,7,8]
        >>> zipped = zip(a,b)     # 返回一個物件
        >>> zipped
        <zip object at 0x103abc288>
        >>> list(zipped)  # list() 轉換為列表
        [(1, 4), (2, 5), (3, 6)]
        >>> list(zip(a,c))              # 元素個數與最短的列表一致
        [(1, 4), (2, 5), (3, 6)]

        >>> a1, a2 = zip(*zip(a,b))          # 與 zip 相反，*zip 可理解為解壓，返回二維矩陣式
        >>> list(a1)
        [1, 2, 3]
        >>> list(a2)
        [4, 5, 6]
    6.filter() 函式用於過濾序列，過濾掉不符合條件的元素，返回一個迭代器物件，如果要轉換為列表，可以使用 list() 來轉換。
            該接收兩個引數，第一個為函式，第二個為序列，序列的每個元素作為引數傳遞給函式進行判，然後返回 True 或 False，最後將返回 True 的元素放到新列表中。

        exp1:
        def func(n):
            return n % 2 == 1
        ret = filter(func,[1,2,3,4,5,6,7,8,9])
        for i in ret:
            print(i)
        執行結果：1 3 5 7 9
        filter(func,[1,2,3,4,5,6,7,8,9])等同於
        [i for i in [1,2,3,4,5,6,7,8,9] if i % 2 == 1]

        exp2:
        過濾只要為字串的資訊：
        def func(s):
            if type(s) == str:
                return True
        ret = filter(func,[1, 'felix','love', 4, 5, 6,'alina'])
        for i in ret:
            print(i)
                felix
                love
                alina

        exp3:過濾空內容
        def is_str(s):
            return s and str(s).strip()
        ret = filter(is_str, [1, 'hello','','  ',None,[], 6, 7, 'world', 12, 17])
        print(ret)
        for i in ret:
            print(i)
                1
                hello
                6
                7
                world
                12
                17
        exp3:求1-100 平方根是整數的數
        import math
        def my_sqrt(s):
            #return (s**0.5) % 1 == 0
            return math.sqrt(s) % 1 == 0
        ret = filter(my_sqrt,range(1,101))
        for i in ret:
            print(i)

    7.map(function, iterable, ...) 根據提供的函式對指定序列做對映。

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

        filter和map：都是返回一個迭代器
            filter
            1.執行filter的結果集合 <= 執行之前的結果
            2.filter只管篩選，不會改變原來的值

            map:
            1.執行前後元素個數不變
            2.值可能會發生改變

    8.sorted(iterable[, cmp[, key[, reverse]]]) 函式對所有可迭代的物件進行排序操作。
        sort 與 sorted 區別：
        sort 是應用在 list 上的方法，sorted 可以對所有可迭代的物件進行排序操作。
        list 的 sort 方法返回的是對已經存在的列表進行操作，無返回值，
        而內建函式sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操作。

        >>>a = [5,7,6,3,4,1,2]
        >>> b = sorted(a)       # 保留原列表
        >>> a
        [5, 7, 6, 3, 4, 1, 2]
        >>> b
        [1, 2, 3, 4, 5, 6, 7]

        >>> L=[('b',2),('a',1),('c',3),('d',4)]
        >>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函式
        [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
        >>> 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)]
        >>>

        exp2:
        L = [1,-3,7,5,-2,-10]
        print(sorted(L,key=abs,reverse=True))

        L = ['sorted','sort','filter','map']
        print(sorted(L,key=len))