Python进阶4元组与集合

1：什么是元组

一：元组(tuple)

1、元组是不可改变的序列，同list一样，元组可以存放任意类型的元素，一旦元组生成，则它不可以改变（包括增、删、改）。

2、元组的表示方式：用小括号（）括起来，单个元素括起来用逗号（，）区分是单个对象还是元组

3、元组的创建：

创建空元组的字符值：t = ()

创建非空元组的字面值：

t = 200,

t =(20, )

t =(1, 2, 3)

t = 100, 200, 300

4、元组的构造函数（tuple）

A:tuple() 生成一个空的元组，等同于()

B:tuple(iterable) 用可迭代对象生成一个元组

示例：

t = tuple()

t = tuple(range(10))

t = tuple(‘hello’)

2：元组的创建方式

print('-------------------对元组进行测试--------------------')
#空元组的创建
t=()
print(t,type(t))
t=tuple()
print(t,type(t))
t=('python','hello',99)
print(t,type(t))
t=tuple(('hello','python'))
print(t,type(t))

如果元组里面只有一个元素，那么不能直接用（）来进行表示；需要在元素的后面在jia一个 ，

#如果元组里面只有一个元素，不能直接用（‘元素’）；
#需要在元素的最后加一个,
print(' ----------------------单元素测试---------------------')
t=('hello')
print(t,type(t))
t=('world',)
print(t,type(t))

