一. 模組
    模組: 是把裝有特定功能的程式碼進行歸類的結果, 從程式碼編寫的單位來看我們的程式, 從小到大的順序: 一條程式碼 < 語句塊 < 程式碼塊(函式, 類) < 模組. 我們目前寫的所有py檔案都是模組
    引入模組的方式: 
    1. import 模組
    2. from xxx import 模組
二. collections模組
    collections模組主要封裝了一些關於集合類的相關操作和一些除了基本資料型別以外的資料集合型別
    1. Counter
    計數器, 主要用來計數
    collections.Counter()
    之前的做法:
    s = "alex like pig"
    dic = {}
    for c in s:
        dic[c] = dic.get(c, 0) + 1
    print(dic)
    # {'a': 1, 'l': 2, 'e': 2, 'x': 1, ' ': 2, 'i': 2, 'k': 1, 'p': 1, 'g': 1}
    現在的做法:
    print(collections.Counter(s)) 
    # Counter({'l': 2, 'e': 2, ' ': 2, 'i': 2, 'a': 1, 'x': 1, 'k': 1, 'p': 1, 'g': 1})
    2. deque
    先看一下棧和佇列
    (1).棧: Stack, 先進後出
    (2).佇列: queue, 先進先出
    python中沒有給出Stack模組, 手動寫一個粗略版本(注意: 此版本有嚴重的併發問題)
        class StackFullException(Exception):
            pass
    
        class StackEmptyException(Exception):
            pass
        
        class Stack:
            def __init__(self, size):
                self.size = size
                self.top = 0
                self.list = []
        
            def push(self, el):
                if self.top >= self.size:
                    raise StackFullException
                self.list.insert(self.top, el)
                self.top += 1
        
            def pop(self):
                if self.top == 0:
                    raise StackEmptyException
                self.top -= 1
                el = self.list[self.top]
                return el
    python中給出了queue模組, 使用起來很方便
    import queue
    q = queue.Queue()
    再來看deque, 雙向佇列
        import cellections import deque
        q.append()
        q.appendleft()
        q.pop()
        q.popleft()
    3. namedtuple 
    命名元祖, 就是給元祖內的元素進行命名
        from collections import namedtuple
        nt = namedtuple("point", ["x", "y"])
        p = nt(1, 2)
        print(p)
        print(p.x)
        print(p.y)
        # point(x=1, y=2)
        # 1
        # 2
    4. OrderDict 和 defaultdict
    orderdict是有序化的, 字典的key是無序的
    defaultdict: 可以給字典設定預設值, 當key不存在時, 直接獲取預設值
    from collections import defaultdict

    dd = defaultdict(list)
    print(dd["娃哈哈"])
    # []
三. time 時間模組
    在python中時間有三種表現形式:
    1. 時間戳(timestamp): 時間戳使用的是從1970年01月01日00點00分00秒到現在一共經過了多少秒, 使用float來表示
    2. 格式化時間(strftime): 這個時間可以根據我們的需要對時間進行任意的格式化
    3. 結構化時間(struct_time): 得到元祖的形式, 這個時間主要可以把時間進行分類劃分
    import time
    time.time()        返回當前時間的時間戳

    time.localtime(s)    將一個時間戳轉換為當前時區的結構化時間struct_time
    #time.struct_time(tm_year=2018, tm_mon=12, tm_mday=26, tm_hour=20, tm_min=11, tm_sec=32, tm_wday=2, tm_yday=360, tm_isdst=0)
    time.gmtime(s)    將一個時間戳轉換為UTC時區(0時區)的結構化時間struct_time

    time.mktime(st)    將一個struct_time轉換為時間戳

    time.sleep(s)    執行緒推遲指定的時間執行

    time.strftime("時間格式", st)    把一個代表時間的元祖或者struct_time轉換成格式化的時間字串
    time.strptime(st, "時間格式")    把一個格式化時間字串轉換成struct_time

    涉及時間轉換的都要通過結構化時間st在中間過度
    (1). 時間戳s --> 格式化時間ft        
        a. 時間戳s --> 結構化時間st
        st = time.localtime(s)
        b. 結構化時間st --> 格式化時間ft
        ft = time.strftime("時間格式", st)
    (2). 格式化時間ft --> 時間戳s
        a. 格式化時間ft --> 結構化時間st
        st = time.strptime(st, "時間格式")
        b. 結構化時間st --> 時間戳s
        s = time.mktime(st)
    綜上: localtime(s) 和 strftime("timeformat", st) 一起用
        strptime(st, "timeformat") 和 mktime(st) 一起用
