Python中的元组和集合

1、什么是元组

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

      不可变序列与可变序列：

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

               可变序列：列表、字典            可变序列可以进行增删改查的操作，对象地址不发生改变  

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

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

             注意事项：元组中存储的是对象的引用

                               （a）如果元组中对象本身不可对象，则不能再引用其它对象

                               （b）如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据                                            可以改变。

# 可变序列 列表、字典
lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))

# 不可变序列 字符串，元组
s='hello'
print(id(s))
s=s+'word'
print(id(s))
print(s)

2、元组的创建

# 元组的创建方式
# 直接小括号
t = ('Python','hello',90)
print(t)
print(type(t))
# 使用内置函数tuple()
t1 = tuple(('Python','hello',90))
print(t1)
print(type(t1))
# 只包含一个元组的元素需要使用逗号和小括号
t2=(10,)
print(t2)
print(type(t2))
# 空元组的创建方式
t3=()
t4=tuple()
print('空元组',t3,t4)

3、元组的遍历

      元组是可迭代对象，所以可以用for in 循环

t=('Python','world',98)
# 第一种获取元组元素的方式，使用索引
print(t[0])
print(t[1])
print(t[2])

#遍历元组
for item in t:
    print(item)

4、什么是集合

      集合：

               Python语言提供的内置数据结构

               与列表、字典一样都属于可变类型的序列

               集合是没有value的字典

5、集合的创建

# 集合的创建方式
# 第一种创建方式使用{}
s={2,3,4,5,6,7,7} #集合中的元素不允许重复
print(s)
print(type(s))

# 使用内置函数set()
s1=set(range(6))
print(s1)
print(type(s1))

s2=set([1,2,3,4,5,6,7,8])
print(s2)
print(type(s2))

s3=set((1,2,3,4,5,5,65))
print(s3)
print(type(s3))

s4=set('Python')
print(s4)
print(type(s4))

s5=set({12,4,34,55,66,44,4})
print(s5)
print(type(s5))

# 定义一个空集合
s6=set()
print(type(s6))

6、集合的增删改查操作

      集合元素的判断操作：  in或not in

s={10,20,30,405,60}
print(10 in s)  # True
print(100 in s) # False
print(10 not in s)# False
print(100 not in s)# True

      集合元素的新操作 ：

                                      调用add()方法，一次添中一个元素

                                      调用update()方法至少添中一个元素    

       集合元素的删除操作：

                                       调用remove()方法，一次删除一个指定元素，如果指定的元素不存在抛出                                         keyError

                                       调用discard()方法，一次删除一个指定元素，如果指定的元素不存在不抛                                         异常

                                       调用pop()方法，一次只删除一个任意元素

                                       调用clear()方法，清空集合

# 集合元素的新增操作
s.add(80)  #  一次只添加一个
print(s)
s.update({200,400,300})  # 一次添加多个
print(s)
s.update([100,99,8])
s.update((78,64,56))
print(s)
# 基合元素的删除操作
s.remove(100)
print(s)
#s.remove(500)  # KeyError: 500   不存在抛异常
#print(s)
s.discard(500) # 不存在不抛异常
print(s)
s.pop()
print(s)
#s.pop(400) # pop方法不能添加参数 TypeError: set.pop() takes no arguments (1 given)
#print(s)
s.clear() # 清空集合元素
print(s)

7、集合间的关系

      两个集合是否相等：可以使用运算符==或!=进行判断

      一个集合是否是另一个集合的子集：1、可以调用方法issubset进行判断   2、B是A的子集

      一个集合是否是另一个集合的超集：1、可以调用方法issuperset进行判断      2、A是B的超集

      两个集合是否没有交集     可以调用方法isdisjoint进行判断

        

# 两个集合是否相等（元素相等，就相等）
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)  # True
print(s!=s2)  # False

# 一个集合是否是另一个集合的子集
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1))
print(s3.issubset(s1))

# 一个集合是否是另一个集合的超集
print(s1.issuperset(s2))
print(s1.issuperset(s3))

# 两个集合是否有交集
print(s2.isdisjoint(s3)) # False 有交集false
s4={100,200,300}
print(s2.isdisjoint(s4)) # True  没有交集为true

# 交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2) #intersection()与&等价，交集操作

# 并集
print(s1.union(s2))
print(s1 | s2) # union 与 | 等价，并集操作
print(s1)
print(s2)

# 差集操作
print(s1.difference(s2))
print(s1-s2)
print(s2.difference(s1))
print(s2-s1)

# 对称差集
print(s1.symmetric_difference(s2))
print(s1^s2)

8、集合和列表的生成式

# 列表生成式
lst=[ i*i for i in range(6)]
print(lst)

# 集合生成式
lst1={ i*i for i in range(10)}
print(lst1)