python基礎之 time,datetime,collections

1.time模塊

python中的time和datetime模塊是時間方面的模塊

time模塊中時間表現的格式主要有三種：
　　一、timestamp：時間戳，時間戳表示的是從1970年1月1日00:00:00開始按秒計算的偏移量
　　2、struct_time：時間元組，共有九個元素組。
　　三、format time ：格式化時間，已格式化的結構使時間更具可讀性。包括自定義格式和固定格式。

 　　

 time的生成方法和time格式的轉換

生成時間 import time
生成時間戳格式的時間：
　　print(time.time())  #是機器看的時間，拿到的是float類型的
　　time = 1553066161.9998

生成結構化格式的時間:
　　print(time.localtime())  #用在修改時間是使用的，獲得一個命名元祖time.struct_time
　　time = time.struct_time(tm_year=2019, tm_mon=3, tm_mday=20, tm_hour=15, tm_min=16, tm_sec=1, tm_wday=2, tm_yday=79, tm_isdst=0)

生成字符串格式的時間:
　　print(time.strftime('%Y-%m-%d %H;%M:%S')) #或者'%Y-%m-%d %X/x
　　time = 2019-03-20 15:17:04 時間格式轉換
　　注意：字符串格式的時間不能與時間戳格式的時間相互轉換

　　轉換順序：字符串時間 <----->結構化時間<---->時間戳
字符串時間---->結構化時間　
t = '2018-11-30 12：30:00'　
f = time.strptime(t,'%Y-%m-%d %H:%M':%S)

結構化時間---->字符串時間
t = time.localtime()
f = time.strftime('%Y-%m-%d %H:%M:%S',t)　

結構化時間---->時間戳時間
t = time.localtime()
f = (time.mktime(t))

時間戳時間---->格式化時間
t = time.time()
f = time.localtime(t)

注意：
time.strftime()     #獲取當前字符串時間
timt.time()=1553052418.0508  #獲取當時間時間戳
時間戳--結構化 time.localtime(time.time())
結構化--時間戳 time.mktime(f)   #f =time.struct_time(tm_year=2019, tm_mon=3, tm_mday=20, tm_hour=11, tm_min=25, tm_sec=56, tm_wday=2, tm_yday=79, tm_isdst=0)
結構化--字符串 time.strftime('%Y-%m-%d %H:%M:%S',f)   f=結構化時間 格式能夠少寫
字符串--結構化 f =time.strptime('2019-03-20 10:40:00','%Y-%m-%d %H:%M:%S') 格式能夠少寫

time模塊練習

t = time.time()  #獲取當前時間戳
t1 = t - 30*86400  #按照30天算，求出30天以前的時間戳
old_time = time.localtime(t1)  #將時間戳時間轉換成字符串時間
print(time.strftime('%Y-%m-%d %X',old_time))

求當前時間的前一個月的如今時間

t = '2018-11-30 12:30:00' 
t1 = time.strptime(t,'%Y-%m-%d %H:%M:%S')   #將字符串時間轉成格式化時間
t2 =time.mktime(t1 ) + 60*60*2  #將格式化時間轉成時間戳+7200秒
t3 = time.localtime(t2)
print(time.strftime('%Y-%m-%d %H:%M:%S',t3))

將當前時間加2個小時

2.datetime模塊

from datetime import datetime ,timedelta
f =datetime.now()  #精確到毫秒 datetime.now()拿到的是時間對象
f1=datetime.timestamp(f)  #將時間對象轉成時間戳
f2=datetime.fromtimestamp(f1)  #將時間戳轉換成時間對象
f3= datetime.strptime('1984-1-29','%Y-%m-%d')  #將字符串轉成時間戳
f5 = datetime.strftime(f,'%Y-%m-%d') #將時間對象轉成字符串

當前時間減去2個小時
print(datetime.now() - timedelta(hours=2))  #這個是datetime的精華

注意;datetime沒有結構化時間

 注意：將a格式的轉化爲b格式的時間，就應該用b將a包起來，好比將結構化的時間轉成字符串時間print(time.strftime('%Y-%m-%d %X',time.localtime()))

 3.數據結構的補充(官方文檔)

Counter:計數器

引入模塊：from collections import Counter
Counter 集成於 dict 類，所以也可使用字典的方法，此類返回一個以元素爲 key 、元素個數爲 value 的 Counter 對象集合

