016.Python基础语法_集合操作

已于 2023-11-17 23:00:28 修改
阅读量106 收藏
点赞数
分类专栏： Python零基础入门 文章标签： python 开发语言
于 2023-08-22 23:19:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_50296259/article/details/132439239
版权

无奋斗不青春

我 的 个 人 主 页：👉👉 失心疯的个人主页 👈👈
入 门 教 程 推 荐 ：👉👉 Python零基础入门教程合集 👈👈
虚 拟 环 境 搭 建 ：👉👉 Python项目虚拟环境(超详细讲解) 👈👈
PyQt5 系 列 教 程：👉👉 Python GUI(PyQt5)文章合集 👈👈
Oracle数据库教程：👉👉 Oracle数据库文章合集 👈👈
优 质 资 源 下 载 ：👉👉 资源下载合集 👈👈

分隔线

Python基础语法_集合操作

集合

概念

  • 概念
    • 无序的，不可随机访问的，不可重复的元素集合（不可随机访问：集合即没有索引，也没有key，只能通过循环取值)
    • 与数学中集合的概念类似，可以进行交、并、差、补等逻辑运算
    • 集合的元素只能是不可变类型
      不可变数据（3 个）：number（数字）、string（字符串）、tuple（元组）、frozenset（不可变集合）
      可变数据（3 个）：list（列表）、dictionary（字典）、set（可变集合）
    • 集合内部可以嵌套元组和不可变集合，不能嵌套列表、字典、可变集合

分类

  • 集合可分为可变集合和非可变集合
    • 可变集合：set，可进行增删改操作
    • 不可变集合：frozenset，不能进行增删改操作

定义

  • 可变集合定义

    • 方式一：通过{}直接定义一个集合

      s = {元素1, 元素2, ...}

    • 方式二：将一个可迭代对象转换成一个集合

      s = set(iterable)

# 将列表转换为集合时，会自动将列表中的重复元素去重
# 如果是将一个字典转换成集合，那么之后将字典的key作为集合的元素

# 示例
s1 = {1, 2, 3, 4, 5}
s2 = set('abcd')
s3 = set(['a', 'b', 'c', 'd', 'a', 'c'])
s4 = set({'name': '失心疯', 'age': 36, 'sex': '男'})

print(s1)       # --> {1, 2, 3, 4, 5}
print(s2)       # --> {'b', 'c', 'a', 'd'}
print(s3)       # --> {'b', 'c', 'a', 'd'}
print(s4)       # --> {'name', 'age', 'sex'}

    • 方式三：集合推导式

      s = set(表达式 for 变量 in range(范围) if 条件)

s = {表达式 for 变量 in range(范围) if 条件}

# 示例
s = set(x**2 for x in range(1, 11) if x % 2 ==0)
print(s)        # --> {64, 100, 4, 36, 16}
  • 不可变集合定义
    • 方式一：将一个可迭代对象转换为集合
      s = frozenset(iterable)
    
# 将列表转换为集合时，会自动将列表中的重复元素去重
# 如果是将一个字典转换成集合，那么之后将字典的key作为集合的元素
    • 方式二：集合推导式
      s = frozenset(表达式 for 变量 in range(范围) if 条件)
  • 注意事项
    • 创建一个空集合时，需要使用set()或者frozenset()，不能直接使用s = {}，python会吧{}默认定义为字典
    • 集合中的元素，必须是可哈希的值（不可变类型）
      （可哈希：如果一个对象在自己的生命周期中有一哈希值<hash value>是不可改变的，那么它就是可哈希的<hashable>）
    • 如果集合中的元素出现重复，则会被合并为1个

常用操作

增
  • 不可变集合frozenset()不能进行增删改操作
  • 通过add()添加
    分类
    对象方法
作用
    给集合添加一个元素
语法
    set.add(element)
参数
    element：要添加的元素
返回值
    返回None，直接修改原集合对象
  • 通过update()添加
    分类
    对象方法
作用
    将可迭代对象中的多个元素添加到集合中
语法
    set.update(iterable)
参数
    iterable：可迭代对象
返回值
    返回None，直接修改原集合对象
删
  • 不可变集合frozenset()不能进行增删改操作
  • 通过remove()删除
    分类
    对象方法
