常用模塊的介紹： time，datetime os，sys hashlib，json，pickle，collections time模塊： time 模塊（和時間相關）：封裝了獲取時間戳和字元串形式的時間的一些方法。 三大對象：時間戳， 結構化時間對象（9大欄位）， 字元串【重點】 ti ...
常用模塊的介紹：
time，datetime
os，sys
hashlib，json，pickle，collections
time模塊：
time 模塊（和時間相關）：封裝了獲取時間戳和字元串形式的時間的一些方法。
三大對象：時間戳， 結構化時間對象（9大欄位）， 時間字元串【重點】
time.time():獲取時間戳
time.gmtime([seconds]):獲取格式化時間對象:是九個欄位組成的
time.localtime([seconds]):獲取格式化時間對象:是九個欄位組成的
time.mktime(t):時間對象 -> 時間戳
time.strftime(format[,t]):把時間對象格式化成字元串
time.strptime(str,format):把時間字元串轉換成時間對象
time模塊三大對象之間的轉換關係：
import time # 獲取時間戳 # 時間戳：從時間元年（1970 1 1 00:00:00）到現在經過的秒數。 python:秒數 java:毫秒數 print(time.time())#1558317680.919616 #格林尼治時間 # 獲取格式化時間對象:是九個欄位組成的。 # 預設參數是當前系統時間的時間戳。預設使用time.time()的返回值。 tm_isdst夏令時 print(time.gmtime())# GMT time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=2, tm_min=1, tm_sec=20, tm_wday=0, tm_yday=140, tm_isdst=0) 模塊名.方法名 # 獲取時間元年過一秒後，對應的時間對象 print(time.gmtime(1))#time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0) print(time.localtime())#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=10, tm_min=1, tm_sec=20, tm_wday=0, tm_yday=140, tm_isdst=0) # 時間對象 ---> 時間戳 t1 = time.localtime() #時間對象 t2 = time.mktime(t1) #獲取對應的時間戳 print(t2)#1558318103.0 print(time.time())#1558318103.9826832 # 格式化時間對象轉換成字元串 strftime(format, p_tuple=None) s = time.strftime("%Y %m %d %H:%M:%S") #註意大小寫 print(s,type(s))#2019 05 20 10:05:17 <class 'str'> # 把時間字元串轉換成時間對象 strptime(string, format) time_obj = time.strptime('2019 05 20','%Y %m %d') #註意字元串中間加空格'2019 05 20' print(time_obj)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=140, tm_isdst=-1) time_obj = time.strptime('2019 05 20 12 30 55','%Y %m %d %H %M %S') print(time_obj)#time.struct_time(tm_year=2019, tm_mon=5, tm_mday=20, tm_hour=12, tm_min=30, tm_sec=55, tm_wday=0, tm_yday=140, tm_isdst=-1) #暫停當前程式，睡眠xxx秒 time.sleep(xxx) for i in range(5): print(time.strftime('%Y %m %d %H:%M:%S')) time.sleep(1)
datetime模塊：
datetime模塊:日期時間模塊，封裝了一些和日期、時間相關的類。 類包含若幹屬性和方法
date:需要年,月,日三個參數
time:需要時,分,秒三個參數
datetime:需要年,月,日,時,分,秒六個參數.
timedelta:需要一個時間段.可以是天,秒,微秒.
- timedelta可以和以下三個類進行數學運算: datetime.time, datetime.datetime, datetime.timedelta
獲取以上類型的對象,主要作用是和時間段進行數學運算. 對時間日期進行數學計算
import datetime #date類 d = datetime.date(2019,5,20) #獲取date對象的各個屬性 print(d)#2019-05-20 print(d.year)#2019 print(d.month)#5 print(d.day)#20 #time類： t = datetime.time(10,11,55) print(t)#10:11:55 #獲取time的各個屬性 print(t.hour)#10 print(t.minute)#11 print(t.second)#55 #datetime類： dt = datetime.datetime(2019,5,20,10,11,46) print(dt)#2019-05-20 10:11:46 #timedelta類：時間的變化量 td = datetime.timedelta(days=1) print(td,type(td))#1 day, 0:00:00 <class 'datetime.timedelta'> ##參與數學運算： # 創建時間對象，只能和以下三類進行數學運算: date,datetime,timedelta 【測試】：(date,datetime,timedelta分別於timedelta運算，datetime與date不能運算) td = datetime.timedelta(days=1) d = datetime.date(2010,10,10) res = d - td print(res)#2010-10-09 #timedelta和時間段進行運算的結果類型: 和另一個操作數的類型保持一致 td2 = datetime.date(2010,10,10) td = datetime.timedelta(days=1) res = d + td print(res,type(res))#2010-10-11 <class 'datetime.date'> d = datetime.datetime(2010,10,10,10,10,10) td = datetime.timedelta(days=1) res = d + td print(res,type(res))#2010-10-11 10:10:10 <class 'datetime.datetime'> d = datetime.timedelta(seconds=20) td = datetime.timedelta(days=1) res = d + td print(type(res),res)#<class 'datetime.timedelta'> 1 day, 0:00:20 # 時間變化量的計算會產生進位。 t = datetime.datetime(2010,12,31,23,59,58) td = datetime.timedelta(seconds=3) res = t + td print(res)#2011-01-01 00:00:01 t = datetime.datetime(2010,10,10,10,10,00) td = datetime.timedelta(seconds=3) res = t - td print(res)#2010-10-10 10:09:57 # 練習:計算某一年的二月份有多少天. # 普通演算法:根據年份計算是否是閏年.是:29天,否:28 # 用datetime模塊.首先創建出指定年份的3月1號.然後讓它往前走一天. year = int(input("請輸入年份:")) d = datetime.date(year,3,1) # 創建指定年份的date對象 td = datetime.timedelta(days=1) # 創建一天 的時間段 res = d - td print(res.day)#根據輸入的年份，顯示 28 或 29
os模塊：
os模塊:和操作系統相關的操作被封裝到這個模塊中，主要是文件刪除,目錄刪除,重命名等操作。
import os #和文件操作相關：重命名，刪除 #重命名：文件，目錄重命名，目標不能事先存在 os.rename('a.txt','b.txt') #刪除： os.remove('b.txt') #刪除目錄，必須是空目錄 os.rmdir('aa') #遞歸刪除空文件夾 os.removedirs('aa') #使用shutil模塊可以刪除帶內容的（非空）目錄（慎用）---自動化運維必會 import shutil shutil.rmtree('aa') #和路徑相關的屬性（瞭解） os.curdir :當前路徑 os.sep :路徑分隔符 os.altsep :備用的分隔符 os.extsep :擴展名分隔符 os.pathsep :路徑分隔符 os.linesep :行分隔符,不要在寫文件的時候,使用這個屬性. #和路徑相關的操作，被封裝到另一個子模塊中：os.path 絕對路徑： 相對路徑： #os.path.dirname(path) 返回一個路徑中的父目錄部分（不會判斷路徑是否存在） res = os.path.dirname(r'd:/aaa/bbb/ccc/a.txt') #路徑不存在，不會報錯 print(res)#d:/aaa/bbb/ccc #os.path.basename(path) 返回path指定的路徑的最後一個內容.如果只是一個盤符,或者是以路徑分隔符結尾的字元串,則返回空;否則返回的是 路徑中的最後一部分內容. res = os.path.basename(r'd:/aaa/bbb/ccc.txt') #路徑不存在，不會報錯 print(res)#ccc.txt res = os.path.basename(r'd:/aaa/bbb/ccc') print(res)#ccc #os.path.split(path) 返回一個元組（只有兩個元素）,第二個元素表示的是最後一部分的內容,第一個元素表示的是剩餘的內容. 如果只是一個盤符或者是以路徑分隔符結尾的字元串,則第二個元素為空。否則第二個元素就是最後一部分的內容。如果path中不包含路徑分隔符,則第一個元素為空. res = os.path.split(r'd:/aa/bb/cc/a.txt') #路徑不存在，不會報錯 print(res)#('d:/aa/bb/cc', 'a.txt') #os.path.join(path,*paths)拼接路徑 如果路徑中有絕對路徑,則在這個路徑之前的路徑都會被丟棄,而從這個路徑開始往後拼接. Windows中盤符一定要帶\,否則不認為是一個盤符. path = os.path.join('aaa','bbb','ccc','a.txt') print(path)#aaa\bbb\ccc\a.txt path = os.path.join('d:\\''aaa','bbb','ccc','a.txt') print(path)#d:\aaa\bbb\ccc\a.txt #os.path.abspath(path) 返回一個路徑的絕對路徑 如果參數路徑以/開始,則把當前盤符和參數路徑連接起來組成字元串返回 如果參數路徑是相對的路徑,就把當前路徑和參數路徑的組合字元串當成結果返回 如果參數路徑已經是絕對路徑,就直接把參數返回. 註意: 此方法只是簡單的將一個拼接好的字元串返回,並不會去檢查這個字元串表示的文件是否存在. #如果是/開頭的路徑，預設是在當前盤符下 res = os.path.abspath(r'/a/b/c') print(res)#D:\a\b\c #參數路徑是相對的路徑 res = os.path.abspath(r'a/b/c') print(res)#D:\python22\day16\a\b\c res = os.path.abspath('aa') print(res)#D:\python22\day16\aa #參數路徑已經是絕對路徑 res = os.path.abspath(r'd:\c\aa\bb') print(res)#d:\c\aa\bb #os.path.getsize(path) :獲取文件的位元組數.如果是文件夾,返回0或者是一個不准確的值 print(os.path.getsize('aa')) # 0 print(os.path.getsize('.')) # 4096 print(os.path.getsize('aa/test.txt')) # 6 #判斷功能： #判斷是否是絕對路徑： print(os.path.isabs('d:/a.txt'))#True 路徑不存在，不會報錯 print(os.path.isabs('a.txt'))#False #判斷是否是目錄： print(os.path.isdir('d:/aaa.txt'))#False aaa.txt文件夾不存在 或者 aaa.txt是文件 從文件名不能判斷是文件還是目錄 print(os.path.isdir('d:/aaa.txt'))#True aaa.txt文件夾存在的情況 #判斷路徑是否真正存在： print(os.path.exists('d:/a.txt'))#False a.txt不存在 print(os.path.exists('d:/s22/aaa.txt'))#True aaa.txt存在的情況 print(os.path.exists('d:/s22'))#True #判斷是否是文件： print(os.path.isfile('d:/aaaa.txt'))#False 文件不存在的情況 print(os.path.isfile('d:/s22'))#False 是目錄的情況 print(os.path.isfile('d:/s22/aaa.txt'))#True
sys模塊：
sys模塊：和python解釋器相關的操作
import sys #sys預設使用os,但是要使用os,還要手動導入。 #獲取命令行方式運行的腳本後面的參數：sys.argv[x] print('腳本名：',sys.argv[0]) #腳本名:D:\python22\day16\tt16.py print('第一個參數：',sys.argv[1]) #第一個參數： hello print('第二個參數：',sys.argv[2]) #第二個參數： world print(type(sys.argv[1])) #<class 'str'> print(type(sys.argv[2])) #<class 'str'> #sys.path :系統尋找模塊的路徑. 路徑的第一項path[0]始終是調用解釋器的腳本所在的路徑.程式中可以隨時對這個路徑進行修改.以達到動態添加模塊路徑的目的. print(sys.path) #sys.modules :返回系統已經載入的模塊,以字典形式返回. print(sys.modules)
hashlib模塊：
hashlib模塊：封裝一些用於加密的類.hashlib模塊中提供的類採用的是單向加密演算法,也稱'哈希演算法','摘要演算法'
- 加密的目的:用於判斷和驗證,而並非解密。給一個數據加密,然後用另一個數據加密的結果和第一次加密的結果對比。如果結果相同,說明原文相同.如果不相同,說明原文不同.
- 特點:
- 把一個大的數據,切分成不同塊,分別對不同的塊進行加密,再彙總的結果,和直接對整體數據加密的結果是一致的.
- 單向加密,不可逆.從加密後的結果反推原始數據幾乎是不可能的.
- 原始數據的一點小的變化,將導致結果的非常大的差異,'雪崩'效應.
給一個數據加密的三大步驟:
例如：md5加密演算法:
1.獲取一個加密演算法對象
2.使用加密對象的update,進行加密,update方法可以調用多次,意味著在前一次的update結果之上,再次進行加密.。參數必須是位元組類型
3.通常通過 hexdigest() 獲取加密結果 或 digest()方法. 密文：加密的結果
原文：
import hashlib # 獲取一個加密對象 m = hashlib.md5() # 使用加密對象的update方法進行加密 ---> 加密結果可以累加 m.update('abc中文'.encode('utf-8')) #對位元組進行加密 m.update('def'.encode('utf-8')) m.update(b'def') #在字元串前加b,包含中文時，不能直接在前面加b # 通過hexdigest獲取加密結果：字元串形式 res = m.hexdigest() print(res)#2f1b6e294e72d25ae196fe4ac2d27de6 #通過digest獲取加密結果 ：位元組形式 res1 = m.digest() ###通過digest獲取加密結果，得到的是位元組串 print(res1)#b'/\x1bn)Nr\xd2Z\xe1\x96\xfeJ\xc2\xd2}\xe6' # 不同加密演算法（不同的加密對象），實際上就是加密結果的長度不同,長度越長,越耗時.常用的是md5 加密對象除了md5之外,還有如下幾種: # 'sha1', 'sha224', 'sha256', 'sha384', 'sha3_224', 'sha3_256', 'sha3_384', 'sha3_512','sha512', 'shake_128', 'shake_256' print(len(hashlib.md5().hexdigest()))#32 print(len(hashlib.sha224().hexdigest()))#56 print(len(hashlib.sha256().hexdigest()))#64 # 在創建加密對象時,可以指定參數,稱為salt（鹽），目的就是為了讓加密的結果更加複雜.。 #1： m = hashlib.md5(b'abc') print(m.hexdigest())#900150983cd24fb0d6963f7d28e17f72 #2：同上面是等價的 m = hashlib.md5() m.update(b'abc') print(m.hexdigest())#900150983cd24fb0d6963f7d28e17f72 m = hashlib.md5() m.update(b'abc') m.update(b'def') print(m.hexdigest())#e80b5017098950fc58aad83c8c14978e #註冊登錄： #註冊登錄(簡版)： def get_md5(username,passwd): #加密 m = hashlib.md5(username[::-1].encode('utf-8'))#加鹽，將用戶名反轉，再轉化為二進位位元組 #m.update(username.encode('utf-8')) m.update(passwd.encode('utf-8')) return m.hexdigest() def register(username,passwd): #註冊 res = get_md5(username,passwd) with open('login',mode='at',encoding='utf-8') as f: f.write(res) f.write('\n') def login(username,passwd): #登錄 res = get_md5(username, passwd)# 獲取當前登錄信息的加密結果 with open('login',mode='rt',encoding='utf-8') as f: # 讀文件,和其中的數據進行對比 for line in f: if res == line.strip(): return True else: return False while True: op = int(input("1.註冊 2.登錄 3.退出")) if op == 3 : break elif op == 1: username = input("輸入用戶名:") passwd = input("輸入密碼:") register(username,passwd) elif op == 2: username = input("輸入用戶名:") passwd = input("輸入密碼:") res = login(username,passwd) if res: print('登錄成功') else: print('登錄失敗')
結構化數據：背後有很多方法、屬性支撐著它，如字元串
磁碟上的數據：線性數據（流式數據）：數據之間沒有引用關係
json模塊：
json模塊：
- JavaScript Object Notation:java腳本對象標記語言.已經成為一種簡單的數據交換格式.
- 序列化:將其他數據格式轉換成json字元串的過程.
- 反序列化:將json字元串轉換其他數據類型的過程.
- 涉及到的方法:
- json.dumps(obj):將obj轉換成json字元串返回到記憶體中. 返回到記憶體中
- json.dump(obj,fp):將obj轉換成json字元串並保存在fp指向的文件中. 序列化到文件中
- json.loads(s):將記憶體中的json字元串轉換成對應的數據類型對象 在文件中有一個json字元串，進行反序列化
- json.load(f):從文件中讀取json字元串,並轉換回原來的數據類型. 從文件中反序列化
註意:
json並不能序列化所有的數據類型:例如:set集合 。
元組數據類型經過json序列化後,變成列表數據類型。
json文件通常是一次性寫入,一次性讀取，但是可以利用文件本身的方式實現：一行存儲一個序列化json字元串,在反序列化時,按行反序列化即可。
通常json文件用來保存一些配置信息,這樣的配置信息不會太大.通過一次寫,一次讀,完全可以滿足數據交換的需求.
import json ##序列化： # json.dumps:將數據轉換成字元串,用於存儲或網路傳輸。 s = json.dumps([1,2,3]) # 把指定的對象轉換成json格式的字元串 print(type(s))#<class 'str'> print(s)#[1, 2, 3] s = json.dumps((1,2,3))# 元組序列化後,變成列表 print(s)#[1, 2, 3] res = json.dumps(10) print(res,type(res))#10 <class 'str'> res = json.dumps({'name':'alex','age':88}) print(res,type(res))#{"name": "alex", "age": 88} <class 'str'> res = json.dumps(set('abc')) print(res)#TypeError: Object of type 'set' is not JSON serializable # json.dump #將json結果寫到文件中 with open('a.txt',encoding='utf-8',mode='a') as f: json.dump([1,2,3],f) #反序列化： #json.loads res = json.dumps([1,2,3]) lst = json.loads(res) ## 反序列化 print(lst,type(lst))#[1, 2, 3] <class 'list'> # 元組會變成列表 res = json.dumps((1,2,3)) lst = json.loads(res) # 反序列化 print(lst,type(lst))#[1, 2, 3] <class 'list'> #json.load #從文件中反序列化： with open('a.txt',encoding='utf-8') as f: res = json.load(f) print(res,type(res))#[1, 2, 3] <class 'list'> # json文件通常是一次性寫,一次性讀.使用另一種方式,可以實現多次寫,多次讀. # 把需要序列化的對象.通過多次序列化的方式, 用文件的write方法,把多次序列化後的json字元串寫到文件中 with open('json.txt',encoding='utf-8',mode='a') as f: f.write(json.dumps([1,2,3]) + '\n') #此時只能用dumps,不能用dump f.write(json.dumps([4,5,6]) + '\n') # 把分次序列化的json字元串,反序列化回來 with open('json.txt',encoding='utf-8',mode='r') as f: res1 = json.loads(f.readline().strip()) print(res1) res2 = json.loads(f.readline().strip()) print(res2) # [1, 2, 3] # [4, 5, 6] #使用迴圈改進： with open('json.txt',encoding='utf-8',mode='r') as f: for line in f: res = json.loads(line.strip()) #此時只能用loads,不能用load print(res) # [1, 2, 3] # [4, 5, 6]
pickle模塊：
序列化過程：將Python中所有的數據類型.轉換成位元組串。
反序列化過程：將位元組串轉換成python中數據類型。
pickle常用場景:和json一樣,一次性寫入,一次性讀取。 （可以多次寫，多次讀）
pickle: python專用的序列化模塊，和json的方法一致。
json,pickle的比較:
json:
- 1.不是所有的數據類型都可以序列化.結果是字元串.
- 2.不能多次對同一個文件序列化.
- 3.json數據可以跨語言傳輸數據
- 4.序列化的結果是字元串
pickle:
- 1.所有python類型都能序列化,結果是位元組串.
- 2.可以多次對同一個文件序列化
- 3.不能跨語言，只在python中使用
import pickle #python所有的數據類型都可以進行序列化 # 列表序列化 bys = pickle.dumps([1,2,3]) print(bys,type(bys))#b'\x80\x03]q\x00(K\x01K\x02K\x03e.' <class 'bytes'> # 保存了元組的數據類型 bys = pickle.dumps((1,2,3))#序列化 print(bys,type(bys))#b'\x80\x03K\x01K\x02K\x03\x87q\x00.' <class 'bytes'> res = pickle.loads(bys) #反序列化 print(res,type(res))#(1, 2, 3) <class 'tuple'> # 集合序列化，反序列化 bys = pickle.dumps(set('abc')) print(bys,type(bys))#b'\x80\x03cbuiltins\nset\nq\x00]q\x01(X\x01\x00\x00\x00cq\x02X\x01\x00\x00\x00bq\x03X\x01\x00\x00\x00aq\x04e\x85q\x05Rq\x06.' <class 'bytes'> res = pickle.loads(bys) print(res,type(res))#{'c', 'b', 'a'} <class 'set'> # 把pickle序列化內容寫入到文件： with open('cc.txt',mode='wb') as f: #轉化成位元組 pickle.dump([1,2,3],f) # 從文件中反序列化pickle數據 with open('cc.txt',mode='rb') as f: #位元組 res = pickle.load(f) print(res,type(res))#[1, 2, 3] <class 'list'> # 多次pickle數據到同一個文件中 with open('cc.txt',mode='ab') as f: pickle.dump([1, 2, 3], f) pickle.dump([1, 2, 3], f) pickle.dump([1, 2, 3], f) pickle.dump([1, 2, 3], f) # 從文件中多次反序列化pickle數據： with open('cc.txt',mode='rb') as f: for i in range(4): res = pickle.load(f) print(res) # [1, 2, 3] # [1, 2, 3] # [1, 2, 3] # [1, 2, 3]
collections模塊：
collections模塊：此模塊定義了一些內置容器類數據類型之外,可用的集合類數據類型.
namedtuple():命名元組。元組的工廠函數
defaultdict():預設值字典.
Counter():計數器 #首字母必須大寫
import collections # namedtuple() 所謂的工廠函數指的是:接收類名和一些創建此類對象所需要的一些參數,返回指定類的一個對象.命名元組的特點是給元素綁定了一個有意義的名字.在使用元素時可以使用元素的名字而不必使用索引 第一個參數指定的是返回的子類的類名。第二個參數指定的是子類元組可以擁有的元素名.以字元串組成的列表表示,或者是以空格,逗號分隔的單個字元串都可以。 Rectangle = collections.namedtuple('Rectangle_class',['length','width']) #'Rectangle_class'為說明信息，不能有空格 r = Rectangle(10,6) # 通過屬性訪問元組的元素 print(r.length)#10 print(r.width)#6 # 通過索引的方式訪問元素 print(r[0])#10 print(r[1])#6 #defaultdict:預設字典 # 創建字典的方式： d = {'name':'alex','age':84} print(d)#{'name': 'alex', 'age': 84} d = dict([('name','alex'),('age',84)]) print(d)#{'name': 'alex', 'age': 84} d = { k:v for k,v in [('name','alex'),('age',84)]} print(d)#{'name': 'alex', 'age': 84} # defaultdict() 第一個參數指定的是一個函數名,用來表示當字典對象中出現了不存在的鍵時,對應的值初始值是如何計算.正因為這個函數是獲取值的,所以,對這個函數規定:不能有參數.預設情況下,第一個參數是None,意味著不存在的鍵對應的值為None. 一旦使用defaultdict 時,指定了不存在的鍵,則會引發兩件事情:1.調用第一個參數指定的函數得到預設值 2.把返回值賦值給這個新鍵. d = collections.defaultdict(int,name='alex',age=84) print(d['name'])#alex print(d['age'])#84 print(d['addr'])#0 # {'addr':0} 也會被添加到字典 print(d)#defaultdict(<class 'int'>, {'name': 'alex', 'age': 84, 'addr': 0}) d = collections.defaultdict(bool,name='alex',age=84) print(d['name'])#alex print(d['age'])#84 print(d['addr']) #False # {'addr':False} 也會被添加 print(d)# defaultdict(<class 'bool'>, {'name': 'alex', 'age': 84, 'addr': False}) # 可自定義：自定義函數充當其第一個參數，要求自定義函數不能有參數 def f(): return 'hello' d = collections.defaultdict(f,name='Andy',age=20) #第一個參數：函數名 第二，三個是傳參：關鍵字不能加引號 print(d['addr'])#hello print(d)# defaultdict(<function f at 0x000002A685A41E18>, {'name': 'Andy', 'age': 20, 'addr': 'hello'}) # Counter ：生成統計信息，用於統計可哈希對象的數量。是dict的子類.一種特殊的字典.它的鍵是可哈希對象,值是這個對象的個數統計信息 c = collections.Counter('asdfgkoiunbbsgfawpag') #括弧內為可哈希對象 print(c)#Counter({'a': 3, 'g': 3, 's': 2, 'f': 2, 'b': 2, 'd': 1, 'k': 1, 'o': 1, 'i': 1, 'u': 1, 'n': 1, 'w': 1, 'p': 1}) #顯示數量最多的前幾名. print(c.most_common(3))#[('a', 3), ('g', 3), ('s', 2)] c = Counter('12435634567') print(c) print(c.most_common(3)) #Counter({'4': 2, '3': 2, '5': 2, '6': 2, '1': 1, '2': 1, '7': 1}) #[('4', 2), ('3', 2), ('5', 2)]
