pyhton中的元组与集合

最新推荐文章于 2024-05-25 08:31:31 发布

沙丁鱼意大利面

最新推荐文章于 2024-05-25 08:31:31 发布

阅读量400

点赞数 1

分类专栏： Python入门文章标签： python 开发语言

本文链接：https://blog.csdn.net/ShawLee0925/article/details/127952539

版权

Python入门专栏收录该内容

17 篇文章 4 订阅

订阅专栏

2. 调用update（）至少添加一个元素

3. 集合元素的删除操作

1.调用remove()方法，一次删除一个指定元素，如指定元素不存在，则KeyError

2.调用discard()方法，一次删除一个指定元素，如指定元素不存在，则异常

3.调用pop（）方法，一次删除任意一个元素

4.调用clear()，清空集合

7.集合间的关系

1.两个集合是否相等可以使用==或者!=进行判断

2.一个集合是否是另一个集合的子集，可以调用.issubset（）进行判断.

3.一个集合是否是另一个集合的超集，可以调用.issuperset（）进行判断

4.两个集合是否没有交集，可以用.isdisjoint（）进行判断

5.求两个集合之间的交集.intersection()，并集.union(), A对B的差集（就是A减去AB的交集）.difference(), 对称差集.symmetric_difference()

8.集合生成式

9.总结

1.什么是元组

元组是python内置的数据结构之一，是一个不可变序列。

不可变序列：字符串，元组，没有增删改操作

可变序列：列表，字典，可以对序列执行增删改操作，对象地址不发生更改

"----不可变序列与可变序列-------"
# 可变序列（可执行增删改操作）：如列表，字典等
lst = [10, 20, 30, 40, 50, 60, 70]
print(id(lst))
lst.append(80)
print(lst, id(lst))

scores = {'张三': 18, "李四": 20, "王五": 25}
print(id(scores))
scores['陈七'] = 26
print(scores, id(scores))

"""
##########运行结果#######
2980365770048
[10, 20, 30, 40, 50, 60, 70, 80] 2980365770048
2980365797888
{'张三': 18, '李四': 20, '王五': 25, '陈七': 26} 2980365797888

"""
# 不可变序列：如字符串，元组等
s = 'hello!'
print(id(s))  # 2897780738736
s = s * 3
print(s, id(s))  # hello!hello!hello! 2897781065408

可以看出列表，字典，列表经过增加元素之后id并没有发生改变，而字符串经过增加之后,id发生了改变。

2.元组的创建

1.直接用小括号（）创建

2.使用内置函数tuple（）

3.只包含一个元组的元素需要使用逗号和小括号

'------元组的创建方式---------'
## 1.使用()来创建元组
t = ('python', 'hello', 98.5, 55)
print('t的值以及数据类型', t, type(t))
#######################这里用()创建元组的时候，（）是可以省略的
t3 = 'python', 'hello', 98.5, 55
print('t3的值以及数据类型', t3, type(t3))

## 2.使用内置函数tuple()
t1 = tuple(('字符串', 9955,  63.21651,))
print('t1的值以及数据类型', t1, type(t1))
## 3只包含一个元组的元素需要使用逗号和小括号
t4 = ('元组',)
print('t4的值以及数据类型', t4, type(t4))

t5 = ('元组')
print('t5的值以及数据类型', t5, type(t5))  # 这里省略了”，“,导致t5变为了str类型

##  4.空元组的创建
t6 = ()
t7 = tuple()
print('t6以及t7的数据类型', type(t6), type(t7))

为什么要将元组设计成为不可变序列？

在多任务环境下，同时操作对象时不需要加锁，在程序中尽量使用不可变序列。

注意：元组中存储的是对象的引用，如果元组中对象本身不可对象，则不能再引用其它对象，如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。

t = (10, [20, 30], 40)
print(t, type(t), id(t))   # (10, [20, 30], 40) <class 'tuple'> 2128380789184

print(t[0], type(t[0]), id(t[0]))  # 10 <class 'int'> 2128372105744
print(t[1], type(t[1]), id(t[1]))  # [20, 30] <class 'list'> 2128376995136
print(t[2], type(t[2]), id(t[2]))  # 40 <class 'int'> 2128372106704
###    尝试将t[1]修改为100
# t[1] = 100   #######元组是不允许修改元素的，原先是list类型，100是int型，所以这里会报错
"""
但是由于这里的[20，30]是列表，元组是不可变序列，而列表是可变序列，所以可以向表列中添加元素，而列表的内存地址不变
"""
t[1].append(100)  # 向列表中添加元素
print(t, type(t), id(t))  # (10, [20, 30, 100], 40) <class 'tuple'> 2128380789184
print(t[1], type(t[1]), id(t[1]))  # [20, 30, 100] <class 'list'> 1858501451072

3.元组的遍历

元组是可迭代对象，所以可以使用 for ...in进行遍历

t = (95, 'python', 98.015)
'# 第一种获取元组中元素的方法是根据索引'
print(t[0], t[1], t[2])
"# 第二种获取元组中元素的方法  遍历元组"
for item in t:
    print(item)

4.什么是集合

集合： python语言提供的内置数据结构，与字典，列表一样，都是可变类型的序列。根据上图我们可以看到，集合是没有value值的字典。

5.集合的创建

1.直接用{}

{’python‘，"hello", "world",98}

2.直接使用内置函数set{}

'--------集合的创建方式------------'
# 集合同字典一样，字典是键不允许重复，集合同样的里面的元素不允许重复
#######第一种创建方式,使用{}
s = {1, 2, 3, 5, 5, 6, 7, 7}
print(s)
# {1, 2, 3, 5, 6, 7}

#######第二种创建方式，使用内置函数set()

s1 = set(range(6))
print(s1, type(s1))
# {0, 1, 2, 3, 4, 5} <class 'set'>
print(set([3, 4, 5, 6, 7]))  # 使用set()函数，将列表中的元素转为集合中的元素
# {3, 4, 5, 6, 7}
print(set((1, 1, 2, 3, 4, 4, 5, 65)))  # 使用内置函数set(),将元组中的数据转为集合中的元素
# {1, 2, 3, 4, 5, 65}
print(set('hello world'))  # 将字符串转为集合
# {'d', 'w', 'h', ' ', 'o', 'l', 'e', 'r'}    ## 这里可以证明集合是无序的
print(set({1, 2, 3, 5, 5, 6, 7, 7}))  # 将集合元素进行转换，这里不使用set（）函数，其本身也为set类型
# {1, 2, 3, 5, 6, 7}


# 空集合
# {}是字典类型，即dict类型
set()  # 空集合
print(type(set()))