python笔记5-序列-优快云博客

本文链接：https://blog.youkuaiyun.com/arduino121/article/details/128554920

本文介绍了Python中的几种主要序列数据结构——列表、元组、字典和集合。列表是可变的，支持多种操作如append、extend和sort等；元组是不可变的，其访问速度快，可作为字典的键；字典是键值对的无序可变序列，利用散列进行快速查找；集合是无序且不重复的元素集合，底层基于字典实现。各种数据结构的特点和操作在内存管理上有不同影响，如列表的动态扩展和字典的散列特性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

序列的本质和内存结构

序列就是一种数据的储存方式；在内存中序列就是一块用来存放多个值的连续的内存空间。内存结构示意图为：
在这里插入图片描述

列表list

列表是内置可变序列，元素类型可变，列表大小可变
列表对象常用方法如下：

方法	要点	描述
`list.append(x)`	增加元素	将元素x增加到列表list尾部
`list.extend(aList)`	增加元素	将列表alist所有元素加到列表list尾部
`list.insert(index,x)`	增加元素	在列表list指定位置index处插入元素x
`list.remove(x)`	删除元素	在列表list中删除首次出现的指定元素x
`list.pop([index])`	删除元素	删除并返回列表list指定为止index处的元素，默认是最后一个元素
`list.clear()`	删除所有元素	删除列表所有元素，并不是删除列表对象
`list.index(x,[index1],[index2])`	访问元素	返回第一个x的索引位置，若不存在x元素抛出异常
`list.count(x)`	计数	返回指定元素x在列表list中出现的次数
`len(list)`	列表长度	返回列表中包含元素的个数
`list.reverse()`	翻转列表	所有元素原地翻转
`list.sort()`	排序	所有元素原地排序
`a = sorted(b)`	排序	排序指向新对象a
`list.copy()`	浅拷贝	返回列表对象的浅拷贝

列表的创建
1. a = [] 创建一个空列表
2. a = list(range([start,],end,[step])) 创建一个整数列表
3. a = list() 创建一个空列表
4. a = [x*2 for x in range(5)] 列表推导式
列表元素删除的实质是：列表元素的拷贝
列表的索引切片同字符串
列表的遍历（for循环）
列表求和sum(),列表最大最小值max() min()
列表嵌套，多维列表

元组tuple

元组列表对比(各个方法与列表一样)
元组的创建
1. a = (1,)或a = 1,
2. a = tuple()
3. 生成器推导式创建元组
  1. 从形式上看，生成器推导式与列表推导式类似，只是生成器推导式使用小括号。
  2. 列表推导式直接生成列表对象，生成器推导式生成的不是列表也不是元组，而是一个生成器对象。
  3. 我们可以通过生成器对象，转化成列表或者元组。也可以使用生成器对象的 __next__() 方法进行遍历，或者直接作为迭代器对象来使用。不管什么方式使用，元素访问结束后，如果需要重新访问其中的元素，必须重新创建该生成器对象。
```
#列表推导式： [0, 2, 4, 6, 8]
#a = [x*2 for x in range(5)]
#print(a)
s = (x*2 for x in range(5))
print(s)   #<generator object <genexpr> at0x0000021C80BE2880>
b = tuple(s)
print(b)    #(0, 2, 4, 6, 8)
c = tuple(s)
print(c)    #()
s2 = (x for x in range(3))
print(s2.__next__())        #0
print(s2.__next__())        #1
print(s2.__next__())        #2
print(s2.__next__())        #报错：StopIteration
```
元组总结
1. 元组的核心特点是：不可变序列。
2. 元组的访问和处理速度比列表快。
3. 与整数和字符串一样，元组可以作为字典的键，列表则永远不能作为字典的键使用。

zip

zip(列表1，列表2，...)将多个列表对应位置的元素组合成为元组，
并返回这个zip对象。

a = [10,20,30]
b = [40,50,60]
c = [70,80,90,100]
d = zip(a,b,c)
print(d)   #zip object
e = list(d) #列表：[(10, 40, 70), (20, 50,
80), (30, 60, 90)]
print(e)

字典dict

字典是“键值对”的无序可变序列，字典中的每个元素都是一个“键值
对”，包含：“键对象”和“值对象”。可以通过“键对象”实现快速获取、
删除、更新对应的“值对象”。
字典键任意不可变不可重复数据。
字典值任意可变可重复数据。

字典的创建

a = {}空的字典对象
a = dict()空的字典对象
a = {'name':'zhangsan','age':18,'job':'programmer'}直接创建
b = dict(name='zhangsan',age=18,job='programmer') 间接创建

 k = ['name','age','job']
 v = ['zhangsan',18,'teacher']
 d = dict(zip(k,v))
 print(d) #{'name': 'zhangsan', 'age': 18,'job': 'techer'}

通过zip()创建

 f = dict.fromkeys(['name','age','job'])
 print(f)  #结果：{'name': None, 'age':None, 'job': None}

通过fromkeys创建值为空的字典

字典元素的访问
1. 通过 [键] 获得“值”。若键不存在，则抛出异常。
2. 通过get()方法获得“值”。❤️推荐使用。优点是：指定键不存在，返回None；也可以设定指定键不存在时默认返回的对象。推荐使用get()获取“值对象”
3. items()列出所有键值对
4. keys()列出所有的键
5. value()列出所有的值
6. len()列出键值对的个数
7. 检测一个“键”是否在字典中，in
字典元素的添加、修改和删除
1. 给字典新增“键值对”。如果“键”已经存在，则覆盖旧的键值对；如果“键”不存在，则新增“键值对”
2. 使用 update() 将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复，则直接覆盖
3. 字典中元素的删除，可以使用 del() 方法；或者 clear() 删除所有键值对； pop() 删除指定键值对，并返回对应的“值对象”
4. popitem() ：随机删除和返回该键值对。字典是“无序可变序列”，因此没有第一个元素、最后一个元素的概念； popitem 弹出随机的项，因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项，这个方法就非常有效（因为不用首先获取键的列表）
序列解包
1. 元组(x, y, z) = (1, 2, 3)
2. 列表[a, b, c] = [4, 5, 6]
3. 字典：序列解包用于字典时，默认是对“键”进行操作；如果需要对键值对操作，则需要使用items()；如果需要对**“值”进行操作，则需要使用values()；如果需要对“键”**进行操作，则需要使用keys()
表格数据用字典和列表存储访问
字典核心底层原理（关键字：稀疏数组，散列值，hash()）
1. 为字典添加键值对的底层过程
2. 根据键查找键值对的底层过程
字典用法总结
1. 字典在内存中开销巨大，典型的以空间换时间
2. 字典的键查询速度很快
3. 往字典里面添加新键值对可能导致扩容，导致散列表中键的次序变化。因此，不要在遍历字典的同时进行字典的修改
4. 键必须可散列
  1. 数字、字符串、元组，都是可散列的
  2. 自定义对象需要支持下面三点:
    1. 支持hash()函数
    2. 支持通过__eq__方法检测相等性
    3. 支持若a==b为True,那么hash(a) == hash(b)也为True

集合set

集合是无序可变，元素不能重复。实际上，集合底层是字典实现，集合的所有元素都是字典中的“键对象”，因此是不能重复的且唯一的。
集合的创建与删除
1. 使用{}创建集合对象，并且使用add()方法添加元素
2. 使用set()，将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据，则只保留一个
3. remove()删除指定元素；clear()清空整个集合
集合相关操作（同数学中的集合操作）