python内置数据结构

python 内置数据结构

• 数值型

  • int：python3的int就是长整型，且没有大小限制，受限于内存区域的大小
  • float：有整数部分和小数部分组成。支持十进制和科学计数法表示。只有双精度型。
  • complex：有实数和虚数部分组成，实数和虚数部分都是浮点数，3+4.2J
  • bool：：int的子类，仅有2个实例True、False对应1和0，可以和整数直接运算

• 序列对象

  • list
  • tuple
  • str

• 键值对

  • set
  • dict

列表list -> 可变的

• 初始化
  • list() -> 创建一个空列表
  • list(iterable) -> 将一个可迭代的对象转换为列表
  • 列表不能定义大小
• 列表访问
  • list[index] ，index就是索引，使用中括号访问
• 列表查询
  • index(value,[start,[stop]])
  • 通过值value，从指定区间查找列表内的元素是否匹配
  • 匹配第一个就立即返回索引
  • 匹配第一个就立即返回索引
  • count(value)
    • 返回列表中匹配value的次数
  • len()
    • 返回列表中元素的个数
  • 时间复杂度
    • index和count方法都是O(n)
    • 随着列表数据规模的增大，而效率下降
• 列表元素修改
  • 索引访问修改
    • list[index] = value
    • 索引不要超界
  • append(object) -> None
    • 列表尾部追加元素，返回None
    • 返回None就意味着没有新的列表产生，就地修改
    • 时间复杂度是O(1)
  • insert(index, object) -> None
    • 在指定的索引index处插入元素objec
    • 返回None就意味着没有新的列表产生，就地修改
    • 时间复杂度是O(n)
    • 超越上界，尾部追加
    • 超越下界，头部追加
• 列表增加，插入元素
  • extend(iteratable) -> None
    • 将可迭代对象的元素追加进来，返回None
    • 就地修改
  • + -> list
    • 连接操作，将两个列表连接起来
    • 产生新的列表，原列表不变
    • 本质上调用的是_add_()方法
  • * -> list
    • 重复操作，将本列表元素重复n次，返回新的列表
• 列表删除元素
  • remove(value) -> None
    • 从左至右查找第一个匹配value的值，移除该元素，返回None
    • 就地修改
  • pop([index]) -> item
    • 不指定索引index，就从列表尾部弹出一个元素
    • 指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
  • clear() -> None
    • 清除列表所有元素，剩下一个空列表
• 列表其他操作
  • reverse() -> None
    • 将列表元素反转，返回None
    • 就地修改
  • sort(key=None, reverse=False) -> None
    • 对列表元素进行排序，就地修改，默认升序
    • reverse为True，反转，降序
    • key一个函数，指定key如何排序
      • lst.sort(key=functionname)
  • in
    • 成员运算符
    • [3,4] in [1, 2, [3,4]]
    • for x in [1,2,3,4]
• 列表复制
  • copy() -> List
    • shadow copy返回一个新的列表
      • 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已
  • 深拷贝
    • copy模块提供了deepcopy

元组tuple -> 不可变对象

• 初始化
  • tuple() -> empty tuple
  • tuple(iterable) -> tuple initialized from iterable’s items
• 元素访问
  • tuple[index] ，index就是索引，使用中括号访问
• 元素查询
  • index(value,[start,[stop]])
    • 通过值value，从指定区间查找列表内的元素是否匹配
    • 匹配第一个就立即返回索引
    • 匹配不到，抛出异常ValueError
  • count(value)
    • 返回列表中匹配value的次数
  • len(tuple)
    • 返回元素的个数
  • 时间复杂度
    • index和count方法都是O(n)
    • 随着列表数据规模的增大，而效率下降
• 元组其它操作
  • 元组是只读的，所以增、改、删方法都没有

字符串 str -> 不可变对象

• 字符串定义 初始化
  • s1 = ‘string’
  • s1 = r’string’
• 字符串元素访问
  • 字符串支持使用索引访问
• 有序的字符集合，字符序列
• 可迭代
  • lst = list(s1)