四. random 模組
    所有關於隨機的相關內容都在random中
    random.seed(x)
    #產生隨機數時，需要提供一個基礎數然後根據此季楚書產生偽隨機數
    #random.seed(x)可以讓你提供基礎數，需要你手動呼叫random.seed(x)
    #如果沒有手動呼叫random.seed(x)，則系統預設使用系統時間為基礎數
    random.randint(n,m)
    #生成n，m之間的隨機整數int，結果∈[n, m)
    #n和m必須都是整數，且a>b或者a==b，而a<b將語法錯誤
    random.random()
    #生成0,1之間的隨機浮點數float，結果∈[0.0, 1,0)
    random.uniform(a,b)
    #生成a,b之間的隨機浮點數float，結果屬於(float)[a,b]
    #a,b不用必須都是整數(或浮點數)，a>b，a<b，a==b都合法
    random.choice(seq)
    #從序列中隨機選一個元素，序列中元素型別無限定
    random.randrange(start, stop, step)
    #生成一個從start止到stop(不包括stop)，間隔為step的一個隨機整數
    #start，stop，step必須都是整數
    #必須start < stop
    #start預設是0，step預設是1
    #制定step時，必須指定start
    #效果等同random.choice(range(start, stop, step))
    random.randrange(start, stop)     等效random.randrage(start, stop, 1)
    random.randrange(stop)             等效random.randrange(0, stop, 1)
    random.sample([], k)
    #從population序列中，隨機獲取k各元素，生成一個新序列
    random.shuffle(seq)
    #效果是把seq中的元素順序打亂
    #lst = [1, 2, 3, 4, 5]
    #random.shuffle(lst)
    #print(lst)
五. functools 模組  https://blog.csdn.net/hang916/article/details/80301303
    1. wraps 常和裝飾器一起用, 改變一個函式的名字
    from functools import wraps
    def wrapper(fn):    
        @wraps(fn)          #把inner的名字改變為原來的func
        def inner(*args, **kwargs)
            print("前")
            ret = fn(*args, **kwargs)
            print("後")
            return ret
        return inner 
    
    @wrapper        # func = wrapper(func)
    def func():
        print("哈哈")
    
    print(func.__name__)
    # func
    2. reduce 歸納  map和reduce用法:https://www.cnblogs.com/weiman3389/p/6047095.html
    reduce()函式原型是reduce(function,sequence),它的作用是用function對序列進行累積操作。它返回值可以直接輸出，不像map和filter返回的是一個迭代物件，還得去轉化。
    所謂的累計操作就是就是第 1、2 個元素用 function 函式運算，得到的結果再與第三個資料用 function 函式運算，然後得到的結果再與第四個進行運算，一次類推。
    下面通過一個具體的例子來說明所謂的累計操作是怎麼樣的。
    #函式功能是實現階乘
    from functools import reduce  
    print(reduce(lambda x,y:x*y, [1,2,3,4])
    #輸出是24
    #整個過程如下：
    1、操作第1，2個元素，即1*2 得到2
    2、操作1的結果和第3個元素，即 2*3 得到6
    3、操做2的結果和第4個元素，即 6*4 得到24
    4、返回24
    3. partial(func, *args, **kwargs)    詳情: https://blog.csdn.net/appleyk/article/details/77609114
    對函式區域性進行控制，這個區域性最常見的就是對引數的控制
    from functools import partial
    def run(name, age):
        print(name, age)
    run2 = partial(run, age=18)
    run2("laowang")
    輸出：
    laowang, 18