元组：元组就是一个不可变的列表

1、用途：当我们需要记录多个同种属性的值，并且只有读的需求，没有改的需求，应该用元组。

2、定义方式：在（）内用逗号分隔开多个任意类型的元素

t=（‘egon’）#注意：当元组内只有一个元素时，必须加逗号，t=tuple(('egon)),

print(t,type(t））

print（t[0]）

数据类型转换：

t=tuple('hello')

print(t,type(t））

常用操作+内置方法

3.1优先掌握的操作

1、按索引取值（正向取+反向取 ）：只能取

t=（‘ａ’，＇ｂ＇，＇ｃ＇）

ｔ［0］＝＇Ａ＇

2　切片，（顾头不顾尾，步长）

ｔ＝（＇ａ＇，＇ｂ＇，＇ｃ＇）

ｐｒｉｎｔ＝（ｔ［0：2］）

3长度

ｐｒｉｎｔ（ｌｅｎ（ｔ））

4成员运算ｉｎ　和　not in

t=('a','b','c','d')

print('a' in t)

5循环

t=('a','b','c','d')

for item in t:

print(item)

3.2需要掌握的操作

t=('a','b','c','d'，（1,2,3）)

print（t.count('b'）数B的数量

print（t.index('b',2,4）在2和4之间查找‘b’的索引

总结：

可以存多个值

有序

不可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，id就变。不可变==可hash）

0    1             2

t=(1,'a',['m'n])

print(id(t[0]),id(t[1]),id(t[2]))

t[2][0]='m'

print(id(t[0]),id(t[1]),id(t[2]))

t[2]的内存地址没有改变所以元组的内存地址不变=========================================================================

集合类型

一：引入
# pythons=['李铁蛋','张全蛋','王铜蛋','赵银蛋','oldboy','艾利克斯']
# linuxs=['kevin','egon','tank','艾利克斯','王铜蛋']
#
# l=[]
#
# for item in pythons:
#     if item in linuxs:
#         l.append(item)
#
# print(l)
二、集合（set）
1、用途：
1.1做关系运算
1.2去重
2、定义方式：在{}内用逗号分隔开多个元素，多个元素必须满足以下条件
2.1每个元素必须是不可变类型
2.2集合内元素不能重复
2.3集合无序
s={1,1.1,'aaa',1,1,1,1}
print(s,type(s))
注意点：
d={}#默认定义为字典
print(type(d))
s=set()
print(s,type(s))

数据类型转换

s=set('hello')

print(s)

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

pythons={'李铁蛋’，‘张全蛋’，‘王银蛋’，‘oldboy’，‘艾利克斯’

linuxs={'kevin','egon','tank','艾利克斯’，‘王铜蛋 ’}

#

求刚报名pythons课又报名linuxs课时的学员：交集

res=pythons&linuxs

print(res)

res1=pythons.intersection(linuxs)

print(res1)

求所有的学员姓名：并集

res=pythons-linuxs

print(res)

print(pythons.difference(linuxs))

res=linuxs-pythons

print(res)

求没有同时报名两门课程的学员：对称差集

res=pythons^linuxs

print(res)

print(pythons.symmertrip_difference(linuxs))

父集/子集;

包含与被包含关系：

 

s1={1,2,3}

s2={3,1,2}

print(s1==s2)

s1={1,2,3}

s2={3,1,2}

print(s1>=s2)

print(s1.issuperset(s2))

print(s2<=s1)

print(s2.issuperset(s))

长度len

print(3 in s1)

成员运算in和not in

掌握的操作

1,s1={'a','b','cc','2','3'}

print(id(s1))

2,s1.update({3,4,5}）

print(s1,id(s1))

3,s1.add(4)

print(s1)

4,res=s1.pop()

print(res)

5,res=s1.remove('b')

print(s1)

print(res）

6,s1={1,2,3}

s2={1,2,3}

s1.difference_update(s2)#s1=s1-s2

print(s1)

s1.intersection_update(s2)#s1=s1&s2

print(s1)

s1.symmetric_difference_update(s2)#s1=s1^s2

print(s1)

'''

s1={1,2,3}

s1.remove(4)

s1.discard(3)

print(res)#None

'''

'''s1={1,2,3}

s2={4,5,6}

print (s1.isdisjoint(s2))

'''

类型总结

1，可以存多个值

2，无序

3，set可变类型

4，去重

name=['egon','egon','keven','keven','alex'，'alex']

方法：

l=[]

for name in names:

    if name not in l ；

        l.append(name)

print(l）

2，如果去重的对象都是不可变类型并且不要求结果跟原来的顺序一致，那么就用set解决

# res=set(names)
# # print(res)
# l=list(res)
# print(l)

info=[
    {'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'},
]
l=[]
for dic in info:
    if dic not in l:
        l.append(dic)
print(l)

字典类型：

# ======================================基本使用======================================

1、用途：记录多个不同属性的值

2、定义方式：在{}内用逗号分隔开多个元素，每一个元素都是key:value的形式，其中value可以是任意类型，Key必须是不可变类型（通常应该str类型）

dic={1:'aaa',1.3:'bbc',(1,2,3):'ccc','xxx':'ddd'}#dic=dict()

dic={'x':1'x':'2','x':3}

print(dic)

数据类型转换：dict

li=(['name','egon'],('age',18),('gender','male')

dic={}

for k,v in li:

dic[k]=v

dic=dict(li)

dic=dict(x=1,y=2,z=3)

print(dic)

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

3.1、优先掌握的操作

1、按key存取值：可存可取

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

print(dic['name'])

print(id(dic))

dic['name']=EGON

print(dic,id(dic))

dic['height']=1.81#/如果key不存在新增一组key:value

print(dic)

l=['a']

l[1]='b'

2、长度len

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

print(len(dic))

3、成员运算in 和not in

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

print('name' in dic)

4、删除

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

del dic['name']  删除的通用操作，拿到的返回值为None

print(dic)

t=dic.popitem()  无序删除，可以拿到返回值

print(t,type(t))

v=dic.pop('name') 可以指定删除数据，根据key来删除

print（v）

5、键keys(),值value(),键值对items()

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

keys=dic.keys()

print=(keys)

取到的值：['gender','name','age']

values=dic.values()

print(values)

取到的值：['male','eon',18]

items=dic.items()

print(items)

取到的值：[('gender','male'),('age',18),('name','egon')]

print(list(keys))

print(list(values))

print(list(items))

5、循环

for k in dic.keys():

print(k)

for k in dic:

print(k)

for k,v in dic.items():

print(k,v)

for v in dic.values():

print(v)

7、get 取值:值存在，则取值，值不存在，则返回None

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

if 'xxx' in dic:

print(dic['xxx'])

else:

print(None)

v=dic.get('age')

print(v)

3.2需要掌握的操作

dic.fromkeys()   给一个列表附上空值。

li=['name','age','gender']

dic={}

for k in li :

dic[k]=None

print(dic)

dic={}.fromkeys(li,None)

print（dic）

dic.update() 更新功能：如果原字典存在则替换，如果原字典不存在则新增

old_dic={'name':'egon','age':18,'gender':'male'}

new_dic={'x'=1,'name':'EGON'}

old_dic.update.(new_dic)

print(old_dic)

dic.setdefault(k,v):执行完毕后是为了保证字典中必须有这么一个k

dic={'name':'egon','age'：18，‘gender’:'male'}

v=dic.setdefault('helght',1.81)字典中没有‘height’这个键，则新增

print（dic）

print（v）

v=dic.setdefault('name','EGON')字典中有‘name’这个键，则新增

print（dic）

print（v）

v=dic.setdefault('name','EGON')#字典中有‘name’这个键，不修改字典

print(dic)

print(v) 拿到的是字典里原有的‘egon’

#setdefault 的原理分析：

k='name'

v='EGON'

if k not in dic:

dic[k]=v

print(dic)

======================================该类型总结====================================

存多个值

无序

可变（1、可变：值变，id不变。可变==不可hash 2、不可变：值变，ID就变，不可变==可hash）