1. 线性结构

  • 可迭代，比如支持遍历语句 for i in 可迭代对象。
  • 可以用len()函数获取长度。
  • 可以使用索引访问，obj[index] => 当前索引的值，索引也叫下标，从左到右由0开始，从右到左由-1开始，正负索引不可超界，否则会出错IndexError。

  • 可以进行切片。

    2. 列表

    一种容器类数据结构，可以存储所有合法类型数据，可变数据类型，元素可以自由增删改

    2.1 定义

    1. l1 = [] # 使用list()创建空列表时会有函数调用，创建栈，[]是一个内置得c函数，可直接调用
    2. l2 = [1, 2.0, 'abc', None, True, [1, 2, ""]] # 合法类型都可以
    3. l3 = list(可迭代对象) # 参数可以不传，即空列表

    2.2 增

  • ls.append(obj) => None尾部追加元素，就地修改，O(1)

  • ls.extend(iterable) => None 追加可迭代对象的元素，就地修改，O(1)

  • ls.insert(index, obj) => None指定索引处插入值，就地修改，会有元素移动效率很差，O(n)，可超界，最右相当于尾部追加，最左相当于头部追加

    2.3 删

  • ls.remove(value) => None按值删除，会遍历列表进行移除，就地修改，效率低O(n)

  • ls.pop(index) => 移除的值按索引移除，会引起列表内元素的移动，不推荐；不指定索引，会从尾部弹出元素，从尾部弹出O(1)，使用比较多，会有超界错误IndexError

  • ls.clear() => None清空列表内所有元素(将元素的引用计数减一)，剩下一个空列表，不存在效率问题，除非真的没用了，否则最好不用

    2.4 改

  • ls[index] = value就地修改且元素不挪动，会超界错误IndexError

    2.5 查

  • ls[index] => value直接获取，O(1)

  • ls.index(value, [start, [stop]]) => index根据值获取其索引，匹配不到则ValueError，从左向右遍历列表，O(n)，能少用则少用
  • ls.count(value) => value的总数返回value的总数，如果值不存在，会返回0，遍历列表，O(n)，能少则少

  • len(ls) => 列表的长度列表是封装类型，拥有长度属性，O(1)

    2.6 其他操作

  • ls.reverse() => None列表反转，就地修改，少用，效率极低，不如倒着读数据

  • ls.sort(key=None, reverse=False) => None就地修改，按key指定类型进行排序，默认升序，元素本身不变，key可以指定函数，将列表内元素按照key的函数进行转换，比如key=int，即将列表内的元素通过int进行转换(会报错)
  • obj in ls => True/False判断obj对象是否在列表l里，一般用于判断语句里
  • id(ls) 返回ls的内存地址，只要是python对象，均可用
  • [] + [] => 新的列表原列表不改变，吃内存，空间复杂度大，耗时，不推荐
  • [] * 数字列表复制，比如[1] * 5 => [1, 1, 1, 1, 1]；多维矩阵最好别用此复制，存在浅拷贝

    3. 拷贝

    3.1 影子(浅)拷贝

    对可变数据类型拷贝的是其在内存中的引用地址，如果对拷贝对象的值进行修改，则会影响原来的对象的值 ```python l0 = [1, [2, 3], 4]

    等号，星号也是浅拷贝

    l1 = l0.copy() print(l0 == l1) # 内容对比 True print(l0 is l1) # 内存地址对比 True

l1[1][0] = 1 # [1, [1, 3], 4] print(l0) # [1, [1, 3], 4]

l0[1][1] = 100 # [1, [1, 100], 4] print(l1) # [1, [1, 100], 4]

  1. <a name="ST8Aa"></a>
  2. ## 3.2 深拷贝
  3. 将可变数据类型的值另开辟一块内存进行存储，此时l0 与 l1互不干扰
  4. ```python
  5. import copy
  8. l0 = [1, [2, 3], 4]
  9. l1 = copy.deepcopy(l0)
  10. print(l0 == l1) # True
  11. print(l0 is l1) # False
  13. l1[1][0] = 1 # [1, [1, 3], 4]
  14. print(l0) # [1, [2, 3], 4]
  16. l0[1][1] = 100 # [1, [1, 100], 4]
  17. print(l1) # [1, [1, 3], 4]

4. random模块

  1. import random
  3. # 常用
  4. random.randint(a, b) => [a, b]之间的整数，与randrange()类似
  5. random.randrange([start,] stop [,step]) => [start, stop)中的一个整数，step为步长
  6. random.choices(seq) => 非空序列元素中的一个元素
  7. random.shuffle(list) => None 就地打乱，效率可能会低
  8. random.sample(list, k) => 新list 取样，取list中k个不同索引的元素，k不填，默认两次元素

5. 元组

5.1 定义

  1. t1 = ()
  2. t2 = tuple(可迭代对象) # 参数可为空，即定义一个空元组
  3. t3 = (1,) # 定义一个元素的元组时，别忘加逗号
  4. t4 = (1, [2, 3], 'a', None,...)

不可变数据类型，一旦创建，元组本身不可更改，但元素是可变对象时，可变对象是可以更改的，其类似于只读列表，增删改都没有

5.2 查

支持索引，不可超界
t[index] => 索引对应的值
t.index(value, [start, [stop]]) => 元组内值对应的索引
t.count(value) => 元组内值的总数
len(t) => 元组长度

5.3 namedtuple

  1. from collections import namedtuple
  3. # 一旦创建不可更改的对象
  4. # 参数中的User用来看的，第二个参数可以是"name age"，"name,age"
  5. User = namedtuple('User', ['name', 'age'])
  6. print(User.__base__) => <class 'tuple'>
  8. user = User("xiao_ming", 0)
  9. print(user) => User(name='xiao_ming', age=0)
  10. print(user.g) => AttributeError: 'User' object has no attribute 'g'
  11. user.age = 10 => AttributeError: can't set attribute
  12. print(getattr(user, "name")) => 'xiao_ming'