一.元组

1. 什么是元组(tuple)
   元组就是不可变的列表。(有序，不可变)
   有序——可以通过下标获取元素
   不可变——不支持增、删、改
2. 元组的字面量：通过小括号将多个元素括起来，多个元素之间用逗号隔开

tuple1 = (1,True,'abc',[1,'df'],1)
print(tuple1)
#a.只有一个元素的元组：在元素的后面必须加一个逗号
tuple2 = (10,)
print(tuple2,type(tuple2))#(10,) <class 'tuple'>
#b.直接将多个数据用逗号隔开，不用括号括起来。还是一个元组值
tuple3 = 1,2,3,'abc'
print(tuple3,type(tuple3))#(1, 2, 3, 'abc') <class 'tuple'>
#c.获取元组元素
tuple4 = 10,20
print(tuple4[0])#10
#可以通过变量个数和元组元素个数保持一致来获取元组中的每个元素
x,y = tuple4 #x,y = 10,20
print(x,y)#10,20
#通过在变量名前加*，获取没有*的变量获取到的元素的剩下的部分。以列表的形式返回
tuple5 = ('ddf',98,90,99,87,78)
name, *scores = tuple5
print(name,scores)#ddf [98, 90, 99, 87, 78]

name,number,*scores = tuple5
print(name,number,scores)#ddf 98 [90, 99, 87, 78]

*list1,num = tuple5
print(list1,num)#['ddf', 98, 90, 99, 87] 78

num1,*list1,num2 = tuple5
print(num1,list1,num2)#ddf [98, 90, 99, 87] 78

#了解
tuple1 = (1,2,3)
print(*tuple1)#1 2 3
list1 = ('aa','bb','cc')
# a = list1[0]
# b = list1[1]
# c = list1[2]
# *list1 ==a b c
print(*list1)#aa bb cc

3. 获取元组元素和列表获取列表元素一摸一样

tuple1 = 1,2,3,4,5
print(tuple1[1])#2
print(tuple1[:3])#(1,2,3)
for item in tuple1:
    print(item)#

4. 相关运算的列表一样
   +,*,in/not in,len(),tuple(),max(),min()

print((1,2)+('a','n'))#(1,2,'a','n')
print((1,2)*3)#(1, 2, 1, 2, 1, 2)
print(1 in (1,2))#True
print(len((1,2,4)))#3
print(max((1,89,0)))#89
print(min((1,89,0)))#0

5. 元组相关的方法:只有列表中的count和index

二.字典

1. 什么是字典(dict)
   字典是python中内置的容器类的数据类型，可变，无序的。字典的元素是键值对
2. 字典的字面量：使用大括号括起来，大括号里面是键值对，多个键值对之间用逗号隔开
   键值对——键:值
   键(key)——不可变的；唯一的(一般使用字符串作为key)
   值(value)——任何类型的数据

import random
n = random.randint(1,10)
dict1 = {'aa':n,10:'abc',(10,20):'hello'}
print(dict1)#{'aa': 8, 10: 'abc', (10, 20): 'hello'}
#列表不能作为key
#dict2 = {[1,2]:100}#TypeError: unhashable type: 'list'

#key是唯一的
dict2 = {'aa':100,'aa':200,'bb':300}
print(dict2)#{'aa': 200, 'bb': 300}#如果key重复存最后一个

3. 什么时候使用字典
   如果一个容器里面存储的数据是不同意义的数据(数据之间需要区分)，就使用字典

#用一个变量来存储一个学生的信息：姓名、年龄、电话、成绩、学号
student = ['小明',18,'18098898881',30,'1982001']
student = {'name':'小明','age':28,'tel':'18098898881','score':30,'学号':'1982001'}
print(student['name'])#小明

4. 字典的增删改查
   1.查(获取字典的值)
   a.获取单个值
   字典[key] - 获取字典中key对应的值 (注意：如果key不存在，会报错:KeyError)
   字典.get(key) - 获取字典中key对应的值 (如果key不存在，不会报错，并且会返回一个默认值None)
   None是python中的关键字，表示一个特殊值，(没有、空的意思)

dog1 = {'name':'旺财','age':3,'color':'黄色','type':'土狗'}
print(dog1['name'])#旺财
print(dog1['color'])#黄色
# print(dog1['sex'])#KeyError: 'sex'

print(dog1.get('age'))#3
print(dog1.get('type'))#土狗
print(dog1.get('sex'))#None

b.遍历

#直接遍历字典拿到的是字典中所有的key
for key in dog1:
    print(key,dog1[key],dog1.get(key))
print('=============')

#同时获取key和value(看着方便但是性能差，内存消耗多)
print(dog1.items())
for key,value in dog1.items():
    print(key,value)

2.增(添加键值对)
字典[key] = 值——当key不存在的时候，就是在字典中添加键值对

