【python】（四）python常用数据结构

最新推荐文章于 2023-03-29 11:30:00 发布
最新推荐文章于 2023-03-29 11:30:00 发布
阅读量953 收藏 5
点赞数
分类专栏： Python 文章标签： python 数据结构 列表 元祖 字典
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gjj920318/article/details/126723362
版权

目录

1. 列表 list

1.1 列表定义与使用

1.1.1 列表定义

在这里插入图片描述

  • 列表是有序的可变元素的集合，使用中括号[]包围，元素之间用逗号分隔
  • 列表是动态的，可以随时扩展和收缩
  • 列表是异构的，可以同时存放不同类型的对象
  • 列表中允许出现重复元素

1.1.2 列表使用

1.1.2.1 创建
  1. 通过构造函数创建
  2. 中括号创建并填充
  3. 列表推导式
# 1、通过构造函数创建
# 创建空列表
li1 = list() 
# 字符串
li1 = list('hogwarts') 
print(type(li1),li1)
#类型：<class 'list'> ；内容：['h', 'o', 'g', 'w', 'a', 'r', 't', 's']

li1_1 = list((1, 2, 3))  # 元组
li1_2 = list({4, 5, 6})  # 集合
li1_3 = list({4, 5, 6})  # 字典
li1_4 = list(1,2,{4, 5, 6},{4, 5, 6}) #混合内容

# 2、中括号创建并填充元素
li2 = []  # 空列表

li2 = [1, 2, 3]  # 直接填充对象
print(type(li2), li2)
#打印结果：<class 'list'> [1, 2, 3]

#3.列表推导式
li3=[i for i in range(1,11) if i%2==0]
print(type(li3),li3)
#打印结果：<class 'list'> [2, 4, 6, 8, 10]
1.1.2.2 索引

在这里插入图片描述

  • 默认正向索引，编号从 0 开始。
  • 支持反向索引，编号从-1 开始。
li = [1, 2, 3, 4, 5]

# 1、正向索引
print(li[0])  # 打印1
print(li[3])  # 打印4

# 2、反向索引
li = [1, 2, 3, 4, 5]
print(li[-1])  # 打印 5
1.1.2.3 切片

在这里插入图片描述

切片： [start: stop: step]

  • start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
  • stop 值: 指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取列表允许的最大索引值；
  • step 值: 步长值指示每一步大小，如果没有指定，则默认步长值为 1。
  • 三个值都是可选的，非必填
# 切片基本用法
li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
print(li[0:5:2])  # 打印['h', 'g', 'a']
print(li[2:4])  # 省略了step，打印['g', 'w']
print(li[:4])  # 省略了start和step，打印['h', 'o', 'g', 'w']
print(li[2:])  # 省略了stop和step，打印['g', 'w', 'a', 'r', 't', 's']
print(li[::2])  # 省略start和stop，打印['h', 'g', 'a', 't']
print(li[::-1])  # 特殊的切片写法：逆序打印['s', 't', 'r', 'a', 'w', 'g', 'o', 'h']
1.1.2.4 运算符

重复：

  • 使用 * 运算符可以重复生成列表元素。
# 1、重复
li = [1] * 5
print(li)  # 打印[1, 1, 1, 1, 1]

合并：

  • 使用 + 加号运算符，可以将两个列表合二为一。
# 2、合并
li1 = [1, 2, 3]
li2 = [99, 100]
print(li1 + li2)  # 打印[1, 2, 3, 99, 100]
1.1.2.5 成员检测
  • in：检查一个对象是否在列表中，如果在则返回 True，否则返回 False。
  • not in：检查一个列表是否不包含某个元素。如果不在返回 True，否则返回 False。
li = [1, 2, 3]

# in
print(1 in li)  # 返回True
print(100 in li)  # 返回False

# not in
print(1 not in li)  # 返回False
print(100 not in li)  # 返回True

1.2 列表常用方法

1.2.1 append()

  • append(item)：将一个对象 item 添加到列表的末尾。
  • 入参：对象 item
  • 返回：None
