关于python:图解python-数据结构

作者：韩信子 @ShowMeAI
教程地址：http://www.showmeai.tech/tuto…
本文地址：http://www.showmeai.tech/article-detail/83
申明：版权所有，转载请分割平台与作者并注明出处

Python 中有大量的数据结构与容器供编程应用，在本节内容中咱们汇总后面所学的知识点，并拓展一些新常识，来介绍 Python 数据结构。

Python 中列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表能够批改，而字符串和元组不能。

对于 Python 列表的具体内容请参考前序内容 Python 列表及利用

以下是 Python 中列表的办法：

办法	形容
list.append(x)	把一个元素增加到列表的结尾，相当于 a[len(a):] = [x]。
list.extend(L)	通过增加指定列表的所有元素来裁减列表，相当于 a[len(a):] = L。
list.insert(i, x)	在指定地位插入一个元素。第一个参数是筹备插入到其后面的那个元素的索引，例如 a.insert(0, x) 会插入到整个列表之前，而 a.insert(len(a), x) 相当于 a.append(x)。
list.remove(x)	删除列表中值为 x 的第一个元素。如果没有这样的元素，就会返回一个谬误。
list.pop([i])	从列表的指定地位移除元素，并将其返回。如果没有指定索引，a.pop()返回最初一个元素。元素随即从列表中被移除。（办法中 i 两边的方括号示意这个参数是可选的，而不是要求你输出一对方括号，你会常常在 Python 库参考手册中遇到这样的标记。）
list.clear()	移除列表中的所有项，等于 del a[:]。
list.index(x)	返回列表中第一个值为 x 的元素的索引。如果没有匹配的元素就会返回一个谬误。
list.count(x)	返回 x 在列表中呈现的次数。
list.sort()	对列表中的元素进行排序。
list.reverse()	倒排列表中的元素。
list.copy()	返回列表的浅复制，等于 a[:]。

上面示例演示了列表的大部分办法（在线 python3 环境）：

a = [2, 123, 123, 1, 1234.5]
print('''a.count(123), a.count(1), a.count('x')''')
print(a.count(123), a.count(1), a.count('x'), "\n")

a.insert(2, -1)
print('''a.insert(2, -1)''')
print(a, "\n")

a.append(456)
print('''a.append(456)''')
print(a, "\n")

a.index(456)
print('''a.index(456)''')
print(a.index(456), "\n")

a.remove(456)
print('''a.remove(456)''')
print(a, "\n")


a.reverse()
print('''a.reverse()''')
print(a, "\n")

a.sort()
print('''a.sort()''')
print(a, "\n")

运行后果

a.count(123), a.count(1), a.count('x')
2 1 0 

a.insert(2, -1)
[2, 123, -1, 123, 1, 1234.5] 

a.append(456)
[2, 123, -1, 123, 1, 1234.5, 456] 

a.index(456)
6 

a.remove(456)
[2, 123, -1, 123, 1, 1234.5] 

a.reverse()
[1234.5, 1, 123, -1, 123, 2] 

a.sort()
[-1, 1, 2, 123, 123, 1234.5]

留神：相似 insert, remove 或 sort 等批改列表的办法没有返回值。

列表办法使得列表能够很不便的作为一个堆栈来应用，堆栈作为特定的数据结构，最先进入的元素最初一个被开释（后进先出）。用 append() 办法能够把一个元素增加到堆栈顶。用不指定索引的 pop() 办法能够把一个元素从堆栈顶释放出来。

参考如下代码（在线 python3 环境）：

stack = ['Baidu', 'ShowMeAI', 'google']
stack.append('ByteDance')
stack.append('Tencent')
print(stack)

stack.pop()
print('''stack.pop()''')
print(stack, "\n")

stack.pop()
print('''stack.pop()''')
print(stack, "\n")

stack.pop()
print('''stack.pop()''')
print(stack, "\n")

运行后果为

['Baidu', 'ShowMeAI', 'google', 'ByteDance', 'Tencent']
stack.pop()
['Baidu', 'ShowMeAI', 'google', 'ByteDance'] 

stack.pop()
['Baidu', 'ShowMeAI', 'google'] 

stack.pop()
['Baidu', 'ShowMeAI']

也能够把列表当做队列用，只是在队列里第一退出的元素，第一个取出来；然而拿列表用作这样的目标效率不高。在列表的最初增加或者弹出元素速度快，然而在列表里插入或者从头部弹出速度却不快（因为所有其余的元素都得一个一个地挪动）。

from collections import deque
queue = deque(['Baidu', 'ShowMeAI', 'google'])
queue.append('ByteDance')       
queue.append('Tencent')
print(deque)

print('''queue.popleft()''')
print(queue.popleft(), "\n")
print('''queue.popleft()''')
print(queue.popleft(), "\n")
print(deque)

