今日内容：    1、元组    2、字典    3、集合

一、元组 tuple    1、定义：        t = ()        tuple(t)        print(type(t))        RUN====》        <class 'tuple'>

    参数为for可以循环的对象(可迭代对象)的数据类型可以被定义成元组        t1 = tuple('123')        print(t1,type(t1))        t2 = tuple([1,2,3])        print(t2,type(t2))        t3 = tuple({'name': 'egon'})        print(t3,type(t3))        t4 = tuple((1,2,3))        print(t4,type(t4))        RUN====》        ('1', '2', '3') <class 'tuple'>        (1, 2, 3) <class 'tuple'>        ('name',) <class 'tuple'>        (1, 2, 3) <class 'tuple'>

    定义只有一个值的元组：        # 把字符串'egon'定义成tuple        print(tuple('egon',))        print(tuple(['egon'])        RUN====》        ('Owen',)        ('Owen',)

    2、特性        有序存储 | 可存放多个数据 | 不可变(内部可以包含可变对象，可变对象依旧可变)

    3、常用操作：        3.1 索引取值            t = (1,2,3,4,5)            print(t[2])            RUN====》            3

        3.2 切片            t = (1,2,3,4,5)            print(t[::1])            print(t[-1:-4:-1])            RUN====》            (1, 2, 3, 4, 5)            (5, 4, 3)

        3.3 长度 len            t = (1,2,3,4,5)            print(len(t))            RUN====》            5

    4、元组内置方法        4.1 计数 count            t = (1,2,3,2,5)            print(t.count(2))            RUN====》            2

        4.2 查找索引 index            t = (1,2,3,2,5)            print(t.index(2))            print(t.index(2,0,3))            RUN====》            1            3

二、字典 dict    1、定义        {} | dict()        dic = {'name’： 'egon', 'age': '18'}        print(type(dic))        dic = dict({'name’： 'egon', 'age': '18'})        print(type(dic))        RUN====》        <class 'dict'>        <class 'dict'>

    2、特性        字典是无序的        可以存放多个值        字典是可变的        可以通过key来取值

    3、常用操作        # 增删改查:        增：            dic = {'name'： 'egon', 'age': '18'}            dic['name'] = 'owen'            print(dic)            dic['sex'] = 'fame'            print(dic)            RUN====》            {'name': 'owen', 'age': '18'}            {'name': 'owen', 'age': '18', 'sex': 'fame'}

        # 取，如果key存在就报错，所以用get(key, defalut)            dic = {'name'： 'egon', 'age': '18'}            print(dic['name'])            print(dic['sex'])            print(dic.get('sex'))            RUN====》            egon            报错；            None

        删：            pop(key): 根据key删且返回对应value

        改：            dic = {'name': 'egon', 'age': '18'}            dic.update({'name': 'owen', 'sex': 'fame'})            # key已存在则更新所对应的value，无则新增key_value对            print(dic)            RUN====》            {'name': 'owen', 'age': '18', 'sex': 'fame'}

        查：只查key,只查value，查key_value对            dic = {'a': 10, 'b': 20, 'c': 30}            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)            for v in vs:                print(v)            for k in keys:  # 输出结果跟直接遍历字典是一样的            print(k)            for k, v in dic.items(): # ***** 同时遍历k和v            print(k,v)            RUN====》            dict_values([10, 20, 30]) <class 'dict_values'>            dict_keys(['a', 'b', 'c']) <class 'dict_keys'>            dict_items([('a', 10), ('b', 20), ('c', 30)]) <class 'dict_items'>            10            20            30            a            b            c            a 10            b 20            c 30

    4、案例        # 不区分大小写，计算每一个名字出现的次数，记录在字典中        方法一：        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)

三、集合 set    1.定义        s1 = set()        s2 = set({1, 2, 3})

    2.重点：数据具有唯一性 （*****）        # i) 单列数据集合：str，list，tuple，set    双列：dict        # ii) 无序存储：无key无index（索引），无法取值        # iii) 可变数据类型，内部可以存放任意类型数据，但数据具有唯一性

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

    4.运算        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'}

    5、案例与应用场景        # 选课：        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)  # True        print(sup_set < sub_set)  # False        print(temp_set == sub_set)  # True        # 两个set是否没有交集        res = flag_set.isdisjoint(temp_set)  # True