Python-容器类型数据

容器类型数据

序列

序列 (sequence) 是一种可迭代的, 元素有序的容器类型的数据.

索引操作

• 正值索引

  a = "12345"
  
  a[0]  # 1
  

• 负值索引

  a = "12345"
  
  a[-1]  # 5
  

加和乘操作

a = "Hello"
b = "World"

a * 2  # "HelloHello"
a + b  # "HelloWorld"

切片操作

• [start:end:step]:
  切下的小切片包括索引为 start 的元素, 不包含 end 位置的元素.
  step的正负号决定了切取方向.

  a = "0123456789"
  
  a[1:3]     # "12"
  a[0:]      # "0123456789"
  a[:5]      # "01234"
  a[1:-1]    # "12345678"
  a[0:5:2]   # "024"
  a[5:0:-2]  # "531"
  a[-3::-1]  # "76543210"
  

成员测试

• in 和 not in

  a = "Hello"
  
  'e' in a  # True
  'E' in a  # False
  

列表

列表 (list) 是一种可变序列类型, 我们可以追加, 插入, 删除和替换列表中的元素.

创建列表

• list(iterable)^[1]

  list("Hello")
  # ['H', 'e', 'l', 'l', 'o']
  

• [元素1, 元素2, 元素3, ...]

  a = []     # 空列表
  a = [1, ]  # ", "可省略
  a = [1, "Hello"]
  

列表操作

方法	说明
list.append(obj)	在列表末尾添加对象
list.extend(seq)	在列表末尾添加另一个序列的多个值
list.insert(index, obj)	将对象插入相应位置
list.pop(index=-1)	根据索引删除对象并返回其值
list.remove(obj)	删除某个值的第一个匹配项
list.count(obj)	统计某个值在列表中的个数
list.index(obj)	返回值的第一个匹配项的索引
list.reverse()	将列表反向排列
list.sort(reverse=False)	默认将列表升序排列
sorted(iterable, key=None, reverse=False)	返回一个排序后的结果
list.clear()	清空列表
list.copy()	复制列表

• sort(reverse=False) 列表原地排序

  a = [1, 3, 2, 5, 4]
  
  a.sort(reverse=True)  # a = [5, 4, 3, 2, 1]
  

• sorted(iterable, key=None, reverse=False)

  a = [1, 3, 2, 5, 4]
  b = sorted(a, reverse=False)  # b = [1, 2, 3, 4, 5]
  
  students = [
      {"sno": 101, "score": 88},
      {"sno": 102, "score": 99},
      {"sno": 103, "score": 77},
      {"sno": 104, "score": 66}
  ]
  s = sorted(students, key=lambda x: x["score"], reverse=True)
  # s = [{'sno': 102, 'score': 99}, {'sno': 101, 'score': 88}, {'sno': 103, 'score': 77}, {'sno': 104, 'score': 66}]
  

• 列表(一切可迭代对象)解析

  a = [1, 2, 3, 4]
  
  b = [i*2 for i in a if i*2<5]  # b = [2, 4]
  

元组

元组 (tuple) 是一种不可变序列类型.

创建元组

• tuple(iterable)

  tuple([1, 2, 3])
  # (1, 2, 3)
  

• (元素1, 元素2, 元素3, ...)

  a = ()
  a = 21, 32, 43  # (21, 32, 43)
  a = 21,   # 创建一个只有一个元素的元组, 元素后面的逗号不能省略. 
  a = ('H', "Hello", 1)
  

元组解包

• x, y, ... = (元素1, 元素2, ....)

  x, y = (104, "张三")
  # x = 104
  # y = '张三'
  

集合

集合 (set) 是一种可迭代的, 无序的, 不能包含重复元素的容器类型数据.

• 可变集合set: 可以添加和删除元素, 不可哈希, 不能作为字典的键, 也不能做其他集合的元素
• 不可变集合frozenset: 与可变集合相反.

创建集合

• set(iterable)

• frozenset()

  a = set("Hello")
  # {'o', 'H', 'l', 'e'}
  b = frozenset("Hello")
  # frozenset{'o', 'H', 'l', 'e'}
  print(a == b)  # True
  

