3.25学习笔记

一.元组

1.定义：`

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)) #ValueError: tuple.index(x): x not in tuple

元组案例：
案例一：
提前拥有一个老师列表，打算开除，如果是校长亲友团，免开

原始列表为list类型
手动输入是否是亲友团，决定是否能开除（）

# teas = ['Bob','Alex']
# friends = input('亲友团[0,1]:')
# if friends == '1':
#     teas = tuple(teas)
# # =>异常处理
# # 判断teas对象是否为tuple 类型
# if not isinstance(teas,tuple):
#     teas.clear()
# for t in teas:
#     print('在职老师：%s' %t)

案例二：
元组中的数据一定不能改变，但是元组中的数据(可变类型)的数据可以改变。

# t1 = (1,2,'abc',True,(1,2)) # t1永远无法改变
# t2 = (1,2,[])
# print(t2,type(t2),id(t2),id(t2[2]))
# t2[2].extend((10,20))
# print(t2,type(t2),id(t2),id(t2[2]))

二.字典

dict是python中仅存的mapping(标准映射类型)类型。
1.申明：
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 = 18)
# print(d3)

字典无序存储数据，无索引与切片，用key取值。
2.增删查改：

# dic = {}
# # 增：key不存在
# dic['name'] = 'Mac'
# print(dic)
# 添加的参数字典，与dic可以重复，就是更新值，新key就是新增
# dic = {'a':10,'b':20}
# dic.update({'a':100,'c':300})
# print(dic)
# # 改：key已cun'zai
# dic['name'] = 'Big mac'
# print(dic)
# # 查
# print(dic['name'])
# # 删
# del dic['name']
# print(dic)

3.get取值*****
Python 字典 get() 函数返回指定键的值，如果值不在字典中返回默认值。

# dic = {'a':10,'b':20}
# # print(dic['c'])      # KeyError: 'c
#
# res = dic.get('c')   # 拥有默认值，None可以避免错误
# print(res)
#
# res = dic.get('d','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)
# 浅copy：之作第一层copy，内部成员地址还是原来的的地址

随机删除，返回值是(key,value)：

# dic = {'a':10,'b':20}
# print(dic)
# print(dic.popitem())
# print(dic.popitem())
# print(dic)

如何定义一个空字典：
第一个参数：keys：list|tuple|str，第二个参数：统一的默认value。

# d3 = {}.fromkeys(['a','b','c'],'')
# print(d3)  #{'a': '', 'b': '', 'c': ''}
# 独自设置默认值
# d4 = {'a':10,'teas':'egon'}
# d4 = {'a':10}

添加老师：

# 如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
# if 'teas' not in d4:
#     d4['teas'] = []
# d4['teas'].append('egon')
# d4['teas'].append('liuxx')
# print(d4)
# 原d4中，如果有teas这个key，setdefault相当于什么都没干
# 如果没有，就将第二个参数(默认值)传给teas存放到d4中
# d4.setdefault('teas',[])
# d4['teas'].append('egon')
# d4['teas'].append('liuxx')
# print(d4)

字典循环与案列：
字典的定义：{} | 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()
#     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_dic.setdefault(name,0)
#     name_dic[name] +=1
# print(name_dic)

三.集合set

1.定义与声明
i）单列数据集合： str,list,tuple,set 双列：dict。
ii)无序存储：无key无index，无法取值。
ii）可变数据类型，内部可以存放任意数据类型，但数据具有唯一性******

{}代表空字典，用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)

#并集
# res = p_set | l_set
# print(res)
# res = p_set.union(l_set)
# print(res)

#差集
# 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)    #{'a', 'c', 'b'}
# print(l_set)    #{'z', 'x', 'y', 'egon'}

# 添加删除操作
# s =set()
# s.add('abc')
# s.add('xyz')
# print(s)
# res = s.pop()#随机删除一个ele元素
# print(res)
# if 'xyz' in s:
#     s.remove('xyz')   #有ele删除，无lele抛异常

案例：
选课：

# 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)