Python数据结构

列表

列表可以修改，而字符串和元组不能修改

列表中的方法：

注：insert、remove、sort等修改列表的方法没有返回值

list=[1,2,3,4,5,"啾咪"]
list.append("增加一个哦")
print(list)
list.extend([0,8,9,7])
print(list)
list.insert(3,"插入")
print(list)
list.remove("啾咪")
print(list)
list.pop(3)
print(list)
print(list.index(3))
print(list.count(3))

a=[4,3,2,7,6,9,0,1]
a.sort()
print(a)
a.reverse()
print(a)
a.copy()
print(a)

将列表当做堆栈使用

堆栈的数据结构：最先进入的元素最后一个被释放（先进后出，后进先出）

用append()可以把一个元素添加到堆栈的顶部，用不指定索引pop可以将堆栈中的元素从堆栈顶部释放出来

stack=[1,2,3]
stack.append(7)
stack.append(9)
print(stack)
#[1, 2, 3, 7, 9]
stack.pop()
print(stack)
#[1, 2, 3, 7]
stack.pop()
print(stack)
#[1, 2, 3]

结果：
[1, 2, 3, 7, 9]
[1, 2, 3, 7]
[1, 2, 3]

将列表当做队列使用

队列的数据结构：第一个加入的元素，第一个取出（先进先出、后进后出）

把我列表当做队列使用的效率不高：在列表的尾部添加/释放元素的速度更快，而从头部添加/释放元素的速度却不快（所有的其他元素都是一个一个移动的）

from collections import deque

queue=deque(["KK","CC","Chili"])
queue.append("cli.im")
print(queue)
#deque(['KK', 'CC', 'Chili', 'cli.im'])
queue.popleft()
print(queue)
#deque(['CC', 'Chili', 'cli.im'])
queue.popleft()
print(queue)
#deque(['Chili', 'cli.im'])

结果：
deque(['KK', 'CC', 'Chili', 'cli.im'])
deque(['CC', 'Chili', 'cli.im'])
deque(['Chili', 'cli.im'])

列表推导式

1、列表推导式：利用range区间、元组、列表、字典、集合等数据类型，快速生成一个满足指定需求的列表（提供了从序列创建列表的途径，通常应用程序将一些操作应用的某个序列的每个元素（每个元素都*3），获得的结果可以生成新列表的元素，或者根据确定的判定条件创建子序列）

2、列表推导式的语法格式：[表达式 for 迭代变量 in 可迭代对象 [if条件表达式]]       （这里的if 条件表达式不是必须的，根据需要加）

3、执行顺序如下：

for 迭代变量 in 可迭代对象
    表达式

列表推导式最终将循环过程中，计算表达式得到的一系列的值组成一个列表

案例1

a=range(10) #创建一个整数列表，一般用for循环
#对a执行迭代，由于a包含10个元素，因此程序a_list同样包含10个元素，每个元素都是a中每个元素的平方（x*x）
a=[x * x for x in a] #对a执行for表达式
print(a) #a集合中包含十个元素

结果：
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

案例2

b=range(10) #创建一个整数列表
b=[x*x for x in b if x%2==0] #只迭代符合条件的元素
print(b) #10个元素中只有5个元素符合条件

结果：
[0, 4, 16, 36, 64]

案例3 

c=[(x,y) for x in range(5) for y in range(4)] 
#x是遍历range(5)的迭代变量(计数器)，因此x可迭代5次；y是遍历range(4)的计数器，因此y可迭代4次，该(x,y)表达式一共会迭代20次，这个for表达式相当于下列的嵌套循环
print(c) #列表中包含20个元素

结果：
[(0, 0), (0, 1), (0, 2), (0, 3), (1, 0), (1, 1), (1, 2), (1, 3), (2, 0), (2, 1), (2, 2), (2, 3), (3, 0), (3, 1), (3, 2), (3, 3), (4, 0), (4, 1), (4, 2), (4, 3)]

相当于：
c = []
for x in range(5):
    for y in range(4):
        c.append((x, y))

案例4

d=[[x, y, z] for x in range(5) for y in range(4) for z in range(6)]
#列表包含120个元素
print(d)

#对于多个循环的for表达式，同样可以指定if条件
#程序要将两个列表中的数据按照“能否整除”的关系配对在一起
src_a = [30, 12, 66, 34, 39, 78, 36, 57, 121]
src_b = [3, 5, 7, 11]
# 只要y能整除x，就将它们配对在一起
result = [(x, y) for x in src_b for y in src_a if y % x == 0]
print(result)

