Python中的数据序列—tuple、dict、set

最新推荐文章于 2023-11-04 14:53:47 发布
最新推荐文章于 2023-11-04 14:53:47 发布
阅读量363 收藏
点赞数
分类专栏： python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LI_dreamit/article/details/119567442
版权

1、元组

1.1元组的定义

  • 单元素元组： 变量 = （数据，）

  • 多元素元组：变量 = （数据1， 数据2， 数据3....）

# 元组:可以储存多个数据,但是元组内的数据不能被修改(元定义后只能被查询)
# 元组的定义:变量 = (数据1, 数据2, 数据3......)
tuple1 = (1, 2, 3, 4)
# 打印后可以展示元组中的全部信息
print(tuple1)  # (1, 2, 3, 4)
# 查询数据类型
print(type(tuple1))  # <class 'tuple'>

# 如果元组中只有一个元素怎么办? 在单一元素后添加逗号
tuple2 = (10)
print(type(tuple2))  # <class 'int'>

tuple3 = ('10')
print(type(tuple3))  # <class 'str'>

tuple4 = (10,)
print(type(tuple4))  # <class 'tuple'>

# 如果小括号包裹单一元素数据不添加逗号,则小括号的意义是提升算术运算符优先级

# 在定义元素或者传值时,元组的括号可以省略

tuple5 = 1, 2, 3, 4, 5
print(tuple5)  # (1, 2, 3, 4, 5)
print(type(tuple5))  # <class 'tuple'>

tuple6 = 5,
print(tuple6)  # (5,)
print(type(tuple6))

tuple7 = (1,2,3,)
print(tuple7)

 1.2 元组的相关操作

元组中的数据不能增删改，所以只能查询
元组的查询方式
  - 索引查询：和列表的使用方式一致
  - index ：从左至右查询指定元素在元组中第一次出现的位置索引，如果存在则返回正向索引，如果不存在则报错
  - count：查询指定元素在元组中出现的次数
  - len：查询元组的长度：也就是查询元组中元素的个数

# 元组的增删改:由于元组中的数据不可修改,所以元组中的数据不能进行增删改操作
tuple1 = (1, 2, 3, 4)
# 修改
print(tuple1[2])
# TypeError: 'tuple' object does not support item assignment
# 元组中的数据不能修改
# tuple1[2] = 6
# 删除
# TypeError: 'tuple' object doesn't support item deletion
# 元组中的数据不能删除
# del tuple1[2]

# 查询
# 通过索引进行查询
# 查询方法和列表一致
# 正向索引,从0开始,从左至右依次递增
# 负向索引,从-1开始,从右至左依次递减
tuple1 = (1, 2, 3, 4, 3)
# 需求:通过正向索引取出3
print(tuple1[2])
# 需求:通过负向索引取出3
print(tuple1[-2])

# index  查询指定元素在元组中所在的位置索引
# 需求:查询3所对应的索引值
# index是从左至右依次查询,返回第一个查到的数据的正向索引值
print(tuple1.index(3))  # 2
# 如果查询的内容不存在,则报错
# print(tuple1.index(8))  # ValueError: tuple.index(x): x not in tuple

# count 查询指定元素在元组中出现的次数
print(tuple1.count(3))  # 2
print(tuple1.count(1))  # 1

# len  查询元组的长度(对所有容器适用)  长度就是计算当前容器中有多少个元素
print(len(tuple1))  # 5
# 其实len()就是调用了括号内对象的__len__方法
print(tuple1.__len__())  # 5

2、字典

2.1 字典的定义

  • 格式：变量 = {key1 : value1, key2: value2......}

  • 空字典定义：

    • {}

    • dict（）

  • 字典中键不能重复，是唯一的，但是值可以重复

  • 字典中的键要见名知意，体现字典可以见名知意的特性

# 字典:储存多个数据,以键值对形式存储,方便快速存取
# 字典的键要见名知意

# 字典定义格式: 变量 = {键1:值1, 键2:值2.....}
dict1 = {'name': 'xiaoming', 'age': 18, 'gender': '女'}
# 使用print打印可以显示字典中的所有数据
print(dict1)
# 查看字典类型
print(type(dict1))  # <class 'dict'>

