模組和棧

一：計數模組collections
    基礎版本：
        s="qwewsfdfjiehrfqweqweqwqewq"
        dic={}
        for el in s:
            dic[el]=dic.setdefault(el,0)+1
        print(dic)

    升級版本：
        import collections
        from collections import Counter
        s="qwewsfdfjiehrfqweqweqwqewq"
 

        qq=Counter(s)
        print("__iter__" in dir(qq))
        for item in qq:
            print(item,qq[item])

    # 同時列表也可以用counter
    # # 列表也可以用Counter
        import collections
        lst=["1","2","1","1","4","1"]
        q=collections.Counter(lst)
        print(q)  #列印： Counter({'1': 4, '2': 1, '4': 1})
 


二：棧和佇列
  001：棧
    棧的進出原則：先進後出
    棧的基本知識點總結：
    棧是一種先進後出的序列表，先放進去的元素，只能通過棧指標去取出來，每當放入一個元素的時候當往棧裡面新增一個元素時，
    棧指標會往上移動一個（index會變成 index+1--〉放元素時），取元素的時候，也是通過棧指標，取指標的下一個元素，此時棧
    頂指標是：  index=index-1（取元素時），，，空棧的時候新增元素只能用插入--〉insert()

    自定義棧滿了之後的異常
    class StackFullError(Exception):
        pass

    class StackEmptyError(Exception):
 

        pass

    class Stack:  #定義一個棧類
        def __init__(self,size):
            self.index=0  #棧頂指標
            self.lst=[]
            self.size=size

        def push(self,item):  #往棧裡面新增元素
            if self.index==self.size:
                #棧已經滿了   需要報錯
                raise StackFullError("the Stack is full")

            self.lst.insert(self.index,item)  #空列表需要用insert
            self.index+=1

        #從棧中獲取資料
        def pop(self):
            if self.index==0:
                raise StackEmptyError("the stack is empty")  #這裡也需要自定義一個異常（棧空了需要報異常）
            self.index-=1  #指標向下移動
            item=self.lst.pop(self.index)  #獲取元素刪除
            return item

    s=Stack(5)  #給棧一個大小
    s.push("q")
    s.push("w")
    s.push("e")
    s.push("r")
    s.push("t")  #往棧裡面新增元素

    print(s.pop())   #從棧裡面拿資料元素
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

    print(s.pop())  #超出棧大小，丟擲異常

  02）：佇列
    佇列資料進出原則：先進先出
   例子01：
    import queue   #引入佇列模組
    q=queue.Queue()  #建立一個佇列，固定模板（在queue模組中有一個）
    q.put("張三")
    q.put("李四")
    q.put("王五")
    q.put("旺財")
    q.put("小白")

    print(q.get())
    print(q.get())
    print(q.get())
    print(q.get())
    print(q.get())
    #列印：張三  李四   王五  旺財  小白
    #
    print(q.get())  #造成阻塞
    print("沒有了")
    #在佇列裡面已經沒有元素了，還繼續拿元素的時候，佇列會一直處於執行狀態，等待著元素的進入，這個時候就是阻塞了

  03):雙向佇列
    from collections import deque  #從系統中自帶的collections 模組 引入 deque
    q=deque() #建立一個雙向佇列

    q.append("張三")  #從右邊末尾開始加元素
    q.append("李斯特") #加在最右邊，提取資料時候，總是從最右邊開始獲取

    q.appendleft("王五")  #加在最左邊，提取的時候總是從最左邊開始獲取資料
    q.appendleft("旺財")

    print(q.pop())  #從最右邊開始獲取
    print(q.popleft()) #從最左邊開始獲取


  04）：namedtuple  #命名元組
    from collections import namedtuple
    Point=namedtuple("點",["x","y","z"])
    p=Point("zhangshan","lisu","王五")
    print(p)
    print(p.x)
    print(p.y)
    print(p.z)

    類似於：
    class Point:
        def __init__(self,x,y):
            self.x=x
            self.y=y
    p=Point(2,3)
    p.z=12
    print(p.z)

  05):預設字典 defaultdict
    例子01：
    from collections import defaultdict
    lst=[11,22,33,44,55,66,77,88,99]
    d=defaultdict(list)   #d是一個空列表
    for el in lst:
        if el<66:
            d["key1"].append(el)   #d["key1"]  是一個字典的鍵，將el 新增到其所對應的鍵值的列表中
        else:
            d["key2"].append(el)  #key1 key2 是不存在的，但是可以拿到key1 key2
    print(d)

  例子2：
    from collections import defaultdict
    d=defaultdict(list)
    #d=defaultdict(abc)    abc 可以是list、set、str等等，作用是當key不存在時，
    # 返回的是abc的預設值，比如list對應[ ]，str對應的是空字串，
    d["wangwu"]="王五"
    print(d["zhangsan"])  #列印：[]
    print(d["wangwu"])  #列印：王五

  06）：orderdict和defaultdict
    orderdict 顧名思義. 字典的key預設是⽆序的. ⽽OrderedDict是有序的
    dic = {'a':'娃哈哈', 'b':'薯條', 'c':'胡辣湯'}
    print(dic)
    from collections import OrderedDict
    od = OrderedDict({'a':'娃哈哈', 'b':'薯條', 'c':'胡辣湯'})  #從這個3.6版本是看不出來的，但是內部是無序的
    print(od)