dict1 = {'a':100}
dict1['b'] = 200
print(dict1)#{'a': 100, 'b': 200}

字典1.update(序列)——将序列中的元素转换成键值对，然后在添加到字典1中
注意：在这儿的序列要求是能够转换成字典的序列。序列中的元素是只有两个元素的小序列

dict1 = {'a': 100, 'b': 200}
#当key值有重名的时候，会用序列中键值对的值，更新原字典的key对应的值
dict1.update({'aa':10,'bb':20,'a':'abc'})
print(dict1)#{'a': 'abc', 'b': 200, 'aa': 10, 'bb': 20}

dict1.update([[1,2],['a',2],[2,'b']])
print(dict1)#{'a': 2, 'b': 200, 'aa': 10, 'bb': 20, 1: 2, 2: 'b'}

dict1.update([('aaa',100),[12,200]])
print(dict1)#{'a': 2, 'b': 200, 'aa': 10, 'bb': 20, 1: 2, 2: 'b', 'aaa': 100, 12: 200}

3.改(修改key对应的值)
字典[key] = 值——当key存在的时候，就是修改key对应的值

dict1 = {'a':10,'b':20}
dict1['a'] = 100
print(dict1)#{'a': 100, 'b': 20}

4.删(删除键值对)
a.del 字典[key]——删除字典中key对应的键对

person = {'name':'张三','age':30,'sex':'man'}
del person['sex']
print(person)#{'name': '张三', 'age': 30}

b.字典.pop(key)——取出字典中key对应的值(删除整个键值对)

person = {'name':'张三','age':30,'sex':'man'}
age = person.pop('age')
print(person,age)#{'name': '张三', 'sex': 'man'} 30

#删除最后一个键值对(取出最后一个键值对,以元组的形式返回）
person = {'name':'张三','age':30,'sex':'man'}
value = person.popitem()
print(person,value)

5. 字典相关的运算和方法

字典不支持+和*

1. in 和 not in
   key in 字典——判断字典中是否存在指定的key
2. clear
   字典.clear()——清空字典(删除字典中所有的键值对)

dict1 = {'a': 100, 'b': 200}
dict1.clear()
print(dict1)#{}

3. copy
   字典.copy() - 复制字典中所有的键值对，产生一个新的字典

dict1 = {'a': 100, 'b': 200}
dict2 = dict1.copy()   # 这儿会产生新的地址
print(dict2)#{'a': 100, 'b': 200}
dict1['a'] = 1
print(dict2)#{'a': 100, 'b': 200}

4. fromkeys
   字典.fromkeys(序列, 值) - 以序列中的元素作为key，值作为所有key对应的默认值，创建一个字典

dict3 = dict.fromkeys('xyzp', 100)
print(dict3)   # {'x': 100, 'y': 100, 'z': 100, 'p': 100}
dict3 = dict.fromkeys(['name', 'age', 'height'], 100)
print(dict3)    # {'name': 100, 'age': 100, 'height': 100}

5. get
   字典.get(key) - 获取key对应的值，如果key不存在，返回None
   字典.get(key,值) - 获取key对应的值，如果key不存在，返回指定的值

dict3 = {'name': 100, 'age': 100, 'height': 100}
print(dict3.get('name'))   # 100
print(dict3.get('name', '不存在'))   # 100
print(dict3.get('name1'))       # None
print(dict3.get('name1', '不存在'))    # 不存在

6. keys, values, items
   字典.keys() - 获取字典所有的key(返回一个序列，序列中的元素就是字典的key)
   字典.values() - 获取字典所有的值(返回一个序列，序列中的元素就是字典的value)
   字典.items() - 获取字典所有的键值对(返回一个序列，序列中的元素是元祖，元祖中元素有两个分别是key和value)

dict4 = {'x':23,'y':89,'z':234,'p':100}
keys = dict4.keys()
print(keys,type(keys))#dict_keys(['x', 'y', 'z', 'p']) <class 'dict_keys'>#返回值是序列，但是不是列表
for item in keys:
    print(item,type(item))
#获取所有的值
print(dict4.values())#dict_values([23, 89, 234, 100])
print(list(dict4.values()))#将value转换为列表输出#[23, 89, 234, 100]
print(dict4.items(),type(dict4))

7. setdefault
   字典.setdefault(key,value)——给字典添加键值对(注意：如果key本来就存在，不会修改这个key的值——对原字典没有影响)

dict4 = {'x':23,'y':89,'z':234,'p':100}
dict4.setdefault('xx','abc')
print(dict4)#{'x': 23, 'y': 89, 'z': 234, 'p': 100, 'xx': 'abc'}
dict4.setdefault('y',200)
print(dict4)#{'x': 23, 'y': 89, 'z': 234, 'p': 100, 'xx': 'abc'}