运行后果为

<class 'collections.deque'>
queue.popleft()
Baidu 

queue.popleft()
ShowMeAI 

<class 'collections.deque'>

列表推导式提供了从序列创立列表的简略路径。通常应用程序将一些操作利用于某个序列的每个元素，用其取得的后果作为生成新列表的元素，或者依据确定的断定条件创立子序列。

每个列表推导式都在 for 之后跟一个表达式，而后有零到多个 for 或 if 子句。返回后果是一个依据表白从其后的 for 和 if 上下文环境中生成进去的列表。如果心愿表达式推导出一个元组，就必须应用括号。

vec = [1, 2, 3]
# 将列表中每个数值乘三，取得一个新的列表：three_times_vec = [3*x for x in vec]
print(three_times_vec)

# 将列表中每个数值平方，并和原始值组成列表后再组成新的列表：cmp_x_square = [[x, x**2] for x in vec]
print(cmp_x_square)

运行后果

[3, 6, 9]
[[1, 1], [2, 4], [3, 9]]

列表推导式还能够用来对序列里每一个元素都调用某函数办法：

fruits = ['banana', 'loganberry', 'apple']
print([fruit.upper() for fruit in fruits])
# 输入['BANANA', 'LOGANBERRY', 'APPLE']

在列表推导式中能够用 if 子句构建过滤器对生成后果过滤：

[3*x for x in vec if x > 2]
# 后果[9]
[3*x for x in vec if x < 3]
# 后果[3, 6]

还能够组合两个列表去应用列表推导式构建更简单的后果

vec1 = [1, 2, 3]
vec2 = [4, 5, 6]
[x*y for x in vec1 for y in vec2] #两两相乘失去新列表
# 后果[4, 5, 6, 8, 10, 12, 12, 15, 18]

[x+y for x in vec1 for y in vec2] #两两相加失去新列表
# 后果[5, 6, 7, 6, 7, 8, 7, 8, 9]

[vec1[i]*vec2[i] for i in range(len(vec1))] #对应地位相乘失去新列表
# 后果[4, 10, 18]

Python 的列表还能够嵌套。

以下代码展现了 3X4 的矩阵列表（在线 python3 环境）：

matrix = [[1, 2, 3, 4],
      [5, 6, 7, 8],
      [9, 10, 11, 12],
       ]

# 将 3X4 的矩阵列表转换为 4X3 列表：trans = [[row[i] for row in matrix] for i in range(4)]
print(trans)

# 等价于下列做法，然而下面的形式更简洁
transposed = []
for i in range(4):
   transposed_row = []
   for row in matrix:
      transposed_row.append(row[i])
   transposed.append(transposed_row)
print(transposed)

应用 del 语句能够从一个列表中依索引而不是值来删除一个元素。这与应用 pop() 返回一个值不同。能够用 del 语句从列表中删除一个切割，或清空整个列表（咱们以前介绍的办法是给该切割赋一个空列表）。例如：

a = [1, 2, 3, 456, 789, 1234.5]
del a[0] #[2, 3, 456, 789, 1234.5]
del a[2:4] #[2, 3, 1234.5]
del a[:]

也能够用 del 删除实体变量：

del a

元组由若干逗号分隔的值组成，例如：

t = 12345, 54321, 'hello!'
t[0] # 12345
t #(12345, 54321, 'hello!')
u = t, (1, 2, 3, 4, 5)
u # ((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

元组在输入时总是有括号的，以便于正确表白嵌套构造。在输出时可能有或没有括号，不过括号通常是必须的（如果元组是更大的表达式的一部分）。

汇合是一个无序不反复元素的集。基本功能包含关系测试和打消反复元素。

能够用大括号 ({}) 创立汇合。留神：如果要创立一个空集合，你必须用 set() 而不是 {}；后者创立一个空的字典，下一节咱们会介绍这个数据结构。

以下是一个简略的代码示例（在线 python3 环境）：

basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
print(basket)                      # 删除反复的
# 后果{'orange', 'banana', 'pear', 'apple'}

'orange' in basket                 # 检测成员
# 后果 True

'crabgrass' in basket
# 后果 False

# 以下演示了两个汇合的操作
a = set('abracadabra')
b = set('alacazam')

a                                  # a 中惟一的字母
# 后果{'a', 'r', 'b', 'c', 'd'}

a - b                              # 在 a 中的字母，但不在 b 中
# 后果{'r', 'd', 'b'}

a | b                              # 在 a 或 b 中的字母
# 后果{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}

a & b                              # 在 a 和 b 中都有的字母
# 后果{'a', 'c'}

a ^ b                              # 在 a 或 b 中的字母，但不同时在 a 和 b 中
# 后果{'r', 'd', 'b', 'm', 'z', 'l'}

另一个十分有用的 Python 内建数据类型是字典。

