python的数据结构

数据类型

不变：string，tuple
可变：list，dictionary，set
其中string，tuple，list是有序的，可以切片
但是dictionary，set是无序的，不可切片

1.string

var=＂hello world＂
var[1:7]

常用操作

len(‘good’) # 4 （字符的长度）
‘good’.replace(‘g’, ‘G’) # ‘Good’ （替换字符）
‘山-水-风-雨’.split(‘-’) # [‘山’, ‘水’, ‘风’, ‘雨’] （用指定字符分隔，默认空格）
‘好山好水好风光’.split(‘好’) # [‘’, ‘山’, ‘水’, ‘风光’]
‘-’.join([‘山’,‘水’,‘风’,‘雨’]) # ‘山-水-风-雨’
‘和’.join([‘诗’, ‘远方’]) # ‘诗和远方’
‘good’.upper() # ‘GOOD’ （全转大写）
‘GOOD’.lower() # ‘good’ （全转小写）
‘Good Bye’.swapcase() # ‘gOOD bYE’ （大小写互换）
‘good’.capitalize() # ‘Good’ （首字母转大写）
‘good’.islower() # True （是否全是小写）
‘good’.isupper() # False （是否全是大写）
‘3月’.zfill(3) # ‘03月’ （指定长度，如长度不够，前面补0）

2.list

x = [] # 空列表
x = [1，2，3，4，5]
x[1：3]

常用操作

a = [1, 2, 3]
len(a) # 3（元素个数）
max(a) # 3（最大值）
min(a) # 1（最小值）
sum(a) # 6（求和）
a.index(2) # 1（指定元素位置）

列表推导式（list comprehension）
[表达式 for 变量 in 可迭代对象 if 条件]
idx = [i for i, v in enumerate(lst) if v == target] # 返回各个下标

a.count(1) # 1（求元素的个数）
for i in a: print(i) # 迭代元素
sorted(a) # 返回一个排序的列表，但不改变原列表
any(a) # True（是否至少有一个元素为真）
all(a) # True（是否所有元素为真）
a.append(4) # a: [1, 2, 3, 4]（增加一个元素）
a.pop() # 每执行一次，删除最后一个元素
a.extend([9,8]) # a: [1, 2, 3, 9, 8]（与其他列表合并）
a.insert(1, ‘a’) # a: [1, ‘a’, 2, 3]（在指定索引位插入元素，索引从0开始）
a.remove(‘a’) # 删除第一个指定元素
a.clear() # []（清空）

3.tuple

t = (0, 10, 20, 30, 40, 50, 60, 70, 80, 90)
print(t[0:9]) # 前9个元素
t = (‘a’, [1, 2], (3, 4), {‘k’: 5})
print(t[1][0]) # 1 → 列表可改
print(t[2][1]) # 4 → 元组不可改
print(t[3][‘k’]) # 5 → 字典可改

常用操作

