python學習14-模塊

引入模塊的方式：

1. import 模塊

2. from xxx import 模塊

 

1、collections 模塊

1.Counter()

 counter是一個計數器，主要用來計數，計算一個字符串中每一個字符出現的次數

from collections import Counter
s = "我要從南走到北，還要從北走到南"

ret = Counter(s)
print("__iter__" in dir(ret))

for item in ret:
print(item,ret[item])

counter

1 from collections import Counter
2 s = "我要從南走到北，還要從北走到南"
3 
4 ret  = Counter(s)
5 print("__iter__" in dir(ret))
6 
7 for item in ret:
8     print(item,ret[item])

 

#補充 

棧：先進後出

隊列：先進先出

因爲python沒有給出Stack模塊. 咱們能夠本身動寫個粗略版原本模擬棧的工做過程(注意， 此版本有嚴重的併發問題)

#棧 先進後出
class StackFullErro(Exception):
pass

class StackEmptyErro(Exception):
pass

class Stack:
def __init__(self,size):
self.size = size
self.lst = []
self.index = 0

def push(self,item):
if self.index == self.size:
raise StackFullErro("the Stack is full")
self.lst.insert(self.index,item)
self.index +=1

def pop(self):
if self.index == 0:
raise StackEmptyErro('the stack is empty')
self.index -= 1
item = self.lst.pop(self.index)
return item

s = Stack(4)
s.push('1')
s.push('2')
s.push('3')
s.push('4')
# s.push('5')
# s.push('6')
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
# print(s.pop())

結果：
4
3
2
1

棧

 1 #棧 先進後出
 2 class StackFullErro(Exception):
 3     pass
 4 
 5 class StackEmptyErro(Exception):
 6     pass
 7 
 8 class Stack:
 9     def __init__(self,size):
10         self.size = size
11         self.lst = []
12         self.index = 0
13 
14     def push(self,item):
15         if self.index == self.size:
16             raise StackFullErro("the Stack is full")
17         self.lst.insert(self.index,item)
18         self.index +=1
19 
20     def pop(self):
21         if self.index == 0:
22             raise StackEmptyErro('the stack is empty')
23         self.index -= 1
24         item = self.lst.pop(self.index)
25         return item
26 
27 s = Stack(4)
28 s.push('1')
29 s.push('2')
30 s.push('3')
31 s.push('4')
32 # s.push('5')
33 # s.push('6')
34 print(s.pop())
35 print(s.pop())
36 print(s.pop())
37 print(s.pop())
38 # print(s.pop())
39 
40 結果：
41 4
42 3
43 2
44 1

對於隊列，python提供了queue模塊

import queue #隊列模塊

q = queue.Queue()
q.put('李')
q.put('嘉')
q.put('家')
q.put('欣')

print(q.get())
print(q.get())
print(q.get())
print(q.get()) #最後一個
# print(q.get()) #拿完了，再拿程序就會阻塞
print('拿完了')
print(dir(queue))

#雙向對列
q2 = queue.deque() #建立對象
q2.append("李") #在右邊添加
q2.appendleft("嘉") #在左邊添加

# print(q2.pop()) #從右邊拿
# print(q2.pop())

print(q2.popleft()) #從左邊拿
print(q2.popleft())

queue模塊

 1 import queue  #隊列模塊
 2 
 3 q = queue.Queue()
 4 q.put('李')
 5 q.put('嘉')
 6 q.put('家')
 7 q.put('欣')
 8 
 9 print(q.get())
10 print(q.get())
11 print(q.get())
12 print(q.get()) #最後一個
13 # print(q.get())  #拿完了，再拿程序就會阻塞
14 print('拿完了')
15 print(dir(queue))
16 
17 #雙向對列
18 q2 = queue.deque()  #建立對象
19 q2.append("李")  #在右邊添加
20 q2.appendleft("嘉")  #在左邊添加
21 
22 # print(q2.pop())  #從右邊拿
23 # print(q2.pop())
24 
25 print(q2.popleft())  #從左邊拿
26 print(q2.popleft())

 

二、deque()

建立雙向隊列

from collections import deque
q = deque() #建立雙向隊列對象

q.append("蓋倫")
q.append('皇子')
q.append('趙信')
q.appendleft('德瑪西亞之力')
q.appendleft('嘉文')
q.appendleft('德邦總管')
# 德邦 嘉文 德瑪 蓋倫 皇子 趙信

# print(q.pop())
# print(q.pop())
# print(q.pop())
print(q.popleft())
print(q.popleft())
print(q.popleft())
print(q.popleft())

collections裏的deque

from collections import deque
q = deque()  #建立雙向隊列對象

q.append("蓋倫")
q.append('皇子')
q.append('趙信')
q.appendleft('德瑪西亞之力')
q.appendleft('嘉文')
q.appendleft('德邦總管')
#  德邦 嘉文 德瑪 蓋倫 皇子 趙信

# print(q.pop())
# print(q.pop())
# print(q.pop())
print(q.popleft())
print(q.popleft())
print(q.popleft())
print(q.popleft())

 