序列是以间断的整数为索引，与此不同的是，字典以关键字为索引，关键字能够是任意不可变类型，通常用字符串或数值。

了解字典的最佳形式是把它看做无序的键 => 值对汇合。在同一个字典之内，关键字必须是互不雷同。

一对大括号创立一个空的字典：{}。

company = {'ShowMeAI': 1234, 'Baidu': 5678}
company['guido'] = 4127

company
# 后果{'Baidu': 5678, 'guido': 4127, 'ShowMeAI': 1234}

company['ShowMeAI']
# 后果 1234

del company['Baidu']
company['irv'] = 4127
company
# 后果{'guido': 4127, 'irv': 4127, 'ShowMeAI': 1234}

list(company.keys())
# 后果['irv', 'guido', 'ShowMeAI']

sorted(company.keys())
# 后果['guido', 'irv', 'ShowMeAI']

'guido' in company
# 后果 True

'ShowMeAI' not in company
# 后果 False

构造函数 dict() 间接从键值对元组列表中构建字典。此外，字典推导能够用来创立任意键和值的表达式词典：

dict([('ShowMeAI', 1234), ('Baidu', 5678)])
# 后果{'ShowMeAI': 1234, 'Baidu': 5678}

{x: x**2 for x in (2, 4, 6)}
# 后果{2: 4, 4: 16, 6: 36}

如果关键字只是简略的字符串，应用关键字参数指定键值对有时候更不便：

dict(ShowMeAI=1234, Baidu=5678)
# 后果{'ShowMeAI': 1234, 'Baidu': 5678}

在字典中遍历时，关键字和对应的值能够应用 items() 办法同时解读进去：

knights = {'ShowMeAI': 1234, 'Baidu': 5678}
for k, v in knights.items():
   print(k, v)

在序列中遍历时，索引地位和对应值能够应用 enumerate() 函数同时失去：

for i, v in enumerate(['tic', 'tac', 'toe']):
   print(i, v)
# 0 tic
# 1 tac
# 2 toe

同时遍历两个或更多的序列，能够应用 zip() 组合：

questions = ['name', 'age', 'color']
answers = ['ShowMeAI', '30', 'blue']
for q, a in zip(questions, answers):
   print('What is the {0}?  It is {1}.'.format(q, a))
# What is the name?  It is ShowMeAI.
# What is the quest?  It is 30.
# What is the color?  It is blue.

要反向遍历一个序列，首先指定这个序列，而后调用 reversed() 函数：

for i in reversed(range(1, 10, 2)):
   print(i)

# 9
# 7
# 5
# 3
# 1

要按程序遍历一个序列，应用 sorted() 函数返回一个已排序的序列，并不批改原值：

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

# apple
# banana
# orange
# pear

本教程系列的代码能够在 ShowMeAI 对应的 github 中下载，可本地 python 环境运行，能迷信上网的宝宝也能够间接借助 google colab 一键运行与交互操作学习哦！

本教程系列波及的 Python 速查表能够在以下地址下载获取：

Python 速查表

Python 教程—Python3 文档
Python 教程 - 廖雪峰的官方网站

python 介绍
python 装置与环境配置
python 根底语法
python 根底数据类型
python 运算符
python 条件管制与 if 语句
python 循环语句
python while 循环
python for 循环
python break 语句
python continue 语句
python pass 语句
python 字符串及操作
python 列表
python 元组
python 字典
python 汇合
python 函数
python 迭代器与生成器
python 数据结构
python 模块
python 文件读写
python 文件与目录操作
python 谬误与异样解决
python 面向对象编程
python 命名空间与作用域
python 工夫和日期

图解 Python 编程：从入门到精通系列教程
图解数据分析：从入门到精通系列教程
图解 AI 数学根底：从入门到精通系列教程
图解大数据技术：从入门到精通系列教程

关于python:图解python-数据结构

Python3 数据结构

1.Python 列表

2. 将列表当做堆栈应用

3. 将列表当作队列应用

4. 列表推导式

5. 嵌套列表解析

6.del 语句

7. 元组

8. 汇合

9. 字典

10. 遍历技巧

材料与代码下载

拓展参考资料

ShowMeAI 相干文章举荐

ShowMeAI 系列教程举荐

Just My Socks（注册教程内含优惠码）

关于python:图解python-数据结构

Python3 数据结构

1.Python 列表

2. 将列表当做堆栈应用

3. 将列表当作队列应用

4. 列表推导式

5. 嵌套列表解析

6.del 语句

7. 元组

8. 汇合

9. 字典

10. 遍历技巧

材料与代码下载

拓展参考资料

ShowMeAI 相干文章举荐

ShowMeAI 系列教程举荐

Just My Socks（注册教程 内含优惠码）

Just My Socks（注册教程内含优惠码）