作用
    指定删除集合对象中的一个元素
语法
    set.remove(element)
参数
    element：指定要删除的元素
返回值
    返回None
    如果指定删除的元素不存在，则报KeyError错误
  • 通过discard()删除
    分类
    对象方法
作用
    指定删除结合中的一个元素
语法
    set.discard(element)
参数
    element：指定要删除的元素
返回值
    返回None
    如果指定删除的元素不存在，也是返回None
  • 通过pop()删除
    分类
    对象方法
作用
    随机删除并返回一个集合中的元素
语法
    set.pop()
参数
    
返回值
    返回被删除的元素
    如果集合为空，则报KeyError: 'pop from an empty set'错误
  • 通过clear()删除
    分类
    对象方法
作用
    清空集合中的所有元素
语法
    set.clear()
参数
    
返回值
    返回None，原集合对象编程空集合，并不会删除集合对象
  • 通过del语句删除
    分类
    
作用
    删除集合对象
语法
    del set
参数
    
返回值
改
* 集合元素为不可变类型，不能修改
查
  • 集合是一个无序的不可随机访问的一个元素集合，所以无法通过index和key进行查询
  • 通过for...in进行遍历
    for 变量 in set:
    # 获取集合元素
    print(变量)
  • 通过迭代器进行访问
    # 1. 生成一个迭代器
变量 = iter(set)

# 2. 通过迭代器取值
# 2.1 使用next()函数获取迭代器元素 
print(next(变量))
print(next(变量))
print(next(变量))
.
.
.

# 2.2 通过for...in获取迭代器元素
for 变量 in 迭代器:
    # 获取迭代器的元素
    print(v)


# 示例
s = {'a', 'b', 'c', 1, 8, 3, 7}

# 1. 创建迭代器
ite = iter(s)

# 2.1 通过next函数取迭代器中的元素
# print(next(ite))
# print(next(ite))
# print(next(ite))
# print(next(ite))
# print(next(ite))
# print(next(ite))
# print(next(ite))

# print(next(ite))  # 取值超出迭代器元素个数，会报错

# 2.2 通过for...in获取迭代器中的元素
for v in ite:
    print(v)

集合之间操作

交集
  • 通过intersection()方法
    分类
    对象方法
作用
    获取集合对象与指定可迭代对象中相同的元素
语法
    set.intersection(iterable)
参数
    iterable：可迭代对象，内部元素只能是不可变类型
    字符串中的数字只能与集合中的字符串类型的数字为交集
    可迭代对象是字典，只会判断key
返回值
    返回一个可变集合/不可变集合，元素为集合和可迭代对象都包含的元素（返回的集合类型与调用方法的对象类型一致）


# 示例
s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a', 'b', 'c', 2, 4, 6, 9}

print(s1.intersection(s2))      # --> {'b', 'a', 'c'}

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = 'abc123'

print(s1.intersection(s2))      # --> {'b', 'a', 'c'}

s3 = {'1', '2', 3, 'a','b','c'}
s4 = 'abc123'
print(s3.intersection(s4))      # --> {'b', 'c', 'a', '2', '1'}

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a':1, 'b': 8, 'f':'c'}
print(s1.intersection(s2))      # --> {'a', 'b'}
  • 通过&逻辑运算符
    • 注意：
    • &逻辑运算符只能对集合与集合求交集
    • 集合与字符串、列表、元组、字典通过&逻辑运算符求交集会报错
    set1 & set2

# 示例
s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a', 'b', 'c', 2, 4, 6, 9}

print(s1 & s2)  # --> {'b', 'a', 'c'}

# -----以下操作均报错----
# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = 'abc'
# 
# print(s1 & s2)  # --> TypeError: unsupported operand type(s) for &: 'set' and 'str'

# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = ['a', 'b', 'c', 2, 4, 6, 9]
# 
# print(s1 & s2)  # --> TypeError: unsupported operand type(s) for &: 'set' and 'list'

# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = ('a', 'b', 'c', 2, 4, 6, 9)
# 
# print(s1 & s2)  # --> TypeError: unsupported operand type(s) for &: 'set' and 'tuple'

# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = {'a': 1, 'b': 8, 'f': 'c'}
# print(s1 & s2)  # --> TypeError: unsupported operand type(s) for &: 'set' and 'dict'
  • 通过intersection_update()方法
    • 该方法只适用可变集合(set)，不可变集合(frozenset)没有该方法
    分类
    对象方法
