python基础——5（元组、字典、集合）

上节复习：
# 数字类型
# int：py3|py2  long：py2
# float: 3.14
# complex(5, 4) => 5 + 4j
num = 123456789012345678901234567890123456789012345678901234567890
print(num)
print(int('123'))

# 字符串：*******
# '' "" """"""
# len() [index] [::]

# 列表类型
# [1, 3.14. 'abc', True, []]
# len() [index|-index] [::] => 有序，存放多个值
# 增删改查

# 可变不可变类型
# 不可变：在id不改变的情况下，无法修改值
# 可变：在id不改变的情况下，可以修改(内部)值

a = [1, 2]
print(id(a))
a = [3, 4]
print(id(a))

# 今日内容
# 元组 ***
# 字典 *****
# set *

一、元组

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'}