#1. 创建
t = (3, 1, 4, 1, 5, 9, 2, 6)
#2. 长度
len(t) # 8
#3. 最值、求和
max(t) # 9
min(t) # 1
sum(t) # 31
#4. 索引 & 出现次数
t.index(5) # 4 （第一次出现的位置）
t.count(1) # 2 （元素 1 出现了两次）
#5. 切片（仍是元组）
t[2:5] # (4, 1, 5)
#6. 排序 → 新列表（想保留元组再包一层 tuple() 即可）
sorted(t) # [1, 1, 2, 3, 4, 5, 6, 9]
#7. 成员判断
5 in t # True
0 not in t # True
#8. 迭代
for item in t:
print(item, end=’ ') # 3 1 4 1 5 9 2 6
#9. 拆包
a, b, *rest = t# a=3, b=1, rest=[4, 1, 5, 9, 2, 6]
#10. 拼接 / 重复（生成新元组）
t + (0, 0) # (3, 1, 4, 1, 5, 9, 2, 6, 0, 0)
t * 2 # (3, 1, 4, 1, 5, 9, 2, 6, 3, 1, 4, 1, 5, 9, 2, 6)

4.dictionary

d = {} # 定义空字典
d = dict() # 定义空字典
d = {‘a’: 1, ‘b’: 2, ‘c’: 3}
d = {‘a’: 1, ‘a’: 1, ‘a’: 1} # {‘a’: 1} key不能重复，重复时取最后一个
d = {‘a’: 1, ‘b’: {‘x’: 3}} # 嵌套字典
d = {‘a’: [1,2,3], ‘b’: [4,5,6]} # 嵌套列表

#以下均可定义如下结果
#{‘name’: ‘Tom’, ‘age’: 18, ‘height’: 180}

d = dict(name=‘Tom’, age=18, height=180)
d = dict([(‘name’, ‘Tom’), (‘age’, 18), (‘height’, 180)])
d = dict(zip([‘name’, ‘age’, ‘height’], [‘Tom’, 18, 180]))

访问
d[‘name’] # ‘Tom’（获取键的值）
d[‘age’] = 20 # 将age的值更新为20
d[‘Female’] = ‘man’ # 增加属性
d.get(‘height’, 180) # 180

#嵌套取值
d = {‘a’: {‘name’: ‘Tom’, ‘age’:18}, ‘b’: [4,5,6]}
d[‘b’][1] # 5
d[‘a’][‘age’] # 18操作方法d.pop(‘name’) # ‘Tom’（删除指定key）
d.popitem() # 随机删除某一项
del d[‘name’] # 删除键值对
d.clear() # 清空字典
#按类型访问，可迭代
d.keys() # 列出所有键
d.values() # 列出所有值 d.items() # 列出所有键值对元组（k, v） # 操作
d.setdefault(‘a’, 3) # 插入一个键并给定默认值3，如不指定，则为None
d1.update(dict2) # 将字典dict2的键值对添加到字典dict
#如果键存在，则返回其对应值；如果键不在字典中，则返回默认值
d.get(‘math’, 100) # 100
d2 = d.copy() # 深拷贝，d变化不影响d2

d = {‘a’: 1, ‘b’: 2, ‘c’: 3}
max(d) # ‘c’（最大的键）
min(d) # ‘a’（最小的键）
len(d) # 3（字典的长度）
str(d) # “{‘a’: 1, ‘b’: 2, ‘c’: 3}”（字符串形式）
any(d) # True（只要一个键为True）
all(d) # True（所有键都为True）
sorted(d) # [‘a’, ‘b’, ‘c’]（所有键的列表排序）

5.set

s = {} # 空集合
s = {‘5元’, ‘10元’, ‘20元’} # 定义集合
s = set() # 空集合
s = set([1,2,3,4,5]) # {1, 2, 3, 4, 5}（使用列表定义）
s = {1, True, ‘a’}
s = {1, 1, 1} # {1}（去重）
type(s) # set（类型检测）常用操作s = {‘a’, ‘b’, ‘c’}

#判断是否有某个元素
‘a’ in s # True

#添加元素
s.add(2) # {2, ‘a’, ‘b’, ‘c’}
s.update([1,3,4]) # {1, 2, 3, 4, ‘a’, ‘b’, ‘c’}

#删除和清空元素
s.remove(‘a’) # {‘b’, ‘c’}（删除不存在的会报错）
s.discard(‘3’) # 删除一个元素，无则忽略，不报错
s.clear() # set()（清空）集合的数学运算s1 = {1,2,3}
s2 = {2,3,4}
s1 & s2 # {2, 3}（交集）
s1.intersection(s2) # {2, 3}（交集）
s1.intersection_update(s2) # {2, 3}（交集，会覆盖s1）

s1 | s2 # {1, 2, 3, 4}（并集）
s1.union(s2) # {1, 2, 3, 4}（并集）

s1.difference(s2) # {1}（差集）
s1.difference_update(s2) # {1}（差集，会覆盖s1）

s1.symmetric_difference(s2) # {1, 4}（交集之外）

s1.isdisjoint(s2) # False（是否没有交集）
s1.issubset(s2) # False （s1是否是s2的子集）
s1.issuperset(s2) # False（s1是否是s2的超集，即s1是否包含s2中的所有元素）