2. 程式人生 > >python資料結構進階

python資料結構進階

阿新 • • 發佈：2018-11-25

文章目錄


collections是Python內建的一個集合模組，提供了許多有用的集合類。

namedtuple

我們知道tuple可以表示不變集合，例如，一個點的二維座標就可以表示成

p = (1, 2)
p

(1, 2)

看到(1, 2)，很難看出這個tuple是用來表示一個座標的

義一個class又小題大做了，這時，namedtuple就派上了用場：

from collections import namedtuple
Point = namedtuple('Point'
 
, ['x', 'y'])
p = Point(1, 2)
print(p.x)
print(p.y)
print(p[0])
print(p[1])

1
2
1
2

namedtuple是一個函式，它用來建立一個自定義的tuple物件，並且規定了tuple元素的個數，並可以用屬性而不是索引來引用tuple的某個元素。

這樣一來，我們用namedtuple可以很方便地定義一種資料型別，它具備tuple的不變性，又可以根據屬性來引用，使用十分方便。

可以驗證建立的Point物件是tuple的一種子類

print(isinstance(p, Point))
print(isinstance(p, tuple))
print(type(p))

True
True
<class '__main__.Point'>

類似的，如果要用座標和半徑表示一個圓，也可以用namedtuple定義：

# namedtuple('名稱', [屬性list]):
Circle = namedtuple('Circle', ['x', 'y', 'r'])
c = Circle(1,2,3)
print(type(c))
print(c)

<class '__main__.Circle'>
Circle(x=1, y=2, r=3)

deque雙端佇列

使用list儲存資料時，按索引訪問元素很快，但是插入和刪除元素就很慢了，因為list是線性儲存，資料量大的時候，插入和刪除效率很低。

deque是為了高效實現插入和刪除操作的雙向列表，適合用於佇列和棧：

建立雙向佇列

from collections import deque
d = deque(maxlen=2)
print(d)


d = deque([],3)
print(d)


deque([], maxlen=2)
deque([], maxlen=3)

append(往右邊新增一個元素)

d.append('x')
d.append('y')
d

deque(['x', 'y'])

appendleft（往左邊新增一個元素）

d.appendleft('z')
d

deque(['z', 'x', 'y'])

d.append('s')
print(d)

deque(['x', 'y', 's'], maxlen=3)

pickle 儲存佇列

dump(object, file)

import pickle
#將對d象存在了temp.pkl這個檔案中
d1 = {1: 'One', 2: 'Two', 3: 'Three'}  
f1 = open('temp.pkl', 'wb')  
pickle.dump(d, f1,True)
pickle.dump(d1, f1,True)
f1.close()

load(file) -> object

f2 = open('temp.pkl', 'rb')  
d2 = pickle.load(f2)
print(d2)
d2 = pickle.load(f2)
print(d2)
f2.close()  

deque(['x', 'y', 's'], maxlen=3)
{1: 'One', 2: 'Two', 3: 'Three'}

dumps(object) -> string

#True ，則該引數指定用更快以及更小的二進位制表示來建立 pickle
p1= pickle.dumps(d,True)
p1

b'}q\x00(K\x01X\x03\x00\x00\x00Oneq\x01K\x02X\x03\x00\x00\x00Twoq\x02K\x03X\x05\x00\x00\x00Threeq\x03u.'

loads(string) -> object

t2 = pickle.loads(p1)  
t2

{1: 'One', 2: 'Two', 3: 'Three'}

clear(清空佇列)

import collections
d = collections.deque()
d.append(1)
d.clear()
print(d)

deque([])

copy(淺拷貝)

import collections
d = collections.deque()
d.append(1)
new_d = d.copy()
d.clear()
print(new_d)

deque([1])

import collections
d = collections.deque()
d.append(1)
new_d = d
d.clear()
print(new_d)

deque([])

count(返回指定元素的出現次數)

import collections
d = collections.deque()
d.append(1)
d.append(1)
print(d.count(1))

2

extend(從佇列右邊擴充套件一個列表的元素)

import collections
d = collections.deque()
d.append(1)
d.extend([3,4,5])
print(d)

deque([1, 3, 4, 5])

extendleft(從佇列左邊擴充套件一個列表的元素)

import collections
d = collections.deque()
d.append(1)
d.extendleft([3,4,5])
print(d)

deque([5, 4, 3, 1])

index（查詢某個元素的索引位置）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
print(d)
print(d.index('e'))
print(d.index('c',0,4))  #指定查詢區間