# 添加元素
# 添加元素
li = []
li.append(1)
li.append(3.14)
li.append("hogwarts")
li.append([6, 6, 6])
li.append((1.2, 1.5))
li.append({'msg': "Hello"})

print(li)  # 打印列表： [1, 3.14, 'hogwarts', [6, 6, 6], (1.2, 1.5), {'msg': 'Hello'}]
print(len(li))  # 获取列表元素个数： 6

1.2.2 extend()

  • extend(iterable)：将一个可迭代对象的所有元素，添加到列表末尾。
  • 入参：可迭代对象 iterable
  • 返回：None
  • 注意：可迭代对象是字典的话，添加的是字典的key值
# extend()的用法

li = []
li.extend('hogwarts')  # 添加的是字符串的所有字母
li.extend([1, 2, 3])  # 接收列表的所有元素
li.extend((4, 5, 6))  # 接收元组的所有元素
li.extend({'a': 1, 'b': 2})  # 接收字典的所有key值

print(li)
#打印结果：['h', 'o', 'g', 'w', 'a', 'r', 't', 's', 1, 2, 3, 4, 5, 6, 'a', 'b']

1.2.3 insert()

  • insert(index, item)：将一个对象插入到指定的索引位置
  • 入参：索引值 index ，一个对象 item
  • 返回：None
  • 原索引位置及后面的元素后移一位
li = [0, 1, 2]
print("插入前: ", li)  # 打印 [0, 1, 2]

# 在索引0的位置插入元素
li.insert(0, 'hogwarts')
print("插入后: ", li)  # 打印 ['hogwarts', 0, 1, 2]

1.2.4 pop()

  • pop(index) 或 pop()
  • 弹出并返回所指定索引的元素。
  • 入参：索引值 index，可不传
  • 返回：指定索引的元素
  • 返回：未指定索引则返回末尾元素
  • 如果索引值不正确，或者列表已经为空，则引发 IndexError 错误
letters = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']

# 传入索引3，弹出元素 w
n1 = letters.pop(3)
print(n1)  # 打印 w

# 不传参数，默认弹出末尾元素
n2 = letters.pop()
print(n2)  # 打印 s

1.2.5 remove()

  • remove(item)
  • 移除列表中第一个等于 item 的元素
  • 入参：指定元素 item
  • 返回：None
  • 目标元素必须已存在，否则会报 ValueError
li = ['h', 'o', 'g', 'w', 'a', 'r', 't', 's']
print(len(li))  # 打印 8

# 1、删除指定元素'h'
li.remove('h')
print(li)  # 打印 ['o', 'g', 'w', 'a', 'r', 't', 's']
print(len(li))  # 打印 7

# 2、移除第一个2
li = [1, 2, 3, 2, 1]
li.remove(2)
print(li)  # 打印 [1, 3, 2, 1]

# 3、删除不存在的元素，会报ValueError错误
li = [1, 2, 3]
li.remove(100)

1.2.6 sort()

  • sort(key=None, reverse=False)
  • 对列表进行原地排序，只使用 < 来进行各项间比较。
  • 入参：支持 2 个关键字参数：
    • key：指定带有一个参数的函数，用于从每个列表元素中提取比较键。
    • reverse：默认值为 **False 表示升序，**为 True 表示降序
  • 返回：None
nums = [2, 4, 3, 1, 5]

# 1、不传参数，默认升序，数字从小到大排列
nums.sort()
print(nums)  # 打印 [1, 2, 3, 4, 5]

# 2、指定key=len，按元素的长度排序
words = ['Python', 'Java', 'R', 'Go']
words.sort(key=len)
print(words)  # 打印 ['R', 'Go', 'Java', 'Python']

# 3、指定reverse=True，降序
nums = [2, 4, 3, 1, 5]
nums.sort(reverse=True)
print(nums)  # 打印 [5, 4, 3, 2, 1]

1.2.7 reverse()

  • reverse()：将列表中的元素顺序反转
  • 参数：无
  • 返回：None
  • 反转只是针对索引值，元素之间不相互比较。
# 反转顺序
nums = [8, 1, 5, 2, 77]
nums.reverse()
print(nums)  # 打印[77, 2, 5, 1, 8]

