Python列表、元祖、字典、集合及其相关操作

2283-鲁同学

发表文章数:26

热门标签

,
首页 » Python » 正文

一、序列简介

序列就是一块用来存放 多个值的连续的内存空间。
a = [10,20,30,40]的存储方式如下:
Python列表、元祖、字典、集合及其相关操作

常用序列结构

字符串、列表、元组、字典、集合

序列解包

可用于元组、列表、字典。方便的对多个变量赋值

x,y,z=(20,30,10)#元祖
(a,b,c)=(9,8,10)
[a,b,c]=[10,20,30]#列表

序列解包用于字典时,默认是对“键”进行操作;
如果需要对键值对操作,则需要使用 items();
如果需要对“值”进行操作,则需要使用 values();

s = {'name':'gaoqi','age':18,'job':'teacher'}
name,age,job=s #默认对键进行操作
name,age,job=s.items() #对键值对进行操作
name,age,job=s.values() #对值进行操作

二、列表

列表:用于存储任意数目、任意类型的数据集合。
内置可变序列,是包含多个元素的有序连续的内存空间

方法 要点 描述
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) 访问元素 返回第一个 x 的索引位置,若不存在 x 元素抛出异常
list.count(x) 计数 返回指定元素 x 在列表 list 中出现的次数
len(list) 列表长度 返回列表中包含元素的个数
list.reverse() 翻转列表 所有元素原地翻转
list.sort() 排序 所有元素原地排序
list.copy() 浅拷贝 返回列表对象的浅拷贝

列表创建

  1. []创建
>>> a = [10,20,'gaoqi','sxt'] 
>>> a = [] #创建一个空的列表对象
  1. list()创建
    使用 list()可以将任何可迭代的数据转化成列表
>>> a = list() #创建一个空的列表对象 
>>> a = list(range(10)) 
>>> a 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
>>> a = list("gaoqi,sxt") 
>>> a ['g', 'a', 'o', 'q', 'i', ',', 's', 'x', 't']
  1. range()创建整数列表
    返回的是一个 range 对象而不是列表。我们需要通过 list()方法将其 转换成列表对象。
    range([start,] end [,step])
    

    start 参数:可选,表示起始数字。默认是 0
    end 参数: 必选,表示结尾数字。
    step 参数:可选,表示步长,默认为 1

  2. 推导式生成列表
>>> a = [x*2 for x in range(5)] #循环创建多个元素 
>>> a 
[0, 2, 4, 6, 8] 
>>> a = [x*2 for x in range(100) if x%9==0] #通过 if 过滤元素
>>> a [0, 18, 36, 54, 72, 90, 108, 126, 144, 162, 180, 198]

列表元素增加和删除

除非必要,我们一般只在列表的尾部添加元素或删除元素,这会大大提高列表的操作效率。

  1. append()方法
    原地修改列表对象,是真正的列表尾部添加新的元素,速度最快,推荐使用
  2. +运算符操作
    不是真正的尾部添加元素,而是创建新的列表对象;将原列表的元素和新列表的元素依次 复制到新的列表对象中。
>>> a = [20,40]
>>> a = a+[50]
  1. extend()方法
    目标列表的所有元素添加到本列表的尾部,属于原地操作,不创建新的列表对象。合并列表推荐
>>> a = [20,40] 
>>> id(a) 
46016072 
>>> a.extend([50,60]) 
>>> id(a) 
46016072
  1. insert()插入元素
    使用 insert()方法可以将指定的元素插入到列表对象的任意制定位置。这样会让插入位置后 面所有的元素进行移动,会影响处理速度。涉及大量元素时,尽量避免使用。类似发生移动的函数还有:remove()、pop()、del()
>>> a = [10,20,30]
>>> a.insert(2,100)
>>> a 
[10, 20, 100, 30]
  1. 乘法扩展
    使用乘法扩展列表,生成一个新列表,新列表元素时原列表元素的多次重复。

列表元素删除

  1. del 删除
    删除列表指定位置的元素,无返回值。

  2. pop()方法
    pop()删除返回指定位置元素,如果未指定位置则默认操作列表最后一个元素

  3. remove()方法
    删除首次出现的指定元素,若不存在该元素抛出异常

列表元素访问和计数

  1. 索引直接访问
    索引的区间在[0, 列表长度-1],超过这个范围则会抛出异常。
  2. index()
    index()可以获取指定元素首次出现的索引位置
    index(value,[start,[end]])
    start 和 end 指定搜索范围
  3. count()获得指定元素在列表中出现的次数
  4. len()返回列表长度

成员是否存在

  1. count()方法,返回 0 则表示不存在,返回 大于 0 则表示存在
  2. in / not in推荐

切片操作

同字符串,“包头不包尾”
[起始偏移量 start:终止偏移量 end[:步长 step]]

列表的遍历

for obj in listObj: 
    print(obj)

复制列表

这是浅拷贝

list1 = [30,40,50] list2 = list1

这是深拷贝

  1. 通过+号
list1 = [30,40,50] list2 = [] + list1
  1. copy模块

列表排序

  1. 修改原列表,不建新列表的排序(sort()方法)
    a.sort() #默认是升序排列
    a.sort(reverse=True) #降序排列
    random.shuffle(a) #打乱顺序

  2. 建新列表的排序(内置函数sorted())
    内置函数 sorted()进行排序,这个方法返回新列表不对原列表做修改
    a = sorted(a) #默认升序
    sorted(a,reverse=True) #降序

  3. reversed()返回迭代器
    内置函数 reversed()也支持进行逆序排列,与列表对象 reverse()方法不同的是,内置函数 reversed()不对原列表做任何修改,只是返回一个逆序排列的迭代器对象

    迭代对象只能用一次

