它是python中内置的数据结构之一,是不可变序列,有序,可以重复值。
可变序列:可以对序列进行增删改,并且对象的地址不发生改变
不可变序列:没有增删改的操作
在多任务环境下,同时操作对象的时候不需要加锁
不可变序列,没有增删改的操作,所以只能去查看,这就是第一点说的不需要加锁
需要注意的是:元组中存储的是对象的引用
如果元组中的对象是不可变对象,则不能在引用其他的对象
如果元组中的对象是可变对象,则可变对象的引用不可改变,但是数据可以改变
# t是元组,里面的[20,30]是列表,列表是可变序列
# 但是地址不可变,可以修改值,对应第5点
t = (10, 30, 40)
t[1] = 50 # 报错不可以修改
# 因为t[1]是列表是可变序列,所以可以进行增删改
t = (10,[20,30],40)
t[1][0] = 50
print(t) # (10,[50,30],40)
# 需要注意的是如果值定义一个元组那么需要加 ,
t2 = ['hello',]
t = (10, [20, 30], 40)
for item in t:
print(item, end='\t') # 10 [20, 30] 40
print()
# 找到指定数据的下标
t1 = ('a','b','c')
print(t1.index('c'))
# 计算该元素出现的次数
t1 = ('a','b','c','a')
print(t1.count('a'))
# 该元组的长度
print(len(t1))
集合是没有value的字典,它也是可变序列
{value,value}
set()
函数# 1. {value,value}
s = {123, 456, 789}
print(s, type(s)) # {456, 123, 789}
# 2. 使用内置的set()函数
s1 = set(range(1, 10))
print(s1, type(s1)) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
s2 = set('helloworld')
print(s2, type(s2)) # {'r', 'w', 'h', 'l', 'e', 'o', 'd'}
# 创建空集合
s3 = {}
s4 = set()
in
判断是否存在not in
判断是否不存在add( )
一次新增一个元素update( )
一次新增多个元素remove( )
一次删除一个指定的元素,如果该元素不存在会报错discard( )
一次删除一个指定的元素,如果该元素不存在不会报错pop( )
随机删除一个元素clear( )
清空集合# 集合的相关操作
# 1. 判断操作
s4 = {10, 20, 30, 40}
print(10 in s4) # True
print(10 not in s4) # False
# 2.新增操作
# 如果添加一个元素使用add()
s5 = {10, 20, 30}
s5.add(40)
# 如果添加多个元素使用update()
s6 = {10, 230, 32, 2352, 6}
s6.update({10, 30, 2})
s6.update([66, 77, 888])
s6.update((55, 22, 3333))
print(s6) # {32, 2, 66, 3333, 230, 6, 10, 77, 2352, 22, 55, 888, 30}
# 根据输出我们可以发现只输出了一个10,集合对于重复的值,只保留一个
# 3. 删除操作
s7 = {15, 5465, 478, 14, 4345, 634, 423}
# 1.remove(xx)
# 一次删除一个指定的元素,如果该元素不存在会报错
s7.remove(15)
print(s7) # {4345, 423, 14, 5465, 634, 478}
# 2.discard(xx)
# 一次删除一个指定的元素,如果该元素不存在不会报错
s7.discard(478)
print(s7) # {4345, 423, 14, 5465, 634}
# 3. pop()
# 随机删除一个元素
s7.pop()
print(s7) # {423, 14, 5465, 634}
# 4. clear()
# 清空集合
s7.clear()
print(s7) # set()
==
和 !=
判断集合是否相等issubset()
判断一个集合是否是另一个集合的子集 issuperset()
判断一个集合是否是另一个集合的超集isdisjoint()
判断两个集合是否没有交集# 1. == 和 != 判断集合是否相等
j = {123, 456, 789}
i = {123, 456}
print(i == j) # False
print(i != j) # True
# 2. issubset(),判断一个集合是否是另一个集合的子集
print(j.issubset(i)) # False
print(i.issubset(j)) # True
# 3. issuperset(),判断一个集合是否是另一个集合的超集
print(j.issuperset(i)) # True
print(i.issuperset(j)) # False
# 4. isdisjoint(),判断两个集合是否没有交集
print(j.isdisjoint(i)) # False
intersection()
union()
difference()
symmetric_difference(s2)
# 1. 取交集
s1 = {123, 456, 789, 111}
s2 = {222, 123, 456, 789}
print(s1.intersection(s2)) # {456, 123, 789}
print(s1 & s2) # {456, 123, 789}
# 2. 取并集
print(s1.union(s2)) # {456, 111, 789, 123, 222}
print(s1 | s2) # {456, 111, 789, 123, 222}
# 3. 差集(s1有的,s2没有)
print(s1.difference(s2)) # {111}
print(s1 - s2) # {111}
# 4. 对称差集 (除去交集外的元素)
print(s1.symmetric_difference(s2)) # {222, 111}
print(s1 ^ s2) # {222, 111}
g = {item*item for item in range(10)}
print(g, type(g)) # {0, 1, 64, 4, 36, 9, 16, 49, 81, 25}
数据类型 | 是否可变 | 是否重复 | 是否有序 | 定义的符号 |
---|---|---|---|---|
列表 | 可变 | 可以重复 | 有序 | [ ] |
元组 | 不可变 | 可以重复 | 有序 | ( ) |
字典 | 可变 | key不可以重复,value可以重复 | 无序 | { key:value } |
集合 | 可变 | 不可以重复 | 无序 | { } |
以上就是今天要讲的内容,希望对大家有所帮助!!!