#讀取history中執行過最多的十條命令
import os
from collections import Counter
c = Counter()
with open(os.path.expanduser('~/.bash_history')) as cmd_info:
　　for line in cmd_info:
　　　　cmd = line.strip().split()
　　　　if cmd:
　　　　c[cmd[0]]+=1
print(c.most_common(10))

經常使用操做：
　　sum(c.values()) # 全部計數的總數
　　c.clear()  # 重置Counter對象，注意不是刪除
　　list(c)  # 將c中的鍵轉爲列表
　　set(c)  # 將c中的鍵轉爲set
　　dict(c) # 將c中的鍵值對轉爲字典
　　c.items() # 轉爲(elem, cnt)格式的列表
　　Counter(dict(list_of_pairs)) # 從(elem, cnt)格式的列表轉換爲Counter類對象
　　c.most_common()[:-n:-1] # 取出計數最少的n-1個元素
　　c += Counter() # 移除0和負值
文章

 nametuple:命名函數

引入模塊：from collections import namedtuple
namedtuple是一個函數，它用來建立一個自定義的tuple對象，而且規定了tuple元素的個數，並能夠用屬性而不是索引來引用tuple的某個元素。
這樣一來，咱們用namedtuple能夠很方便地定義一種數據類型，它具有tuple的不變性，又能夠根據屬性來引用，使用十分方便

#當元組的元素較多時們就可使用命名元組來明確標明每一個元素是什麼意思
tu = namedtuple('people',['name','age','sex','hobby']) #是一個類
print(tu('kobe','19','man','抽菸，喝酒燙頭'))
ll =tu('kobe','19','man','抽菸，喝酒燙頭')  #實例化一個類。對象
print(ll.name)  #調用名字以後返回值

deque:雙端隊列

導入模塊
from collections import deque
使用list存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了，由於list是線性存儲，數據量大的時候，插入和刪除效率很低。deque是爲了高效實現插入和刪除操做的雙向列表。
適合用於隊列和棧： #增
    d = deque([1,2,3,4,5])
    d.append(10)
    print(d)
    d.appendleft(-10)
    print(d)
    d.insert(2,9999)  #在索引爲2的地方添加999
    print(d)
#刪
    print(d.pop())
    print(d.popleft())

deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。

defaultdict:默認字典

導入模塊：from collections import defaultdict
使用dict時，若是引用的Key不存在，就會拋出KeyError。若是但願key不存在時，返回一個默認值，就能夠用defaultdict：

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
dd['key1'] # key1存在
'abc'
dd['key2'] # key2不存在，返回默認值
'N/A' 注意：默認值是調用函數返回的，而函數在建立defaultdict對象時傳入。除了在Key不存在時返回默認值，defaultdict的其餘行爲跟dict是徹底同樣的。

 ordereddict

使用dict時，Key是無序的。在對dict作迭代時，咱們沒法肯定Key的順序。
若是要保持Key的順序，能夠用OrderedDict：
from collections import OrderedDict
d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)
{'a': 1, 'c': 3, 'b': 2} #dict的key是無序的
 od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
OrderedDict([('a', 1), ('b', 2), ('c', 3)]) #OrderedDict的key是有序的
注意，OrderedDict的Key會按照插入的順序排列，不是Key自己排序： >>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> od.keys() # 按照插入的Key的順序返回
['z', 'y', 'x']
OrderedDict能夠實現一個FIFO（先進先出）的dict，當容量超出限制時，先刪除最先添加的Key：

 other

雙端隊列和列表的區別：表如今效率，底層的數據結構上

向列表最後一個地方存值和刪除都是很是快的 儘可能寫append() pop(),
列表中刪除第一個或使用insert插入一個數據是很是耗費性能的，再刪除的時候，後面的值都要向上和以前未刪除的鏈接起來，
在插入的時候，在插入位置後面的數據都要向下後移一個位置，因此儘可能寫append() pop(),不要寫insert和pop(0)

若是從中間插入或者刪除比較頻繁的操做使用:雙端隊列
若是單純的增長append和刪除pop的話，使用列表最好，可是儘可能別使用pop(0)或者insert(1,'23')等

列表的sort()和sorted()的區別是什麼？
　　一個在原有的基礎上進行修改， alist.sort()
　　一個是生成一個新的列表   返回一個新的列表 sorted()，可是alist.sort(更節省內存)　　
　　list提供的方法都是修改這個列表自己

注意：reversed返回一個生成器
內置函數是在已有序列的基礎上，再生成一個新的
filter zip map等內置函數返回的都是生成器或迭代器，爲的就是節省內存

 

 

 

返回系列