Python数据结构

序列sequence

通用的序列操作

• 索引
  • 索引从0开始
  • 最后一个元素的索引可以用-1表示
  • 字面量后面可直接执行索引操作，而不必先把字面量赋值给一个变量
• 切片
  • [起始索引:结束索引:步长]
  • 三个值都可以省略
    • 省略起始索引，表示从第一个元素开始
    • 省略结束索引，表示一直到列表最后，包括最后一个元素
    • 省略步长，则步长为1
  • 返回结果不包含结束索引的值
  • 结束索引可以大于列表的长度，不会报错，返回值一直到最后一个元素
  • 步长不能为0，可以是负数
  • 当步长为负数时
    • 表示从后往前操作
    • 起始索引必须大于结束索引，否则返回的时空列表[]
• 相加
  • 相同类型的序列可以使用加号+直接拼接，不同类型不可以相加
    • 'hello' + 'world' = 'hello world'
    • [1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6]
• 相乘
  • 序列 * n 表示重复这个序列n次创建一个新序列
    • [1, 2, 3] * 2 = [1, 2, 3, 1, 2, 3]
• 成员资格
  • xxx in 序列: 返回True或者False

内置函数

• len(seq): 返回序列元素个数
• max(args): 返回序列或一组参数中最大的元素
• min(args): 返回序列或一组参数中最小的元素
• sorted(seq): 排序函数，可用于所有类型序列，但总是返回一个列表
• reversed(seq): 反向排序
• list(seq): list实际是类型而不是函数，将序列转列表
• tuple(seq): tuple实际是类型而不是函数，将序列转元组

list 列表

• 修改元素
  • _list[index] = xxx
  • 不能跨界赋值，否则报错：IndexError: list assignment index out of range
• 删除元素
  • del _list[开始索引:结束索引:步长]
  • 也就是把选中的元素从列表中删除
• 切片操作
  • _list[开始索引:结束索引:步长] = 新的列表(可以为空列表[])
  • 就是用新列表的元素替换掉原列表中选中的元素
  • 如果步长不是1，则新列表的元素数量要与等待替换的元素数量一致

  a = [1, 2, 3, 4, 5, 6]
  # a[::] = ['a', 'b']  # 输出 ['a', 'b']
  # a[2:] = ['a', 'b']  # 输出 [1, 2, 'a', 'b']
  a[2:5] = ['a', 'b']  # 输出 [1, 2, 'a', 'b', 6]
  # a[2:2] = ['a', 'b']  # 表现为插入 输出 [1, 2, 'a', 'b', 3, 4, 5, 6]
  # a[2:5] = []  # 表现为删除 输出 [1, 2, 6]
  # a[::2] = ['a', 'b']  # 报错 ValueError: attempt to assign sequence of size 2 to extended slice of size 3
  # a[::2] = []  # 报错 ValueError: attempt to assign sequence of size 0 to extended slice of size 3
  # a[::2] = ['a', 'b', 'c']  # 数量要一致，一一替换 输出 ['a', 2, 'b', 4, 'c', 6]
  # a[::-1] = ['a', 'b']  # 报错 ValueError: attempt to assign sequence of size 2 to extended slice of size 6
  print(a)
  

列表方法

• append: 将一个对象附加到列表末尾
• clear: 清空列表
  • 与以下方式效果一致
    • del _list[:]
    • _list[:] = []
• copy: 生成一个列表对应的副本，是浅拷贝
  • 与以下方式效果一致
    • b = _list[:]
    • b = list(_list)
    • b = copy.copy(_list)
• count: 计数，计算指定元素在列表中出现了多少次

  a = [1, 2, 3, 4, 5, [1, 2], 2, [1, 2]]
  print('count 2:', a.count(2))
  print('count [1, 2]: ', a.count([1, 2]))
  '''输出结果
  count 2: 2
  count [1, 2]:  2
  '''
  

• extend: 将多个值附加到当前列表末尾
• index: 在列表中查找指定值第一次出现的索引
• insert: 将一个元素插入列表指定的索引位置
• pop: 返回列表指定索引的元素（默认为最后一个元素），并从列表中删除对应的元素
• remove: 从列表中删除指定值，只会删除第一个
• reverse: 按相反的顺序排列列表中的元素，没有返回值，直接修改原列表
• sort: 对列表进行排序，没有返回值，直接修改原列表
  • key: 键的生成函数，为每个列表元素生成一个键，然后根据这些键对元素进行排序
  • reverse: True或者False，是否按相反的顺序排列