1.3 列表嵌套

  • 嵌套列表是指在列表里存放列表
  • 列表的常用方法都适用于嵌套列表
# 1、创建嵌套列表
li_2d = [['a', 'b', 'c'], [1, 2, 3]]
print(type(li_2d))  # 打印<class 'list'>
print(len(li_2d))  # 打印 2

# 2、访问嵌套列表中的元素
print(li_2d[0][2])  # 打印 'c'

1.4 列表推导式

  • 列表推导式是指循环创建列表，相当于 for 循环创建列表的简化版
  • 语法：[x for x in li if x ...]
"""
实例：将 1-10 中的所有偶数平方后组成新的列表
"""

# 1、传统解决方案
result = []
for ele in range(1, 11):
    if ele % 2 == 0:
        result.append(ele ** 2)
print(result)  # 打印 [4, 16, 36, 64, 100]

# 2、使用列表推导式
result = [ele ** 2 for ele in range(1, 11) if ele % 2 == 0]
print(result)  # 打印 [4, 16, 36, 64, 100]

2. 元祖 tuple

2.1 元组定义与使用

2.1.1 元祖的定义

  • 元组是有序的不可变对象集合

因为元祖不可变，通常我们把元祖当做常量列表

  • 元组使用小括号包围，各个对象之间使用逗号分隔
  • 元组是异构的，可以包含多种数据类型

2.1.2 元祖的使用

2.1.2.1 创建
  1. 直接使用逗号分隔
  2. 通过小括号填充元素
  3. 通过构造方法 tuple(iterable)

使用构造方法，tuple中的元素是可迭代对象中的所有元素

# 1、直接使用逗号分隔
t1 = 1, 2, 3
print(type(t1),t1) 
#<class 'tuple'> (1, 2, 3)

t1_1=1,
print(type(t1_1),t1_1)  #<class 'tuple'> (1,)
t1_2=(1,)
print(type(t1_2),t1_2)  #<class 'tuple'> (1,)
t1_3=(1)
print(type(t1_3),t1_3)  #<class 'int'> 1
#注意：使用此方式创建元素，如果只有一个元素的话，单一元素后面的逗号不可省略。都这会被认为是其他类型

# 2、通过小括号填充元素
t2 = (1, 2, 3)
print(type(t2),t2)
#<class 'tuple'> (1, 2, 3)

t3 = ('a', 'b', 'c')
print(type(t3),t3)
#<class 'tuple'> ('a', 'b', 'c')

# 3、通过构造函数tuple()
t4 = tuple()
print(type(t4),t4)
#<class 'tuple'> ()

t5 = tuple([1, 2, 3])
print(type(t5),t5)
#<class 'tuple'> (1, 2, 3)
#t5中的元素，是可迭代对象[1,2,3]中元素
2.1.2.2 索引

在这里插入图片描述

  • 可以通过索引值来访问对应的元素。
    • 正向索引，默认编号从 0 开始
    • 反向索引，默认编号从-1 开始
t = tuple(range(1, 6))

# 正向索引
print(t[2])

# 反向索引
print(t[-1])
2.1.2.3 切片

[start: stop: step]:

  • 三个值都是可选的，非必填
  • start 值: 指示开始索引值，如果没有指定，则默认开始值为 0；
  • stop 值：指示到哪个索引值结束，但不包括这个结束索引值。如果没有指定，则取元组允许的最大索引值；
  • step 值：步长值指示每一步大小，如果没有指定，则默认步长值为 1。
# 切片的使用
t = (1,2,3,4,5,6)

print(t[:]) #(1, 2, 3, 4, 5, 6)
print(t[:-2]) #(1, 2, 3, 4)
print(t[2:4]) #(3, 4)
print(t[2:5:2]) #(3, 5)
# 特殊的切片写法：逆序
print(t[::-1]) #(6, 5, 4, 3, 2, 1)

2.2 元组常用方法

2.2.1 index()

  • index(item)
  • 返回与目标元素相匹配的首个元素的索引。
  • 目标必须在元组中存在的，否则会报错