# 空字典定义方法
dict2 = {}
# 或者
dict3 = dict()
print(dict2, dict3)
print(type(dict2), type(dict3))

# 见名知意的重要性
# 需求: 使用字典保存一个人的信息  xiaoming  18   男  001
# 保存方式一:
# dict4 = {'name': 'xiaoming', 'age': 18, 'gender': '男', '学号': '001'}
# print(dict4)
# 保存方式二:
# 字典的优势是快速存取,注意命名键的时候要见名知意,并且易于记忆
# 字典占用空间远大于列表,使用字典存储数据本来就是牺牲空间确保时间,所以要尽量利用字典快速存取的特性,而不要想空间的节省
# dict5 = {'xiaoming':18, '男':'001'}  # 不建议这样写

# 定义字典时 ,不能有重复的键,否则后定义的键值对会覆盖先定义的

dict6 = {'name': 'xiaoming', 'age': 18, 'name': 'rose'}
# 字典中的键是惟一的,后定义的内容值会覆盖先定义的
print(dict6)

# 字典中键是唯一的但是值可以随意重复
dict7 = {'name': '小明', 'age': 18, 'id': 18}
print(dict7)

2.2 字典的增加

  • 字典[新的key] = 值

  • 如果key在原字典中已经存在则为修改原key对应的值

# 增  使用新的键 = 值的形式增加键值对
dict1 = {'name':'xiaoming', 'age': 18}
# 使用新的键= 值
# 格式:字典变量[key] = 值  如果为新增,则key在原字典中不存在
dict1['gender'] = '男'
print(dict1)  # {'name': 'xiaoming', 'age': 18, 'gender': '男'}

# 如果原字典中存在该key 则为修改原key所对应的值
dict1['name'] = 'xiaowang'
print(dict1)  # {'name': 'xiaowang', 'age': 18, 'gender': '男'}

# update
# 一般用于两个字典间的拼接
# 如果update中添加的键已经存在则修改原有的值
dict1.update({'id': '001', 'color': 'yellow', 'name': 'rose'})
print(dict1)

2.3 字典的删除

  • del 查找到字典的键所对应的值进行删除

  • clear（）清空字典所在数据空间中的多有键值对

  • pop：删除指定键所对应的键值对，会将删除的键值对所对应的值进行返回

  • popitem： 删除随机一个键值对，尝试后发现总是删除最后一个，会将删除的键值对以元组的形式进行返回

# del
# 使用del删除键值对,先要找到dict所对应的键,进行删除
# 注意,在字典中键值对是成对出现的,删除键值也就消失了,不能出现单独的键或者单独的值
dict1 = {'name': 'xiaoming', 'age': 18}
del dict1['age']
print(dict1)  # {'name': 'xiaoming'}

# clear() 清空字典
# 使用clear将字典所对应的内存空间中的数据进行了清空
dict1.clear()
print(dict1)  # {}

# 通过之前的学习经验我们猜测 pop是删除简直对用的
dict2 = {'name': 'xiaoming', 'age': 18, 'gender': '男'}
# 使用pop可以根据指定的key删除键值对
# 使用pop删除键值对后会将其键对应的值进行返回
# print(dict2.pop('name'))  # xiaoming
# print(dict2)  # {'age': 18, 'gender': '男'}

# 猜测:popitem也是删除键值对使用的
# 随机删除一个键值对,一般都是删除最后一个
# 删除后会将我们所删除的键值对以元组的形式进行返回
print(dict2.popitem())  # ('gender', '男')
print(dict2.popitem())  # ('age', 18)
print(dict2)  # {'name': 'xiaoming'}

# dict  无序的  因为其不能通过索引进行键值对的获取(了解)
# Python3.5以后,字典中键值对的顺序和我们插入键值对的顺序保持一致,但是该顺序没法被利用(了解)

2.4 字典的修改

  • 字典[key] = 值

    • 字典中key必须存在

  • update：

    • update（键 = 值）

    • update（{键：值}）

    • 对应的键一定存在