三：時間模組
    獲取當前時間 （時間戳）
  001：列印本地時間（時間有localtime 和 gmtime ）
    import time
    print(time.time()) #d列印的時當前時間：1542167144.751588

  002格式化時間：
    s=time.strftime("%Y/%m/%d %H:%M:%S")  #string format time
    print(s)  #列印：2018/11/14 11:48:02
    相似類等待時間 ：wait()  #傻等，必須要是 notify()
    例子：
    while 1:   #這是一個計時器
        s=time.strftime("%Y-%m-%d %H:%M:%S")
        print(s)
        time.sleep(2)  #每隔（睡眠） 2秒 然後再執行列印

  003:結構化時間：
    import time
    t=time.localtime()
    print(t)
    #列印：time.struct_time(tm_year=2018, tm_mon=11, tm_mday=14, tm_hour=11, tm_min=55, tm_sec=22, tm_wday=2, tm_yday=318, tm_isdst=0)
    print(t.tm_year)  #只獲取年份，其他的分 秒類似寫法

  004：將時間戳轉換成格式化時間
    時間戳--〉格式化時間：
    import time
    a=19888899
    t=time.localtime(a)
    #t=time.gmtime(0)   #時區   gmtime() 格林尼治時間
    print(t)  #列印：time.struct_time(tm_year=1970, tm_mon=8, tm_mday=19, tm_hour=12, tm_min=41, tm_sec=39, tm_wday=2, tm_yday=231, tm_isdst=0)
    str_time=time.strftime("%Y/%m/%d %H:%M/%S:%A/%Z",t)
    print(str_time)  #列印：1970/08/19 12:41/39:Wednesday

    格式化時間--〉時間戳(思路：格式化時間--〉結構化時間--〉時間戳)

    import time
    # 格式化時間--〉結構化時間
    s="2017-2-23 13:45:34"
    t=time.strptime(s,"%Y-%m-%d %H:%M:%S")
    print(t)  #列印：time.struct_time(tm_year=2017, tm_mon=2, tm_mday=23, tm_hour=13, tm_min=45, tm_sec=34, tm_wday=3, tm_yday=54, tm_isdst=-1)
    # 結構化時間--〉時間戳
    tt=time.mktime(t)
    print(tt) #列印：1487828734.0

  案例：
    時間戳和格式化   結構化時間的相互轉換（用兩種方法寫）
    例子：
    計算時間差(使用者輸入起始時間和結束時間. 計算時間差(小時),
    例如, 使用者輸入 2018-10-08 12:00:00 2018-10-08 14:30:00 輸出 2 小時30分
  方法一：
    思路：格式化時間--〉結構化時間-->時間戳  然後時間戳相減，得到差值，將差值進行轉為結構化時間輸出
    import time
    a1="2018-10-08 12:00:00"
    a2="2018-10-08 14:30:00"
    t1=time.strptime(a1,"%Y-%m-%d %H:%M:%S")  #格式化時間轉換為結構化時間  time.strptime(string,format)
    #print(t1) #time.struct_time(tm_year=2018, tm_mon=10, tm_mday=8, tm_hour=12, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=281, tm_isdst=-1)
    t2=time.strptime(a2,"%Y-%m-%d %H:%M:%S")  #格式化時間轉換為結構化時間  time.strptime(string,format)
    #print(t2) #time.struct_time(tm_year=2018, tm_mon=10, tm_mday=8, tm_hour=14, tm_min=30, tm_sec=0, tm_wday=0, tm_yday=281, tm_isdst=-1)

    tt1=time.mktime(t1)  #將結構化時間通過time.mktime() 轉換為時間戳
    # print(tt1)  #1538971200.0
    tt2=time.mktime(t2) #將結構化時間通過time.mktime() 轉換為時間戳
    # print(tt2)   #1538980200.0
    tt_new=int(abs(tt1-tt2))   #不知道=誰減去誰，直接一個abs（）絕對值就可以了
    # print(tt_new)  #9000
    tt_last=time.gmtime(tt_new) #在將時間戳轉換為結構化時間（不要用time.localtime()  不然會有8小時的時區差）
    print(tt_last)  #  time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=2, tm_min=30, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)
    print("時間差了%d年%d月%d天%d小時%d分鐘%d秒" % (tt_last.tm_year-1970,tt_last.tm_mon-1, tt_last.tm_mday-1,tt_last.tm_hour, tt_last.tm_min, tt_last.tm_sec))

  方法二：
    思路：也是分別將給定的格式化時間轉換為時間戳，然後將時間戳轉換為結構化時間
    import time
    a1="2018-10-08 12:00:00"
    a2="2018-10-08 14:30:00"
    t1=time.strptime(a1,"%Y-%m-%d %H:%M:%S")  #格式化時間轉換為結構化時間  time.strptime(string,format)
    t2=time.strptime(a2,"%Y-%m-%d %H:%M:%S")  #格式化時間轉換為結構化時間  time.strptime(string,format)
    tt1=time.mktime(t1)  #將結構化時間通過time.mktime() 轉換為時間戳
    tt2=time.mktime(t2) #將結構化時間通過time.mktime() 轉換為時間戳
    tt_new=int(abs(tt1-tt2))   #不知道誰減去誰，直接一個abs（）絕對值就可以了
    print(tt_new)  #9000  這個是秒
    tt_Hour=tt_new//3600
    print(tt_Hour)  #顯示出：小時  2
    tt_Min=int((tt_new-tt_Hour*3600)/60) #顯示出來還剩下多少分鐘
    print(tt_Min)  #顯示出來分鐘  30
    print("時間差是%s小時%s分鐘" % (tt_Hour,tt_Min))

  ⽇期格式化的標準:
    %y 兩位數的年份表示（00-99）
    %Y 四位數的年份表示（000-9999）
    %m ⽉份（01-12）
    %d ⽉內中的⼀天（0-31）
    %H 24⼩時制⼩時數（0-23）
    %I 12⼩時制⼩時數（01-12）
    %M 分鐘數（00=59）
    %S 秒（00-59）
    %a 本地簡化星期名稱
    %A 本地完整星期名稱
    %b 本地簡化的⽉份名稱
    %B 本地完整的⽉份名稱
    %c 本地相應的⽇期表示和時間表示
    %j 年內的⼀天（001-366）
    %p 本地A.M.或P.M.的等價符
    %U ⼀年中的星期數（00-53）星期天為星期的開始
    %w 星期（0-6），星期天為星期的開始
    %W ⼀年中的星期數（00-53）星期⼀為星期的開始
    %x 本地相應的⽇期表示
    %X 本地相應的時間表示
    %Z 當前時區的名稱
    %% %號本身

四：random 模組
    import random  #引入隨機數模組
    print(random.randint(1,9))  #1到9 隨機產生 一個整數  （前閉後閉  可以取到9）
    print(random.random())  #隨機產生一個（0，1）之間的小樹
    print(random.choice([1,"張三",["李四","王五","趙四"]]))  # 從這些元素中隨機產生一個
    print(random.sample([["1","2","3"],"旺財","小白",123],2))   #2 代表從這些資料中隨機產生2個出來組成，可也可以改成其他3等等

    lst=[14,6,8,2,32,1,90,7]
    random.shuffle(lst)
    print(lst)  #每次返回的資料都不一樣。random對其順序打亂了
    lst的返回值為None


五：os模組(所有的和作業系統相關的內容都在os模組)
    import os
    os.makedirs("123/345")  #可⽣成多層遞迴⽬錄
    os.removedirs("123")   #FileExistsError: [WinError 183] 當檔案已存在時，無法建立該檔案。: '123/345'
    os.removedirs("123/345")  #刪除123資料夾下的345資料夾或則檔案，如果資料夾下有其他檔案，則無法進行刪除操作
    os.mkdir('123') #生成單級目錄；相當於shell中mkdir dirname
    os.rmdir('123') #刪除單級空⽬錄，若⽬錄不為空則⽆法刪除，報錯；相當於shell中
    print(os.listdir("../整理--day019 約束和異常處理/"))  #返回指定的資料夾包含的檔案或資料夾的名字的列表。這個列表以字母順序
    os.remove("123/234")  #刪除123資料夾下的234檔案（或則資料夾） ，當234資料夾內有內容時，無法刪除
    os.rename("oldname","newname") 重新命名⽂件/⽬錄
    os.stat('path/filename')   獲取⽂件/⽬錄資訊
    os.system("bash command")  #運⾏shell命令，直接顯示
    os.popen("bash command").read()  #運⾏shell命令，獲取執⾏結果
    os.getcwd() 獲取當前⼯作⽬錄，即當前python指令碼⼯作的⽬錄路徑
    os.chdir("dirname") 改變當前指令碼⼯作⽬錄；相當於shell下cd

    os.path
    os.path.abspath(path) 返回path規範化的絕對路徑
    os.path.split(path) 將path分割成⽬錄和⽂件名⼆元組返回
    os.path.dirname(path) 返回path的⽬錄。其實就是os.path.split(path)的第⼀個元素
    os.path.basename(path) 返回path最後的⽂件名。如何path以／或\結尾，那麼就會返回空值。
    即os.path.split(path)的第⼆個元素
    os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False
    os.path.isabs(path) 如果path是絕對路徑，返回True
    os.path.isfile(path) 如果path是⼀個存在的⽂件，返回True。否則返回False
    os.path.isdir(path) 如果path是⼀個存在的⽬錄，則返回True。否則返回False
    os.path.join(path1[, path2[, ...]]) 將多個路徑組合後返回，第⼀個絕對路徑之前的引數
    將被忽略
    os.path.getatime(path) 返回path所指向的⽂件或者⽬錄的最後訪問時間
    os.path.getmtime(path) 返回path所指向的⽂件或者⽬錄的最後修改時間
    os.path.getsize(path) 返回path的⼤⼩
    # 特殊屬性:
    os.sep 輸出作業系統特定的路徑分隔符，win下為"\\",Linux下為"/"
    os.linesep 輸出當前平臺使⽤的⾏終⽌符，win下為"\r\n",Linux下為"\n"
    os.pathsep 輸出⽤於分割⽂件路徑的字串 win下為;,Linux下為:
    os.name 輸出字串指示當前使⽤平臺。win->'nt'; Linux->'posix'

    os.stat() 屬性解讀:
    stat 結構:
    st_mode: inode 保護模式
    st_ino: inode 節點號。
    st_dev: inode 駐留的裝置。
    st_nlink: inode 的連結數。
    st_uid: 所有者的⽤戶ID。
    st_gid: 所有者的組ID。
    st_size: 普通⽂件以位元組為單位的⼤⼩；包含等待某些特殊⽂件的資料。
    st_atime: 上次訪問的時間。
    st_mtime: 最後⼀次修改的時間。
    st_ctime: 由作業系統報告的"ctime"。在某些系統上（如Unix）是最新的元資料更改的時間，在
    其它系統上（如Windows）是建立時間（詳細資訊參⻅平臺的⽂檔）。

六. sys模組
    所有和python直譯器相關的都在sys模組.
    sys.argv 命令⾏引數List，第⼀個元素是程式本身路徑
    sys.exit(n) 退出程式，正常退出時exit(0),錯誤退出sys.exit(1)
    sys.version 獲取Python解釋程式的版本資訊
    sys.path 返回模組的搜尋路徑，初始化時使⽤PYTHONPATH環境變數的值
    sys.platform 返回作業系統平臺名稱