t = (1, 3, 2, 3, 2)
print(t.index(3)) #1

t = ('h', 'o', 'g', 'w', 'a', 'r', 't', 's', 'a')
print(t.index('a')) #4

2.2.2 count()

  • count(item)：返回某个元素出现的次数。
  • 入参：对象 item
  • 返回：次数
t = (1, 2, 2, 3, 3, 3, 3)
print(t.count(3)) #4

t = ('h', 'o', 'o', 'o', 'g', 'w', 'a', 'r', 't', 's')
print(t.count('a')) #1

2.3 元组解包

元组解包：把一个可迭代对象里的元素，一并赋值到由对应的变量组成的元组中。

注意：元祖解包要求变量个数和元素个数一致

# 传统逐个赋值的方式
t = (1, 2, 3)
a = t[0]
b = t[1]
c = t[2]
print(a, b, c)  #1  2 3

# 使用元组解包平行赋值
a, b, c = (1, 2, 3)
print(a, b, c)  # 1 2 3

2.4 元组与列表

  1. 相同点

    • 都是有序的
    • 都是异构的，能够包含不同类型的对象
    • 都支持索引和切片

  2. 区别

    • 声明方式不同，元组使用()，列表使用 []
    • 列表是可变的，元组是不可变的

3. 集合 set

3.1 集合定义与使用

3.1.1 集合定义

  • 无序的唯一对象集合
  • 用大括号{}包围，对象相互之间使用逗号分隔
  • 集合是动态的，可以随时添加或删除元素
  • 集合是异构的，可以包含不同类型的数据

3.1.2 集合的特点

  1. 唯一性：关键特性，集合中任何对象都不会重复
  2. 无序性：使用集合时python解释器不会维持元素插入顺序
  3. 伸缩性：集合可根据需要随意扩展和搜索

3.1.3 集合使用

3.1.3.1 集合创建
  1. 通过使用{}填充元素

注意：创建空集合是不可以单独使用{}

  1. 通过构造方法 set()
  2. 通过集合推导式
# 1、使用大括号{}填充元素
st1 = {1, 2, 3}
print(type(st1),st1) #<class 'set'> {1, 2, 3}
st2 = {'a', 'b', 'c'}
print(type(st2),st2) #<class 'set'> {'b', 'c', 'a'}

# 2、使用构造方法创建集合
st3 = set()  # 空集合
print(type(st3),st3) #<class 'set'> set()
st4 = set('hogwarts')
print(type(st4),st4) #<class 'set'> {'w', 's', 'h', 't', 'o', 'g', 'r', 'a'}

li = [1, 1, 2, 2, 3, 3]
st5 = set(li)
print(type(st5),st5) #<class 'set'> {1, 2, 3}

# 3、使用集合推导式
st6 = {x for x in li}
print(type(st6),st6) #<class 'set'> {1, 2, 3}

# 注意：不要单独使用{ }来创建空集合
st7 = {}  # 这是字典类型
print(type(st7),st7) #<class 'dict'> {}
3.1.3.2 成员检测
  • in
    • 判断元素是否在集合中存在
  • not in
    • 判断元素是否在集合中不存在
"""集合使用：成员检测"""
st = {1, 2, 3, 4, 5}
# in
print(2 in st) #True

# not in
print(99 not in st) #True

3.2 集合常用方法

3.2.1 add()

  • add(item)：将单个对象添加到集合中
  • 入参：对象 item
  • 返回：None
"""集合方法 add()"""
# 添加元素
st = {1, 2, 3}
st.add(99)
st.add('hogwarts')
print(st) #{1, 2, 99, 3, 'hogwarts'}

3.2.2 update()

  • update(iterable)
  • 批量添加来自可迭代对象中的所有元素
  • 入参：可迭代对象 iterable
  • 返回：None
"""集合方法 update()"""
li = [1, 2, 3]
tup = (2, 3, 4)
st = {'a', 'b', 'c'}

# 1、批量添加列表中的元素
st1 = set()
st1.update(li)
# 2、批量添加元组中的元素
st1.update(tup)
# 3、批量添加集合中的元素
st1.update(st)
print(st1) # {1, 2, 3, 4, 'c', 'b', 'a'}