# 通过索引修改字典中的键值对
dict1 = {'name':'小明', 'age':18}
dict1['name'] = '小红'
print(dict1)

# update
# 可以进行制定字段值的修改
# dict1.update(name='小绿')
dict1.update({'name': '小绿'})
print(dict1)

2.5 字典的查询

  • 使用键查询值：字典[key]

    • 查询的键不存在时则报错

  • get：字典.get(key)

    • 查询的键不存在时，不报错，可以默认返回None，或者手动设置返回内容

  • keys：获取所有的键

  • values：获取所有的值

  • items：获取所有的键值对组成的元组

# 直接使用key进行查询
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}
# 查询学员的名称?
print(dict1['name'])

# get查询
# 如果我们查询的键不存在会真么样??? 报错
# KeyError: 'apple'  会出现keyerror  表示查询的键不存在  报错
# print(dict1['apple'])
# 使用get进行查询,只需要在get中传入对应的键即可
# 如果使用get查询的键不存在,则不会报错,会默认返回一个None
print(dict1.get('name'))  # 小明
print(dict1.get('apple'))  # None
# 如果查询的键不存在,get可以自定义默认返回值
# 格式 字典.get(要查询的键, 查询的键不存在时返回的数据)
print(dict1.get('apple', '小刚'))
print(dict1.get('apple', 9))

# keys 获取当前字典中所有的键
print(dict1.keys())  # dict_keys(['name', 'age', 'gender', 'id'])
# keys返回的内容不是列表,而是dict_keys,该数据类型不能直接使用索引查询数据,但是可以进行for遍历
print(type(dict1.keys()))  # <class 'dict_keys'>
keys_1 = dict1.keys()
#  不能使用索引查询
# TypeError: 'dict_keys' object is not subscriptable
# print(keys_1[1])
# 可以被迭代
for i in keys_1:
    print(i)

# values 获取当前字典中所有的值
print(dict1.values())  # dict_values(['小明', 18, '男', '001'])
# dict_values不能使用索引查询,但是可以迭代
print(type(dict1.values()))  # <class 'dict_values'>

# items 获取当前字典中所有的键值对,键值对以元组形式展示
print(dict1.items())  # dict_items([('name', '小明'), ('age', 18), ('gender', '男'), ('id', '001')])
# dict_items不能使用索引查询,但是可以迭代
print(type(dict1.items()))  # <class 'dict_items'>

2.6 字典的遍历

# 字典的遍历
dict1 = {'name': '小明', 'age': 18, 'gender': '男', 'id': '001'}

# 使用for循环对字典进行遍历,默认获取的是字典的每一个键
for i in dict1:
    print(i)
'''
name
age
gender
id
'''
# 获取的是字典的每一个键
for i in dict1.keys():
    print(i)
'''
name
age
gender
id
'''

# 获取的是字典的每一个值
for i in dict1.values():
    print(i)
'''
小明
18
男
001
'''

# 获取的是字典中每一个键值对组成的元组
for i in dict1.items():
    print(i)
'''
('name', '小明')
('age', 18)
('gender', '男')
('id', '001')
'''
# 有没有办法可以分别拿到字典的键和值呢?

for i in dict1:
    print(i, dict1[i])

for key, value in dict1.items():
    print(key, value )

3、集合

3.1 集合的定义

  • 变量 = {数据1， 数据2， 数据3.。。。}

  • 空集合：set（）

  • 集合是一个无序的 不重复的数据序列

# 集合: 集合是一个无序,不重复的数据序列
# 无序: 程序员无法控制其排不顺序,  程序员无法使用索引查找或修改数据
# 不重复:没有办法在字典中放入相同的值,会自动去重,类似于字典的键

# 无序:
set1 = {1, 2, 5, 6, 3, 4}
# 程序员无法利用其顺序,有顺序也无用
# 了解:在集合中会使用数据的值计算哈希值,根据哈希值顺序进行排序
print(set1)  # {1, 2, 3, 4, 5, 6}

# 不重复
set2 = {1, 2, 3, 4, 5, 6, 7, 2, 3}
# set会自动去重
print(set2)  # {1, 2, 3, 4, 5, 6, 7}