结果：
[[0, 0, 0], [0, 0, 1], [0, 0, 2], [0, 0, 3], [0, 0, 4], [0, 0, 5], [0, 1, 0], [0, 1, 1], [0, 1, 2], [0, 1, 3], [0, 1, 4], [0, 1, 5], [0, 2, 0], [0, 2, 1], [0, 2, 2], [0, 2, 3], [0, 2, 4], [0, 2, 5], [0, 3, 0], [0, 3, 1], [0, 3, 2], [0, 3, 3], [0, 3, 4], [0, 3, 5], [1, 0, 0], [1, 0, 1], [1, 0, 2], [1, 0, 3], [1, 0, 4], [1, 0, 5], [1, 1, 0], [1, 1, 1], [1, 1, 2], [1, 1, 3], [1, 1, 4], [1, 1, 5], [1, 2, 0], [1, 2, 1], [1, 2, 2], [1, 2, 3], [1, 2, 4], [1, 2, 5], [1, 3, 0], [1, 3, 1], [1, 3, 2], [1, 3, 3], [1, 3, 4], [1, 3, 5], [2, 0, 0], [2, 0, 1], [2, 0, 2], [2, 0, 3], [2, 0, 4], [2, 0, 5], [2, 1, 0], [2, 1, 1], [2, 1, 2], [2, 1, 3], [2, 1, 4], [2, 1, 5], [2, 2, 0], [2, 2, 1], [2, 2, 2], [2, 2, 3], [2, 2, 4], [2, 2, 5], [2, 3, 0], [2, 3, 1], [2, 3, 2], [2, 3, 3], [2, 3, 4], [2, 3, 5], [3, 0, 0], [3, 0, 1], [3, 0, 2], [3, 0, 3], [3, 0, 4], [3, 0, 5], [3, 1, 0], [3, 1, 1], [3, 1, 2], [3, 1, 3], [3, 1, 4], [3, 1, 5], [3, 2, 0], [3, 2, 1], [3, 2, 2], [3, 2, 3], [3, 2, 4], [3, 2, 5], [3, 3, 0], [3, 3, 1], [3, 3, 2], [3, 3, 3], [3, 3, 4], [3, 3, 5], [4, 0, 0], [4, 0, 1], [4, 0, 2], [4, 0, 3], [4, 0, 4], [4, 0, 5], [4, 1, 0], [4, 1, 1], [4, 1, 2], [4, 1, 3], [4, 1, 4], [4, 1, 5], [4, 2, 0], [4, 2, 1], [4, 2, 2], [4, 2, 3], [4, 2, 4], [4, 2, 5], [4, 3, 0], [4, 3, 1], [4, 3, 2], [4, 3, 3], [4, 3, 4], [4, 3, 5]]

[(3, 30), (3, 12), (3, 66), (3, 39), (3, 78), (3, 36), (3, 57), (5, 30), (11, 66), (11, 121)]

嵌套列表解析

案例1：展示3*4的矩阵列表

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

案例2：将3*4的矩阵列表转换为4*3的列表 

transposed = []
for i in range(4):
    transposed.append([row[i] for row in matrix])
    ...
    ...

c=[[row[i] for row in matrix]for i in range(4)]
或者
transposed = []
for i in range(4):
# the following 3 lines implement the nested listcomp
    transposed_row = []
    for row in matrix:
        transposed_row.append(row[i])
        transposed.append(transposed_row)

del语句

del语句：可以从一个列表中依照索引来删除一个元素，也可以用del语句从列表中删除一个切割、或者清空整个列表

a=[-1,1,4,6,6565,435,345.4]
del a[3]
print(a)
del a[2:4]
print(a)
del a[:]
print(a)

结果：
[-1, 1, 4, 6565, 435, 345.4]
[-1, 1, 435, 345.4]
[]

元组和序列

元组：元组是由若干个逗号分隔的元素组成

a=12,34,5,55
print(a[3])
print(a)
b=a,5,7,7,78,56
print(b)

结果：
(12, 34, 5, 55)
((12, 34, 5, 55), 5, 7, 7, 78, 56)

集合

集合：无序不重复元素的集（功能：关系测试、消除重复元素）

集合用{}来创建，如果创建空集合，必须使用set()而不是{}

a={"c","as","f","h","l","a","k"}
b=set("chili1243")
print(a,b)
print(a-b)
print(a|b)
print(a&b)
print(a^b)

结果：
{'k', 'as', 'h', 'f', 'l', 'c', 'a'} {'i', '4', '3', '2', 'h', '1', 'l', 'c'}
{'a', 'k', 'f', 'as'}
{'k', 'i', '4', '3', 'a', '2', 'as', 'h', 'f', 'l', 'c', '1'}
{'l', 'c', 'h'}
{'k', 'i', '4', '3', 'a', '2', 'as', '1', 'f'}

字典

字典：字典以关键字为索引，用{x:y,...}创建（无序的键值对集合）

a={'red':1,'yellow':2,'jack':3}
b=dict(a=1,b=3)
print(a)
print(b)
a['cc']=9
print(a)
del a['cc']
print(a)
print(list(a.keys()))
print(sorted(a.keys()))


结果：
{'red': 1, 'yellow': 2, 'jack': 3}
{'a': 1, 'b': 3}
{'red': 1, 'yellow': 2, 'jack': 3, 'cc': 9}
{'red': 1, 'yellow': 2, 'jack': 3}
['red', 'yellow', 'jack']
['jack', 'red', 'yellow']

 字典推导可以用来创建任意键值表达式字典

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

结果：
{2: 4, 4: 16, 6: 36}

遍历技巧

在字典中遍历，关键字和对应的值可以使用items()方法同时解读出来

a={'kk':1,'cc':2,'aa':8,'oo':443}
for k,v in a.items():
    print(k,v)

结果：
kk 1
cc 2
aa 8
oo 443

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

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

结果：
0 tic
1 tac
2 toe

同时遍历两个或两个以上的序列，使用zip()组合

questions = ['name', 'quest', 'favorite color']
answers = ['lancelot', 'the holy grail', 'blue']
for q, a in zip(questions, answers):
    print('What is your {0}?  It is {1}.'.format(q, a))

结果：
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite 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