一、元组（tuple）：
python中将一些不能修改的值称为不可变的，而不可变的列表则被称之为元组。
注意元组一旦被定义则不可修改，因此一般我们不定义空元组。
元组是有序的，可存放多个数据|，不可变类型（但是如果元组中包含可变对象时，
可变对 象时依旧可变的。）
应用场景：是将不允许操作的列表可以转化为元组，将允许操作的元组转化为列表。
1.1、如何定义一个只有一个值得元组
# 如何定义一个只有一个元素的元组
print(('qzk',)) # ('qzk',)
print(tuple(['qzk2'])) # ('qzk2',)
1.2、索引取值
# 索引取值
t = (1, 2, 3, 2, 2, 1, 2, 3, 4, 3, 2)
print(t[0]) #
print(t[-1]) #
1.3、切片
t = (1, 2, 3, 2, 2, 1, 2, 3, 4, 3, 2) # 切片
print(id(t)) #
new_t1 = t[:-1:] # (1, 2, 3, 2, 2, 1, 2, 3, 4, 3) 是从0位取到倒数第二位，（-1）位不考虑（顾头不顾尾）
new_t2 = t[-6:-1:1] # (1, 2, 3, 4, 3)
new_t3 = t[-6:-1:-1] # ()
new_t4 = t[-1:-6:1] # ()
new_t5 = t[-1:-6:-1] # (2, 3, 4, 3, 2)
print(new_t1)
print(new_t2)
print(new_t3)
print(new_t4)
print(new_t5)
print(id(new_t1)) #
1.4、长度运算（len（））：实际求取的是items的个数
# 长度运算（len（））
t = (1, 2, 3, 2, 2, 1, 2, 3, 4, 3, 2)
print(len(t)) #
1.5、内置方法：主要与两个 .count()、.index()
.count() 返回的是value的次数
.index(self, value, start=None, stop=None) ,返回的是第一个索引到值的位置。
def count(self, value): # real signature unknown; restored from __doc__
""" T.count(value) -> integer -- return number of occurrences of value """
return 0 def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
"""
T.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
"""
return 0
# 元组内置方法
t = (1, 2, 3, 2, 2, 1, 2, 3, 4, 3, 2)
print(t.count(3)) # 该数据集合可以存放相同数据 # 3
print(t.index(2, 2, 4)) #
二、字典（dict） ：
字典是python中仅存的mapping类型。
字典是无序的，可变类型，可存放多个数据，是通过键值对（key：value）来取值的。
字典的key 可以为所有不可变类型：int float tuple str bool 等。
value 可以为所有可变类型
在字典中key 具有唯一性（重复会覆盖旧值），value可以重复。
2.1、声明字典的方式：
d1 = {'name': 'qzk', 'age': 18}
print(d1)
d2 = dict({'name': 'qzk', 'age': 18})
print(d2)
d3 = dict(name='egon', age=18)
print(d3)
2.2、增删改查
# 增加
dic = {}
dic['name'] = 'qzk'
dic['age'] = 18
print(dic) # 改
dic['name'] = 'qzk1'
print(dic) # 查
print(dic['age']) # 删除
del dic['name']
print(dic) # {'name': 'qzk', 'age': 18}
# {'name': 'qzk1', 'age': 18}
#
# {'age': 18}
2.3、内置方法
# .get() 取值，相当于查询作用
dic12 = {'a': 10, 'b': 20}
# print(dic['c']) # KeyError
res = dic12.get('c') # 拥有默认值，None。可以避免错误
print(res)
res = dic12.get('d', 'key不存在') # 默认值是None，可以自定义默认值
print(res)
# 增：.update()
dic12.update({'a': 100, 'c': 300})
print(dic12) # 添加的参数字典，与dic重复就是更新字典，新的key就是新增字典
# 删：.pop()
res = dic12.pop('c') # 根据key删除指定对象，并返回删除的对象
print(res)
# 复制：(浅拷贝|深拷贝)
d1 = {'list': [1, 2]}
d2 = d1.copy()
print(id(d1), id(d1['list']))
print(id(d2), id(d2['list']))
d1['list'].append('abc')
print(d2)
# 如何定义一个空字典;
dic11 = {}.fromkeys(['a', 'b', 'c']) # {'a': None, 'b': None, 'c': None}
print(dic11)
dic13 = {}.fromkeys(['a', 'b', 'c'], [1, 2, 3]) # {'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}
print(dic13)
# setdefault(key,value)
# 语法：dict.setdefault(key, default=None)
# python 字典 setdefault() 函数和get() 方法类似, 如果键不存在于字典中，将会添加键并将值设为默认值。
# 返回值：如果 key 在 字典中，返回对应的值。如果不在字典中，则插入 key 及设置的默认值 default，并返回 default ，default 默认值为 None。
dic13.setdefault('teas', [])
dic13['teas'].append('egon')
dic13['teas'].append('qzk')
print(dic13)
# None
# key不存在
# {'a': 100, 'b': 20, 'c': 300}
#
# 34734368 34757192
# 41813552 34757192
# {'list': [1, 2, 'abc']}
# {'a': None, 'b': None, 'c': None}
# {'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3]}
# {'a': [1, 2, 3], 'b': [1, 2, 3], 'c': [1, 2, 3], 'teas': ['egon', 'qzk']}
三、集合（set）：
定义与声明：
集合分为单列数据集合和双列数据集合
集合是无序存储，无key 无索引，无法取值
集合是可变数据类型，内部可以存放任意数据类型的数据，且具有唯一性****
常用操作：
s1 = set()
s2 = set('ABC')
print(s1, type(s1))
print(s2, type(s2)) # set() <class 'set'>
# {'C', 'A', 'B'} <class 'set'>
交集、并集、差集、对称差集运算
p_set = {'a', 'b', 'c', 'd'}
l_set = {'x', 'y', 'z', 'a', 'b'}
# 交集&
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res)
# {'a', 'b'}
# {'a', 'b'}
# 并集
res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res)
# {'b', 'z', 'd', 'y', 'c', 'x', 'a'}
# {'b', 'z', 'd', 'y', 'c', 'x', 'a'}
# 差集
res = p_set - l_set
print(res)
res = p_set.difference(l_set)
print(res)
res = l_set.difference(p_set)
print(res)
# {'d', 'c'}
# {'d', 'c'}
# {'z', 'y', 'x'}
# 对称差集
res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res)
print(p_set)
print(l_set)
# {'z', 'd', 'y', 'c', 'x'}
# {'z', 'd', 'y', 'c', 'x'}
# {'a', 'd', 'c', 'b'}
# 如上一些操作带——update的 是作用结果赋值给调用者
# 添加删除操作
s = set()
s.add('abc')
s.add('xyz')
print(s) if 'xyz' in s:
s.remove('xyz') # 有element 删除，无ele 抛异常 res = s.pop() # 随机删除一个
class_map = [
('owen', 'python'),
('egon', 'linux'),
('egon', 'python'),
('liu', 'java'),
('liu', 'linux')
]
#
# 需求：
# 1多少人参加选课：['owen','egon','liu']
names = []
for name, _ in class_map:
# 判断列表中是否已存在，不存在才添加
if name not in names:
names.append(name)
print(names) classes = set()
for _, cless in class_map:
classes.add(cless)
classes = list(classes)
print(classes) # ['owen', 'egon', 'liu']
# ['python']