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]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

可以看的出 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'])
1
2
3
4
5
6
7
8
9
10
11
12

但这种方式毕竟不是链表，移动首位元素后后面所有元素都会移动，而且数据量越大消耗的时间长
这一点与 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]
>>>
1
2
3
4
5
6

示例2：做数组嵌套，对每个元素做乘方然后与原数放到一个新的 [] 中

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

这样的处理类似于 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  ']
1
2
3
4
5

添加 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']
1
2
3
4
5
6
7
8
9
10
11
12

嵌套列表解析

将行列做转换如下例子：

>>> 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]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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)
1
2
3
4
5
6

元组是可以嵌套的

集合

里面的元素无序，不重复。使用 { } 来创建集合，可以执行集合操作，以及消除重复的元素。
用大括号 {} 创建集合。但如果要创建一个空集合，必须用 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

同时 集合也支持 推导式和列表类似

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

字典

即 key value 与 Java 的 Map

可以直接从键值对元组列表中构建字典：

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

字典推导式：

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

如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便

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

遍历方式：
1.key 和 对应的值可以使用 items() 同时读取出来

>>> dict1 = {"aa":124, "bb":125}
>>> for k,v in dict1.items():
...     print(k, v)
...
aa 124
bb 125
1
2
3
4
5
6

2.序列中遍历时，索引位置和对应值可以使用 enumerate() 同时得到

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

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.
1
2
3
4
5
6
7
8

4,反向遍历一个序列，首先指定这个序列，然后调用 reversed() 函数

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

5.按顺序遍历一个序列，使用 sorted() 函数返回一个已排序的序列，并不修改原值

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

1
2
3
4
5
6
7
8
9

参考文章 python3 数据结构