作用
    获取集合对象与指定可迭代对象中相同的元素，并重新赋值给原集合对象
语法
    set.intersection_update(iterable)
参数
    iterable：可迭代对象，内部元素只能是不可变类型
    可迭代对象是字符串，只会判定非数字部分
    可迭代对象是字典，只会判断key
返回值
    返回None，直接修改原集合对象
    由于是直接修改原集合对象，所以该方法只适用可变集合(set)


# 示例
s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a', 'b', 'c', 4, 9}

print(s1.intersection_update(s2))   # --> None
print(s1)                           # --> {'c', 'b', 'a'}
print(s2)                           # --> {'c', 4, 'a', 9, 'b'}

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = 'abcd1'

print(s1.intersection_update(s2))   # --> None
print(s1)                           # --> {'b', 'a', 'c'}
print(s2)                           # --> abcd1

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = ['a', 'b', 'd', 2, 8, 6, 9]

print(s1.intersection_update(s2))   # --> None
print(s1)                           # --> {'b', 8, 'a'}
print(s2)                           # --> ['a', 'b', 'd', 2, 8, 6, 9]

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = ('a', 'b', 'd', 2, 8, 6, 9)

print(s1.intersection_update(s2))   # --> None
print(s1)                           # --> {8, 'a', 'b'}
print(s2)                           # --> ('a', 'b', 'd', 2, 8, 6, 9)

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a': 2, 'b': 8, 'd': 'c'}

print(s1.intersection_update(s2))   # --> None
print(s1)                           # --> {'b', 'a'}
print(s2)                           # --> {'a': 2, 'b': 8, 'd': 'c'}
  • 补充：可迭代对象内部元素只能是不可变类型原因
    • 在集合与可迭代对象求交集的时候，实际上是先将可迭代对象转换成集合，然后再求交集
    • 如果可迭代对象内部有可变类型，那么在转换成集合的时候就会报错
并集
  • 通过union()方法
    分类
    对象方法
作用
    将指定可迭代对象的所有元素合并到集合中，并合并重复项
语法
    set.union(iterable)
参数
    iterable：可迭代对象
返回值
    返回一个包含了所有元素的可变集合/不可变集合，返回的集合类型与调用方法的集合类型一致
    

# 示例
# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a', 'b', 'c', 4, 9}

print(s1.union(s2))     # --> {1, 3, 4, 7, 'b', 8, 'c', 9, 'a'}
print(s1)               # --> {1, 3, 7, 'b', 8, 'a', 'c'}
print(s2)               # --> {4, 'b', 9, 'a', 'c'}

s1 = frozenset(['a', 'b', 'c', 1, 8, 3, 7])
s2 = {'a', 'b', 'c', 4, 9}

print(s1.union(s2))     # --> frozenset({1, 3, 4, 7, 'b', 8, 'c', 9, 'a'})
print(s1)               # --> frozenset({1, 3, 7, 'b', 'c', 8, 'a'})
print(s2)               # --> {4, 'b', 9, 'a', 'c'}

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = 'abc13'

print(s1.union(s2))     # --> {1, 3, 7, 8, '3', 'a', 'b', 'c', '1'}
print(s1)               # --> {1, 3, 'c', 7, 8, 'a', 'b'}
print(s2)               # --> abc13

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = ['a', 'b', 'd', 2, '8', 9, 7]

print(s1.union(s2))     # --> {1, 2, 3, 7, 'a', 8, '8', 9, 'd', 'b', 'c'}
print(s1)               # --> {1, 3, 'c', 7, 'a', 8, 'b'}
print(s2)               # --> ['a', 'b', 'd', 2, '8', 9, 7]

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a': 9, 'b': 'c', 'd': 2}

print(s1.union(s2))     # --> {1, 3, 'a', 7, 8, 'd', 'b', 'c'}
print(s1)               # --> {1, 3, 'b', 'a', 7, 8, 'c'}
print(s2)               # --> {'a': 9, 'b': 'c', 'd': 2}
  • 通过|逻辑运算符
    • 注意：
    • |逻辑或算符只能对集合与集合求并集
    • 集合与字符串、列表、元组、字典通过|逻辑运算符求并集会报错
    set1 | set2
    