# 定义空集合
set3 = set()
# {} 是定义空字典的
print(set3)

# 集合中能够储存什么数据?
# 布尔值在进行计算时  True == 1 Fasle == 0
# 基础数据类型 int  float  bool  字符串 都可以用集合储存
set4 = {1, 12.3, True, 0, False, ''}
print(set4)

# TypeError: unhashable type: 'list'
# 列表数据无法用集合储存
# set5 = {1, 12.3, True, 0, False, '', [1, 2]}
# print(set5)

# 元组类型可以放入集合内储存
set6 = {1, 12.3, True, 0, False, '', (1, 2)}
print(set6)

# TypeError: unhashable type: 'dict'
# 字典类型无法用集合储存
# set6 = {1, 12.3, True, 0, False, '', {1:2}}

# TypeError: unhashable type: 'set'
# 集合类型同样不能使用集合嵌套
# set6 = {1, 12.3, True, 0, False, '', {1,2}}

# 结论:列表  字典  集合,不能放入集合中,作为元素出现

# 拓展:不能作为集合元素的数据类型,同样不能作为字典的键出现
dict1 = {(1, 2): 3}
print(dict1)
# TypeError: unhashable type: 'list'
# 列表 字典 集合不能作为字典的键出现
dict2 = {[1, 2]: 3}
print(dict2)

3.2 集合的相关操作

3.2.1 集合的增加

  • add：添加一个元素，如果值已存在，则去重

  • update： 更新元素（在括号中添加可迭代类型），如果值已存在则去重

# add 增加
set1 = {1, 2, 3, 4}
# set 在使用add命令后,不会产生新的数据,而是原集合中进行修改
set1.add(5)
print(set1)  # {1, 2, 3, 4, 5}

# update 更新
# TypeError: 'int' object is not iterable
# update内部只能填写容器类型(数据序列)
# set1.update(6)
set1.update([6, 7])
print(set1)  # {1, 2, 3, 4, 5, 6, 7}
# 如果更新的数据已经存在,则去重
set1.update([1,2])
print(set1)  # {1, 2, 3, 4, 5, 6, 7}

3.2.2 集合的删除

  • remove：根据元素值进行删除，如果元素不存在则报错

  • discard：根据元素值进行删除，如果元素值不存在则不报错

  • pop：删除任意元素，并返回被删除的值

# remove
set1 = {1, 2, 3, 4}
# 使用remove可以删除指定值的元素
# set1.remove(3)
# print(set1)  # {1, 2, 4}

# pop 随机删除一个元素,并且将删除的元素返回
# print(set1.pop())
# print(set1)

# discard
# 如果使用remove删除的元素不存在会怎样?  报错
# set1.remove(13)  # KeyError: 13
# 如果使用discard删除元素呢?  不会报错
set1.discard(3)
print(set1)  # {1, 2, 4}
set1.discard(13)
print(set1)

3.2.3 集合的判断

  • in

  • not in

# 数据是否在集合中
set1 = {1, 2, 3, 4}
# in 判断元素是否在集合中出现
print(4 in set1)  # True
print(5 in set1)  # Fasle

# not in 判断元素是否不在集合中
print(4 not in set1)  # False
print(5 not in set1)  # True

# 注意:格式  元素 in  集合

# 判断的数据必须要在集合中能够被储存
# TypeError: unhashable type: 'list'
# print([1, 2] in set1)

3.2.4 集合的遍历

集合可以使用for循环遍历，但是遍历顺序随机

# for 遍历
set1 = {1, 2, 3, 4}
for i in set1:
    print(i)

# 注意遍历集合,顺序不定
name_set = {'Tom', 'Bob', 'Rose'}
for i in name_set:
    print(i)
'''
Rose
Tom
Bob
'''

