Python学习记录6元组集合

元组和集合

元组

元组是Python内置数据结构之一，是一个不可变序列。
不可变序列：字符串，元组
不可变序列没有增，删，改操作

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

l=[10,20,30]
print(id(l))
l.append(100)
print(id(l))#增加新元素前后，列表id没有变化化是可变序列
######################################################### 
n='hello'
print(id(n))
n+='name'
print(id(n))#发现两次id不一样说明id改变，索引是不可变序列
print(n)

元组的创建方式
直接小括号：
t=(‘python’,‘hello’,‘home’,30)
使用内置函数tuple():
t=tuple((‘python’,‘hello’,‘home’,30))
只包含一个元组的元素只需要使用小括号和逗号。
t=(10,)

t=('python',98,10,'home')#元组的创建用小括号
print(t)
print(type(t))
t1='python',90,20,'home'#用这种方法小括号可以省略
print(t1)
print(type(t1))

t3=('jack',)#当只有一个元组的元素，必须有"“()”"和","才是元组
print(type(t3))

t2=tuple(('python',20,30,'work'))
print(t2)
print(type(t2))

#空元祖
t=()
t1=tuple()
print(t,t1)

元组为啥是不可变序列
在多任务情况下，同事操作对象时不需要加锁。所以在程序中尽量使用不可变序列。
注意：元组中存储的是对象的引用
如果元组中对象本身不可对象，则不可再引用其他对象。
如果元组中对象时可变对象，可变对象的引用不可改变，但数据可变。

t=('work',[10,20],30)
print(t)
print(type(t))#这是元组
#元组里每个元素是什么，类型
print(t[0],type(t[0]))#这是str类型
print(t[1],type(t[1]))#这是list类型
print(t[2],type(t[2]))#这是int类型

t[1].append(100)#我们在元组里的列表里增加元素，不可以在元组里更改
print(t)

可以对元组里元素进行修改，而不能修改元组。如上元组里的列表，在列表增加一个元素，不是在元组里。

元组的遍历
元组是可迭代对象用for in 进行遍历。

t=('work',[10,20],30)
for i in t:
    print(i)

集合

Python中内置的数据结构。
与列表，字典一样是可变类型的序列。
集合是没有value的字典。

创建方式
用{}进行创建。
使用内置函数set进行创建。

s={1,2,3,4,5,5,6,6,7}#生成集合，集合不能有重复，所以输出是重复的就会输出一个
print(s)
#集合是无序的
print(set(range(1,6,2)))#把整数转化成集合
print(set([1,2,3,4]))#把列表转化成集合
print(set((1,2,3)))#把元组转化成集合
print(set('python'))#吧字符串转化成集合
print(set({1,2,3,55,55,6}))#集合转化成集合
print(set())#空集合若用{}type就是dict字典了

集合是无序的。

集合的判断操作
in或not in

#判断元素是否在集合里
j={10,20,30,6,50,66}
print(10 in j)
print(10 not in j)
print(100 not in j)
print(100 not in j)

集合元素的新增操作
调用add()方法，一次添加一个元素。
调用updata()方法，至少添加一个元素。

j={10,20,30,6,50,66}
j.add(100)#一次添加一个元素
print(j)
#一次至少添加一个
j.update({666,888,90})#可以放集合
j.update((22,36,63))#可以放元组
j.update([98,87,54])#可以放列表
print(j)#把里面的每一个元素添加到集合里

集合元素的删除操作
调用remove()方法，一次删除一个指定元素，如果指定元素不存在，则抛出KeyError。
调用discard()方法，一次删除一个指定元素，如果指定元素不存在，不抛出异常。
调用pop()方法，异常删除任意一个元素。
待遇clear()方法，清空整个集合。

#集合元素的删除
j.remove(100)
print(j)
#j.remove(1000)删除一个集合里没有的元素会异常
j.discard(1000)#用这个方法删除集合了没有的元素不会异常
j.discard(36)
print(j)
j.pop()#删除集合里的任意一个元素，刷了谁不知道，不能指定添加参数
print(j)
j.pop()
print(j)
j.clear()#清空了集合所有元素
print(j)

集合间的关系
1.两个集合是否相等可以用运算符==和!=进行判断。
2.一个集合是否是另一个集合的子集
可以调用issubset进行判断。
B是A的子集。
3.一个集合是否是另一个集合的超集。
可以调用issuperset进行判断。
A是B的超集。
4.两个集合是否没有交集
可以调用isdisjonint进行判断。

j={10,20,30}
j1={20,10,30}
print(j==j1)#True，j等于j1是对的
print(j!=j1)#Falsej不等于j1是错的

i={10,20,30,40,60,90}
i1={20,90,60}
i2={10,50,30}
print(i1.issubset(i))#True，i1是i的子集
print(i2.issubset(i))#False,i2不是i的子集

print(i.issuperset(i1))#i是i1的超集
print(i.issuperset(i2))#i不是i2的超集

print(i1.isdisjoint(i2))#Truei1和i2没有交集
print(i1.isdisjoint(i))#Falsei1和i有交集

集合的数学操作

s={10,20,60,80,90,70,50,30}
s1={60,80,100,70,50}
print(s.intersection(s1))#s和s1的交集
print(s & s1)#交集intersection与&是等价的

print(s.union(s1))#并集
print(s | s1)#union与|这个符号相等

print(s.difference(s1))#差集
print(s-s1)#差集就集合做差用减号-

print(s.symmetric_difference(s1))#对称差集
print(s ^ s1)#对称差集符号 ^

做集合运算原集合不变的。

集合生成式
生成集合的公式;

如果把{}改成[]就是列表生成式。
没有元组生成式。

s=[i*i for i in range(11)]#列表生成式
print(s)
#我们把【】改成{}便是集合生成式
a={i*i for i in range(11)}
print(a)

**

总结

**