deque(['a', 'b', 'c', 'd', 'e'])
4
2

insert（在指定位置插入元素）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.insert(2,'z')
print(d)

deque(['a', 'b', 'z', 'c', 'd', 'e'])

pop（獲取最右邊一個元素，並在佇列中刪除）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
x = d.pop()
print(x,d)
x = d.pop()
print(x,d)

e deque(['a', 'b', 'c', 'd'])
d deque(['a', 'b', 'c'])

popleft（獲取最左邊一個元素，並在佇列中刪除）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
x = d.popleft()
print(x,d)
x = d.popleft()
print(x,d)


a deque(['b', 'c', 'd', 'e'])
b deque(['c', 'd', 'e'])

remove（刪除指定元素）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.remove('c')
print(d)

deque(['a', 'b', 'd', 'e'])

reverse（佇列反轉）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.reverse()
print(d)

deque(['e', 'd', 'c', 'b', 'a'])

rotate（把右邊元素放到左邊）

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.rotate(2)   #指定次數，預設1次
print(d)

deque(['d', 'e', 'a', 'b', 'c'])

import collections
d = collections.deque()
d.extend(['a','b','c','d','e'])
d.rotate(3)   #指定次數，預設1次
print(d)

deque(['c', 'd', 'e', 'a', 'b'])

練習：猜數字大小

import random
import collections 

number = random.randint(0,100)
history = collections.deque(maxlen = 5)

def guess(n):
    if n == number:
        print("right")
        return True
    elif n < number:
        print("%s is less than the number " % n)
    elif n > number:
        print("%s is greater than the number " % n)
    return False

count = 0
while count < 6:
    line = input("please input a number:")
    if line.isdigit():
        n = int(line)
        history.append(n)
        if n > 100:
            print("attention the range between [0 ,100]")
        else:
            if guess(n):
                break
    elif line == "history" or line == "h?" or line == "h":
        print(list(history))
        
    else:
        print("please input a integer")
    count += 1
else:
    print("you have tried too many times..fuck off")



please input a number:1
1 is less than the number 
please input a number:1
1 is less than the number 
please input a number:1
1 is less than the number 
please input a number:1
1 is less than the number 
please input a number:1
1 is less than the number 
please input a number:1
1 is less than the number 
you have tried too many times..fuck off

defaultdict

使用dict時，如果引用的Key不存在，就會丟擲KeyError。如果希望key不存在時，返回一個預設值，就可以用defaultdict：

from collections import defaultdict
dd = defaultdict(lambda: 'N/A')
dd['key1'] = 'abc'
print(dd['key1']) # key1存在
print(dd['key2']) # key2不存在，返回預設值

abc
N/A

adict = {'a':'sun','b':'cheng','c':'quan'} 
print(adict.get('a'))                            #獲取鍵‘a’對應的值
print(adict.get('d')) 

sun
None

adict = {'a':'sun','b':'cheng','c':'quan'} 
adict['d']

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-27-9173c523be71> in <module>
      1 adict = {'a':'sun','b':'cheng','c':'quan'}
----> 2 adict['d']


KeyError: 'd'

注意預設值是呼叫函式返回的，而函式在建立defaultdict物件時傳入。

除了在Key不存在時返回預設值，defaultdict的其他行為跟dict是完全一樣的。

OrderedDict 有序字典

使用dict時，Key是無序的。在對dict做迭代時，我們無法確定Key的順序。

如果要保持Key的順序，可以用OrderedDict：

from collections import OrderedDict
d = dict([('a', 1), ('c', 2), ('b', 3),('d', 2),('e', 2)])
print(list(d.keys())) # dict的Key是無序的

od = OrderedDict([('a', 1), ('c', 2), ('b', 3),('d', 2),('e', 2)])
print(od)# OrderedDict的Key是有序的

od = OrderedDict()
od['z'] = 1
od['y'] = 2
od['x'] = 3
list(od.keys()) # 按照插入的Key的順序返回


['a', 'c', 'b', 'd', 'e']
OrderedDict([('a', 1), ('c', 2), ('b', 3), ('d', 2), ('e', 2)])





['z', 'y', 'x']

%%python2
a={'key1':'a','key2':'b','key3':'c','key4':'d','key5':'e'}
print(a)

{'key3': 'c', 'key2': 'b', 'key1': 'a', 'key5': 'e', 'key4': 'd'}

!python -V

Python 3.7.0

Counter

Counter是一個簡單的計數器，例如，統計字元出現的個數：