LI_dreamLT
关注
专栏目录
python数据类型——字典表dictionary和元组tuple基本操作举例
Carla0528的博客
05-19 631
python数据类型——字典表dict和元组tuple基本操作举例* 字典表dict1. 字典表dict的声明* --------- ① 花括号{} 声明法* --------- ② dict函数声明法2. 字典表dict的操作* --------- ① 值的获取d['键']* --------- ② 字典的合并 d.update()* --------- ③ 删除某键值对 d.pop(‘键’)3. 字典表dict的属性* --------- ① 获得所有键.keys()* ------
python中list、tuple、dict、set用法
Tianqinse的博客
01-11 977
1.list 列表会将所有元素都放在一对中括号[ ]里面，相邻元素之间用逗号,分隔，个数没有限制，可以存储整数、小数、字符串、列表、元组等任何类型的数据，并且同一个列表中元素的类型也可以不同。 1.1初始化 (1)使用 [ ] 直接创建列表:listname = [element1 , element2 , element3 , ... , elementn] (2)使用 list() 函数创建列表。内置的函数 list()，使用它可以将其它数据类型转换为列表类型。 1.2访问方式 (1)按索引
Python中List, Tuple, dict, set 的比较
weixin_44372476的博客
04-08 895
Python中List, Tuple, dict, set 的比较1. List2. Tuple3. dict4. setOverview 参照廖雪峰官方网站链接: 廖雪峰Python教程. 1. List list是一种有序的集合，可以随时添加和删除其中的元素。 列出班里所有同学的名字，就可以用一个list表示： 下面以一个例子来说明一些List的操作 classmates = ['Wang', 'Cao', 'Tian','Sun'] # 创建一个list len(classmates) # list的
Python内置数据结构str、list、tuple、set、dict
mini_xiang的博客
04-05 640
数据结构 可变 可迭代 有序 特性 str ✖ ✔ ✔ list ✔ ✔ ✔ tuple ✖ ✔ ✔ set ✔ ✔ ✖ key不重复，且必须可hash dict ✔ ✔ ✖ 同上 字符串 一个个字符组成的有序的序列，是字符的集合...
Specifying Keys(指定key之tuple)
MOL
08-31 9360
Specifying Keys Some transformations (join, coGroup, keyBy, groupBy) require that a key be defined on a collection of elements. Other transformations (Reduce, GroupReduce, Aggregate, Windows) allow data being grouped on a key before they are applied. A Dat
Python中的数据结构（列表list、元组tuple、字典dict、集合set）
Python栈
05-25 1879
从上面可以看出集合中有两个函数,add()和update(),两者的区别在于，add()做新增时候，参数作为一个整体字符串添加，update()新增的时候，字符串会拆分成当个字符添加到set中，也就是update会进行将对象迭代添加，这样update()的参数中必须是一个可迭代的对象。从上面代码中可以看出，remove()和discard()的区别是，remove()删除一个不存在的key会报KeyError的错误，discard()如果删除一个set中本不存在的key时，将不进行任何操作。
python(list,tuple,set,dict)
12-21
在Python编程语言中，列表（list）、元组（tuple）、集合（set）和字典（dict）是四种基本的数据结构，它们各自具有独特的特性和用途。 **列表（List）** 列表是可变的序列，允许存储任意类型的元素，包括字符串、...
python中list与tuple，dict与set详解
02-21
### Python中的Dict与Set #### Dict `dict`是一种键值对存储结构，类似于哈希表，提供快速查找功能。 - **创建字典**： - 使用花括号`{}`来创建字典，例如：`d = {"TOM": 12, "Jack": 30, "Bob": 50}`。 - **访问...
python数据容器 list tuple str set dict
最新发布
m0_73889365的博客
11-04 134
1,元组与列表的区别：元组和列表都是数据容器，列表可以修改数据，但是元组不可以修改数据，但是可以修改里面嵌套的列表或者元组2，元组的定义#元组的定义格式：元组名=（元素1，元素2，元素3，元素4）#空元组的定义 元组名=（）#注意点，当元组里面只有一个元素时，必须在后面加上,号，否则就不是元组类型 a=("hello",）3，元组内元素和列表一样不受类型的限制，可以嵌套元组，列表字符串时字符的容器，同时支持通过下标索引查找字符，和元组一样，不允许修改字符串里面的字符。
Python学习笔记：tuple、list、range、set、dict类型
太行一粟
01-04 391
Python常用的元组、列表、集合、字典、数组类型 元组tuple 代码： print(F"type((1,2,3)):", type((1,2,3)), (1,2,3)) 运行结果： >>> print(F"type((1,2,3)):", type((1,2,3)), (1,2,3)) type((1,2,3)): <class 'tuple'> (1, 2, 3) 列表list 代码： print(F"type([1,2,3]):", type([
python中tuple的意思_python中元组（tuple）的用法
weixin_39827798的博客
12-04 693
通过AF &quot&semi;get&quot&semi; 请求html页面总是失败的问题AFHTTPRequestOperationManager *manager = [AFHTTPRequestOperationManager manager]; manager.responseSe ...Maven基础笔记，原理1.什么是Maven ①Maven是一款实...
Halcon深度学习总结
Douhaoyu的博客
06-14 8256
Halcon深度学习
Python 中的 list、tuple、set、dict的底层实现的理解
qq_27944187的博客
08-19 2734
Python 中的 list、tuple、set、dict的底层实现的理解
set dict tuple 内置方法
weixin_30602505的博客
07-04 165
今日内容* 元祖及内置方法* 字典及内置方法* 集合及内置方法* 字符编码 元祖tuple与列表类似可以存多个值，但是不同的是元祖本身不能被修改```python一：基本使用：tuple 1 用途：记录多个值，当多个值没有改的需求，此时用元组更合适 2 定义方式：在()内用逗号分隔开多个任意类型的值t=(1,1.3,'xx',('a','b'),[1,2]) t=tuple((1,1.3,'xx...
使用halcon实现基于深度学习的目标检测
weixin_42295969的博客
09-19 6502
halcon实现目标检测（使用深度学习）
python 的list、dict、tuple、set之间的区别
duus_nabolun的博客
02-28 844
简介 dict: python 内置的字典，在其他的语言中称其为map(j键值对key-value)存储数据，具有极快的查找速度，这种通过key计算位置的方法也称为哈希算法（Hash) list:是一个有序的集合，可以随时添加和删除其中的数据 tuple:也是一种有序的集合，但与list不同的是tuple一点初始化，其中的元素就不能做出修改 set与dict类似但set中只有key,并不存储va...
Python中的列表（list），元组（Tuple），字典（Dict）和集合（Set）
热门推荐
liuyanfeier的专栏
12-18 2万+
一，列表（list） python内置的一种数据类型是列表：list是一种有序的数据集合，可以随意的添加和删除其中的数据。比如列出班里所有的同学的名字，列出所有工厂员工的工号等都是可以用到列表的。不知道有没有人和我一样，刚刚接触列表对于说的这个有序不是很懂，不知道是什么有序。等我自己查资料的时候才知道，这个有序不是说list中的元素自己自动排好了序，而说的是这下面的这种情况：定义一个列表使用一对中
Python中的list,tuple,dict和set
python学习者的博客
09-28 986
List list的创建与检索 Python内置的一种数据类型是列表：list。list是一种有序的集合，可以随时添加和删除其中的元素。 构造list非常简单，直接用 [ ] 把list的所有元素都括起来，就是一个list对象。 Python是动态语言，所以list中包含的元素并不要求都必须是同一种数据类型，我们完全可以在list中包含各种数据： 例如： >>> L = ['Michael', 100, True] list索引从 0 开始，也就是说，第一个元素的索引是0，第二个元素的索
元组tuple,集合set字典dict的补充
qq_45911278的博客
12-24 848
参考了《Python3从入门到实战》这本书 元组tuple与集合set的补充参考了《Python3从入门到实战》这本书一、元素tuple（1）元组是一个有序序列,但它是不可修改的（2）创建一个元组,和list一样,tuple的对象的元素类型可以不同,可以包含list tuple等各种类型的对象（3）创建只包含一个元素的tuple时,必须在这个元素后面加一个逗号,否则就不是一个元组（4）可以用tuple删除指向tuple对象的变量,减少该对象的引用计数（5）不能修改一个对象是指不能修改其每个元素的值,这些元素
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值