# 示例
s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a', 'b', 'c', 4, 9}

print(s1 | s2)          # --> {1, 'a', 3, 4, 7, 8, 9, 'b', 'c'}
print(s1)               # --> {1, 'a', 3, 'c', 7, 8, 'b'}
print(s2)               # --> {'a', 'c', 4, 9, 'b'}

s1 = frozenset(['a', 'b', 'c', 1, 8, 3, 7])
s2 = {'a', 'b', 'c', 4, 9}

print(s1 | s2)          # --> frozenset({1, 3, 4, 'c', 7, 8, 9, 'a', 'b'})
print(s1)               # --> frozenset({1, 3, 'c', 7, 8, 'a', 'b'})
print(s2)               # --> {'b', 4, 'c', 9, 'a'}

# -----以下运算会报错-----
# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = 'abc13'
#
# print(s1 | s2)          # --> TypeError: unsupported operand type(s) for |: 'set' and 'str'
# print(s1)
# print(s2)

# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = ['a', 'b', 'd', 2, '8', 9, 7]
#
# print(s1 | s2)          # --> TypeError: unsupported operand type(s) for |: 'set' and 'list'
# print(s1)
# print(s2)

# s1 = {'a', 'b', 'c', 1, 8, 3, 7}
# s2 = {'a': 9, 'b': 'c', 'd': 2}
# 
# print(s1 | s2)          # --> TypeError: unsupported operand type(s) for |: 'set' and 'dict'
# print(s1)
# print(s2)
  • 通过update()方法
    • 该方法只适用可变集合(set)，不可变集合(frozenset)没有该方法
    分类
    对象方法
作用
    合并集合对象与指定可迭代对象中的元素，并合并重复项，重新赋值给原集合对象
语法
    set.update(iterable)
参数
    iterable：可迭代对象，内部元素只能是不可变类型
    可迭代对象是字符串，只会判定非数字部分
    可迭代对象是字典，只会判断key
返回值
    返回None，直接修改原集合对象
    由于是直接修改原集合对象，所以该方法只适用可变集合(set)
    
    
# 示例
s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a', 'b', 'c', 4, 9}

print(s1.update(s2))    # --> None
print(s1)               # --> {1, 3, 4, 7, 8, 9, 'c', 'a', 'b'}
print(s2)               # --> {'c', 'a', 4, 9, 'b'}

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = 'adg69'

print(s1.update(s2))    # --> None
print(s1)               # --> {1, 3, 7, 8, 'a', 'd', 'c', '9', '6', 'b', 'g'}
print(s2)               # --> adg69

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = ['a', 'b', 'd', 2, '8', 9, 7]

print(s1.update(s2))    # --> None
print(s1)               # --> {1, 2, 3, 7, 8, 'b', 9, 'c', 'a', 'd', '8'}
print(s2)               # --> ['a', 'b', 'd', 2, '8', 9, 7]

s1 = {'a', 'b', 'c', 1, 8, 3, 7}
s2 = {'a': 9, 'b': 'c', 'd': 2}

print(s1.update(s2))    # --> None
print(s1)               # --> {1, 3, 7, 8, 'b', 'd', 'a', 'c'}
print(s2)               # --> {'a': 9, 'b': 'c', 'd': 2}
差集
  • 通过difference()方法
    分类
    对象方法
作用
    获取包含在集合中但不包含在可迭代对象中的元素
语法
    set.difference(iterable)
参数
    iterable：可迭代对象，内部元素只能是不可变类型
    如果可迭代对象是字典，只会判断key
返回值
    返回一个可变集合或不可变集合，返回的集合类型与调用方法的集合对象类型一样

# 示例
s1 = {'a', 'b', 'c'}
s2 = {'a', 'b', 'd'}

print(s1.difference(s2))    # --> {'c'}
print(s1)                   # --> {'a', 'b', 'c'}
print(s2)                   # --> {'a', 'b', 'd'}

s1 = {'a', 'b', 'c', '1', 2}
s2 = 'a1df2'

print(s1.difference(s2))    # --> {2, 'b', 'c'}
print(s1)                   # --> {2, 'a', '1', 'b', 'c'}
print(s2)                   # --> a1df2

