一.python元组
定义：元组是不可改变的序列，同list一样，元组是可以存放任意类型的容器
--->实质是一个不可改变的list.
创建空元组：
t = () #t绑定空元组
创建非空元组：
t = 200,
t = (20,)
-------------->用（）括起来，单个元素括起来后加逗号（,），区分单个对象还是元组
t = (1, 2, 3)
t = 100, 200, 300
错误示例：
t = (20) #t绑定整数20，而不是元组
x, y, z = 100, 200, 300 #序列赋值
x, y, z = (100, 200, 300) #序列赋值
x, y, z = [100, 200, 300] #序列赋值
x, y, z = "ABC" #序列赋值
tuple() 生成一个空的元组，等同于()
tuple(iterable) 用可迭代对象生成一个元组
示例：
t = tuple()
t = tuple([1, 2, 3, 4])
t = tuple(range(8))
t = tuple(reversed([1, 2, 3, 4])) #reversed()函数用序列生成一个倒序的可迭代对象
元组的方法：
T.index(v[,begain[,end]]) 返回对应元素的索引下标，begin为开始索引，end为结束索引，V不存在时触发ValueError错误
T.count(x) 返回元组中对应元素的个数
二.序列(sequence)
序列(sequence)的种类：
字符串str,列表list,元组tuple,字节串bytes,字节数组bytearray
能用于序列的函数：
len(seq),max(seq),min(seq),sum(seq),any(seq),all(seq)
str(obj),list(iterable),tuple(iterable),reversed(seq)
----------------------------------------------------->返回可迭代对象
sorted(iterable,reversed=False)
------------------------------->返回列表
三.字典
字典 dict
一种可变的容器，可以存储任意类型的数据；
字典中的每个数据都是用“键”（key）进行索引，而不像序列可以用下标进行索引；
字典中的数据没有先后顺序关系，字典的存储是无序的；
字典中的数据以键（key）-值（value）对的形式进行映射存储（关联关系）
字典的键不能重复，且只能用“不可变类型作为字典的键”。
表示方式：
{} 括起来，以冒号(:)分隔键-值对，各个键-值用逗号分隔开
创建空字典：
d = {} #空字典
创建非空字典：
d = {"name":"Alex","age":12}
d = {1:"星期一",2:"星期二"}
字典的构造（创建）函数:
dict() #创建空字典，等同于{}
dict(iterable) 用可迭代对象初始化一个字典
d = dict([('name', 'Alex'),('age', 13)]) #每个元组里面提供2个值，一个为键，一个为值
dict(**kwargs) 关键字传参形式生成一个字典
d = dict(name='Alex',age=15) #此方法中，键必须只能是字符
添加/修改字典的元素：
字典[键] = 值
示例：
d = {}
d['name'] = 'Alex'
键索引赋值说明:
当键不存在时，创建键并绑定键对应的值
当键存在时，修改键绑定的对象
删除字典的元素：
del语句用来删除字典的键
语法：
del dict[key]
示例：
d = {1:"星期一",2:"星期二"}
del d[1]
in/not in运算符:
判断一个“键”是否存在与字典中，如果存在则返回True，否则返回False
示例：
d = {1:"one", 2:"two","three":3}
1 in d #True
"two" in d #False
字典的迭代访问：
字典是可迭代对象，字典只能对键进行迭代访问。可以使用索引间接访问值。
示例：
d = {1:"one", 2:"two","three":3}
for k in d:
print(k,'对应的值是：', d[k])
字典常用函数：
len(x) 返回‘’键‘’值对的个数
max(x) 返回‘’键‘’的最大值
min(x) 返回‘’键‘’的最小值
sum(x) 返回‘’键‘’的和
any(x) 真值测试，如果字典中一个‘’键‘’为真，则结果为真
all(x) 真值测试，字典中所有‘’键‘’为真，则结果才为真
字典的方法：
clear()
D.clear() ->清空字典
copy()
D.copy() -> 返回字典D的副本，只复制一层（浅拷贝）
get()
D.get(k[,d]) -> 返回键key对应的值，如果没有此键，则返回default
items()
D.items() -> 返回可迭代的dict_item对象
d = {1:"one", 2:"two","three":3} #dict_items([(1, 'one'), (2, 'two'), ('three', 3)])
keys()
D.keys() ->与直接访问字典的效果相同,返回可迭代的dict_key对象。
d = {1:"one", 2:"two","three":3} #dict_keys([1, 2, 'three'])
values()
D.values() ->返回可迭代的dict_value对象
d = {1:"one", 2:"two","three":3} #dict_values(['one', 'two', 3])
pop()
D.pop(k[,d]) ->移除键，同时返回此键对应的值
update()
D.update(D2)->合并字典；如果key值重复，则更新为D2中的值
四.字典和列表
1.都是可变对象
2.索引方式不同，列表用整数索引，字典用键索引
3.字典的查找速度“可能”会快于列表（重要）------------>在使用in运算时
4.列表的存储是有序的，字典的存储是无序的：
5.列表：顺序存储--->append()很快，但insert()很慢
6.字典：映射存储--->插入的速度很快