• 字符串连接
  • “string”.join(iterable) -> str
    • 将可迭代对象连接起来，使用string作为分隔符
    • 可迭代对象本身元素都是字符串
    • 返回一个新字符串
  • + -> str
    • 将2个字符串连接在一起
    • 返回一个新字符串
• 字符串分割
  • split(sep=None, maxsplit=-1) -> list of strings
    • 从左至右 将字符串按照分隔符分割成若干字符串，并返回列表
    • sep 指定分割字符串，缺省的情况下空白字符串作为分隔符
    • maxsplit 指定分割的次数，-1 表示遍历整个字符串
  • rsplit(sep=None, maxsplit=-1) -> list of strings
    • 从右向左
  • splitlines([keepends]) -> list of strings
    • 按照行来切分字符串
    • keepends 指的是是否保留行分隔符
    • 行分隔符包括\n、\r\n、\r等
  • partition(sep) -> (head, sep, tail)
    • 从左至右，遇到分隔符就把字符串分割成两部分，返回头、分隔符、尾三部分的三元组
    • 如果 没有找到分隔符，就返回头、2个空元素的三元组
    • sep 分割字符串，必须指定
  • rpartition(sep) -> (head, sep, tail)
    • 从右至左
• 字符串大小
  • upper()
    • 全大写
  • lower()
    • 全小写
  • swapcase()
    • 交互大小写
  • title() -> str
    • 标题的每个单词都大写
  • capitalize() -> str
    • 首个单词大写
• 其他方法
  • center(width[, fillchar]) -> str
    • width 打印宽度
    • fillchar 填充的字符
  • zfill(width) -> str
    • width 打印宽度，居右，左边用0填充
  • ljust(width[, fillchar]) -> str 左对齐
  • rjust(width[, fillchar]) -> str 右对齐
• 字符串修改
  • replace(old, new[, count]) -> str
    • 字符串中找到匹配替换为新子串，返回新字符串
    • count表示替换几次，不指定就是全部替换
  • strip([chars]) -> str
    • 从字符串两端去除指定的字符集chars中的所有字符
    • 如果chars没有指定，去除两端的空白字符
  • lstrip([chars]) -> str
    • 从左开始
  • rstrip([chars]) -> str
    • 从右开始
• 字符串查找
  • find(sub[, start[, end]]) -> int
    • 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到返回-1
  • rfind(sub[, start[, end]]) -> int
    • 在指定的区间[start, end)，从右至左，查找子串sub。找到返回索引，没找到返回-1
  • index(sub[, start[, end]]) -> int
    • 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
  • rindex(sub[, start[, end]]) -> int
    • 在指定的区间[start, end)，从左至右，查找子串sub。找到返回索引，没找到抛出异常ValueError
  • len(string)
    • 返回字符串的长度，即字符的个数
  • count(sub[, start[, end]]) -> int
    • 在指定的区间[start, end)，从左至右，统计子串sub出现的次数
• 字符串判断
  • endswith(suffix[, start[, end]]) -> bool
    • 在指定的区间[start, end)，字符串是否是suffix结尾
  • startswith(prefix[, start[, end]]) -> bool
    • 在指定的区间[start, end)，字符串是否是prefix开头
  • isalnum() -> bool 是否是字母和数字组成
  • isalpha() 是否是字母
  • isdecimal() 是否只包含十进制数字
  • isdigit() 是否全部数字(0~9)
  • isidentifier() 是不是字母和下划线开头，其他都是字母、数字、下划线
  • islower() 是否都是小写
  • isupper() 是否全部大写
  • isspace() 是否只包含空白字符

切片

• 通过索引区间访问线性结构的一段数据
• sequence[start:stop] 表示返回[start, stop)区间的子序列
• 支持负索引
• start为0，可以省略
• stop为末尾，可以省略
• 超过上界（右边界），就取到末尾；超过下界（左边界），取到开头
• start一定要在stop的左边
• [:] 表示从头至尾，全部元素被取出，等效于copy()方法

集合set -> 可变的、无序的、不重复的元素的集合

• 集合初始化
  • set() -> new empty set object
  • set(iterable) -> new set object
