Python内置数据结构

内置数据结构

分类

• 数值型

  1. int：在python3中皆为长整型，大小限制取决于内存
  2. float：整数部分+小数部分；只有双精度
  3. complex：实部+虚部；皆为浮点数
  4. bool：int的子类，只有2个实例（对象）：True(1)，False(0)；可与整数运算

• 序列对象

  1. 字符串 str
  2. 列表 list
  3. 元组 tuple

• 键值对

  1. 集合 set
  2. 字典 dict

数字处理函数

• import math #导入数学模块
• print(math.floor()) #地板（向下取整）
• print(math.ceil()) #天花板（向上取整）
• int() #取整
• // #整除且向下取整

• round() #四舍 “六” 入五取偶（“五” 取最近的偶数，“六” 大于.5向上入）
  

• pow(x,y) == x**y #pow(2,3) == 2**3 == 8

• math.sqrt(9) == 9**0.5 == 3.0
• 8**(1/3) == 2.0

进制函数，返回字符串

• bin(2)=='0b10' #二进制；0b10==2
• oct(8)=='0o10' #八进制；0o10==8
• hex(16)=='0x10' #十六进制；0x10==16

类型判断

• type()
  

• 隐式转换
  

列表list

• 可迭代未必可索引
• 队列：排列顺序，按顺序执行，先进先出
• 列表list：一个可变的、有顺序可索引的线性数据结构队列。 #查询快，修改慢
• 链表linked：有顺序（物理分布不一定连续）、可索引的存储结构。 #查询慢，修改快
• queue：先进先出的队列
• stack：后进先出/先进后出的队列（栈）
• 列表定义
  
  1. 列表一开始不能定义大小
  2. l = [] == l = list()
  3. l = [2, 6, 9, ‘ab’]
  4. l = list(range(5))
     

列表索引访问

• 列表通过索引访问：list[index]
• 索引：下标
• 正索引：左→右，从0开始，为列表中每个元素编号
• 负索引：右→左，从-1开始
• 索引不能超界，否则会异常：IndexError
• 列表排序：左→右。左：头部、下界。右：尾部、上界

列表查询

• index(value,[start,[stop]])
• 通过value从指定区间查询列表内元素
• 匹配一个即返回索引
• 匹配不到，返回异常：ValueError
• count(value) #返回列表中匹配value的次数
• 时间复杂度
  
  1. index和count都是O(n)
  2. 列表规模增大，效率下降
• len() #返回列表元素个数

列表元素修改

• list[index] = value
• 索引不能超界

列表增加、插入元素

• append(object)

  1. 列表尾部追加元素，返回None（即不产生新列表，就地修改）
  2. 时间复杂度为O(1)
  3. 追加元素全部输出为一个整体

• insert(index,object)

  1. 在指定索引位置插入元素object，返回None，就地修改
  2. 时间复杂度为O(n)
  3. 索引超界：超越上界，尾部追加；超越下界，头部追加

• extend(iterable)

  1. 追加可迭代对象的元素，返回None，就地修改
  2. 追加可迭代元素即进行全部迭代

• +

  1. 返回list
  2. 连接两个列表
  3. 产生新列表，原列表不变（临时使用）

• *

  1. 返回list
  2. 将本列表元素重复n次，返回新列表

列表删除元素

• remove(value) → None

  1. 左至右查找，匹配第一个并移除该元素；返回None。未找到返回异常：ValueError
  2. 就地修改
  3. 效率低

• pop([index]) → item

  1. 不指定index即从尾部弹出一个元素
  2. 指定index即从索引出弹出一个元素，超界返回异常：IndexError
  3. 不指定index：时间复杂度O(1)，效率高。反之相反

• clear() → None

  1. 清除列表中元素，剩下空列表
  2. 返回None

列表其它操作

• reverse() → None

  1. 反转列表元素，返回None
  2. 就地修改

• sort(key = None，reverse = False) → None

  1. 排序列表元素，就地修改，默认升序。返回None
  2. reverse为True，反转，降序
  3. lst.sort(key = functionname)

• in

  • [3,4] in [1,2,3,4]
  • for x in [1,2,3,4]

列表复制

• copy() → list
• shadow copy（影子拷贝/浅拷贝）返回一个新列表
• lst1 == lst2 # 内容是否相同
• lst1 is lst2 # ID是否相同
• copy后内容相同，ID不同
• 简单类型：数字常量，字面常量，字符串字面常量，None…
• 复杂类型（引用类型）
• deep copy（深拷贝）
  
  

元组tuple

• 有序的元素集合
• 不可变对象
• 以()表示
• tuple() → empty tuple
• tuple(interable) → item
• 单个元素定义：t = (1,) #必带逗号
• 元组是只读的，没有增删改

命名元组namedtuple

• 返回一个元组的子类并定义了字段
• field_named可是空白符或逗号分割的字段的字符串，可是字段的列表
• 语法：

from collections import namedtuple

Point = namedtuple('_Point',['x','y']) # Point为返回的类

