python的数据结构

不变：string，tuple可变：list，dictionary，set其中string，tuple，list是有序的，可以切片但是dictionary，set是无序的，不可切片1.stringvar=＂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.listx = [] # 空列表 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（指定元素位置） 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.tuplet = (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) # 9min(t) # 1sum(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 # True0 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.dictionaryd = {} # 定义空字典 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.sets = {} # 空集合
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中的所有元素）