列表相关其他函数

max 和 min

返回列表最大最小值

sum

数值型列表的所有元素进行求和操作,对非数值型列表运算则会报错

多维列表

[[“高一”,18,30000,‘北京’], [‘高二’,19,2000,‘上海’], [‘高一’,20,10000,‘深圳’], ]
最后子列表后的,可加可不加

三、元组

不可变序列
支持一下操作
1. 索引访问 2. 切片操作 3. 连接操作 4. 成员关系操作 5. 比较运算操作 6. 计数:元组长度 len()、最大值 max()、最小值 min()、求和 sum()等。7.创建和删除

元祖创建

  1. 通过()创建元组。
    小括号可以省略
    元组只有一个元素,则必须后面加逗号。这是因为解释器会把(1)解释为整数 1,(1,) 解释为元组。
  2. 通过 tuple()创建元组
    tuple(可迭代的对象)
    tuple()可以接收列表、字符串、其他序列类型、迭代器等生成元组。
    list()可以接收元组、字符串、其他序列类型、迭代器等生成列表。
  3. 生成器推导式创建元组
    从形式上看,生成器推导式与列表推导式类似,只是生成器推导式使用小括号。列表推导式直接生成列表对象,生成器推导式生成的不是列表也不是元组,而是一个生成器对象

通过生成器对象:

  1. 转化成列表或者元组
  2. 使用生成器对象的__next__() 方法进行遍历
  3. 直接作为迭代器对象来使用。
    只能访问一次元素

元组的元素访问和计数

元组的元素访问和列表一样,只不过返回的仍然是元组对象

元组无sorted()方法(因不可变)。对元组排序,只能使用内置函数 sorted(tupleObj),并生成列表对象。

zip()

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

元组优点

元组的访问和处理速度比列表快
元组可作为字典的键

四、字典

“键值对”的无序可变序列
”是任意的不可变数据,比如:整数、浮点数、字符串、元组。
”可以是任意的数据,并且可重复。

  1. 键必须可散列
    (1) 数字、字符串、元组,都是可散列的。
    (2) 自定义对象需要支持下面三点才可为键:
    支持 hash()函数
    支持通过__eq__()方法检测相等性。
    a==b 为真,则 hash(a)==hash(b)也为真。
  2. 字典在内存中开销巨大,典型的空间换时间
  3. 键查询速度很快
  4. 往字典里面添加新建可能导致扩容,导致散列表中键的次序变化。因此,不要在遍历字典的同时进行字典的修改(先遍历后修改)。

字典创建

  1. 通过{}、dict()来创建字典对象
    a = {‘name’:‘gaoqi’,‘age’:18,‘job’:‘programmer’}
    b = dict(name=‘gaoqi’,age=18,job=‘programmer’)
    a = dict([(“name”,“gaoqi”),(“age”,18)])
    c = {} #空的字典对象
    d = dict() #空的字典对象
  2. zip()创建字典对象
  3. 通过 fromkeys 创建值为空的字典

字典元素访问

  1. 通过 [键] 获得“值”。若键不存在,则抛出异常。
  2. 通过 get()方法获得“值”。推荐使用。优点是:指定键不存在,返回 None;也可以设 定指定键不存在时默认返回的对象。推荐使用 get()获取“值对象”
  3. 列出所有的键值对a.items()
  4. 列出所有的键a.keys(),列出所有的值a.values()
  5. len() 键值对的个数
  6. 检测一个“”是否在字典中 in / not in

字典元素添加、修改、删除

1.给字典新增“键值对”。如果“键”已经存在,则覆盖旧的键值对;如果“键”不存在, 则新增“键值对”。
a['address']='西三旗 1 号院'
2. 使用 update()将新字典中所有键值对全部添加到旧字典对象上。如果 key 有重复,则直接覆盖。
3. 字典中元素的删除,可以使用 del()方法;或者 clear()删除所有键值对;pop()删除指定键值对,并返回对应的“值对象”;
4. popitem() 随机删除和返回该键值对。字典是“无序可变序列”,因此没有第一个元素、最后一个元素的概念;popitem 弹出随机的项,因为字典并没有"最后的元素"或者其他有关顺序的概念。若想一个接一个地移除并处理项,这个方法就非常有效(因为不用首先获取键的列表)

字典底层实现

字典对象的核心是散列表。散列表是一个稀疏数组,bucket 有两部分:一个是键对象的引用,一个是值对象的引用
Python列表、元祖、字典、集合及其相关操作
扩容:python 会根据散列表的拥挤程度扩容。接近 2/3 时,数组就会扩容。

五、集合

无序可变,元素不能重复
集合底层类似字典实现,集合的所有元素都是字典中的“键对象”,因此是不能重复的且唯一的。

集合创建和删除

  1. 使用{}创建集合对象,并使用 add()方法添加元素
  2. 使用 set(),将列表、元组等可迭代对象转成集合。如果原来数据存在重复数据,则只保留一个
  3. remove()删除指定元素;clear()清空整个集合

集合相关操作

并集:a|b a.union(b)
交集:a&b a.intersection(b)
差集:a-b a.difference(b)

标签:

未经允许不得转载:作者:2283-鲁同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《Python列表、元祖、字典、集合及其相关操作》 发布于2021-10-12

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录