三、namedtuple  

命名元組，就是給元組內的元素進行命名

from collections import namedtuple

point = namedtuple("點",['x','y','z']) #至關於寫了一個類
# print(namedtuple.__doc__) #Returns a new subclass of tuple with named fields.
p = point(5,2,1) #至關於建立對象

print(p.x) #5
print(p.y) #2
print(p.z) #1
print(p) #點(x=5, y=2, z=1) 給元組中每一個元素命名了

namedtuple

 1 from collections import namedtuple
 2 
 3 point = namedtuple("點",['x','y','z'])  #至關於寫了一個類
 4 # print(namedtuple.__doc__)  #Returns a new subclass of tuple with named fields.
 5 p = point(5,2,1)  #至關於建立對象
 6 
 7 print(p.x)  #5
 8 print(p.y)  #2
 9 print(p.z)  #1
10 print(p)  #點(x=5, y=2, z=1)   給元組中每一個元素命名了

 

四、OrderedDict  

排序字典，按咱們存儲的順序給字典排序

1 dic = {'a':'娃哈哈', 'b':'薯條', 'c':'胡辣湯'}   #無序的
2 print(dic)
3 
4 from collections import OrderedDict
5 od = OrderedDict({'a':'娃哈哈', 'b':'薯條', 'c':'胡辣湯'})  #排序的
6 print(od)

1 dic = {'a':'娃哈哈', 'b':'薯條', 'c':'胡辣湯'}   #無序的
2 print(dic)
3 
4 from collections import OrderedDict
5 od = OrderedDict({'a':'娃哈哈', 'b':'薯條', 'c':'胡辣湯'})  #排序的
6 print(od)

 

五、defaultdict

默認值字典，查找key時，若是key不存在會返回一個默認值

from collections import defaultdict

lst = [11,22,33,44,55,66,77,88,99]

d = defaultdict(list) #當查找的key不存在時返回一個[]，並將key添加到d中，因此參數必須是可調用的
#這至關於給每一個key都有一個默認值[]

for el in lst:
if el <66:
d["key1"].append(el) #key1 不存在，將key1添加到字典d中，而且默認值時[],而後再往列表中添加元素
else:
d["key2"].append(el)

print(d)

def fun():
return "胡辣湯"
d2 = defaultdict(fun) #參數要callable
print(d2["key1"])

默認值字典

 1 from collections import defaultdict
 2 
 3 lst = [11,22,33,44,55,66,77,88,99]
 4 
 5 d = defaultdict(list)  #當查找的key不存在時返回一個[]，並將key添加到d中，因此參數必須是可調用的
 6                        #這至關於給每一個key都有一個默認值[]
 7 
 8 for el in lst:
 9     if el <66:
10         d["key1"].append(el)  #key1 不存在，將key1添加到字典d中，而且默認值時[],而後再往列表中添加元素
11     else:
12         d["key2"].append(el)
13 
14 print(d)
15 
16 def fun():
17     return  "胡辣湯"
18 d2 = defaultdict(fun)   #參數要callable
19 print(d2["key1"])

 

2、time模塊

日期格式化的標準：（記到秒就行，其餘看看）

%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 當前時區的名稱

%%  %號自己

time模塊的方法：

時間戳 = time.time()                                   看當前的時間戳
格式化時間 = time.strftime(格式)                把時間戳轉爲格式化形式
結構化時間 = time.localtime(時間戳)          將時間戳按當地時間結構化
結構化時間 = time.gmtime(時間戳)            將時間戳按格林尼治時間結構化
結構化時間 = time.strptime(s,格式)            把格式化時間轉爲結構化形式
時間戳 = time.mktime(結構化)                    把結構化時間轉爲時間戳

#將時間戳格式化爲當地時間

1 import time
2 
3 t = time.localtime(1888888)  #時間戳轉爲當地結構化時間
4 # print(t)
5 str_time = time.strftime("%Y-%m-%d %H:%M:%S",t)  
6 print(str_time)

1 import time
2 
3 t = time.localtime(1888888)  #時間戳轉爲當地結構化時間
4 # print(t)
5 str_time = time.strftime("%Y-%m-%d %H:%M:%S",t)  
6 print(str_time)

#將格式化時間轉化爲時間戳

1 s = time.strftime("%Y-%m-%d %H:%M:%S")  #按這種格式產生一個格式化時間
2 #print(s)
3 jiegou_time = time.strptime(s, "%Y-%m-%d %H:%M:%S") #按對應格式解構
4 #print(jiegou_time)
5 ss = time.mktime(jiegou_time)   #將結構化時間轉爲時間戳
6 print(ss)

1 s = time.strftime("%Y-%m-%d %H:%M:%S")  #按這種格式產生一個格式化時間
2 #print(s)
3 jiegou_time = time.strptime(s, "%Y-%m-%d %H:%M:%S") #按對應格式解構
4 #print(jiegou_time)
5 ss = time.mktime(jiegou_time)   #將結構化時間轉爲時間戳
6 print(ss)

