python全栈开发day06元组、字典、集合

元组类型

一：基本使用：tuple

1. 用途：记录多个值，当多个值没有改的需求，此时用元组更合适
2. 定义方式：在()内用逗号分隔开多个任意类型的值
3. 常用操作+内置方法

优先掌握的方法
1. 按索引取值(正向取+反向取)：只能取

t=('egon',123,['a','b'])
 print(id(t[0]))
 print(id(t[1]))
 print(id(t[2]))
print(id(t))
t[2][0]='A'      #元组内存放的是单个变量的内存地址
print(t)
print(id(t))
print('='*50)
print(id(t[0]))
print(id(t[1]))
print(id(t[2]))
# t[0]='EGON'

# t[2]='xxxx'
# t[2][0]='A'
# print(t)

2、切片(顾头不顾尾，步长)

t=(1,2,3,4,5)
print(t[0:3])
print(t)

3.长度：和列表相同

4.成员运算in和not in：和列表相同

5.循环

for item in ('a','b','c'):
    print(item)

• 需要掌握的操作*

t=('a','b','c','a')
print(t.count('a'))        #变量‘a’出现的数量
print(t.index('a',1,10))         #查找‘a’的位置
print(t.index('xxx',1,10))        #没有回报错

二：该类型总结

1. 存多个值
2. 有序
3. 不可变

补充元组符号

t=(1,)        #单个变量组成的元组，必须在变量后面加个",“（逗号）
print(t,type(t))     

字典类型

一：基本使用dict

1. 用途：记录多个值，每一个值都对应的key用来描述value的作用
2. 定义方式：在{}内用逗号分隔开多 个key:value，其中value可以是任意类型，而key必须是不可变的类型，通常情况下应该str类型

dic={0:'aaa',1:'bbb',2:'cccc'} #dic=dict({0:'aaa',1:'bbb',2:'cccc'})
print(dic,type(dic))
print(dic[0])

dic={[1,2]:'aaa'}      #key必须是不可变得变量
dic={(1,2):'aaa'}
print(dic[(1,2)])


#用法一：
dic=dict(x=1,y=2,z=3)  #用dict工场函数创建一个字典
print(dic)

#用法二：
userinfo=[
    ['name','egon'],
    ['age',18],
    ['sex','male']
]
d={}
for k,v in userinfo: #k,v=['name', 'egon']
    # print(k,v)
    d[k]=v
print(d)

d=dict(userinfo)    #把规律的列表转换为字典和上面的方法效果一样
print(d)

3. 常用操作+内置的方法

优先掌握的操作
1、按key存取值：可存可取

dic={'name':'egon'}
print(dic['name'])
dic['name']='EGON'   #根据key修改值
print(dic)
dic['age']=18
print(dic)

l=['a','b']
l[0]='A'
l[2]='c'

2、长度len（可以说是key的长度，也可以说是值得长度）

dic={'name':'egon','age':18,'name':'EGON','name':'XXXX'}
print(dic)
print(len(dic))

3、成员运算in和not in:字典的成员运算判断的是key

dic={'name':'egon','age':18,}
print(18 in dic)
print('age' in dic)

4、删除

# 通用
del dic['name']
print(dic)
del dic['xxx'] ##key不存在则报错


res=dic.pop('age') #删除key对应的value,并返回value
print(dic)
print(res) #
dic.pop('xxx') #key不存在则报错

res=dic.popitem()     #删除返回值是键值对
print(dic)
print(res)

5、键keys()，值values()，键值对items()

dic={'name':'egon','age':18,}
print(dic.keys())       #keys返回值是key
l=[]
for k in dic.keys():
    l.append(k)
print(l)
print(list(dic.keys()))

print(dic.values())        #返回值是value
print(list(dic.values()))
print(dic.items())        #返回值是item键值对
print(list(dic.items()))

6、循环

dic={'name':'egon','age':18,'sex':'male'}

for k in dic.keys():
    print(k,dic[k])

for k in dic:
    print(k,dic[k])

for v in dic.values():
    print(v)

for k,v in dic.items():
    print(k,v)

#8.dic.get()

dic={'name':'egon','age':18,'sex':'male'}

v=dic.get('name')     #和v=dic['name']相同
print(v)
#和v=dic['xxx']不同：当这个key在字典中不存在时不会报错，返回值为None
v=dic.get('xxx')      
print(v)
      

需要掌握的操作
dic.fromkeys()的用法:

l=['name','age','sex']
#dic={'name':None,'age':None,'sex':None}
dic={}
for k in l:
    dic[k]=None
print(dic)          #新建一个for循环的方式用l中的值当key，valnes为None

