一、元组
1、定义:
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}
# 2
d2 = dict({'name':'Owen','age':18})
# 3
d3 = dict(name = 'Egon',age = 58)
字典存储数据是无序的,没有索引与切片,用key来取值
2、增删改查
dic = {}
# 增:key不存在
# 第一种
dic['name'] = 'Mac'
print(dic)
# 第二种:添加的参数字典,与dic可以重复,就是更新值,新key就是新增
dic.update({'a': 100, 'c': 300})
print(dic)
# 改:key已存在
dic['name'] = 'Big Mac'
# 查
print(dic['name'])
# 删
# 第一种
del dic['name']
print(dic)
# 第二种
res = dic.pop('c') # 根据key删除指定对象,并返回删除的对象的value
print(res)
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)
# 随即删除,返回值是(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']}
# 添加老师
# 如果有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中
# 用setdefault实现上面的代码
d11.setdefault('teas',[])
d11['teas'].append('Egon')
d11['teas'].append('LiuXX')
print(d11) #{'a': 10, 'teas': ['Owen', 'Egon', 'LiuXX']}
# 字典的定义:{} | dict()
# 字典的常用操作:增删改查
# 字典的内置方法:
# 字典的循环(迭代)
dic = {'a':10,'b':20,'c':30}
# 直接for循环(遍历)字典得到的是key
for k in dic:
print(k,dic[k])
#或者使用.keys()方法得到存放key的集合
keys = dic.keys()
print(keys,type(keys)) # dict_keys(['a', 'b', 'c']) <class 'dict_keys'>
for k in keys: # 遍历key,跟直接遍历字典是一样的
print(k)
# 只循环值
values = dic.values()
print(values,type(values)) # dict_values([10, 20, 30]) <class 'dict_values'>
for v in values: #遍历值
print(v)
#存放key-value的键值对关系
K_vs = dic.items()
print(k_vs,type(k_vs)) # dict_items([('a', 10), ('b', 20), ('c', 30)]) <class 'dict_items'>
# 同时遍历k-v
for k,v in dic.items():
print(k,v)
# dic.values() | dic.keys() | dic.items() 不是原生list,不能直接索引取值,但可以for循环取值
vs = list(values) #转为列表,按索引取值
print(vs[1])
for v in vs: # 循环取值
print(v)
#多级字典嵌套
'''info1 = {
"1":{"4":["aaa","bbb"]},
"2":{"5":["ccc","ddd"]},
"3":{"6":["eee","fff"]}
}
# info1["1"]["4"][1] = "ggg" #{'2': {'5': ['ccc', 'ddd']}, '1': {'4': ['aaa', 'ggg']}, '3': {'6': ['eee', 'fff']}}
# print(info1.keys()) #打印键值
# print(info1.values()) #打印有效值
info1.setdefault("4",{"7":["xxx","zzz"]}) #如果找到键值直接返回,没找到就插入后面的有效值
print(info1) #{'4': {'7': ['xxx', 'zzz']}, '2': {'5': ['ccc', 'ddd']}, '3': {'6': ['eee', 'fff']}, '1': {'4': ['aaa', 'bbb']}}
print(info1)'''
# 案例: 不区分大小写,计算每一个名字出现的次数,记录在字典中
ls = ['Owen', 'owen', 'Egon', 'LiuXX', 'Liuxx', 'egon', 'egon']
# 第一种方法
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)
# 第二种方法
name_dic = {}
for name in ls:
name = name.lower()
# name已存在,返回key的值;不存在,把key插入字典中,返回指定的默认值
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)) #set() <class 'set'>
s2 = set('abc')
print(s2,type(s2)) #{'b', 'a', 'c'} <class 'set'>
2、内置方法与使用——集合间的运算(& | ^ - > < ==)
p_set = {'a','b','c','egon'} # {'a', 'c', 'b', 'egon'}
l_set = {'x','y','z','egon'} #{'z', 'egon', 'x', 'y'}
# 交集 &
res = p_set & l_set
print(res) # {'egon'}
res = p_set.intersection(l_set)
print(res) # {'egon'}
# 并集
res = p_set | l_set
print(res) #{'y', 'x', 'egon', 'c', 'z', 'b', 'a'}
res = p_set.union(l_set)
print(res)
# 差集:在p中不在l中
res = p_set - l_set
print(res) #{'b', 'c', 'a'}
res = p_set.difference(l_set)
print(res)
# 对称差集:除去公共的部分
res = p_set ^ l_set
print(res) # {'a', 'x', 'c', 'y', 'z', 'b'}
res = p_set.symmetric_difference(l_set)
print(res)
# 值更新的差集
print(p_set) #{'c', 'egon', 'a', 'b'}
print(l_set) #{'x', 'egon', 'z', 'y'}
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.update('s','d','f') #添加多项
s.add('xyz')
print(s) #{'d', 'abc', 'xyz', 'f', 's'}
res = s.pop() # 随机删除一个element元素,并将其返回
print(res)
if 'xyz' in s:
s.remove('xyz') # 有element删除,没有就抛异常
print(s) # {'abc', 's', 'f', 'd'}
#删除不存在的元素不会报错;返回None
s.discard('abc') # {'d', 'f', 's'}
print(s)
list_1 = [1,4,5,7,3,6,7,9]
list_1 = set(list_1) #转为集合去重,集合也是无序的
list_2 = set([2,6,0,66,22,8,4])
#子集
print(list_1.issubset(list_2))
#父集
print(list_1.issuperset(list_2))
#判断是否有交集
print(list_2.isdisjoint(list_1)) #如果两个集合没有交集,则返回True
# 了解:父子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)
# 案例与应用场景
# 选课
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) #['owen', 'egon', 'liuxx']
# 利用集合去重
classes = set()
for _,cless in class_map:
classes.add(cless)
print(classes) #{'java', 'linux', 'python'}