s1 = {'a', 'b', 'c', '1', 2}
s2 = ['a', 1, '2', 'd']

print(s1.difference(s2))    # --> {2, 'c', 'b', '1'}
print(s1)                   # --> {2, 'c', 'b', 'a', '1'}
print(s2)                   # --> ['a', 1, '2', 'd']

s1 = {'a', 'b', 'c', '1', 2}
s2 = {'a': 'b','c': 1, 'd': 2}

print(s1.difference(s2))    # --> {'b', 2, '1'}
print(s1)                   # --> {2, 'c', 'a', '1', 'b'}
print(s2)                   # --> {'a': 'b', 'c': 1, 'd': 2}
  • 通过-运算符
    • 注意：
    • -运算符只能对集合与集合求差集
    • 集合与字符串、列表、元组、字典通过-逻辑运算符求交集会报错
    set1 - set2

# 示例
s1 = {'a', 'b', 'c'}
s2 = {'a', 'b', 'd'}

print(s1 - s2)              # --> {'c'}
print(s1)                   # --> {'a', 'b', 'c'}
print(s2)                   # --> {'a', 'b', 'd'}


# -----以下运算会报错-----
# s1 = {'a', 'b', 'c', '1', 2}
# s2 = 'a1df2'
#
# print(s1 - s2)              # --> TypeError: unsupported operand type(s) for -: 'set' and 'str'
# print(s1)
# print(s2)
#
# s1 = {'a', 'b', 'c', '1', 2}
# s2 = ['a', 1, '2', 'd']
#
# print(s1 - s2)              # --> TypeError: unsupported operand type(s) for -: 'set' and 'list'
# print(s1)
# print(s2)
#
# s1 = {'a', 'b', 'c', '1', 2}
# s2 = {'a': 'b','c': 1, 'd': 2}
# 
# print(s1 - s2)              # TypeError: unsupported operand type(s) for -: 'set' and 'dict'
# print(s1)
# print(s2)
  • 通过difference_update()方法
    • 该方法只适用可变集合(set)，不可变集合(frozenset)没有该方法
    分类
    对象方法
作用
    获取包含在集合中但不包含在可迭代对象中的元素，并重新赋值给原集合
语法
    set.difference_update(iterable)
参数
    iterable：可迭代对象，内部元素只能是不可变类型
返回值
    返回None，直接修改原集合对象
    由于是直接修改原集合对象，所以该方法只适用可变集合(set)


# 示例
s1 = {'a', 'b', 'c'}
s2 = {'a', 'b', 'd'}

print(s1.difference_update(s2))     # --> None
print(s1)                           # --> {'c'}
print(s2)                           # --> {'a', 'b', 'd'}

# # 不可变集合frozenset没有difference_update()方法，会报错
# s1 = frozenset(['a', 'b', 'c'])
# s2 = {'a', 'b', 'd'}
#
# print(s1.difference_update(s2))     # --> AttributeError: 'frozenset' object has no attribute 'difference_update'
# print(s1)
# print(s2)


s1 = {'a', 'b', 'c', '1', 2}
s2 = 'a1df2'

print(s1.difference_update(s2))     # --> None
print(s1)                           # --> {2, 'c', 'b'}
print(s2)                           # --> a1df2

s1 = {'a', 'b', 'c', '1', 2}
s2 = ['a', 1, '2', 'd']

print(s1.difference_update(s2))     # --> None
print(s1)                           # --> {2, 'c', 'b', '1'}
print(s2)                           # --> ['a', 1, '2', 'd']

s1 = {'a', 'b', 'c', '1', 2}
s2 = {'a': 'b', 'c': 1, 'd': 2}

print(s1.difference_update(s2))     # --> None
print(s1)                           # --> {2, 'b', '1'}
print(s2)                           # --> {'a': 'b', 'c': 1, 'd': 2}
判定
  • isdisjoint()判断集合与可迭代对象元素是否不相交
    分类
    对象方法
作用
    判断集合与指定可迭代对象的元素是否不相交
语法
    set1.isdisjoint(iterable)
参数
    iterable：可迭代对象，元素是不可变类型
返回值
    返回True或False
    

# 示例
s1 = {'a', 'b', 'c'}
s2 = {'a', 'b', 'd'}
l2 = ['a', 'b', 'd']
d2 = {'e':'a', 'f':'b', 'g':'d'}

print(s1.isdisjoint(s2))        # --> False
print(s1.isdisjoint(l2))        # --> False
print(s1.isdisjoint(d2))        # --> True
  • issuperset()判断集合是否包含可迭代对象的所有元素
    分类
    对象方法
作用
    判断集合是否包含可迭代对象的所有元素
    个人理解：判断集合是否是可迭代对象的父集合
语法
    set.issuperset(iterable)
参数
    iterable：可迭代对象，元素是不可变类型
    如果可迭代对象是字典，只会与key进行判断
返回值
    返回True或False
    

# 示例
s1 = {'a', 'b', 'c', 'd', 'e'}
s2 = {'a', 'b', 'd', 'e'}
s3 = ['a', 'b', 'c', 'f']
s4 = {'a': 1, 'b': 2, 'c': 3}

print(s1.issuperset(s2))        # --> True
print(s1.issuperset(s3))        # --> False
print(s1.issuperset(s4))        # --> True
  • issubset()判断一个集合是否包含于指定可迭代对象
    分类
    对象方法
作用
    判断集合所有元素是否包含于指定可迭代对象
    个人理解：判断集合是否是可迭代对象的子集合
语法
    set.issubset(iterable)
参数
    iterable：可迭代对象，元素是不可变类型
    如果可迭代对象是字典，只会与key进行判断
返回值
    返回True或False


# 示例
s1 = {'a', 'b', 'c'}
s2 = {'a', 'd', 'b', 'c', 'f'}
s3 = ['a', 'b', 'f', 'c', 'g', 1, 2]
s4 = {'a': 'b', 'c': 'd', 'e': 1}
s5 = 'abc123'

print(s1.issubset(s2))      # --> True
print(s1.issubset(s3))      # --> True
print(s1.issubset(s4))      # --> False
print(s1.issubset(s5))      # --> True

推导式

列表推导式

  • 作用

    • 列表推导式可以通过一个可迭代对象快速的生成一个新列表

  • 语法

    # 格式一
[表达式 for 变量 in 可迭代对象]

# 格式二
[表达式 for 变量 in 可迭代对象 if 条件]

# 格式三
[表达式1 if 条件 else 表达式2 for 变量 in 可迭代对象]

  • 示例

  • 格式一示例

    old_list = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

new_list = [i[1] for i in old_list]

print(new_list)         # [2, 5, 8]

  • 图解

    • 在这里插入图片描述

  • 格式二示例

    old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

new_list = [i ** 2 for i in old_list if i % 2 == 0]

print(new_list)         # [4, 16, 36, 64, 100, 144, 196, 256, 324, 400]


# 拆解 new_list = [i ** 2 for i in old_list if i % 2 == 0]

# new_list = []

# for i in old_list:
#     if i % 2 == 0:
#         new_list.append( i ** 2)

  • 图解

    • 在这里插入图片描述

  • 格式三示例

    old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

new_list = [i ** 2 if i % 2 == 0 else i * 0 for i in old_list ]

print(new_list)         # [0, 4, 0, 16, 0, 36, 0, 64, 0, 100, 0, 144, 0, 196, 0, 256, 0, 324, 0, 400]


# 拆解 new_list = [i ** 2 if i % 2 == 0 else i * 0 for i in old_list ]

# new_list = []
# 
# for i in old_list:
#     if i % 2 == 0:
#         new_list.append(i ** 2)
#     else:
#         new_list.append(i * 0)

  • 图解

    • 在这里插入图片描述

  • 理解

  • 由于最终生成的是一个列表，所以可以先写一个列表

    new_list = []

  • 然后再在这个列表内部写推导式

    old_list = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

new_list = [i[1] for i in old_list]

print(new_list)         # [2, 5, 8]

集合推导式

  • 与列表推导式的区别就是将[]替换成{}
  • 语法
    # 格式一
{表达式 for 变量 in 可迭代对象}

# 格式二
{表达式 for 变量 in 可迭代对象 if 条件}

# 格式三
{表达式1 if 条件 else 表达式2 for 变量 in 可迭代对象}
  • 示例
  • 示例一
    old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

new_set = {i * 2 for i in old_list}

print(new_set)          # {2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40}
  • 示例二
    old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

new_set = {i ** 2 for i in old_list if i % 2 == 0}

print(new_set)          # {64, 256, 100, 4, 36, 196, 324, 16, 144, 400}
  • 示例三
    old_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]

new_set = {i ** 2 if i % 2 == 0 else i * 0 for i in old_list}

print(new_set)          # {0, 64, 256, 4, 36, 100, 196, 324, 16, 144, 400}

# 由于集合是一个无序且不可重复的元素集合，所以输出结果中只有一个0，且并未根据old_list元素的顺序生成

字典推导式

  • 可以根据特定的条件或逻辑快速生成一个新的字典，同时也可以对已有的字典进行修改和过滤
  • 语法
    # 格式一
{key: value for 变量 in 可迭代对象}

# 格式二
{key: value for 变量 in 可迭代对象 if 条件}

# 格式三
{key: value1 if 条件 else value2 for 变量 in 可迭代对象}
  • 示例
  • 示例一
    old_list = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

new_dic = {i[0]: i[1] for i in old_list}

print(new_dic)          # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
  • 示例二
    old_list = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

new_dic = {i[0]: i[1] for i in old_list if i[1] % 2 == 0}

print(new_dic)          # {'b': 2, 'd': 4}
  • 示例三
    old_list = [('a', 1), ('b', 2), ('c', 3), ('d', 4)]

new_dic = {i[0]: i[1] if i[1] % 2 ==0 else i[1]**2 for i in old_list}

print(new_dic)          # {'a': 1, 'b': 2, 'c': 9, 'd': 4}
失心疯_2023
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
9.Python基础语法（六）【数据类型转换】
孤寒者的博客
02-11 2万+
Python基础语法（六） Python数据类型转换~
python空集合_python空集合
weixin_39730911的博客
11-21 1799
广告关闭腾讯云11.11云上盛惠 ，精选热门产品助力上云，云服务器首年88元起，买的越多返的越多，最高返5000元！- 不可变数据类型实现某个功能,需要将结果赋值给另外一个变量; 是否实现for循环可迭代数据类型: str, list, tuple, dict, set不可迭代数据类型:数值类型是否支持索引,切片, 重复和连接特性有序的数据类型: str, list,tuple无序的数据类型: d...
Python基础知识_集合（Set）
w_naKing的博客
08-23 1572
Python基础知识_集合（Set）用法大全详解
深入浅出Python——Python基础语法全解
热门推荐
路虽远，行则必至！
07-24 7万+
前言：Python 是一个高层次的结合了解释性、编译性、互动性和面向对象的脚本语言。 文章目录一、Python简介1. 了解Python2. Python介绍3. Python特点4. Python发展历史5. Python版本二、Python解释器1. 解释器的作用2. 解释器的安装三、PyCharm安装与使用1. PyCharm的作用2. PyCharm安装与使用四、注释1. 注释的作用2. 注释的分类及语法五、变量1. 变量的作用2. 定义变量2.1 标识符2.2 命名习惯2.3 使用变量2.4 认识
Python基础语法
qq_45443475的博客
05-06 1577
示例：%5d：表示将整数的宽度控制5位，如数字11 会变成【空格】【空格】【空格】11。（1）单行注释：以#号开头 起辅助说明的作用，#号和注释内容一般建议以一个空格隔开，（2）多行注释：以 一对三个双引号 引起来（"""注释内容"""）m：控制宽度，要求是数字（很少使用），设置宽度小于数字自身，不生效。m.n的形式（m和.n均可省略）：如%5d、%5.2f、%.2f。（3）三引号：name = """tangbb"""（2）字符串：%s、整数：%d、浮点数：%f。（1）概念：在程序运行时，记录数据用的。
python基础系列教程——python基础语法全解
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
10-29 6万+
全栈工程师开发手册 （作者：陈玓玏） python教程全解 了解python 1. 了解Python Python是一种解释型（这意味着开发过程中没有了编译这个环节）、面向对象（支持面向对象的风格或代码封装在对象的编程技术）、动态数据类型的交互式（可在命令行中通过Python提示符及直接代码执行程序）高级程序设计语言。 2. Python标识符 标识符由字母、数
2.Python从入门到精通—Python 基础语法详细讲解-上
Java 技术专栏，从入门到精通，熟悉企业级开发
05-06 1万+
在Python中，变量是用来存储数据的容器。Python不需要声明变量的类型，变量的类型是根据所赋的值自动推导出来的。
Python 基础语法：基本数据类型（集合）
moment159的博客
03-12 1649
在处理一些需要快速判断元素是否存在的场景，或者需要去除重复元素的场景时，集合是一个非常好的选择。集合中的元素是唯一的，即集合中不会出现重复的元素。需要注意的是，由于集合是无序的，所以每次打印集合时元素的顺序可能会有所不同，但这并不影响集合中元素的唯一性和存在性。同样地，列表和元组也可以转换为集合，但需要注意的是，集合是无序的，所以转换后的集合元素的顺序可能与原列表或元组不同。函数传入了一个包含重复元素的列表，返回的集合中也只会包含不重复的元素。方法不会抛出错误，也不会改变集合，因为集合中的元素是唯一的。
Python 实例教学_01_基础语法
yake1965
09-13 2059
Python 实例教学： Python 零基础，通过 leetcode 题目练习，掌握 python 的基础语法。
python基础语法实验_列表、集合、元组、字典
Despondent的博客
08-13 2204
python基础语法实验 本文主要是为了实现对python的基础语法和基本的数据结构进行系统的了解，比较适合初学者 1.编写程序，输入一个大于2 的自然数，然后输出小于该数字的所有素数组成的列表。 输入格式: 一个大于2的自然数。 输出格式: 小于该数字的所有素数组成的列表。 输入样例: 在这里给出一组输入。例如： 47 输出样例: 在这里给出相应的输出。例如： [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43] num = int(input()) l
python基础总结_基础语法案例_python_
10-01
Python是一种高级编程语言，以其...以上就是Python基础语法的一些关键点，通过案例练习，你可以更好地理解和掌握这些概念。在两天的学习过程中，你将有机会实践这些知识，从而在Python编程的道路上迈开坚实的第一步。
2.Python数据类型_python教程_源码
10-04
Python是一种高级编程语言，以其简洁明了的语法和强大的功能深受程序员喜爱。在Python的世界里，数据类型是构建任何程序的基础。本教程将深入探讨Python中的核心数据类型，包括基本类型、容器类型以及它们的使用方法...
千行代码入门python.rar_python_python 代码_python代码_python入门代码_trieduba
09-24
2. **基础语法**：讲解Python的基本语法，包括注释、变量声明、数据类型（如整型、浮点型、字符串和布尔型），以及基本的输入输出操作。 3. **控制结构**：介绍流程控制，如条件语句（if-elif-else）、循环（for和...
python.rar_Python_
08-09
1. **基础语法**：包括变量、数据类型（如整型、浮点型、字符串、列表、元组、字典等）、条件语句（if-else）、循环（for、while）、函数定义与调用等。 2. **控制结构**：涵盖异常处理（try-except）、模块导入...
python.zip_pdf_python pdf_python 教程_python教程_教程
07-14
这本书可能会讨论更高级的语法特性，如装饰器、生成器、上下文管理器，以及Python的高级数据结构，如列表推导式、字典和集合。此外，它可能深入讲解模块化编程、单元测试、调试技巧、性能优化，以及Python在网络编程...
随机数种子的作用
帆的博客
07-23 807
设置随机数种子（random seed）的目的是为了确保随机数生成器在每次运行时产生相同的随机数序列，从而保证实验结果的一致性。随机数种子通过初始化随机数生成器的内部状态，使得在相同的种子值下，随机数生成器每次调用时生成的序列是相同的。
Java-Lambda
lizhiwei21的博客
07-21 460
lambda表达式可以理解为对匿名内部类的一种简化 , 但是本质是有区别的面向对象思想 :强调的是用对象去完成某些功能函数式编程思想 :强调的是结果 , 而不是怎么去做。
使用9种方法隐藏和显示元素
lulei5153的博客
07-21 186
【代码】使用9种方法隐藏和显示元素。
提取autocad2024图形中图块的属性的代码-统计选中图块长度属性的总长度
最新发布
VB973490770的专栏
07-24 101
阀门位号：XV-123。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

失心疯_2023

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值