from collections import Counter
c = Counter()
for ch in 'programming':
    c[ch] = c[ch] + 1
print(c)

Counter({'r': 2, 'g': 2, 'm': 2, 'p': 1, 'o': 1, 'a': 1, 'i': 1, 'n': 1})

Counter實際上也是dict的一個子類，上面的結果可以看出，字元’g’、‘m’、'r’各出現了兩次，其他字元各出現了一次。

Queue佇列

Python的Queue模組提供一種適用於多執行緒程式設計的FIFO實現。它可用於在生產者(producer)和消費者(consumer)之間執行緒安全(thread-safe)地傳遞訊息或其它資料，因此多個執行緒可以共用同一個Queue例項。Queue的大小（元素的個數）可用來限制記憶體的使用。

Basic FIFO Queue

Queue類實現了一個基本的先進先出(FIFO)容器，使用put()將元素新增到序列尾端，get()從佇列尾部移除元素。

from queue import Queue

q = Queue(maxsize=10)

for i in range(3):
    q.put(i)

while not q.empty():
    print(q.get())

0
1
2

LIFO Queue

與標準FIFO實現Queue不同的是，LifoQueue使用後進先出序（會關聯一個棧資料結構）

from queue import LifoQueue

q = LifoQueue(maxsize=10)

for i in range(3):
    q.put(i)

while not q.empty():
    print(q.get())

2
1
0

Priority Queue（優先佇列）

除了按元素入列順序外，有時需要根據佇列中元素的特性來決定元素的處理順序。例如，財務部門的列印任務可能比碼農的程式碼列印任務優先順序更高。PriorityQueue依據佇列中內容的排序順序(sort order)來決定那個元素將被檢索

from queue import PriorityQueue 

class Job(object): 
    def __init__(self, priority, description): 
        self.priority = priority 
        self.description = description 
        print('New job:', description) 
       
    def __lt__(self, other): 
        return self.priority < other.priority 
    
q = PriorityQueue(maxsize=10)
q.put(Job(5, 'Mid-level job'))
q.put(Job(10, 'Low-level job')) 
q.put(Job(1, 'Important job')) 

while not q.empty(): 
    next_job = q.get() 
    print('Processing job', next_job.description)


New job: Mid-level job
New job: Low-level job
New job: Important job
Processing job Important job
Processing job Mid-level job
Processing job Low-level job

相關推薦

python資料結構進階