#計算時間差

方式一：

import time

str1 ="2018-11-14 12:24:00"
str2 = "2018-11-14 14:58:03"

def diff_time(str1,str2): #傳入格式化時間

time_stamp1 = time.mktime(time.strptime(str1,"%Y-%m-%d %H:%M:%S")) #對應時間戳
time_stamp2 = time.mktime(time.strptime(str2,"%Y-%m-%d %H:%M:%S"))
cha =abs(time_stamp2 - time_stamp1)
shi, n = divmod(cha, 3600)
fen, miao = divmod(n, 60)
print("%s時:%s分:%s秒"%(int(shi), int(fen), int(miao)))

diff_time(str1,str2)

 1 import time
 2 
 3 str1 ="2018-11-14 12:24:00"
 4 str2 = "2018-11-14 14:58:03"
 5 
 6 def diff_time(str1,str2):  #傳入格式化時間
 7 
 8     time_stamp1 = time.mktime(time.strptime(str1,"%Y-%m-%d %H:%M:%S"))  #對應時間戳
 9     time_stamp2 = time.mktime(time.strptime(str2,"%Y-%m-%d %H:%M:%S"))
10     cha =abs(time_stamp2 - time_stamp1)
11     shi, n = divmod(cha, 3600)
12     fen, miao = divmod(n, 60)
13     print("%s時:%s分:%s秒"%(int(shi), int(fen), int(miao)))
14 
15 diff_time(str1,str2)

方式二：

import time
str1 ="2018-11-14 12:24:00"
str2 = "2018-11-14 14:58:03"

g1 = time.strptime(str1,"%Y-%m-%d %H:%M:%S")
chuo1 = time.mktime(g1) #轉成對應時間戳

g2 = time.strptime(str2,"%Y-%m-%d %H:%M:%S")
chuo2 = time.mktime(g2)

cha = abs(chuo2-chuo1) #時間戳之差，秒
s = time.gmtime(cha) #將差轉爲結構化時間
# print(s)
#減去起點時間
year = s.tm_year - 1970
month = s.tm_mon -1
day = s.tm_mday - 1
hour = s.tm_hour - 0
min = s.tm_min -0
second = s.tm_sec -0

print("%s-%s-%s %s:%s:%s" %(year,month,day,hour,min,second))

 1 import time
 2 str1 ="2018-11-14 12:24:00"
 3 str2 = "2018-11-14 14:58:03"
 4 
 5 g1 = time.strptime(str1,"%Y-%m-%d %H:%M:%S")
 6 chuo1 = time.mktime(g1)   #轉成對應時間戳
 7 
 8 g2 = time.strptime(str2,"%Y-%m-%d %H:%M:%S")
 9 chuo2 = time.mktime(g2)
10 
11 cha = abs(chuo2-chuo1)  #時間戳之差，秒
12 s = time.gmtime(cha)   #將差轉爲結構化時間
13 # print(s)
14 #減去起點時間
15 year = s.tm_year - 1970    
16 month = s.tm_mon -1
17 day = s.tm_mday - 1
18 hour = s.tm_hour - 0
19 min = s.tm_min -0
20 second = s.tm_sec -0
21 
22 print("%s-%s-%s %s:%s:%s" %(year,month,day,hour,min,second))

 

3、random模塊

產生隨機數

import random

print(random.random())                        # 0-1小數 （0, 1）

 

print(random.uniform(3, 10))                  # 3-10小數（3,10）

print(random.randint(1, 10))                  # 1-10整數   [1, 10]

print(random.randrange(1, 10, 2))                          # 1-10奇數   [1,10)

print(random.choice([1, '周杰倫', ["蓋倫", "胡辣湯"]]))              # 從列表中隨機選一個

print(random.sample([1, '23', [4, 5]], k))             # 列表元素隨機選k個    

 

 

lst = [1, 2, 3, 4, 5, 6, 7, 8]

random.shuffle(lst)                # 隨機打亂順序

print(lst)

 

4、os模塊

os.makedirs('dirname1/dirname2') 可生成多層遞歸目錄

os.removedirs('dirname1') 若目錄爲空，則刪除，並遞歸到上一級目錄，如若也爲空，則刪 除，依此類推

os.mkdir('dirname') 生成單級目錄；至關於shell中mkdir dirname

os.rmdir('dirname') 刪除單級空目錄，若目錄不爲空則沒法刪除，報錯；至關於shell中 rmdir dirname

os.listdir('dirname') 列出指定目錄下的全部文件和子目錄，包括隱藏文件，並以列表形式 打印

os.remove() 刪除一個文件

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的屬性：

5、sys模塊

全部和python解釋器相關的都在sys模塊.

sys.argv 命令行參數List，第一個元素是程序自己路徑

sys.exit(n) 退出程序，正常退出時exit(0),錯誤退出sys.exit(1)

sys.version 獲取Python解釋程序的版本信息

sys.path 返回模塊的搜索路徑，初始化時使用PYTHONPATH環境變量的值

sys.platform 返回操做系統平臺名稱