tuple 元组

• 不可修改的序列
• 直接用逗号隔开元素就能自动创建元组

  a = 1, 2, 3
  print(a)
  '''输出结果
  (1, 2, 3)
  '''
  

• 一个元素的元组，元素后面要带上逗号

  print((1))
  print((1,))
  print(3*(1+2))
  print(3*(1+2,))
  
  '''输出结果
  1
  (1,)
  9
  (3, 3, 3)
  '''
  

str 字符串

• 字符串是不可变的
• string模块
  • 方法
    • capwords(s[, sep]): 使用split根据sep拆分s，将每项的首字母大写，再以分隔符将它们合并起来

      import string
      
      s = 'hello,world world'
      print(string.capwords(s))
      print(string.capwords(s, ','))
      
      '''输出结果
      Hello,world World
      Hello,World world
      '''
      

字符串方法

• center: 居中展示
• find: 在字符串中查找子串，找到则返回第一个字符的索引，否则返回-1
• join
• split
• lower
• title
• replace: 替换子字符串
• translate: 替换单个字符
• strip
• isxxx: is开头的各种判断特定条件的方法
  • islower
  • isdigit

映射mapping

dict 字典

• 字典就是由键值对组成，这种键值对称为项(item)
• 键必须是独一无二的，并且是不可变类型，比如：数，字符串或者元组
• 可使用dict(xxx)从其他映射或者键值对序列创建字典

  items = [('name', 'John'), ('age', 20)]
  # dict_ = dict(items)
  dict_ = dict(name='John', age=20)
  print(dict_)
  
  '''输出结果
  {'name': 'John', 'age': 20}
  '''
  

• k in _dict 判断的是k是否在字典的键之中
• for循环
  • for k in _dict: k是键
  • for k, v in _dict.items(): k是键，v是值

字典方法

• clear: 清除所有项

  x = {}
  y = x
  x['key'] = 'value'
  print('x:', x)
  print('y:', y)
  x = {}
  # x.clear()
  print('x:', x)
  print('y:', y)
  
  '''x = {}输出结果
  x: {'key': 'value'}
  y: {'key': 'value'}
  x: {}
  y: {'key': 'value'}
  '''
  
  '''x.clear() 输出结果
  x: {'key': 'value'}
  y: {'key': 'value'}
  x: {}
  y: {}
  '''
  

• copy: 是浅复制

• fromkeys: 这是一个类方法，创建一个包含所有指定的键的新字典，值都是None

• get: 获取指定键的值，如果键不存在则返回None，可以传入默认值

  • 直接使用[key]获取，如果key不存在，则会报异常

• items: 返回值类型是dict_items，可对其进行迭代，迭代的项是元组(key, value)

• keys: 返回所有键

• pop: 返回指定键对应的值，并会将键值对从字典中删除

• popitem: 随机的弹出一个字典项

• setdefault(key[, default]): 如果key不存在，则添加(key, default)键值对到字典中，否则只是返回key对应的值

• update: 更新当前字典，参数可以是一个映射或者一个由键值对组成的序列或者是关键字参数

• values: 返回值类型是dict_values，由字典中的值构成的视图，可迭代

• 示例

  d = dict.fromkeys(['a', 'b', 'c'])
  print(d)
  print(d.get('a', 'A'))
  print(d.get('d', 'D'))
  print('items:', d.items())
  print('keys:', d.keys())
  print('values:', d.values())
  print(list(d.items()))
  print(type(list(d.items())[0]))
  print('pop:', d.pop('a'))
  print(d)
  print('popitem:', d.popitem())
  print(d)
  print('setdefault:', d.setdefault('e', 'E'))  # e不存在，在字典中添加(e, E)键值对，并返回E
  print(d)
  print('setdefault2:', d.setdefault('e', 'E2'))  # e已经存在，不做任何修改，直接返回原值
  print(d)
  
  '''输出结果
  {'a': None, 'b': None, 'c': None}
  None
  D
  items: dict_items([('a', None), ('b', None), ('c', None)])
  keys: dict_keys(['a', 'b', 'c'])
  values: dict_values([None, None, None])
  [('a', None), ('b', None), ('c', None)]
  <class 'tuple'>
  pop: None
  {'b': None, 'c': None}
  popitem: ('c', None)
  {'b': None}
  setdefault: E
  {'b': None, 'e': 'E'}
  setdefault2: E
  {'b': None, 'e': 'E'}
  '''