元组，字典

元组
元组定义)小括号
类型:tuple
元组是不可变的(定义好元组后不能够直接去修改元组中元素)

元组中的元素只有1个的时候，一定要在后面加上一个逗号,如果不加原始元素
是什么类型打印出来它就是什么类型
t1=(1)
print(type(t1))#

t2=(1,)#在元素后加逗号
print(type(t2))#

#不能直接进行增删改
t=(1,2,3,4,5,6)#定义元组
print(type(t))#
t.pop
print(t)#抛异常

#往元组中添加元素
t=(1,2,3,4,5,6)#定义元组
print(type(t))#
t1=list(t)#通过list把元组转换为列表
print(type(t1))#
print(t1)#[1, 2, 3, 4, 5, 6]
t1.append(7)#往列表中插入元素
print(t1)#[1, 2, 3, 4, 5, 6, 7]
t2=tuple(t1)#把列表转换为元组
print(type(t2))#
print(t2)#(1, 2, 3, 4, 5, 6, 7)


元组和列表的区别？
1.类型不同 list、tuple
2.定义不同 列表通过[ ]定义,元组通过()定义
3.列表定义后是可以随意的增删改(元素不受保护)
4.元组定义后是不可以随意的增删改(元素受保护)

#字符串转元组
a='hello'#定义字符串
a1=tuple(a)
print(a1)#('h', 'e', 'l', 'l', 'o')

#元组转换字符串
t=(1,2,3,4,5,6)#定义元组
t1=t.__str__()
print(type(t1))#
print(t1)#(1, 2, 3, 4, 5, 6)

元组也是支持切片操作
t=(1,2,3,4,5,6)#定义元组
print(t[4])#5

字典
定义:{}花括号(大括号)
类型：dict
字典中：键值对，键是唯一值可以不唯一
键和值有冒号分割;
键值对之间用逗号分割

d={}#定义空字典
print(type(d))#

d1={'name':'zhangsan'}#定义字典,里面有一个键值对
print(d1)#{'name': 'zhangsan'}

d2={'name':''}#定义字典,字典中没有值一定要加上引号，否则会抛异常
print(d2)#{'name': ''}

d1={'name':'zhangsan','age':18}#定义字典,多个键值对用逗号分隔

# t=('a',1)#定义元组
# print(type(t))#
# d=dict(t)#转换为字典
# print(type(d))#不能转换字典

t1=[('a',1)]#定义列表
print(type(t1))#
d=dict(t1)#转换为字典
print(type(d))#
print(d)#{'a': 1}


d1={'name':'zhangsan','age':18}#定义字典
#原字典中没有相同的键,则会将键值添加到字典中
d1['score']=100 #设置键值对
print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d2={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
#原字典中有此键,会执行替换
d2['score']=90#设置键值对
print(d2)#{'name': 'zhangsan', 'age': 18, 'score': 90}


#键 keys
d2={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
k=d2.keys()#取出当前字典中的所有键
print(k)#dict_keys(['name', 'age', 'score'])

#值 values
d3={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
v=d3.values()#取出当前字典中所有的值
print(v)#dict_values(['zhangsan', 18, 100])

#取指定键的值
d3={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
value=d3['name']#获取name这个键对应的值
print(value)#zhangsan

#设置键值对
注：此方法执行后会进行判断，如果发现字典中没有此键则会把键值对设置到字典中；
如果原字典中有此键则不会执行替换
3={'name': 'zhangsan', 'age': 18}#定义字典
d3.setdefault('score',100)#添加键值对
print(d3)#{'name': 'zhangsan', 'age': 18, 'score': 100}

d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d4.setdefault('score',93)#添加键值对
print(d4)#{'name': 'zhangsan', 'age': 18, 'score': 100}

#删除字典
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
del d4#删除整个字典
print(d4)#抛异常，因为字典已被删除

#删除指定键及值
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
del d4['score']#删除键和对应的值
print(d4)#{'name': 'zhangsan', 'age': 18}

字典遍历 for 变量名 in 字典名
当前变量获取到的值为键，值不显示
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for i in d4:
    print(i)#name age score

#获取值
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for i in d4:
    #print(i)
    print(d4)#zhangsan 18 100


d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for i in d4:
    #print(i)
    print(i,d4)

通过items 函数实现变量获取键值对
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
for k,v in d4.items():
    print(k,v)

d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d5=d4.pop('score')#删除score这个键，返回对应键的值
print(d5)#100

#清空字典
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
d4.clear()#把字典中的所有键值清除掉
print(d4)#{}  空字典

获取指定键的值
如果没有指定的键则返回none
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
a=d4.get('name')#获取name这个键对应的值
print(a)#zhangsan
print(d4.get('name'))#zhangsan
print(d4.get('a'))#None

给键指定值
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
#不指定值
print({}.fromkeys(['name','age']))#{'name': None, 'age': None}
#指定值
print({}.fromkeys(['name','age'],'dcs'))#{'name': 'dcs', 'age': 'dcs'}

python2 has_key 函数检查字典是否有指定的键存在
python3 __contains__ 函数检查字典是否有指定的键存在
有存在返回true 反之返回false

d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
print(d4.__contains__("name"))#True
print(d4.__contains__('na'))#False

删除字典中的键值对,并返回删除的数据(默认删除末尾)
d4={'name': 'zhangsan', 'age': 18, 'score': 100}#定义字典
print(d4.popitem())#('score', 100)
print(d4.popitem())#('age', 18)

更新把两个字典拼接形成新的字典
d1={'name': 'zhangsan', 'age': 18}#定义字典
d2={'score': 100}#定义字典
d1.update(d2)
print(d1)#{'name': 'zhangsan', 'age': 18, 'score': 100}

#存在相同的键，则执行替换
d3={'name': 'zhangsan', 'age': 18,'score': 90}#定义字典
d4={'score': 100}#定义字典
d3.update(d4)
print(d3)#{'name': 'zhangsan', 'age': 18, 'score': 100}

把两个列表设置为字典
a=['a','b','c']#定义列表
c=[1,2,3]#定义列表
l=zip(a,c)#把列表拼接形成多个元组，索引值相同的为一个整体如('a',1)
d=dict(l)#转换为字典
print(d)#{'a': 1, 'b': 2, 'c': 3}
print(type(d))#


集合
可变集合：set
不可变集合:frozenset

区别点：
相同点都能够去重
不同点：
可变集合去重后可以实现增删改
不可变集合去重后不可以进行增删改

#可变集合
list1=[1,2,3,4,1]#定义列表
a=set(list1)#可变集合去重
print(a)#{1, 2, 3, 4}
a.add('zhangsan')#添加元素
print(a)#{'zhangsan', 1, 2, 3, 4}


#不可变集合
list1=[1,2,3,4,1]#定义列表
a=frozenset(list1)#不可变集合去重
print(a)#frozenset({1, 2, 3, 4})
a.add #无法调用