dic=dic.fromkeys(l,None)  #用fromkeys方法实现
print(dic)

update方法：

#用把新的字典添加到旧的字典中
old_dic={'name':'egon','age':18,'sex':'male'}
new_dic={'name':'EGON','x':1,'y':2}
old_dic.update(new_dic)      #如果旧字典中有则更改成新字典中的值，就字典中没有的就添加一个
print(old_dic)

setdefault:有则不动/返回原值,无则添加/返回新值

dic={'name':'egon','age':18}
res=dic.setdefault('name','EGON') # 字典中已经存在key则不修改,返回已经存在的key对应的value
print(dic)
print(res)

res=dic.setdefault('sex','male') # 字典不存在key则添加"sex":"male",返回新的value
print(dic)
print(res)

二：该类型总结

1. 存多个值
2. 无序
3. 可变

dic={'x':1}
print(id(dic))
dic['x']=2
print(id(dic))

集合类型

1. 什么是集合
   在{}内用逗号分隔开多个值,集合的特点:
   1. 每个值必须是不可变类型
   2. 集合无序
   3. 集合内元素不能重复

2. 为何要用集合

   1. 用于做关系运算
   2. 去重

3. 如何用集合

s={1,1.3,'aa',[1,2,]}   #集合中的值必须是不可变类型
s={1,1.3,'aa'}
print(s)

s={1,1,1,1,1,1,1,2} #s=set(....)
print(type(s))
print(s)          #集合中不能存在相同的值，它可以去重
d={'x':1,'x':2,'x':3}
print(d)

res=set('hello')     #字符串转换为元组
res=set([1,2,['a','b']])      #会报错，不能转换，因为元组中不能存在可变的值
print(res)

集合的第一大用途: 关系运算

# 1 求同时报名两门课程的学生姓名:交集
print(pythons & linuxs)      #符号方法
print(pythons.intersection(linuxs))   #intersection方法

pythons=pythons & linuxs
print(pythons) #{'李铜蛋', '艾里克斯'}
pythons.intersection_update(linuxs) #pythons=pythons.intersection(linuxs)
print(pythons) #{'艾里克斯', '李铜蛋'}


# 2 求报名老男孩学校课程的所有学生姓名:并集
print(pythons | linuxs)   #符号方法
print(pythons.union(linuxs))   #union方法

# 3 求只报名python课程的学生姓名: 差集
print(pythons - linuxs)     #符号方法 
print(pythons.difference(linuxs))    #difference方法
print(linuxs - pythons) #求只报名linux课程的学生姓名
print(linuxs.difference(pythons))

# 4 求没有同时报名两门课程的学生姓名: 对称差集
print((pythons - linuxs) | (linuxs - pythons))
print(pythons ^ linuxs)      #^符号是对称差集
print(pythons.symmetric_difference(linuxs))     #symmetric_difference方法

# 5 父子集:指的是一种包含与被包含的关系
s1={1,2,3}
s2={1,2}
print(s1 >= s2)     #符号
print(s1.issuperset(s2))   #ssuperset方法
print(s2.issubset(s1))

#情况一:
print(s1 > s2) #>号代表s1是包含s2的,称之为s1为s2的父集
print(s2 < s1)
#情况二:
s1={1,2,3}
s2={1,2,3}
print(s1 == s2) #s1如果等于s2,也可以称为s1是s2的父集合

#综上:
s1 >= s2 就可以称为s1是s2的父集

s5={1,2,3}
s6={1,2,3}
print(s5 >= s6)
print(s6 >= s5)

集合的第二大用途:去重

# 集合的第二大用途:去重
stus=['egon','lxx','lxx','alex','alex','yxx']
new_l=list(set(stus))
print(new_l)        #列表转换成集合，集合在转换成列表

# 集合去重的局限性:
# 1. 会打乱原值的顺序
# 2. 只能针对不可变的值去重

#for循环完成可变值得去重
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
    if dic not in new_l:
        new_l.append(dic)
print(new_l)

需要掌握的操作:

s1={1,2,3}
s1.update({3,4,5})       #update方法 合并
print(s1)
print(s1.pop())    #pop删除，无参数，随机删除
print(s1)

s1.remove(2)     #remove删除，有参数，删除2
print(s1)

s1={1,2,3}
print(id(s1))
s1.add(4)     #add添加
print(s1)
print(id(s1))

s1={1,2,3}
s1.discard(4)   #删除，当集合中没有要删除的值时，不会报错，依然返回原集合
s1.remove(4)
print(s1)

s1={1,2,3}
s2={4,5}
print(s1.isdisjoint(s2))   #如果两个集合有不交集，返回True

总结

1. 存多个值
2. 无序
3. set可变