print('==========================元组的不可变测试============================')
'''1.元组中存储的是元素的引用地址，这个地址是不可以改变的
   2.不可改变元组中的值，因为不同的值用不同的地址
   3.如果元组里面有列表，那么列表可以增加元素，删除元素，并且列表的引用地址并不改变。
'''
t=(12,[10,20],90)
print(t,type(t),id(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
t[1].append(90)
print(t[1],type(t[1]),id(t[1]))
#  t[0]=10    #  t[0]=10
# TypeError: 'tuple' object does not support item assignment元组对象不支持赋值
print(t[0])

3：元组的遍历

方法一：元组名[索引] 但是容易超出范围

方法二：for in 循环进行遍历

​ for t in 元组名 ：

​ 操作

​

print('=========================元组的遍历==========================')
t=('hello','python',89)
for i in t :
    print(i)
print(t[0])
#print(t[3])#IndexError: tuple index out of range,#超出索引范围

4：什么是集合

集合是没有值的字典，并且也是可变的

数据存储地址也是通过哈希函数进行计算过后进行分配的空间

集合中的元素不允许重复 range（）函数，列表[],元组（）

集合里面可以是字符串，

5：集合的创建

print('=========================集合的创建=========================')
#方法一：直接用   { }
t={1,2,3,1,32,23,4}
print(t)
'''结果为
=========================集合的创建=========================
{32, 1, 2, 3, 4, 23}      结果为无序的，说明集合和字典差不多，
'''
#方法二：使用内置函数set()
#range()范围函数，左闭右开，从0~n-1开始，顺序输出
t=set(range(6))
print(t)
#set()函数里面直接放置{      }集合
t=set({12,21 ,132 ,213 })
print(t)
#元组转集合，输出类型为集合型，并且乱序输出
t=set((12,131,43,12,4,3))
print(t)
#字符串转集合，会把字符串中的单词进行拆开，然后乱序输出
t=set('python')
print(t)
#列表转集合，顺序输出，但是相同的元素会删掉
t=set([321,312,321,2,'hwd'])
print(t)
#字典转集合只输出键
t=set({'姓名':'毛腾凯'})
print(t)

#输出结果
#=========================集合的创建=========================
#{32, 1, 2, 3, 4, 23}
#{213, 132, 12, 21}
#{3, 131, 4, 43, 12}
#{'o', 't', 'y', 'h', 'p', 'n'}
#{312, 321, 2, 'hwd'}
#{'姓名'}

6：集合的增，删，改，查操纵

1，集合中判断元素是否存在

数据 in /not in 集合名 输出结果为True 或者False

2，元素的增加

​ 1：添加一个元素：集合名.add( 增加一个元素)

​ 2：添加至少一个元素：集合名.update（），括号里面可以是元组，集合，列表

t={21,23,32,3,54}#原集合
print(t)
t.add(100)#增加一个元素
print(t)
t.add('python')#增加一个元素，把python看作一个元素，放进集合不拆开
print(t)
t.update({10,20,30})#增加集合，乱序
print(t)
t.update([40,50,60])#增加列表，乱序显示
print(t)
t.update((70,80,90))#增加元组
print(t)
t.update('world')#增加字符串，拆开后乱序增加
print(t)
'''输出结果为：
{32, 3, 21, 54, 23}
{32, 3, 100, 21, 54, 23}
{32, 3, 100, 21, 54, 23, 'python'}
{32, 3, 100, 10, 20, 21, 54, 23, 'python', 30}
{32, 3, 100, 40, 10, 60, 50, 20, 21, 54, 23, 'python', 30}
{32, 3, 100, 70, 40, 10, 60, 80, 50, 20, 21, 54, 23, 90, 'python', 30}
{3, 10, 20, 21, 23, 30, 32, 40, 50, 54, 60, 'python', 'w', 70, 'r', 'o', 80, 'l', 90, 100, 'd'}
'''

2，删除操作

​ 1：remove（）函数，删除指定的元素，如果集合中没有则会报异常

​ 2：discard()函数，删除指定的元素，如果集合中没有不会报异常

​ 3：pop()删除第一个元素,括号里面不能填入东西，也可以说删除随机的元素，因为一开始组成集合的时候是随机排列的，但是一旦生成集合，那么它一般就不会变，然后再用pop()就是删除第一个元素

​ 4：clear()清空列表

print('===================集合的删除操作==================')
s={1,2,3,4,5,6,7,8,}
print(s)
#remove（）函数，删除指定的元素，如果集合中没有则会报异常
#s.remove(9)#错误显示为：  s.remove(9)    KeyError: 9
s.remove(2)
print('删除2'  ,s)
#discard()函数，删除指定的元素，如果集合中没有不会报异常
s.discard(1)
print('删除1',s)
s.discard(1)
print('再删除一次不存在的1',s)
#pop()删除第一个元素,括号里面不能填入东西，也可以说删除随机的元素，
# 因为一开始组成集合的时候是随机排列的，但是一旦生成集合，那么它一般就不会变，
# 然后再用pop()就是删除第一个元素
s.pop()
print(s)
s.pop()
print(s)
s.pop()
print(s)
#清空集合
s.clear()
print(s)
'''显示结果
===================集合的删除操作==================
{1, 2, 3, 4, 5, 6, 7, 8}
删除2 {1, 3, 4, 5, 6, 7, 8}
删除1 {3, 4, 5, 6, 7, 8}
再删除一次不存在的1 {3, 4, 5, 6, 7, 8}
{4, 5, 6, 7, 8}
{5, 6, 7, 8}
{6, 7, 8}
set()
'''

集合间的关系

1， s1.issubset(s5):翻译为：s1是不是s5的子集，如果是，输出结果为True

2，s1.issuperset(s5)：翻译为：s1是不是s5的超集，即父集，如果是，则输出True

3， s2.isdisjoint(s3):翻译为：s2是和s3没有交集如果有交际返回False，没有返回True

print('=====================集合之间的关系===================')
s1={10,20,30}
s5={20,10}
s2={10,20,30,40,50}
s3={100,101}
s4={10,90}

#判断两个集合是否相等
# #与顺序无关，只要集合里面的元素相等，那么就是相等的元素
print(s1==s5)
print(s1!=s5)#s5={20,10}
#判断两个集合是否为子集      s1.issubset(s5):翻译为：s1是不是s5的子集，如果是，输出结果为True
print(s1.issubset(s5))#s1={10,20,30}
print(s5.issubset(s1))#s5={20,10}
print(s1.issubset(s4))#s4={10,90}
#判断两个自己是否为超集      s1.issuperset(s5)：翻译为：s1是不是s5的超集，即父集，如果是，则输出True
print(s1.issuperset(s5))#s5={20,10}
print(s5.issuperset(s1))#s1={10,20,30}
print(s1.issuperset(s4))#s4={10,90}
#判断两个集合是有交集    s2.isdisjoint(s3):翻译为：s2是和s3没有交集如果有交际返回False，没有返回True
print(s2.isdisjoint(s3))#s2={10,20,30,40,50}   s3={100,101}
print(s2.isdisjoint(s1))#s2={10,20,30,40,50}

集合的数学表达：

s1={1,2,3,4}
s2={2,3,4,5}
#两个集合的交集,  s1.intersection(s2):输出s1与s2的交集
print(s1.intersection(s2))
print(s1 & s2)
#两个集合的差集
print(s1.difference(s2))#表示s1减去交集
print(s1-s2)
print(s2.difference(s1))#表示s2减去他俩之间的交集
print(s2-s1)
#两个并集
print(s1.union(s2))
print(s1 | s2)
#两个集合的对等差集：就是两个集合都减去交集，然后再把剩下的部分并在一起
print(s1.symmetric_difference(s2))
print('==================自己瞎编================')
print((s1-s1.intersection(s2)  ) |  ( s2-s2.intersection(s1)))

7：集合的生成式

 #集合生成式
s= {i*i for i  in  range(9) }
print(s)
#列表生成式
l=[ i*i for  i  in  range(9)]
print(l)
#字典打包
t1={'姓名','性别','年龄'}
t2={'毛腾凯','男',19}
t={t1 :t2  for  t1,t2  in zip(t1,t2)}
print(t)

tion(s1)))

# 7：集合的生成式

```python
 #集合生成式
s= {i*i for i  in  range(9) }
print(s)
#列表生成式
l=[ i*i for  i  in  range(9)]
print(l)
#字典打包
t1={'姓名','性别','年龄'}
t2={'毛腾凯','男',19}
t={t1 :t2  for  t1,t2  in zip(t1,t2)}
print(t)