• {元素1, 元素2, 元素3, ...}

  a = {}
  a = {10, 20, 10, 30}  # a = {10, 20, 30}
  

修改集合

• add(elem): 添加元素. 将字符串作为整体插入集合.

  update(): 将字符串拆分后插入集合.

  如果元素已经存在, 则不能添加, 不会抛出错误.

  a = {'hello'}
  
  a.add('world')     # {'hello', 'world'}
  a.update('world')  # {'world', 'd', 'r', 'l', 'o', 'w', 'hello'}
  

• remove(elem): 删除元素. 如果元素不存在, 则抛出错误.

  discard(elem): 不会抛出错误.

  pop(): 随机删除集合的一个元素并返回该元素.

  a = {10, 20, 30}
  
  a.remove(30)  # a = {10, 20}
  30 in a  # False
  

• clear() 清空集合.

  del 删除集合.

  a = {10, 20, 30}
  
  a.clear()  # a = set()
  del a
  

其他操作

方法	说明
issubset(t)	是否是t的子集
issuperset(t)	是否是t的超集
copy()	返回集合的浅拷贝
in/not in	元素是否在集合内
==/!=	等价/不等价
<, <=, >, >=	真子集, 子集, 真超集, 超集
|, &, -, ^	如下

• | 或 union(): 求并集

• & 或 intersection(): 求交集

• - 或 difference(): 差补

• ^ 或 symmetric_difference(): 对称差分

  s1 = set("abcd")
  s2 = set("cdef")
  
  s1 | s2  # s1.union(s2)
  # {'c', 'd', 'b', 'f', 'e', 'a'}
  s1 & s2  # s1.intersection(s2)
  # {'c', 'd'}
  s1 - s2  # s1.difference(s2)
  # {'b', 'a'}
  s1 ^ s2  # s1.symmetric_difference(s2)
  # {'a', 'b', 'f', 'e'}
  

字典

字典 (dict) 是可迭代的, 通过键 (key) 来访问元素的可变的容器类型数据.

键视图不能包含重复的元素, 值视图能. 在键视图中, 键和值是成对出现的.

创建字典

• dict()

  dict({103: "张三", 104: "李四", 105: "王五"})  # 通过字典创建字典
  dict(((103, "张三"), (104, "李四"), (105, "王五")))
  # 一个元组里面放了三个元组
  dict([(103, "张三"), (104, "李四"), (105, "王五")])
  # 一个列表里面放了三个元组
  dict(zip([103, 104, 105], ["张三", "李四", "王五"]))
  # zip(iterable) 将可迭代的对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表
  

• {key1: value1, key2: value2, ..., key_n: value_n}

  a = {}
  a = {103: "张三", 104: "李四", 105: "王五"}
  

修改字典

字典的修改都是针对键和值同时操作的.

包含添加, 替换和删除.

a = {103: "张三", 104: "李四", 105: "王五"}

a[103]          # '张三', 查询103: "张三"
a[106] = "孙七"  # 添加106: "孙七"
a[106] = "赵六"  # 替换106: "赵六"
a.pop(106)      # '赵六', 删除106: "赵六"

其他操作

方法	说明
clear()	删除字典中所有元素
copy()	返回字典的一个浅拷贝
fromkeys(seq, val=None)	创建一个新的字典, 以seq中的元素作为键, 以val作为所有键的值
get(key, default=None)	返回指定键的值, 如果不存在则返回default
setdefault(key, default=None)	返回指定键的值, 如果不存在, 添加键并将值设为default
update(dict2)	把字典2的键值对更新到字典中

• items() 返回字典所有键值对视图

• keys() 返回字典键视图

• values() 返回字典值视图

  a = {103: "张三", 104: "李四", 105: "王五"}
  
  a.items()
  # dict_items([(103, '张三'), (104, '李四'), (105, '王五')])
  a.keys()
  # dict_keys([103, 104, 105])
  a.values()
  # dict_values(['张三', '李四', '王五'])
  
  # list(a.items())
  # [(103, '张三'), (104, '李四'), (105, '王五')]
  

---

1. iterable: 可迭代对象, 指字符串, 列表, 元组, 集合, 字典, range类型和map类型等. ↩︎