3.2.3 remove()

  • remove(item)：从集合中移除指定元素 item。
  • 入参：指定元素值
  • 返回：None
  • 如果 item 不存在于集合中则会引发 KeyError
"""集合方法 remove()"""
# 1、删除已存在的元素
st = {1, 2, 3, 4, 5}
st.remove(2)
print(st)  #{1, 3, 4, 5}

# 2、删除不存在的元素
# st.remove(1024)  # KeyError

3.2.4 discard()

  • discard(item)：从集合中移除指定对象 item。
  • 入参：指定对象值
  • 返回：None
  • 元素 item 不存在没影响，不会抛出 KeyError 错误。
"""集合方法 discard()"""
# 1、删除已存在的元素
st = {1, 2, 3, 4, 5} 
st.remove(2)
print(st)  #{1, 3, 4, 5}

# 2、删除不存在的元素
st.discard(1024)
print(st) #{1, 3, 4, 5}

3.2.5 pop()

  • pop()：随机从集合中移除并返回一个元素。
  • 入参：无。
  • 返回：被移除的元组。
  • 如果集合为空则会引发 KeyError。
"""集合方法 pop()"""

# 1、随机删除某个对象
st = {1, 2, 3, 4, 5}
item = st.pop()
print(item, st) #1 {2, 3, 4, 5}

# 2、集合本身为空会报错
st = set()
st.pop()  # KeyError

3.2.6 clear()

  • clear()：清空集合，移除所有元素
  • 入参：无
  • 返回：None
"""集合方法 clear()"""

# 1、清空集合
st = {1, 2, 3, 4, 5}
st.clear()
print(st) # set()

3.3 集合运算

3.3.1 交集运算

在这里插入图片描述

  • 交集运算
  • intersection()
  • 操作符：&
"""集合运算：交集"""

# 交集运算
set1 = {1, 3, 2}
set2 = {2, 4, 3}
print(set1.intersection(set2)) #{2, 3}
print(set1 & set2) #{2, 3}

3.3.2 并集运算

在这里插入图片描述

  • 并集运算
  • union()
  • 操作符：｜
"""集合运算：并集"""

# 求两个集合的并集
set1 = {1, 3, 2}
set2 = {2, 4, 3}
print(set1.union(set2)) #{1, 2, 3, 4}
print(set1 | set2) #{1, 2, 3, 4}

3.3.3 差集运算

在这里插入图片描述

  • 差集运算
  • difference()
  • 操作符： -
"""集合运算：差集"""
# 集合求差集
set1 = {1, 3, 2}
set2 = {2, 4, 3}

#属于集合1，不属于集合2
print(set1.difference(set2)) #{1}
print(set1 - set2) #{1}

3.4 集合推导式

  • 类似列表推导式，同样集合支持集合推导式
  • 语法：{x for x in ... if ...}
# 使用推导式生成集合
st = {x for x in 'hogwarts' if x in 'hello world'}
print(st) #{'w', 'o', 'h', 'r'}

4. 字典 dict

4.1 字典定义与使用

4.1.1 字典定义

在这里插入图片描述

  • 字典是无序的键值对集合
  • 字典用大括号{}包围
  • 每个键/值对之间用一个逗号分隔
  • 各个键与值之间用一个冒号分隔
  • 字典是动态的
  • 字典的键：任意不可变字符，通常是字符串和数值。同一字典层级内key不可重复
  • 字典的值：任意python对象，可以是另外一个字典对象

4.1.2 字典的使用

4.1.2.1 创建
  1. 使用大括号填充键值对
  2. 通过构造方法 dict()
  3. 使用字典推导式
# 1、使用大括号填充键值对
dc = {'name': 'Harry Potter', 'age': 18}
print(type(dc), dc) #<class 'dict'> {'name': 'Harry Potter', 'age': 18}

# 2、使用字典构造方法
dc1 = dict()  # 空字典
dc2 = dict(name="Harry Potter", age=18)  # 关键字参数赋值
print(type(dc2), dc2) #<class 'dict'> {'name': 'Harry Potter', 'age': 18}
dc3 = dict([("name", "Harry Potter"), ("age", 18)])
print(type(dc3), dc3) #<class 'dict'> {'name': 'Harry Potter', 'age': 18}