p = Point(11,22)

冒泡法

• 交换排序
• 两两比较，交换位置
• 结果分为升序、降序
• 可设定一个标记判断此轮是否交换数据。若没有交换，则结束排序；若发生交换，则继续排序
• 最差情况：初始顺序与目标顺序完全相反，遍历次数 n(n-1)/2
• 最好情况：初始顺序与目标顺序完全相同，遍历次数 n-1
• 时间复杂度为 O(n²)

字符串

• 由字符组成的有序的序列，是字符的集合
• 不可变对象
• unicode类型。使用' '、" "、''' '''表示

字符串元素访问

• 索引访问：sql[index]
• 有序的字符序列
• 可迭代：lst = list(sql)
  

字符串join连接

• ”string”.join(iterable) → str
  
  1. 将可迭代对象连接，用string分隔，返回新字符串
  2. 可迭代对象本身元素都是字符串

字符串修改

• replace(old,new[,count]) → str

  1. 字符串中匹配替换返回新字符串
  2. count表示替换次数，不指定即为全部替换，次数可超界（最多只替换至字符串的首尾）

• strip([chars]) → str

  1. strip()不指定即去除两端空白字符；lstrip从左端去除，rstrip从右端去除
  2. srtip(’ ‘)从两端去除空格，至第一个不满足条件（不为空格）的位置即停止，剩下的原样输出
  3. strip(‘…’)从字符集里找字符，字符1 or 字符2 or 字符3…满足一个即从两端依次去除，不可跳过字符进行去除（\r\n无法被\n去除，无法跳过\r，包含 \r 如 \t\n\r 可去除）

• find(sub[,start[,end]]) → int

  1. find在区间[start,end) 左→右查找字串sub（坐标系中start须在end左侧）。找到返回正索引，未找到返回-1
  2. rfind在区间[start,end) 右→左查找字串sub（坐标系中start须在end左侧）。找到返回正索引，未找到返回-1

• index(sub[,start[,end]]) → int

  1. index在区间[start,end)从左至右查找字串sub（坐标系中start须在end左侧）。找到返回正索引，未找到返回异常：ValueError
  2. rindex在区间[start,end)从右至左查找字串sub（坐标系中start须在end左侧）。找到返回正索引，未找到返回异常：ValueError

字符串查找

• count(sub[,start[,end]]) → int

  1. 在区间[start,end)从左至右统计字符串sub出现的次数（坐标系中start须在end左侧）
  2. 从字符串sub中首个字符出现的位置开始匹配

• index和count时间复杂度都是O(n)，列表规模与效率反比

• len(string) # 返回字符串长度（字符的个数）

字符串判断 —— is系列

• isalnum() → bool # 是否是字母和数字
• isalpha() # 是否是字母
• isdecimal() # 是否只包含十进制数字
• isdigit() # 是否全部数字（0~9）
• isidentifier() # 是否是标识符
• islower() # 是否都是小写
• isupper() # 是否都是大写
• isspace() # 是否只包含空白字符

字符串格式化

• ‘{}{xxx}’.format(*args,**kwargs) → str
  
  1. args是位置参数，是一个元组
  2. kwargs是关键字参数，是一个字典
  3. {xxx}表示在关键字参数中搜索名称一致的
  4. {}表示占位符，按照顺序匹配位置参数
  5. {{}}表示打印{}
• 对齐
  

字符串列题

bytes、bytearray

• 字符串是字符组成的有序序列
• bytes # 不可变字节序列
• bytearray # 可变的字节序列
• 编码与解码
  
  1. 字符串按照不同的字符集编码encode返回字节系列bytes
  2. 字节系列按照不同的字符集编码decode返回字符串str

bytes

• bytes () # 空bytes
• bytes(int) # 指定字节的bytes，被0填充
• 使用b前缀定义
• 只允许基本ASCII使用字符形式
• 使用16进制表示
• 输入、输出都是bytes
• 索引 # b’abcdef’[2]返回该字节对应的数，int类型

bytearray

• bytearray () # 空bytearray
• bytearray(int) # 指定字节的bytes，被0填充
• 索引 # bytearray(b’abcdef’)[2]返回该字节对应的数，int类型

int 和 bytes

• int.from_bytes(bytes,byteorder)
  
  • 将一个字节数组表示成整数
• int.to_bytes(length,byteorder)
  
  • byteorder字节序
  • 将一个整数表达成一个指定长度的字节数组

线性结构

• 列表、元组、字符串、bytes、bytearray
• 可迭代
• len()获取长度
• 通过下标访问
• 可切片

切片

• 通过索引区间访问信息结构的一段数据
• sequence[start:stop]表示返回[start,stop)区间的子序列
• 支持负索引
• [start:stop:step]
  
  • step步长可以是正负整数，默认为1，须与start:stop同向，否则返回空序列
  • start为0时可以省略；stop为末尾时可以省略
  • start须在stop左侧
• 可以超界，超界只取到首/尾
• [:]表示全部取出元素，等效于copy()方法