Python3 列表，元組，字典 在數據結構方面的使用

列表

列表的堆棧使用

堆棧即數據中的單個元素後進先出，棧頂入棧，棧頂出棧
例如：

>>> myStack = [1, 2, 3, 4.5];
>>> myStack.append(66);
>>> myStack.append(77);
>>> myStack.append(88);
# 輸出後如下
>>> myStack;
[1, 2, 3, 4.5, 66, 77, 88]
>>> myStack.pop();
88
>>> myStack.pop();
77
>>> myStack;
[1, 2, 3, 4.5, 66]

可以看的出 append 每次添加元素到列表末尾， pop 每次刪除最後一個元素並返回，符合堆棧的定義

列表的隊列使用

隊列，即數據中的元素後進後出，最先進入隊列的元素最早出隊列
示例如下：

>>> from collections import deque
>>> myquence = deque(["a", 'b', "c"]);
>>> myquence.append("dd");
>>> myquence.append("ee");
>>> myquence;
deque(['a', 'b', 'c', 'dd', 'ee'])
>>> myquence.popleft();
'a'
>>> myquence.popleft();
'b'
>>> myquence
deque(['c', 'dd', 'ee'])

但這種方式畢竟不是鏈表，移動首位元素後後面所有元素都會移動，而且數據量越大消耗的時間長
這一點與 Java 類似，同樣的Java 執行這種操作的時候也推薦 使用 LinkedList 即鏈表的子實現類，從而加快速度

列表推導式

對一個基本列表元素的每個元素做一定的操作最終得到新的結果集。
每個列表推導式都在 for 之後跟一個表達式，然後有零到多個 for 或 if 子句。返回結果是一個根據表達從其後的 for 和 if 上下文環境中生成出來的列表。如果希望表達式推導出一個元組，就必須使用括號。

示例1： 例如對數組內的每個元素做乘2的操作然後得到新的結果：

>>> list1 = [1, 2, 3];
>>> [x*3 for x in list1];
[3, 6, 9]
>>> list1;
[1, 2, 3]
>>>

示例2：做數組嵌套，對每個元素做乘方然後與原數放到一個新的 [] 中

>>> list1 = [1, 2, 3];
>>> [[x, x**2] for x in list1];
[[1, 1], [2, 4], [3, 9]]
>>> list1;
[1, 2, 3]
>>>

這樣的處理類似於 Java 中的 foreach 以及 lambda 的操作方式

對於這樣的操作我是如下理解的：
不論內部如何寫 都先看 for in 的內容，即 理解為先對 in 後的列表中每個元素 x 做 for 前的操作並作為一個結果最終放到 整個 [] 中作為一個元素，遍歷所有元素後將結果即作為本身推導式的結果集；

逐一調用某個方法的示例：

>>> list1 = [" daw ", "lcd ", "11 56 "];
>>> [item.strip() for item in list1]
['daw', 'lcd', '11 56']
>>> list1;
[' daw ', 'lcd ', '11 56 ']

添加 if 的幾個例子以及其他使用例子

>>> list1 = [1, 2, 3];
>>> list2 = [4, 5, 6];
>>> [ x*x for x in list1 if x > 1]
[4, 9]
>>> [x*y for x in list1 for y in list2]
[4, 5, 6, 8, 10, 12, 12, 15, 18]
>>> [x+y for x in list1 for y in list2]
[5, 6, 7, 6, 7, 8, 7, 8, 9]
>>> [list1[i]+list2[i] for i in range(len(list1))]
[5, 7, 9]
>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

嵌套列表解析

將行列做轉換如下例子：

>>> myMat = [
... [1, 2, 3, 10],
... [4, 5, 6, 11],
... [7, 8, 9, 12]
... ]
>>>
>>> [ [ row[index] for row in myMat] for index in range(4)]
[[1, 4, 7], [2, 5, 8], [3, 6, 9], [10, 11, 12]]
>>> listmat = []
>>> for i in range(4):
... listmat.append([row[i] for row in myMat])
...
>>> listmat
[[1, 4, 7], [2, 5, 8], [3, 6, 9], [10, 11, 12]]
>>> listmat2 = []
>>> for item in range(4):
... temp_row = []
... for row in myMat:
... temp_row.append(row[item])
... listmat2.append(temp_row)
...
>>> listmat2
[[1, 4, 7], [2, 5, 8], [3, 6, 9], [10, 11, 12]]