# 3、使用字典推导式
dc4 = {k: v for k, v in [("name", "Harry Potter"), ("age", 18)]}
print(type(dc4), dc4) #<class 'dict'> {'name': 'Harry Potter', 'age': 18}
4.1.2.2 访问元素
  • 与字典也支持中括号记法[key]。
  • 字典使用键来访问其关联的值。
  • 访问时对应的 key 必须要存在
"""字典使用：访问元素"""
dc = {"name": "Harry Potter", "age": 18}
# 1、访问存在的key
print(dc["name"]) # Harry Potter
print(dc["age"]) # 18

# 2、访问不存在的key，会报KeyError错误
print(dc['hobby']) # KeyError: 'hobby'
4.1.2.3 操作元素
  • 语法：dict[key] = value
  • 添加元素
    • 键不存在
  • 修改元素
    • 键已经存在
"""字典使用：操作元素"""
dc = {"name": "Harry Potter", "age": 18}
# 1、修改年龄，改为20
dc['age'] = 20
print(dc) # {'name': 'Harry Potter', 'age': 20}

# 2、新增hobby字段
dc['hobby'] = 'Magic'
print(dc) # {'name': 'Harry Potter', 'age': 20, 'hobby': 'Magic'}
4.1.2.4 嵌套字典
  • 嵌套字典
  • 字典的值可以是字典对象
"""字典使用：嵌套字典"""
dc = {"name": "Harry Potter", "age": 18, "course": {"magic": 90, "python": 80}}
# 1、获取课程Magic的值
print(dc['course']['magic']) #90

# 2、把python分数改成100分
dc['course']['python'] = 100
print(dc) #{'name': 'Harry Potter', 'age': 18, 'course': {'magic': 90, 'python': 100}}

4.2 字典常用方法

4.2.1 keys()

  • keys()
  • 返回由字典键组成的一个新视图对象。
  • 入参：无
"""字典方法 keys()"""
dc = {"name": "Harry Potter", "age": 18}
keys = dc.keys()
print(type(keys), keys) #<class 'dict_keys'> dict_keys(['name', 'age'])

# 1、遍历查看所有的键
for key in keys:
    print(key)
# name
# age

# 2、将视图对象转成列表
print(list(keys)) #['name', 'age']

4.2.2 values()

  • values()
  • 返回由字典值组成的一个新视图对象。
"""字典方法 values()"""
dc = {"name": "Harry Potter", "age": 18}
values = dc.values()
print(type(values), values) #<class 'dict_values'> dict_values(['Harry Potter', 18])

# 1、遍历查看所有的值
for value in values:
    print(value)
# Harry Potter
# 18

# 2、将视图对象转成列表
print(list(values)) # ['Harry Potter', 18]

4.2.3 items()

  • items()
  • 返回由字典项 ((键, 值) 对) 组成的一个新视图对象。
"""字典方法 items()"""
dc = {"name": "Harry Potter", "age": 18}
items = dc.items()
print(type(items), items) # <class 'dict_items'> dict_items([('name', 'Harry Potter'), ('age', 18)])

# 1、遍历查看所有的项
for item in items:
    print(item)
# ('name', 'Harry Potter')
# ('age', 18)

# 2、将视图对象转成列表
print(list(items)) # [('name', 'Harry Potter'), ('age', 18)]

4.2.4 get()

  • get(key)
  • 获取指定 key 关联的 value 值。
  • 入参：
    • key：字典的键，必传。
  • 返回：
    • 如果 key 存在于字典中，返回 key 关联的 value 值。
    • 如果 key 不存在，则返回 None。
  • 此方法的好处是无需担心 key 是否存在，永远都不会引发 KeyError 错误。
"""字典方法 pop()"""
dc = {"name": "Harry Potter", "age": 18}

# 1、访问存在的key
name = dc['name']
print(name) #Harry Potter