• set的元素
  • set的元素要求必须可以hash
  • 目前学过的不可hash的类型有list、set
  • 元素不可以索引
  • set可以迭代
• set增加
  • add(elem)
    • 增加一个元素到set中
    • 如果元素存在，什么都不做
  • update(*others)
    • 合并其他元素到set集合中来
    • 参数others必须是可迭代对象
    • 就地修改
• set删除
  • remove(elem)
    • 从set中移除一个元素
    • 元素不存在，抛出KeyError异常
  • discard(elem)
    • 从set中移除一个元素
    • 元素不存在，什么都不做
  • pop() -> item
    • 移除并返回任意的元素
    • 空集返回KeyError异常
  • clear()
    • 移除所有元素
• set修改、查询
  • 无法修改
  • 非线性结构，无法索引
  • 可以遍历所有元素
  • in 和 not in 判断元素是否在set中
• 集合运算
  • 并集
    • union(*others)
    • | 运算符重载
      • 等同union
    • update(*others)
    • |=
      • 等同update
  • 交集
    • intersection(*others)
    • &
      • 等同intersection
    • intersection_update(*others)
    • &=
      • 等同intersection_update
  • 差集
    • difference(*others)
    • • 等同difference
    • difference_update(*others)
    • -=
      • 等同difference_update
  • 对称差集
    • symmetric_differece(other)
    • ^
    • symmetric_differece_update(other)
    • ^=
      • 等同symmetric_differece_update
• 集合运算
  • issubset(other)、<=
    • 判断当前集合是否是另一个集合的子集
  • set1 < set2
    • 判断set1是否是set2的真子集
  • issuperset(other)、>=
    • 判断当前集合是否是other的超集
  • set1 > set2
    • 判断set1是否是set的真超集
  • isdisjoint(other)
    • 当前集合和另一个集合没有交集
    • 没有交集，返回True

字典dict -> 可变的、无序的、key不重复

• 初始化

  • d = dict() 或者 d = {}
  • dict(**kwargs) 使用name=value对初始化一个字典
  • dict(iterable, **kwarg) 使用可迭代对象和name=value对构造字典，不过可迭代对象的元素必须是 一个二元结构
    • d = dict(((1,‘a’),(2,‘b’))) 或者 d = dict(([1,‘a’],[2,‘b’]))
  • dict(mapping, **kwarg) 使用一个字典构建另一个字典
  • d = {‘a’:10, ‘b’:20, ‘c’:None, ‘d’:[1,2,3]}
  • 类方法dict.fromkeys(iterable, value)
    • d = dict.fromkeys(range(5))
    • d = dict.fromkeys(range(5),0)

• 字典元素的访问

  • d[key]
    • 返回key对应的值value
    • key不存在抛出KeyError异常
  • get(key[, default])
    • 返回key对应的值value
    • key不存在返回缺省值，如果没有设置缺省值就返回None
  • setdefault(key[, default])
    • 返回key对应的值value
    • key不存在，添加kv对，value为default，并返回default，如果default没有设置，缺省为None

• 字典增加和修改

  • d[key] = value
    • 将key对应的值修改为value
    • key不存在添加新的kv对
  • update([other]) -> None
    • 使用另一个字典的kv对更新本字典
    • key不存在，就添加
    • key存在，覆盖已经存在的key对应的值
    • 就地修改
      • d.update(red=1)
      • d.update(((‘red’,2),))
      • d.update({‘red’:3})

• 字典删除

  • pop(key[, default])
    • key存在，移除它，并返回它的value
    • key不存在，返回给定的default
    • default未设置，key不存在则抛出KeyError异常
  • popitem()
    • 移除并返回一个任意的键值对
    • 字典为empty，抛出KeyError异常
  • clear()
    • 清空字典
  • del语句
    • 本质上减少了一个对象的引用，del 实际上删除的是名称

• 字典遍历

  • for k in d:

  • for k in d.keys():

  • for v in d.values():

  • for _ ,v in d.items():

  • Python3中，keys、values、items方法返回一个类似一个生成器的可迭代对象，不会把函数的返回结 果复制到内存中