python 元祖字典集合

一、元祖

　　1.用途:记录多个值，当多个值没有改变的需求，元祖不能修改，但元祖里的数据的数据可以修改。

　　2.定义方式:在()内用逗号分隔开多个任意值。

　　　　思考:如果定义一个只有一个一个值的元祖。 # 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))

元祖案例:

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

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

 teas = ['Bob', 'Alex']

 friends = input("亲友团[0, 1]：")

 if friends == '':
     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)

2.1用途:记录多个值，每一个值都是对应的key用来描述value的作用

2.2定义方法：在{}内用逗号分隔开多个：key-value其中value可以定

义可以使任意类型，而可以必须是不可变的类型，通常情况下应该是

str类型。

2.3字典无序存储数据，无索引与切片，用key来取值

2.4优先掌握的操作

①.按key存取值：可存、可取

②.长度len()

③.成员运算 in not in

4④删除：del()   pop() 删除对应的值并返回value  popitem()随机删除，有返回值

⑤.循环：

 #示例
 d={'name':'zhaokang','age':18}
 #取key
 #方法一
 for i in d:
     print(i)
 #方法二
 for i in d.keys():
     print(i)

 #取Value
 for i in d.values:
     print(i)

 #取key-value
 for k,v in d.item():
     print(k,v)

2.5字典的内置方法

 #增删改查
 dic={}
 #增：key不存在
 #方法一
 dic['name']='Mac'
 print(dic)
 结果是：{'name':'Mac'}
 #方法二
 #update添加的参数字典，与dic 可以重复，就是更新值，新key就是新增
 dic.update({'a':100,'c':300})
 print(dic)
结果是：{'a':100,'b':30,'c':300}
#方法三 setdefault 有两个参数 ①key ②default
#字典中已经存在key则不做任何操作，返回的结果是已存在的Value
#如果字典不存在key则添加，返回新的value
#一
dic = {'name':'zhaokang'}
dic.setdefault('name','ZhaoKang')
print(dic)
输出结果是:{'name':'zhaokang'}  返回值是 zhaokang
#二
dic = {'name':'zhaokang'}
dic.setdefault('name1','ZhaoKang')
print(dic)
输出结果是:{'name1':'ZhaoKang'}  返回值是 ZhaoKang
 #改：key已经存在
 dic['name']='Big Mac'
 print(dic)
 输出结果是:{'name':'Big Mac'}

#查
print(dic['name'])
输出结果是:{'name':'zhaokang'}

#删
#方法一
del dic['name']
print(dic)
输出结果是：{}
#二  据key删除指定对象，并返回删除的对象的value
print(dic.pop(['name']))
输出结果是:{}
#三 随机删除
print('dic.popitems()')
输出结果是:{}

2.6需要掌握的操作:

   #get 当需要取得值得key不在字典中则不会报错返回默认值None
   #如果需要取得值得key存在字典中则取到value
 dic={'a':20,'b':30}
 res=dic.get('c')  # 拥有默认值.None，可以避免报错
 print(res)
 输出结果是:None
 dic = {'a': 20, 'b': 30}
 res = dic.get('b')  # 拥有默认值.None，可以避免报错
 print(res)
 输出结果是:30

 {}.fromkeys('n',20)
 输出结果是:{'n': 20}

 #copy:
 #浅copy：只做第一层copy，内部的成员地址还是原来的地址
 dic = {'a': 20, 'b': 30}
 print(dic.ccopy())
 输出结果是:{'a': 20, 'b': 30}

 # 字典的定义：{} | 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']
 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)

字典循环与案例

三、集合

#定义与声明:
#什么事set:
#①单列数据集合：str，list，tuple，set
#双列:dict
②无序存储：无key无index，无法取值
③可变数据类型，内部可以存放任意数据类型，但数据具有唯一性
#{}代表空字典，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'}
# 交集 &   intersection
res = p_set & l_set
print(res)
res = p_set.intersection(l_set)
print(res)  # {'egon'}

# 并集 |   union
res = p_set | l_set
print(res)
res = p_set.union(l_set)
print(res)  # {'z', 'c', 'y', 'x', 'b', 'a', 'egon'}

#差集  - difference
res = p_set - l_set
print(res)  # {'a', 'b', 'c'}
res = l_set.difference(p_set)
print(res)  # {'x', 'z', 'y'}

# 对称差集  ^   symmetric_difference
res = p_set ^ l_set
print(res)
res = p_set.symmetric_difference(l_set)
print(res)  # {'y', 'a', 'b', 'x', 'z', 'c'}

# 添加删除操作
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抛异常

#循环 利用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)

 # 需求：
 # 1.多少人参加了选课: ['owen', 'egon', 'liuxx']
 # 2.都选了哪些课程: ['python', 'linux', 'java']
 # 利用逻辑代码去重
 names = []
 for name, _ in class_map:
     # 判断列表中是否已存在，不存在才添加
     if name not in names:
         names.append(name)
 print(names)

案例