python學習筆記：第21天常用內置模塊之collections和time

2023-12-25 阅读 28 评论 0

摘要：目錄一、collections模塊二、時間模塊也可以在我的個人博客上閱讀一、collections模塊 1. Counter Counter是?個計數器，主要?統計字符的數量，之前如果我們要統計字符串的話要寫如下算法： s = 'Wed Nov 14 08:58:45 CST 2018'dic = {

一、collections模塊
二、時間模塊

也可以在我的個人博客上閱讀

一、collections模塊

1. Counter

Counter是?個計數器，主要?統計字符的數量，之前如果我們要統計字符串的話要寫如下算法：

s = 'Wed Nov 14 08:58:45 CST 2018'dic = {}for c in s:dic[c] = dic.setdefault(c, 0) + 1print(dic)# 結果：
# {'W': 1, 'e': 1, 'd': 1, ' ': 5, 'N': 1, 'o': 1, 'v': 1, '1': 2, '4': 2, '0': 2, '8': 3, ':': 2, '5': 2, 'C': 1, 'S': 1, 'T': 1, '2': 1}

但是使用Count函數要簡單的多：

from collections import Counters = 'Wed Nov 14 08:58:45 CST 2018'
c = Counter(s)
for k in c:print(f'{k}: {c[k]}')# 結果：
# W: 1
# e: 1
# d: 1
#  : 5
# N: 1
# o: 1
# v: 1
# 1: 2
# 4: 2
# 0: 2
# 8: 3
# :: 2
# 5: 2
# C: 1
# S: 1
# T: 1
# 2: 1

2. 雙向隊列

這里的雙向隊列的操作其實很簡單，但是我們需要明確兩個概念：棧和隊列

棧：棧就像是一個桶，可以往里面放東西和從里面把東西拿出來，但是我們在放當西的時候（push）會發現最開始放進去的東西總是在最下面，而最后放的東西會在最上面，于是我們從里面拿東西（pop）的時候都是從最上面開始拿的。這就是棧所遵循的先進后出的原則：FILO（Last In First Out）

由于python中并沒有棧的實現，這里寫一個簡單版的棧來看一下棧實現的效果：

class Node:def __init__(self, value):              # 創建了一個節點類，代表棧中每一個元素self.value = valueself.next = None                    # 這里的next指向下一個元素的位置class Stack:def __init__(self):self.top = None                     # 初始化的時候棧頂元素默認值設置為Nonedef push(self, val):node = Node(val)                    # push的時候先創建一個新的節點node.next = self.top                # 把新節點的next指向原來的棧頂元素self.top = node                     # 把添加的新節點標記為棧頂節點def pop(self):if self.top is not None:            # 判斷棧中是否存在元素，如果存在再拋出棧頂元素top = self.top                  # 先把棧頂元素賦值給一個臨時變量self.top = self.top.next        # 再把棧頂元素指向自己的下一個節點return top.value                # 拋出之前的棧頂元素（即臨時變量top）return None

以上代碼就是一個簡單版本棧的實現，我們可以來測試一下：

s = Stack()
s.push('饅頭一號')
s.push('饅頭二號')
s.push('饅頭三號')
s.push('饅頭四號')
s.push('饅頭五號')print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())# 結果：
# 饅頭五號
# 饅頭四號
# 饅頭三號
# 饅頭二號
# 饅頭一號
# None

從上可以看出，棧始終遵循著先進后出的原則。

隊列

在python中已經有了隊列的實現，我們來看看對列的特性：

from queue import Queueq = Queue()q.put("李嘉誠")
q.put("張開")
q.put("張毅")
print(q)                            # 這里的q返回的是一個Queue對象
print(q.get())
print(q.get())
print(q.get())# 結果：
# <queue.Queue object at 0x000001DD79D68630>
# 李嘉誠
# 張開
# 張毅

如果隊列?沒有元素了. 再也就拿不出來元素了. 此時程序會阻塞.

隊列的特性就像是我們買火?票排隊的情景，排在前面的就先買然后買完出來，排在后面就后面買，隊列遵循的是先進先出的原則：FIFO(first in first out)。

雙向隊列

然后我們再來看下雙向隊列deque：

from collections import dequeq = deque()q.append('高圓圓')
q.append('江疏影')
q.appendleft('趙又廷')
q.appendleft('趙麗穎')
# q: 趙麗穎  趙又廷  高圓圓  江疏影print(q.pop())
print(q.popleft())
print(q.popleft())# 結果：
# 江疏影
# 趙麗穎
# 趙又廷

3. namedtuple 命名元組

命名元組，顧名思義即給元組內的元素進?命名，比如我們說(x, y) 這是?個元組同時，我們還可以認為這是?個點坐標。這時，我們就可以使?namedtuple對元素進?命名。

from collections import namedtuplet = namedtuple('Point', ['x', 'y', 'z', 'u'])p = t(10, 100, 34, 89)
print(p.x)                              # 可以像訪問實例變量一樣用 . 訪問
print(p.y)
print(p)
print(p[1])                             # 也可以用下標訪問
print(p[0])
print('--------------')
for i in p:                             # 也可以對這個對象做循環遍歷print(i)# 結果：
# 10
# 100
# Point(x=10, y=100, z=34, u=89)
# 100
# 10
# --------------
# 10
# 100
# 34
# 89