del 的使用

用於刪除變量或者列表中的某一個元素，但是不會和pop 一樣返回刪除的元素
可以直接通過 del a[index] 即指定某一個列表下指定索引的元素

元組

內部元素直接使用 ， 分割即可，輸出後一般都會套上 () 用以區分

>>> tp1 = "dwjhd", 154, "zxcccc";
>>> tp1;
('dwjhd', 154, 'zxcccc')
>>> tp2 = tp1, "dwab", "mmn", 544;
>>> tp2;
(('dwjhd', 154, 'zxcccc'), 'dwab', 'mmn', 544)

元組是可以嵌套的

集合

裡面的元素無序，不重復。使用 { } 來創建集合，可以執行集合操作，以及消除重復的元素。
用大括號 {} 創建集合。但如果要創建一個空集合，必須用 set() 而不是 {} ；{} 用於創建一個空的字典

使用 { }創建集合後會自動對裡面的元素做去重，一些例子如下：

>>> a1 = {
"hahahaha", "dawdwd", "haha", 154, 145, 1, 2, 3, 4, 1, "dawdwd"}
>>> a1;
{
1, 2, 3, 4, 'dawdwd', 'hahahaha', 145, 'haha', 154}
>>> a2 = set('dajkciweifbkljbsfb')
>>> a2;
{
'k', 'c', 'f', 'j', 'l', 'i', 'a', 's', 'd', 'w', 'b', 'e'}
>>> a3 = set("mnbbvczx")
>>> a3;
{
'c', 'v', 'm', 'z', 'x', 'b', 'n'}
>>> a2 - a3; # 差集
{
'k', 'f', 'j', 'l', 'i', 'a', 's', 'd', 'w', 'e'}
>>> a2 & a3; # 交集
{
'b', 'c'}
>>> a2 | a3; # 並集
{
'c', 'f', 'm', 's', 'w', 'x', 'e', 'n', 'k', 'v', 'j', 'z', 'l', 'i', 'a', 'd', 'b'}
>>> a2 ^ a3; # 不同時在兩個集合內
{
'f', 'm', 's', 'w', 'x', 'e', 'n', 'k', 'v', 'j', 'z', 'l', 'i', 'a', 'd'}
>>> "haha" in a1;
True
>>> "haha" not in a1;
False

同時 集合也支持 推導式和列表類似

>>> a = {
x for x in 'abcded' if x not in 'abc'}
>>> a
{
'd', 'e'}

字典

即 key value 與 Java 的 Map

可以直接從鍵值對元組列表中構建字典：

>>> dict([('a', 1), ('b', 2), ('c', 3)])
{
'a': 1, 'b': 2, 'c': 3}

字典推導式：

>>> {
x: x**2 for x in (2, 4, 6)}
{
2: 4, 4: 16, 6: 36}

如果關鍵字只是簡單的字符串，使用關鍵字參數指定鍵值對有時候更方便

>>> dict(a=1, b=2, c=3)
{
'a': 1, 'b': 2, 'c': 3}

遍歷方式：
1.key 和 對應的值可以使用 items() 同時讀取出來

>>> dict1 = {
"aa":124, "bb":125}
>>> for k,v in dict1.items():
... print(k, v)
...
aa 124
bb 125

2.序列中遍歷時，索引位置和對應值可以使用 enumerate() 同時得到

>>> for i, j in enumerate(['one', 'two', 'tri']):
... print(i, j)
...
0 one
1 two
2 tri

3.同時遍歷兩個或更多的序列 可以使用 zip()

>>> a1 = ['name', 'c', 'favorite color']
>>> b1 = ['xxx', 'cc', 'red']
>>> for q, a in zip(a1, b1):
... print('What is your {0}? It is {1}.'.format(q, a))
...
What is your name? It is xxx.
What is your quest? It is cc.
What is your favorite color? It is red.

4,反向遍歷一個序列，首先指定這個序列，然後調用 reversed() 函數

>>> for i in reversed(range(1, 10, 2)):
... print(i)
...
9
7
5
3
1

5.按順序遍歷一個序列，使用 sorted() 函數返回一個已排序的序列，並不修改原值

>>> basket = ['apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
... print(f)
...
apple
banana
orange
pear

參考文章 python3 數據結構