# 2、访问不存在的key
hobby = dc.get('hobby')
print(hobby) # None

4.2.5 update()

  • update(dict)
  • 使用来自 dict 的键/值对更新字典，覆盖原有的键和值。
  • 入参：
    • dc：字典对象，必传
  • 返回：None
dc = {"name": "Harry Potter", "age": 18}
dc.update({"age": 20, "hobby": "magic"})
print(dc) # {'name': 'Harry Potter', 'age': 20, 'hobby': 'magic'}

4.2.6 pop()

  • pop(key)
  • 删除指定 key 的键值对，并返回对应 value 值。
  • 入参：
    • key：必传
  • 返回：
    • 如果 key 存在于字典中，则将其移除并返回 value 值
    • 如果 key 不存在于字典中，则会引发 KeyError。
"""字典方法 pop()"""
dc = {"name": "Harry Potter", "age": 18}

# 1、弹出
item = dc.pop("age")
print(dc, item) #{'name': 'Harry Potter'}  18

# 2、删除不存在的key
# dc.pop("hobby")  # 报错keyError

4.3 字典推导式

  • 字典推导式：可以从任何以键值对作为元素的可迭代对象中构建出字典。
  • 实例：给定一个字典对象{'a': 1, 'b': 2, 'c': 3}，找出其中所有大于 1 的键值对，同时 value 值进行平方运算。
# 未使用字典推导式的写法
dc = {'a': 1, 'b': 2, 'c': 3}
d_old = dict()
for k, v in dc.items():
    if v > 1:
        d_old[k] = v ** 2
print(d_old) #{'b': 4, 'c': 9}