文章目錄 namedtuple deque雙端佇列 建立雙向佇列 append(往右邊新增一個元素) appendleft（往左邊新增一個元素） pickle 儲存佇列 dump(object, fi

4302 Interval GCD 0x40「資料結構進階」例題（線段樹，差分）

題意： 4302 Interval GCD 0x40「資料結構進階」例題 描述 給定一個長度為N的數列A，以及M條指令 (N≤5*10^5, M<=10^5)，每條指令可能是以下兩種之一： “C l r d”，表示把 A[l],A[l+1],…,A[r] 都加上 d。 “Q l

4301 Can you answer on these queries III 0x40「資料結構進階」例題（線段樹）

4301 Can you answer on these queries III 0x40「資料結構進階」例題 描述 給定長度為N的數列A，以及M條指令 (N≤500000, M≤100000)，每條指令可能是以下兩種之一： “2 x y”，把 A[x] 改成 y。 “1 x

資料結構進階——二叉樹，紅黑樹

基本定義：一個根節點下分兩個子節點的樹結構稱為二叉樹。A為根節點，B、C分別為左孩子和右孩子，E這種無孩子的結點成為葉子結點，A，B，D，G共4層。二叉樹存在的三種排序方式圖中也說明的很清晰了。 先序：根->左->右； 中序：左->根->右； 後

資料結構進階 一 稀疏矩陣

稀疏矩陣 一、稀疏矩陣的定義       對於那些零元素數目遠遠多於非零元素數目，並且非零元素的分佈沒有規律的矩陣稱為稀疏矩陣（sparse）。       人們無法給出稀疏矩陣的確切定義，一般都只是憑個人的直覺來理解這個概念，即矩

資料結構進階(一)稀疏矩陣

稀疏矩陣一、稀疏矩陣的定義      對於那些零元素數目遠遠多於非零元素數目，並且非零元素的分佈沒有規律的矩陣稱為稀疏矩陣（sparse）。      人們無法給出稀疏矩陣的確切定義，一般都只是憑個人的直覺來理解這個概念，即矩陣中非零元素的個數遠遠小於矩陣元素的總數，並且非零

資料結構進階(四)二叉排序樹(二叉查詢樹)

資料結構進階(四)二叉排序樹(二叉查詢樹)    注:構造一棵二叉排序樹的目的，其實並不是為了排序(中序遍歷)，而是為了提高查詢、插入、刪除關鍵字的速度。定義    二叉排序樹又叫二叉查詢樹，英文名稱是：Binary Sort Tree.BST的定義就不詳細說了，我用一句話概

資料結構進階：ST表

## 簡介 ST 表是用於解決 **可重複貢獻問題** 的資料結構。 #### 什麼是可重複貢獻問題？ ​ **可重複貢獻問題** 是指對於運算 $\operatorname{opt}$ ，滿足 $x\operatorname{opt} x=x$ ，則對應的區間詢問就是一個可重複貢獻問題。例

Python基礎知識進階（五---2）----程序基本結構、簡單分支、異常處理、三大實例分析、基本循環結構、通用循環構造方法、死循環嵌套循環、布爾表達式

方法 算法 嵌套 構造方法 決策樹 輸入 繼續 實例 控制 上一篇隨筆寫的內容有點多了，決定分成兩節，不然自己看的時候也頭疼。 三者最大實例: 分支結構可以改變程序的控制流，算法不再是單調的一步步順序執行。 　　　　假設：以找出三個數字中最大者的程序設計為例。 　　　　　

Python爬蟲新手進階版：怎樣讀取非結構化、圖像、視頻、語音數據

image clas 訓練 在線的 功能 方式 base64編碼 contain width 通過open讀取之後會返回一個圖像文件對象，後續所有的圖像處理都基於該對象進行。上述代碼執行後，通過 img.show() 會調用系統默認的圖像瀏覽器查看打

python視覺化進階---seaborn1.5 分類資料視覺化

分類資料視覺化 - 分類散點圖 stripplot() / swarmplot() 載入模組，設定風格、尺度 import numpy as np import pandas as pd import matplotlib.pyplot as plt import se

python視覺化進階---seaborn1.8 線性關係資料視覺化 Implot（）

線性關係資料視覺化 1. Implot（） 示例1： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns #設定風格、尺度 sns.se

python django -5 進階

內容 search pic super dex this ava 搜索框 框架 高級知識點包括： 靜態文件處理 中間件 上傳圖片 Admin站點 分頁 使用jquery完成ajax 管理靜態文件 項目中的CSS、圖片、js都是靜態文件 配置靜態文件 在settin

第九章：循環結構進階

con 語法 條件 ont while bsp 概念 while循環 循環 第九章：循環結構進階 二重循環結構 概念 二重循環就是一個循環體內包含了另一個完整的循環結構。 語法 while與while循環嵌套 while（循環條件1）{ 循環操作1

13 Python 函數進階

desktop peter spl 語法糖 自由 font close bad 場景 代碼在運行伊始，創建的存儲“變量名與值的關系”的空間叫做全局命名空間，在函數的運行中開辟的臨時的空間叫做局部命名空間 命名空間和作用域 　　命名空間的本質：存放名字與值的綁定關系 1

python 函數進階

內部函數 調用 code post 聲明變量 logs username 會計 變現 函數進階 命名空間 namespace, 顧名思義, 就是存放名字的地方.舉例:若聲明變量 x = 1, 值1存放與內存中, 那變量名x 就存放在命名空間裏. 命名空間是存放x 和 1

Python學習(九)--[進階]函數

相同 pen 調用 UNC 返回函數 列表 日誌 ref str 閉包 Python的函數時可以嵌套的，可以將一個函數放在另外一個裏面。 def multiplier(factor): def multiplyByFactor(numb

python函數進階

調用 形參 () code war lob class **kwargs python 一、函數的動態參數 　　1.位置動態參數 *args :將實參的位置參數全部接收，形成一個元組 　　2.關鍵字動態參數 **kwargs: 將實參的關鍵字參數全部接收形成一個字典 　　3

2.3.10 Python 函數進階

臨時 名稱空間 函數定義 綁定 說明 查看 模塊 () globals 名稱空間 又名 name space。 說明：若變量 x=1， 1存放於內存中，那名字x存放在哪裏？ 名稱空間正是存放名字x與1綁定關系的地方 名稱空間共三種： locals

python從零進階之路——day2

列表list：增，刪，查，改，切片，拷貝 1.切片 # -*- coding-utf8 -*- # author:zingerman name=['hu','zhao','wang','zhou'] print(name[:2]) 　　#預設從0開始 print(name[-3: