Python学习（五）——数据类型之列表、元组、字典和集合

最新推荐文章于 2024-05-25 08:31:31 发布
最新推荐文章于 2024-05-25 08:31:31 发布
阅读量1.1k 收藏 10
点赞数 1
分类专栏： Python 文章标签： python 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50705021/article/details/127110056
版权

数据类型


创建空集合时，必须使用set()，不能是{}；因为{}默认为空字典。 

list1 = []  # 空列表
tuple1 = ()  # 空元祖
str1 = ""  # 空字符串
dict1 = {}  # 空字典
set1 = set()  # 空集合

序列类型

字符串 str

不可变：创建好后内部无法修改。
内置功能均为创建新字符。

a = 'abc'
b = a.upper()
print(a)
print(b)	# 新字符串
# 结果：abc
#		ABC

列表 list

有序且可变，可存放多个不同类型、同一类别的元素。
内置功能都是直接在列表内部操作，不会创建新列表。

创建列表：普通方式：列表名 = [ ]

list1 = ['笔', '本子']
list1.append('橡皮')
print(list1)
# 结果：['笔', '本子', '橡皮']
  • 生成一到五的列表
# 普通方式
list1 = [1, 2, 3, 4, 5]
print(list1)
# 使用range()
print(list(range(1, 6)))
# for循环
list1 = []
for i in range(1, 6):
	list1.append(i)
print(list1)
# 列表生成式生成
print([i for i in range(1, 6)])

# 列表推导式创建列表[1,4,7,10,13]
print([i for i in range(1,14,3)])	# 1~13之间的数，步长为3

增

append()

将数据添加至列表末尾。

  • 语法：列表名.append(“所需添加的内容”)
list1 = [1, 2, 3, 4, 5]
list1.append("小王")
print(list1)
# 结果：[1, 2, 3, 4, 5, '小王']
insert()

将数据添加至列表指定下标的位置。

  • 语法：列表名.insert(下标, “所需添加的内容”)
list1 = [1, 2, 3, 4, 5]
list1.insert(1, "小王")
print(list1)
# 结果：[1, '小王', 2, 3, 4, 5]
extend()

将数据添加至列表末尾，并把序列类型拆分。

  • 语法：列表名.extend(“序列类型”)
list1 = [1, 2, 3, 4, 5]
list1.extend("小王")
print(list1)
# 结果：[1, 2, 3, 4, 5, '小', '王']

将数据添加至列表末尾。

  • 语法：列表名.extend([“序列类型”])
list1 = [1, 2, 3, 4, 5]
list1.extend(["小王"])
print(list1)
# 结果：[1, 2, 3, 4, 5, '小王']

删

pop()

从列表指定下标的位置，删除一个值，默认从最后一个开始删除。

  • 语法：列表名.pop(下标)
list1 = [1, 2, 3, 4, 5]
list1.pop(1)
print(list1)
list1.pop()
print(list1)
# 结果：[1, 3, 4, 5]
#		[1, 3, 4]
remove()

从列表中删除一个指定的值，若有多个，则从第一个开始删除。

  • 语法：列表名.remove(“删除对象的值”)
list1 = [1, 2, 3, 4, 5, 3]
list1.remove(3)
print(list1)
# 结果：[1, 2, 4, 5, 3]
clear()

将列表中所有内容全部删除。

  • 语法：列表名.clear(")
list1 = [1, 2, 3, 4, 5]
list1.clear()
print(list1)
# 结果：[]
del

从列表指定下标的位置，删除一个值，也可以全部删除。

  • 语法：del 列表名[下标]
list1 = [1, 2, 3, 4, 5]
del list1[2]
print(list1)
# 结果：[1, 2, 4, 5]

全局删除。

  • 语法：del 列表名
list1 = [1, 2, 3, 4, 5]
del list1
print(list1)
# 结果：报错

改

单个修改

直接通过下标进行修改。

  • 语法：列表名[下标] = 内容
list1 = [1, 2, 3, 4, 5]
list1[1] = "张三"
print(list1)
# 结果：[1, '张三', 3, 4, 5]
多个修改

通过切片方式，由下标对其进行修改。

  • 语法：列表名[起点:终点] = 数据1,数据2… 左闭右开
list1 = [1, 2, 3, 4, 5]
list1[2:4] = 9, 8
print(list1)
# 结果：[1, 2, 9, 8, 5]

查

index()

根据内容获取指定数据的下标。

  • 语法：
    1.列表名.index(“所需查找的内容”)
    2.列表名.index(“所需查找的内容”,起点值)
list1 = [1, 3, 2, 3, 4, 5]
print(list1.index(3))
print(list1.index(3,2))
# 结果：1
#		3
count()

统计数据出现的次数。

  • 语法：列表名.count(“所需查找的内容”)
list1 = [1, 3, 2, 3, 4, 5]
print(list1.count(3))
# 结果：2

排序 sort()和sorted()

全int类型的列表才可以排序

  • sort：在原列表上修改
    • 升序：列表名.sort()
    • 降序：列表名.sort(reverse=True)
list1 = [4, 2, 7, 5, 9, 3]
list1.sort()
print(list1)
list1.sort(reverse=True)
print(list1)
# 结果：[2, 3, 4, 5, 7, 9]
#		[9, 7, 5, 4, 3, 2]
  • sorted：返回一个新的列表
list1 = [4, 2, 7, 5, 9, 3]
list2 = sorted(list1)	# 生成一个新列表
print(list2)
# 结果：[4, 2, 7, 5, 9, 3]
#		[2, 3, 4, 5, 7, 9]

元组 tuple

不可变，只有查询方法，和列表的用法一样。
若元素数量是固定的，建议使用元组，因为占用空间更小。

创建元组：普通方式：列表名 = ( ) # 小括号可省略

# 或 tuple1 = ("Python","Java")
tuple1 = "Python", "Java"
print(tuple1)

功能

1.相加。两个元组相加获取生成一个新元组

tuple1 = ('Python', 'Java')+('hi', '你好')
print(tuple1) 
# 结果：('Python','Java', 'hi', '你好')

2.相乘，元组*整型。将元组中的元素创建n份并生成一个新的元组

tuple1 = ('hi', '你好')*2
print(tuple1)
# 结果：('hi', '你好', 'hi', '你好')

3.获取长度

tuple1 = ('123', 'Python', '你好')
print(len(tuple1))  
# 结果：3

4.索引

tuple1 = ('Python', 'Java', 'hi', '你好')
print(tuple1[0])
# 结果：Python

5.切片

tuple1 = ('Python', 'Java', 'hi', '你好')
print(tuple1[0:2])	# 左闭右开
print(tuple1[2:])
# 结果：('Python', 'Java')
#		('hi', '你好')

6.步长，隔多少取值

tuple1 = ('Python', 'Java', 'hi', '你好', 'import')
print(tuple1[1:4:2])
print(tuple1[0::2]) 
# 结果：('Java', '你好')
#		('Python', 'hi', 'import')

7.for循环

tuple1 = ('Python', 'Java', 'hi', '你好')
for i in tuple1:
    print(i)
# 结果：Python
#		Java
#		hi
#		你好    
tuple1 = ('Python', 'Java', 'hi', '你好')
for i in tuple1:
    if i == 'hi':
        continue
    print(i)
# 结果：Python
#		Java
#		你好

散列类型

散列类型的特征：无序、内部元素不重复。

字典 dict

用键值对的方式来存储一些典型的对应关系的数据类型。查询速度快。
键值：类似于我们生活中的字典，根据拼音找某个字。拼音就是key(键)，字就是value(值)。

字典语法：字典名 = {键:值}
键值对的语法：key:value ——> (键:值)
输出语法：字典名[键]
键重新赋值语法：字典名[键] = 值

  • 特点
  1. 字典是无序的，即没有下标。直接通过键值对的方式进行数据的存储，通过键来取值。
num = {'Jim':'1101','Amiy':'1102','Bob':'1103'}
user = {'姓名':'Jim','年龄':18,'工作':'python工程师'}
print(num['Jim'])
print(user['工作'])
# 结果：1101
#       python工程师
  1. 不重复，字典里的键(key)是不可以重复的，若重复则取最后一个
dict1 = {'a':1,'b':2,"b":3,"a":4,"a":5}
print(dict1)  # 默认取最后一个键
# 结果：{'a': 5, 'b': 3}
  1. 可变性，字典里面的数据是可变的
dict1 = {'a':1,'b':2,"a":3,"a":4,"a":5}
dict1['b'] = 10
print(dict1)
# 结果：{'a': 5, 'b': 10}

# 通过key访问value
scores = {'语文':98}
print(scores['语文']) 
# 结果：98

# 通过key添加key-value对
scores = {'语文':98}
scores['数学'] = 96
scores[90] = 8.2
print(scores)  
# 结果：{'语文': 98, '数学': 96, 90: 8.2}
 
# 通过key删除key-value对，使用del语句
scores = {'语文':98}
scores['数学'] = 96
scores[90] = 8.2
del scores['语文']
del scores['数学']
print(scores) 
# 结果：{90: 8.2}
 
# 通过key修改key-value对，新赋的值就会覆盖原有的值
scores = {'语文': 98, '数学': 96, 90: 8.2}
scores['语文'] = 88
scores[90] = 7.8
print(scores)
# 结果：{'语文': 88, '数学': 96, 90: 7.8}
 
# 通过key判断指定key-value对是否存在，可以使用in或者not in，都是基于key来判断的
scores = {'语文': 98, '数学': 96, 90: 8.2}
scores['语文'] = 88
scores[90] = 7.8
print('语文' in scores) 
print('英语' in scores) 
print('体育' not in scores)
# 结果：True
#		False
#		True

只能通过key访问value
key可以是任意不可变类型

字典可以对不存在的key赋值

字典的常用方法

clear()

清空字典中所有的键值对

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores)  
scores.clear()
print(scores)
# 结果：{'语文': 98, '数学': 96, 90: 8.2}
# 		{}
get()

根据key获取value，相当于是方括号语法的增强版。
如果使用方括号语法访问并不存在的key的时候，程序会报错；但是如果使用get()方法访问不存在的key的时候，这个方法会返回一个None，不会导致程序报错。

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores.get('语文'))  #  98
print(scores.get('英语'))  #  None
print(scores['英语'])  # 会报错
len()

获取长度

scores = {'语文': 98, '数学': 96, 90: 8.2}
data = len(scores)
print(data)
# 结果：3
update()

可以使用一个字典所包含的键值对来更新已有的字典

scores = {'语文': 98, '数学': 96, 90: 8.2}
scores.update({'语文':91,'体育':84})
print(scores) 
# 结果：{'语文': 91, '数学': 96, 90: 8.2, '体育': 84}
items()、keys()、values()

分别获取字典中所有的键值对、key、value。

这三个方法依次会返回dict_items、dict_keys和dict_values的对象。
python不能直接操作这几个方法，应先通过list()函数把这三个方法的返回值转换成列表。

#获取字典所有的键值对
scores = {'语文': 98, '数学': 96, 90: 8.2}
items1 = scores.items()
print(type(items1))
print(list(items1)) 
print(list(items1)[0])
# 结果：<class 'dict_items'>
#		[('语文', 98), ('数学', 96), (90, 8.2)]
#		('语文': 98) 

# 获取字典中所有的key
scores = {'语文': 98, '数学': 96, 90: 8.2}
keys1 = scores.keys()
print(type(keys1)) 
print(list(keys1))
print(list(keys1)[1])
# 结果：<class 'dict_keys'>
#		['语文', '数学', 90]
#		数学

# 获取字典中所有的value
scores = {'语文': 98, '数学': 96, 90: 8.2}
values1 = scores.values()
print(type(values1))
print(list(values1))  
print(list(values1)[2]) 
# 结果：<class 'dict_values'>
#		[98, 96, 8.2]
#		8.2
pop()

用于获取指定的key对应的value，并且删除这个键值对

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores.pop('数学')) 
print(scores)
# 结果：96
#		{'语文': 98, 90: 8.2}
setdefault()

用于根据key来获取对应的value
当所获取的key在字典中不存在时，会先为这个不存在的key设置一个默认的value，然后再返回这个key对应的value。

scores = {'语文': 98, '数学': 96, 90: 8.2}
print(scores.setdefault('体育',84))# 若不存在，直接添加
print(scores)
print(scores.setdefault('语文',34))  # 若存在，则不会改变
print(scores) 
# 结果：84
#		{'语文': 98, '数学': 96, 90: 8.2, '体育': 84}
#		98
#		{'语文': 98, '数学': 96, 90: 8.2, '体育': 84}
for循环
scores = {'语文': 98, '数学': 96, 90: 8.2}
# 遍历字典，获取所有的键
# Type1
for item in scores:
    print(item)  # 获取所有键
# Type2
for key in scores.keys():
    print(key)  # 获取所有键
# 结果：语文
#		数学
#		90
 
for value in scores.values():
    print(value)  # 获取所有的值
# 结果：98
#		96
#		8.2 

for k,v in scores.items():
    print(k,v)  # 获取所有的键值
# 结果：语文 98
#		数学 96
#		90 8.2

集合 set

  • 特点
    • 唯一性。保存不重复的元素，即集合中的元素都是唯一的，互不相同。
    • 无序性。每次输出时，元素的顺序可能都不同。

只能存储不可变的数据类型，无法存储列表，字典，集合。

语法： 集合名 = {数据1,数据2,数据3…}

因为集合中的元素具有唯一性，所以集合中每种数据元素只会保留一份。
若有重复数据，是不会被添加到内存空间里面的。

a = {1, 2, 1, (1,2), 'b', 'c', 'b'}
print(a)
# 结果：{1, 2, (1, 2), 'c', 'b'}

因为集合的无序性，所以集合不能通过下标提取元素，否则会报错。（无下标）

a = {1, 2, 1, (1,2), 'b', 'c', 'b'}
print(a[1])  
# 结果：报错

集合的作用：

  1. 存储非重复数据
  2. 用于将序列类型去重
  3. 逻辑判断 交集，并集，差集
#   去重
a = [1,1,1,2,3,6,3,1]
print(list(set(a)))		# 将列表a用set()转换成集合，去重后，再转换成列表输出
# 结果：[1, 2, 3, 6]

集合数学运算

运算符操作python运算符含义
交集&取两集合公共的元素
并集|取两集合全部的元素（不包括重复数据，集合本身也不能重复）
差集-取一个集合中另一集合没有的元素（减去共有的，剩下的就是差集）
成员运算in 和 not in判断一个某个元素是否在或者不在集合中
set1 = {1, 2, 3}
set2 = {2, 3, 4}
print(set1 & set2) 
print(set1 | set2)
print(set1 - set2)
print(set2 - set1)
print(3 in set2)
# 结果：{2, 3}
#		{1, 2, 3, 4}
#		{1}
#		{4}
#		True

增

add()

无序添加

  • 语法：集合名.add(元素)
set1 = {'Python'}
set1.add("Java")
print(set1)
set1.add("MySQL")
print(set1)
set1.add("Linux")
print(set1)
# 结果：{'Python', 'Java'}
#		{'Python', 'MySQL', 'Java'}
#		{'Linux', 'Python', 'MySQL', 'Java'}

删

pop()

当集合元素是int类型时，默认删除第一个元素。
当集合元素是字符串时，随机删除一个元素。

set1 = {1, 5, 3, 7}
set1.pop()
print(set1)
set1.pop()
print(set1)
set1.pop()
print(set1)
# 结果：{3, 5, 7}
#		{5, 7}
#		{7}

set2 = {'Linux', 'Python', 'MySQL', 'Java'}
set2.pop()
print(set2)
set2.pop()
print(set2)
set2.pop()
print(set2)
# 结果：{'MySQL', 'Python', 'Java'}
# 		{'Python', 'Java'}
#		{'Java'}
remove()

必须有参数，参数为要删除的元素，若元素不存在则报错。

set1 = {'Linux', 'Python', 'MySQL', 'Java', 1}
set1.remove('MySQL')
print(set1)
# 结果：{1, 'Linux', 'Java', 'Python'}
set1.remove(2)
print(set1)  # 元素不存在会报错
discard()

和remove一样，但元素不存在不会报错。

set1 = {'Linux', 'Python', 'MySQL', 'Java'}
set1.discard("aaa")
print(set1)  # 元素不存在不会报错
# 结果：{'Java', 'Linux', 'MySQL', 'Python'}
clear()

清空集合中所有元素

set1 = {'Linux', 'Python', 'MySQL', 'Java'}
set1.clear()
print(set1)
# 结果：set()
del

删除集合

set1 = {'Linux', 'Python', 'MySQL', 'Java'}
del set1  # 先删除了变量再去打印变量set1就会报错，显示变量set1不存在
print(set1)
# 结果：报错
mport
关注
  • 1
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【Python】基础数据结构：列表——元组——字典——集合
满堂花醉三千客，一剑霜寒十四州
08-06 7436
Python基础数据结构。
python基本练习——基本数据类型
weixin_74204162的博客
07-09 602
创建变量a,b,c,d,e,f，分别存储任意数值、字符串、元组、列表、集合、字典，并通过type查看，将对应结果与字符串一起输出（5种方法），并写出一定的注释。format(type(d))) #中间有英文运算符中的句号，并且注意format的拼写。①print("b的类型为：%s"%(type(b))) #“”与%之间无任何符号。"c的类型为：{type(c)}") #print括号开头有f。变量a勇于接受一个字符串，可能接受“1”，也有可能接受“1.1”，④print("d的类型为：{0}"
Python列表,元组,集合,字典详解一篇搞懂
最新发布
暗武逢天的博客
05-25 1963
需要顺序访问和修改数据时考虑列表；需要去除重复元素或执行集合运算时选择集合；需要键值对映射时使用字典；而当数据集合不应被修改时，元组是理想选择。每种数据结构都有其独特的性能特点和适用场景，合理选择能够提高程序的效率和可读性。
Python基础（三）列表、元组、字典、集合
qq_33491651的博客
05-14 1539
一、列表list 简介 列表可以保存多个有序（数据按添加的顺序存储）的数据，另外Python不用声明变量类型，所以列表可以直接存放不同类型的对象。 my_list = [10, 2.2, "33", True, None] 但是如果Java想实现这一点，则要声明List的泛型为Object。 List list = new ArrayList<>(); 可以通过索引获取列表中的元素，若索引超出长度，则报 list index out of range 异常。 ...
二、Python之列表（list）、元组（tuple）、字典（dict）和集合（set）详解
lhh_qrsly的博客
09-22 2797
一、什么是序列，Python序列 所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号（称为索引）访问它们。 为了更形象的认识序列，可以将它看做是一家旅店，那么店中的每个房间就如同序列存储数据的一个个内存空间，每个房间所特有的房间号就相当于索引值。也就是说，通过房间号（索引）我们可以找到这家旅店（序列）中的每个房间（内存空间）。 在 Python 中，序列类型包括字符串、列表、元组、集合和字典，这些序列支持以下几种通用的操作，但比较特殊的是，集合和字典不支持索引、
python序列结构（列表、字典、元组、集合）大总结(万字长文，建议收藏)
weixin_65049289的博客
06-30 5097
python序列结构（列表、字典、元组、集合）大总结(万字长文，建议收藏)
【Python入门基础】常用数据结构（二）——元组，集合及字典
01-20
 元组是可以用一个变量（）对象存储多个数据的容器数据类型，特殊之处在于元组的元素不能修改。事实上在项目中尤其是多线程环境中可能更喜欢使用的是那些不变对象，一方面因为对象状态不能修改，所以可以避免由此...
Python入门——组合数据类型
12-21
在Python中，组合数据类型是指可以容纳多个不同类型数据的容器，主要包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）。本篇文章将详细介绍这些组合数据类型。 ### 第一部分 列表 List 1.1 **...
python入门之：列表+元组+字典+集合（csdn）————程序.pdf
12-03
总之，理解并熟练运用Python的列表、元组、字典和集合对于学习Python编程至关重要。它们各自有其独特的应用场景，能够帮助我们高效地处理和组织数据。在实际编程中，根据需求选择合适的数据结构，可以极大地提高代码...
浅谈python四种集合数据类型—【列表、元组、集合、字典】（csdn）————程序.pdf
12-05
在Python编程语言中，有四种主要的集合数据类型：列表(List)、元组(Tuple)、集合(Set)和字典(Dictionary)。这些数据结构各自具有独特的特性和用途，理解并熟练掌握它们对于编写高效且易维护的代码至关重要。 一、...
python3基础篇（二）——数据类型
12-21
【Python3基础篇（二）——数据类型】 Python3 是一种高级编程语言，以其简洁的语法和强大的功能受到程序员的广泛喜爱。在Python3中，理解数据类型是学习编程的基础，因为它们决定了变量如何存储和操作数据。这篇...
Python列表（list）、元组（tuple）和字典（dictionary）的区别
热门推荐
qq_44444503的博客
05-12 1万+
Python列表（list）、元组（tuple）和字典（dictionary）的区别和用法
列表、元组及字典
qq_60381063的博客
01-29 2447
列表、元组及字典三兄弟
数据分析利器Python——列表、元组和字典
风暖暖的博客
04-12 2489
本文介绍了Python中列表，元组和字典的必备知识及序列解包和序列封包的概念
【python学习】列表、元组、字典、集合（详解）
平淡中造就不平凡
03-31 1万+
关注作者，持续阅读作者的文章，学习更多知识！ https://blog.csdn.net/weixin_53306029?spm=1001.2014.3001.5343 一、列表 列表（list）是Python中的一种数据结构，它可以存储不同类型的数据。不同元素以逗号分隔。 eg: A = [1,'zhangsan','a', [2, 'b']] 列表使用规则 1.使用方括号[]表示开始和结束。 2.不同元素以逗号分隔。 3.每个元素的排列是有序号的，元素相同但排列不同的列表属于不同的列表。 4...
Python基本数据结构简介——列表、元组、字典、集合
ppss177的博客
05-23 421
Python基本数据结构简介—列表、元组、字典、集合 1.列表 可变可重复的有序序列，符号标记：[ ]。 一个列表中可同时存放多种类型的数据 1.1 定义 赋值运算直接创建：listName = [1,8,a,‘hello’,‘数据’,3.125] 赋值创建空列表：listName = [ ] 创建数值列表：listName = list(range(10,20,2)) #创建一个10-20之间所有偶数的列表 列表推导使生成：listName = [ int(x*0.5) for x in price]#p
python 列表、元组、字典、集合
weixin_47314602的博客
07-04 675
1.列表list list是处理⼀组有序项⽬的数据结构，即你可以在⼀个列表中存储⼀个序列的项⽬。列表中的项⽬。列表中的项⽬应该包括在⽅括号中，这样python就知道你是在指明⼀个列表。⼀旦你创建了⼀个列表，你就可以添加，删除，或者是搜索列表中的项⽬。由于你可以增加或删除项⽬，我们说列表是可变的数据类型，即这种类型是可以被改变的，并且列表是可以嵌套的。 2.元组tuple() 元祖和列表⼗分相似，不过元组是不可变的。即你不能修改元组。元组通过圆括号中⽤逗号分隔的项⽬定义。元组通常⽤在使语句或⽤户定义的函数能.
Python基础之列表、元组和字典
H931053的博客
11-03 2525
列表（List）对象 经常被用来存储数据对象。我们可以把列表想象为 一连串的储物格，就像下面这样：其中每个储物格里面都可以存储任何类型的对象注意：是任何类型的对象， 整数、小数、字符串、函数、等等 都可以。也可以存储另一个列表对象。# 方括号用来表示一个列表如果定义列表的时候，里面就存放了一些数据对象，只需要填写到方括号里面就可以了。每个对象之间用逗号隔开。# 这个列表里面就包含了多种类型的对象: 整数、小数 、 字符串。# 列表里面的每个对象，就称之为列表的一个元素。列表中还可以包含另一个。
【小白讲python】八、列表&元组&字典&集合
m0_73359086的博客
06-12 113
可以使用切片操作访问列表中一段连续的元素，其中第一个索引表示切片开始的位置（包含），第二个索引表示结束的位置（不包含）。可以使用切片操作访问元组中一段连续的元素，其中第一个索引表示切片开始的位置（包含），第二个索引表示结束的位置（不包含）。方法来移除集合中的元素，如果指定的元素不存在于集合中，则会抛出异常或不做任何操作。可以使用方括号创建一个空列表，也可以在方括号中添加元素创建一个包含指定元素的列表。来向集合中添加单个元素，如果添加的元素已经存在于集合中，则不会有任何影响。
Python教材：第4章详解组合数据类型——列表、元组、字典与集合
总结来说，第4章全面介绍了Python中的四种组合数据类型——列表、元组、字典和集合，强调了它们的特性、创建方法以及常见应用场景。通过实践练习，学习者能够熟练运用这些数据结构处理和组织数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

mport

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

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

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

打赏作者

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

抵扣说明：

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

余额充值