4. orderdict和defaultdict

orderdict：字典的key默認是?序的，?OrderedDict是有序的（自3.6的版本后已經沒有太大的差異了，打印的時候默認也是順序的）

from collections import OrderedDictod = OrderedDict({'a':1, 'c':3, 'b':2})print(od)
print(od['a'])# 結果：
# OrderedDict([('a', 1), ('c', 3), ('b', 2)])
# 1

defaultdict：可以給字典設置默認值，當key不存在時，直接獲取默認值:

from collections import defaultdictlst = [11, 22, 33, 44, 55, 66, 77, 88, 99]
d = defaultdict(list)                       # 傳入默認值listfor i in lst:if i < 66:d['key1'].append(i)else:d['key'].append(i)print(d)# 結果：
# defaultdict(<class 'list'>, {'key1': [11, 22, 33, 44, 55], 'key': [66, 77, 88, 99]})

二、時間模塊

時間模塊是我們要熟記的,對我們后期的項目開發來說很重要,要使用時間模塊首先我們要導入這個模塊：

#常用方法
time.sleep(secs)                            # (線程)推遲指定的時間運行。單位為秒。time.time()                               # 獲取當前時間戳
# 1542166453.105443

在python中時間分成三種表現形式:

時間戳(timestamp)：時間戳使?的是從1970年01?01?00點00分00秒到現在?共經過了多少秒... 我們運行type(time.time())獲取到的就是時間戳了，使?float來表?。
格式化時間(strftime)：這個時間可以根據我們的需要對時間進?任意的格式化，具體的格式如下表：

格式	格式說明	取值范圍或其他
%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），星期天為星期的開始	0-6
%W	一年中的星期數，星期一為星期的開始	00-53
%x	本地相應的日期表示
%X	本地相應的時間表示
%Z	當前時區的名稱
%%	%號本身

結構化時間(struct_time)：這個時間主要可以把時間進?分類劃分. 比如. 1970年01?01? 00點00分00秒這個時間可以被細分為年, ?, ?.....??堆東?：

索引（Index）	屬性（Attribute）	值（Values）
0	tm_year（年）	比如2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（時）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 60
6	tm_wday（weekday）	0 - 6（0表示周一）
7	tm_yday（一年中的第幾天）	1 - 366
8	tm_isdst（是否是夏令時）	默認為0

我們先看下這幾種時間表現形式：

In [1]: import timeIn [2]: time.time()                             # 查看當前時間的時間戳
Out[2]: 1542447516.5602913In [3]: time.localtime()                        # 查看當前的結構化時間
Out[3]: time.struct_time(tm_year=2018, tm_mon=11, tm_mday=17, tm_hour=17, tm_min=38, tm_sec=43, tm_wday=5, tm_yday=321, tm_isdst=0)In [4]: time.strftime('%Y-%m-%d %I:%M:%S %p')   # 查看當前的格式化時間
Out[4]: '2018-11-17 05:39:10 PM'

時間模塊常用的幾個方法：

time.sleep(s)                                   # 掛起進程，讓程序睡眠s秒
time.time()                                     # 查看當前的時間戳
time.strftime(format[, tuple])                  # 把格式化時間轉化成格式化時間，默認轉換當前時間
time.strptime(string, format)                   # 以指定的format格式把格式化時間轉換成結構化時間
time.gmtime(timestamp)                          # UTC時間，與英國倫敦當地時間一致
time.localtime(timestamp)                       # #當地時間。例如我們現在在北京執行這個方法：與UTC時間相差8小時
time.mktime(struct_time)                        # 把結構化時間轉化成時間戳

時間戳、結構化時間和格式化時間的關系和轉化：

# 時間戳轉化為格式化時間
st1 = 18888888
struck_time = time.localtime(st1)
print(struck_time)
# time.struct_time(tm_year=1970, tm_mon=8, tm_mday=7, tm_hour=22, tm_min=54, tm_sec=48, tm_wday=4, tm_yday=219, tm_isdst=0)# 格式化時間轉化成時間戳
st2 = time.mktime(struck_time)
print(st2)
# 18888888.0# 格式化時間轉換成結構化時間
ft1 = '2018-11-19 20:34'
st1 = time.strptime(ft1, '%Y-%m-%d %H:%M')
print(st1)
# time.struct_time(tm_year=2018, tm_mon=11, tm_mday=19, tm_hour=20, tm_min=34, tm_sec=0, tm_wday=0, tm_yday=323, tm_isdst=-1)# 結構化時間轉換成格式化時間
ft2 = time.strftime('%Y-%m-%d %H:%M:%S', st1)
print(ft2)
# 2018-11-19 20:34:00

時間戳和格式化時間的互轉（最常用）：

# 時間戳轉成格式化時間:
ft3 = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(1888888888))
print(ft3)
# 2029-11-09 11:21:28# 格式化時間轉成時間戳:
st3 = time.mktime(time.strptime(ft3, '%Y-%m-%d %H:%M:%S'))
print(st3)
# 1888888888.0

轉載于:https://www.cnblogs.com/zpzhue1/p/9985589.html

原文链接：https://hbdhgg.com/2/194918.html

上一篇：python多線程并發，Python并發機制的實現(一)——多進程

下一篇：winform打包成安裝程序，Winform打包-NSIS 檢測.NetFramework版本（親測可用）

发表评论: