容器类型数据

序列

序列 (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 位置的元素. Start 和 end 可以省略.

  a = "Hello"
  
  a[1:3]    # "el"
  a[0:]     # "Hello"
  a[:5]     # "Hello"
  a[1:-1]   # "ell"
  a[0:5:2]  # "Hlo"
  

成员测试

• 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"]
  

修改列表

• append(x) 追加单个元素

  a = [1, ]
  
  a.append(2)  # a = [1, 2]
  

• extend(t) 或 + 追加多个元素

  a = [1, ]
  b = [2, 3]
  
  a.extend(b)  # a = [1, 2, 3]
  a += [4, 5]     # a = [1, 2, 3, 4, 5]
  

• insert(i, x) 插入元素

  a = ['a', 'b', 'd', ]
  
  a.insert(2, 'c')  # a = ['a', 'b', 'c', 'd']
  

• list[i]=x 替换元素也即赋值

  a = ['a', 'a', 'c', ]
  
  a[1] = 'b'  # a = ['a', 'b', 'c']
  

• remove(x) 删除元素

  a = list("acbc")
  
  a.remove('c')  # a = ['a', 'b', 'c']
  

元组

元组 (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(iterable)

  set("Hello")
  # {'o', 'H', 'l', 'e'}
  

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

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

修改集合

• add(elem) 添加元素.

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

  a = {10, 20, 30}
  
  a.add(40)  # a = {10, 20, 30, 40}
  

• remove(elem) 删除元素.

  如果元素不存在, 则抛出错误.

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

• clear() 清除集合.

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

字典

字典 (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: "赵六"

访问字典视图

• 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, '王五')]