知识概要
isinstance()方法，用来判断数据类型
一、元组
1定义： #该数据集合可以存放相同数据
t1 = ()
t2 = tuple("abc") #t2 = ( 'a', 'b', 'c' )
如何定义一个只有一个值的元组：
t1 = ( 'jhc', )
t2 = tuple(['jhc'])
2.元组为有序类型，可以按索引取值，切片
3、用len()方法获取元组长度
4、元组内置方法：
t1.count('aa')
t1.index('aa' , 0 ,8)
5.元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变
6、应用场景：将不允许操作的列表可以转化为元组，将允许操作的元组转化为列表
二、字典
# 特别了解：dict是python中仅存的mapping类型
# 1、声明
# *****
# dict的key：可以为所以不可变类型：int float tuple str bool None， 一般就采用字符串
# dict的value：可以为所以数据类型
# 注：key具有唯一性（重复会覆盖旧值），value可以重复
# 字典无序存储数据，无索引与切片，用key来取值
# 如何定义
# 第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10) # {'a': '', 'b': '', 'c': ''}
# 独自设置默认值
d11 = {'a': 10, 'teas': ['Owen']}
#2 、增删改查
d1[key] = value: key存在就是改，不存在就是增
d1[key]: 取，如果key存在就报错，所以用get(key, defalut)
update({'a': 100, 'c': 300}): key有更新，无新增
pop(key): 根据key删且返回对应value
popitem() # 随机删除，返回值是(key, value)
# 3、get取值 *****
dic = {'a': 10, 'b': 20}
# print(dic['c']) # KeyError
res = dic.get('c') # 拥有默认值，None，可以避免错误
print(res)
res = dic.get('d', 'key不存在') # 可以自定义默认值
print(res)
4 、循环
# 直接for循环(遍历)字典得到的是key
# 只循环value，for i in dic.values() # 注意type（dic.values())不是原生列表
# 只循环key ， for i in dic.keys() # 注意type（dic.keys())不是原生列表
# 循环key-value的键值对关系，for k,v in dic.items() # 注意type（dic.items())不是原生列表
三、集合
1.定义
s1 = set()
s2 = set({1, 2, 3})
2.重点：数据具有唯一性
# i) 单列数据集合：str，list，tuple，set 双列：dict
# ii) 无序存储：无key无index，无法取值
# iii) 可变数据类型，内部可以存放任意类型数据，但数据具有唯一性
3.运算
p_set = {'a', 'b', 'c', 'egon'}
l_set = {'x', 'y', 'z', 'egon'}
# 交集 &
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res) # {'egon'}
# 并集
res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res) # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}
# 差集
res = p_set - l_set
print(res) # {'a', 'b', 'c'}
res = l_set.difference(p_set)
print(res) # {'x', 'z', 'y'}
# 对称差集
res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res) # {'y', 'a', 'b', 'x', 'z', 'c'}
# p_set.difference_update(l_set) # 将运算结果赋值给调用者，相关update的方法都是如此
p_set = p_set - l_set
print(p_set) # {'c', 'a', 'b'}
print(l_set) # {'egon', 'z', 'y', 'x'}
# 添加删除操作
s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop() # 随机删除一个ele元素
print(res)
if 'xyz' in s:
s.remove('xyz') # 有ele删除，无ele抛异常
'''
'''
了解：
sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}
print(sup_set > sub_set) # True
print(sup_set < sub_set) # False
print(temp_set == sub_set) # True
# 两个set是否没有交集
res = flag_set.isdisjoint(temp_set) # True
'''
# 利用set去重
sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}
# 了解：父子set
sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}
print(sup_set > sub_set)
print(sup_set < sub_set)
print(temp_set == sub_set)
# 两个set是否没有交集
res = flag_set.isdisjoint(temp_set)
print(res)
res = temp_set.isdisjoint(sup_set)
print(res)
-----------------------------------------草稿--------------------------------------
元组
# 一、定义
t1 = ()
print(t1, type(t1))
# 参数为for可以循环的对象(可迭代对象)
t2 = tuple("123")
print(t2, type(t2))
t3 = tuple([1, 2, 3])
print(t3, type(t3))
t4 = tuple((7, 8, 9))
print(t4, type(t4))
# 思考:如何定义一个只有一个值的元组
# "Owen"
print(("Owen", ))
print(tuple(['Owen']))
# 总结：
# t = (1, 2, 3)
# t = (1, )
# 常用操作
# 元组有序存储
# 索引取值
t = (1, 2, 3, 2, 3, 2)
print(t[1])
print(t[-2])
# 切片
print(id(t))
nt = t[:-1:]
print(nt, id(nt))
# 长度（item元素个数）
print(len(t))
# 元组内置方法
print(t.count(2)) # 该数据集合可以存放相同数据
print(t.index(2, 2, 3))
二、字典
# 特别了解：dict是python中仅存的mapping类型
# 一、声明
# *****
# dict的key：可以为所以不可变类型：int float tuple str bool None， 一般就采用字符串
# dict的value：可以为所以数据类型
# 注：key具有唯一性（重复会覆盖旧值），value可以重复
dic = {1: None, None: None, 3.14: None,
True: None, 'abc': None, (1,): None,
None: 12345
}
print(dic)
# 1
d1 = {'name': 'Owen', 'age': 18}
print(d1)
# 2
d2 = dict({'name': 'Owen', 'age': 18})
print(d2)
# 3
d3 = dict(name='Egon', age=58)
print(d3)
# 字典无序存储数据，无索引与切片，用key来取值
# 二、增删改查
dic = {}
# 增：key不存在
dic['name'] = 'Mac'
print(dic)
# 改：key已存在
dic['name'] = 'Big Mac'
print(dic)
# 查：
print(dic['name'])
# 删：
del dic['name']
print(dic)
# 三、get取值 *****
dic = {'a': 10, 'b': 20}
# print(dic['c']) # KeyError
res = dic.get('c') # 拥有默认值，None，可以避免错误
print(res)
res = dic.get('d', 'key不存在') # 可以自定义默认值
print(res)
# 增
# 添加的参数字典，与dic可以重复，就是更新值，新key就是新增
dic.update({'a': 100, 'c': 300})
print(dic)
# 删 **
res = dic.pop('c') # 根据key删除指定对象，并返回删除的对象的value
print(res)
# 复制：(浅拷贝|深拷贝)
newDic = dic.copy()
print(newDic)
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)
# 浅copy：只做第一层copy，内部的成员地址还是原来的地址
# 随机删除，返回值是(key, value)
print(dic)
print(dic.popitem())
print(dic.popitem())
print(dic)
# 如何定义一个空字典
# 第一个参数：keys：list|tuple|str，第二个参数：统一的默认value
d10 = {}.fromkeys(['a', 'b', 'c'], '')
print(d10) # {'a': '', 'b': '', 'c': ''}
# 独自设置默认值
d11 = {'a': 10, 'teas': ['Owen']}
# d11 = {'a': 10}
# 添加老师
# 如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
# if 'teas' not in d11: # 成员运算
# d11['teas'] = []
# d11['teas'].append('Egon')
# d11['teas'].append('LiuXX')
# print(d11)
# 原d11中，如果有teas这个key，setdefault相当于什么都没干
# 如果没有，就将第二个参数(默认值)传给teas存放到d11中
d11.setdefault('teas', [])
d11['teas'].append('Egon')
d11['teas'].append('LiuXX')
print(d11)
字典循环案例
'''
# 字典的定义：{} | dict()
# 字典的常用操作：增删改查
# 字典的内置方法：
# 字典的循环(迭代)
dic = {'a': 10, 'b': 20, 'c': 30}
# 直接for循环(遍历)字典得到的是key
for k in dic:
print(k, dic[k])
# 能不能只循环值
values = dic.values()
print(values, type(values))
# 存放key的集合
keys = dic.keys()
print(keys, type(keys))
# 存放key-value的键值对关系
k_vs = dic.items()
print(k_vs, type(k_vs))
# dic.values() | dic.keys() | dic.items() 不是原生list，不能直接索引取值，但可以for循环取值
# vs = list(values)
# print(vs[1])
# for v in vs:
# print(v)
for v in values:
print(v)
print()
for k in keys: # 跟直接遍历字典是一样的
print(k)
print()
# ***** 同时遍历k-v
for k, v in dic.items():
print(k, v)
'''
'''
# 案例: 不区分大小写，计算每一个名字出现的次数，记录在字典中
ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
# {'owen': 2, 'egon': 3 ...}
name_dic = {}
for name in ls:
# 名字全小写，不用区分大小写
name = name.lower()
# 名字是否在字典中存在：存在 - 次数+1 | 不存在 - 添加并设置初值1
if name not in name_dic:
# 不存在
name_dic[name] = 1
else:
# 存在
name_dic[name] += 1
print(name_dic)
'''
ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
name_dic = {}
for name in ls:
name = name.lower()
# name已存在，不管，不存在，初始化指定key：name值为1
name_dic.setdefault(name, 0)
name_dic[name] += 1
print(name_dic)
三、集合
# 1、定义与声明
# 什么是set：
# i) 单列数据集合：str，list，tuple，set 双列：dict
# ii) 无序存储：无key无index，无法取值
# iii) 可变数据类型，内部可以存放任意类型数据，但数据具有唯一性 *****
# {}代表空字典，用set()来创建空集合
s1 = set()
print(s1, type(s1))
s2 = set('abc')
print(s2, type(s2))
# 2、内置方法与使用 - 集合间的运算 （& | ^ - > < ==）
p_set = {'a', 'b', 'c', 'egon'}
l_set = {'x', 'y', 'z', 'egon'}
# print(p_set)
# print(l_set)
# 交集 &
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res) # {'egon'}
# 并集
res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res) # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}
# 差集
res = p_set - l_set
print(res) # {'a', 'b', 'c'}
res = l_set.difference(p_set)
print(res) # {'x', 'z', 'y'}
# 对称差集
res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res) # {'y', 'a', 'b', 'x', 'z', 'c'}
print(p_set)
print(l_set)
# p_set.difference_update(l_set) # 将运算结果赋值给调用者
p_set = p_set - l_set
print(p_set) # {'c', 'a', 'b'}
print(l_set) # {'egon', 'z', 'y', 'x'}
# 添加删除操作
s = set()
s.add('abc')
s.add('xyz')
print(s)
res = s.pop() # 随机删除一个ele元素
print(res)
if 'xyz' in s:
s.remove('xyz') # 有ele删除，无ele抛异常
# 3、案例与应用场景
# 选课：
class_map = [
('owen', 'python'),
('egon', 'linux'),
('egon', 'python'),
('liuxx', 'python'),
('liuxx', 'java')
]
# 需求：
# 1.多少人参加了选课: ['owen', 'egon', 'liuxx']
# 2.都选了哪些课程: ['python', 'linux', 'java']
# 利用逻辑代码去重
names = []
for name, _ in class_map:
# 判断列表中是否已存在，不存在才添加
if name not in names:
names.append(name)
print(names)
# 利用set去重
classes = set()
for _, cless in class_map:
classes.add(cless)
classes = list(classes)
print(classes)
# 了解：父子set
sup_set = {1, 2, 3, 4, 5}
sub_set = {1, 2, 3}
temp_set = {3, 2, 1}
flag_set = {7, 8, 9}
print(sup_set > sub_set)
print(sup_set < sub_set)
print(temp_set == sub_set)
# 两个set是否没有交集
res = flag_set.isdisjoint(temp_set)
print(res)
res = temp_set.isdisjoint(sup_set)
print(res)