# 使用字典推导式
d_new = {k : v ** 2 for k,v in dc.items() if v > 1 }
print(d_new) #{'b': 4, 'c': 9}
爱测试的高胖胖
关注
专栏目录
python升序数判断_检查列表是升序还是降序（用于）
weixin_39869432的博客
12-07 3052
这可能有助于：A=[10,9,8,3,1,0]B=[1,9,18,33,41,50]C=[1, 1, 1, 1, 1]D= [1]E=[1, 2, 3, 2, 1]F =[]def order(someList):asc = Truedesc = Truefor idx in range(1, len(someList)):if someList[idx] - someList[idx - 1] ...
python数组判断是否顺序、逆序,输出UP,DOWN,WRONG
weixin_44281002的博客
08-14 1246
python判断数组是升序还是逆序
核心函数--少儿编程
刘先生倒了u的博客
11-06 1090
Teacher
python升序数判断_Python判断列表是否已排序的各种方法及其性能分析
weixin_39876595的博客
12-02 1267
Test 1: HeadUnorderedList, list len: 200IsListSorted_fastd(): False =>Time Elasped: 0.757 msec, repeated 1000 time(s).IsListSorted_fastk(): False =>Time Elasped: 1.091 msec, repeated 1000 time(s...
判断一个列表中的元素是否按升序排好序
zhanghongyi_cpp的博客
03-11 1129
s = []m = "True"else:breakprint(m)
在 Python 中对元组列表进行排序
最新发布
迹忆客
03-29 4552
第一个和第二个元组中的第二个项目相等（都是 3），所以比较第三个项目，因为 50 小于 100，所以它排在第二位。该示例按每个元组中索引 1 和 2 处的元素对元组列表进行排序。如果我们需要按降序（从大到小）对元组列表进行排序，请在调用。该示例按每个元组中的第二项（索引 1）对元组列表进行排序。函数接受一个迭代并从迭代中的项目返回一个新的排序列表。该函数将按指定索引处的元组元素对元组列表进行排序。我们还可以使用这种方法按多个索引对元组列表进行排序。函数的 key 参数对元组列表进行排序，例如。
【Python入门基础】常用数据结构（二）——元组，集合及字典
01-20
数据结构 列表 元组  元组是可以用一个变量（）对象存储多个数据的容器数据类型，特殊之处在于元组的元素不能修改。事实上在项目中尤其是多线程环境中可能更喜欢使用的是那些不变对象，一方面因为对象状态不能修改...
python 常用数据结构实例
04-14
本篇将深入探讨Python中的四种常见数据结构：树、栈、队列以及Bitmap（位图），并结合实例进行解析。 首先，我们来讨论树数据结构。树是一种非线性的数据结构，它由节点（或称为顶点）和边组成，每个节点可以有零个...
Python常用列表数据结构小结
12-25
本文汇总了Python列表list一些常用的对象方法，可供初学者参考或查询，具体如下： 1.list.append(x) 把元素x添加到列表的结尾，相当于a[len(a):] =[x]，代码如下： >>> a=[1,2,3,4,5] >>> a [1, 2, 3, 4, 5] >>> a....
详解常用查找数据结构及算法（Python实现）
12-24
查找（Searching）就是根据给定的某个值，在查找表中确定一个其关键字等于给定值的数据元素（或记录）。 查找表（Search Table）：由同一类型的数据元素（或记录）构成的集合 关键字（Key）：数据元素中某个数据项...
python列表中的升序与降序
weixin_46277959的博客
03-08 2万+
在使用python进行编程的时候，我们经常使用到列表，并需要对列表里的元素进行升降序操作，下面以一个简单的例子来展示python列表中的升序与降序操作。 **例如：**输入三整数x,y,z,现在需要把这三数进行升序和降序操作 **tips:**使用 .sorted()方法；.sorted()方法默认将列表里的元素进行升序，.sorted(list,reverse=True)则为降序。 1.由小到大排列输出： 当然，也可直接使用list.sort()方法直接进行升序操作： 2. 由大到小排列输出（降.
6-1 判断一个数列是否已排好序
qq_63433878的博客
12-27 1447
6-1 判断一个数列是否已排好序
Python3 DataFrame数据排序与排名
Robin Hu的专栏
05-11 6264
pandas的DataFrame极大地简化了数据分析过程中一些烦琐操作，它是一个表格型的数据结构, 每一列代表一个变量，而每一行则是一条记录。简答地说，DataFrame是共享同一个index 的Series的集合。DataFrame数据的排序分为三类：1、对索引排序sort_index()；2、对值进行排序sort_values()；3、是对值进行排名rank()。 （1）、索引排名   对于索引排序，涉及到对行的索引和对列的索引进行升序或者降序排序函数df.sort_index(axis= , asc
在Python中如何对一个字典(dict)的值进行排序
寒江独钓的博客
09-19 4611
上代码 >>> xs = {'a': 4, 'b': 3, 'c': 2, 'd': 1} >>> sorted(xs.items(), key=lambda x: x[1]) [('d', 1), ('c', 2), ('b', 3), ('a', 4)] 或者 >>> import operator >>> ...
python列表的 升降序
huzi的博客
12-15 7155
题目 给定list=[2,9,6,45,13]，使她升序排列 解答 答案一 list = [2,9,6,45,13] list.sort() print list 答案二 list = [2,9,6,45,13] a = sorted(list) print a 思考 第一想法是冒泡排序，一个一个进行比较。 这
python 列表 升序_python中列表的升序
weixin_39900736的博客
11-30 3820
# 列表排序|去重# 列表的排序:# 升序sort() sorted()a = [1, 3, 5, 2, 6]a.sort()print(a)# =================a = [1, 3, 5, 2, 6]a_sorted = sorted(a)print(a_sorted)# 降序 [::-1] reverse()a = [1, 3, 5]a_list = a[::-1]print(...
python升序排列列表
热门推荐
Katios
11-29 3万+
题目给定list=[2,9,6,45,13]，使她升序排列解答 答案一 list = [2,9,6,45,13] list.sort() print list 答案二 list = [2,9,6,45,13] a = sorted(list) print a 思考第一想法是冒泡排序，一个一个进行比较。 这恰恰不符合python简单优雅的宗旨， 还没从面向过程转移到面向对象的思路
Python列表数据结构详解与常用方法
其中，列表是最常用的数据结构之一，它允许存储任意类型的对象，并且支持动态增长。列表提供了多种内置方法，用于对数据进行各种操作。 1. **列表的方法** - `list.append(x)`：此方法将元素`x`添加到列表的末尾，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值