Python 元组、字典、集合

阳光穿透心脏的1/2处 2022-01-12 10:27 378阅读 0赞

## 今日目录： ##

*  ###### 一、元组 ######
 *  ###### 二、字典 ######
 *  ###### 三、集合 ######
 *  ###### 四、后期添加内容 ######

## 一、元组 ##

#### 1.定义 ####

t1 = ()  # 参数为for可以循环的对象（可迭代对象）
    
    思考：
        如何定义一个只有一个值的元组？
    ("lisi")
    tuple(['lisi'])

#### 2.常用操作 ####

###### 2.1 元组有序存储,索引取值 ######

t = (1,2,3)
    print(t[1])
    print(t[-2])

###### 2.2 切片 ######

print(id(t))
    nt = t[:-1:]
    print(nt, id(nt))

###### 2.3 长度（item元素个数） ######

print(len(t))

###### 2.4 元组内置方法 ######

t.count(2)  # 该数据集合可以有效存放相同数据
    t.index(2)
    # .count(obj)  .index(obj,bindex,eindex)

###### 案例一： ######

*  ###### 提前有一个老师列表，打算开出，如果是亲友团，免开 ######
 *  ###### 原始列表为list类型 ######
 *  ###### 手动输入是否是亲友团，决定是否能开除 ######

teas = ['Bob','lisi']
    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]))
    # (1, 2, []) <class 'tuple'> 2654984899464 2654984915912
    # (1, 2, [10, 20]) <class 'tuple'> 2654984899464 2654984915912

## 二、字典 ##

特别了解：dict 是Python中仅存的mapping类型

#### 1.声明 ####

d1 = {'name': 'zhangsan', 'age': 18}
    1.dict 的 key 可以为所有不可变类型 （一般用str）int，float,tuple,str,bool,None
    
    注：key具有唯一性（重复会覆盖旧值）
        value可以重复
        
    2.dict的value 可以为所有数据类型
    d1 = {'name':'zhangsan','age' = 18}
    d2 = dict({'name': 'lisi', 'age': 18})
    d3 = dict(name='zhangsan', age=17)
    # 字典无序存储数据，无索引与切片，用key来取值

#### 2.增删改查 ####

增：
        d3['gender'] = 'female'
     改：
        d3['name'] = 'lisi'
     查：
        print(d2['name'])
     删：
        del d3['name']

#### 3.内置方法 ####

###### 3.1 get 取值 ######

dic = {'a': 10, 'b': 20}
    # print(dic['c'])  # KeyError: 'c'
    res = dic.get('c')  # 拥有默认值None,可以避免错误
    print(res)  # None
    
    res = dic.get("c", "key不存在")  # 可以自定义默认值
    print(res)  # key不存在

###### 3.2 增 ######

dic = {'a': 10, 'b': 20}
    dic.update({'f': 100, 'c': 300})
    
    print(dic)  # {'a': 10, 'b': 20, 'c': 300, 'f': 100}
    
    # 参数有就修改，没有就添加
    # 参数字典 与 dic可以重复，就是更新值，新key就是新增

###### 3.3 删 ######

dic.pop('c')  # 根据key删除指定对象，并返回删除的对象的值
    print(dic)  # {'a': 10, 'b': 20, 'f': 100}

###### 3.4 复制 ######

（浅拷贝   深拷贝）
    # 浅拷贝 ：只做第一层copy ，内部的成员地址还是原来的地址
    
    new_dic = dic.copy()
    d1 = {'list': [1, 2]}
    d2 = d1.copy()
    print(id(d1), id(d1['list']))  # 1805017721608 1805018516424
    print(id(d2), id(d2['list']))  # 1805018516744 1805018516424
    
    d1['list'].append('abc')
    print(d2)  # {'list': [1, 2, 'abc']}  d2 的‘list’ id与d1的'list' id 相同

浅拷贝：（宏观字典会拷贝，但内部数据依旧使用原来的）
    dic = {'list':[10,20]}
    d1 = dic.copy()
    
    深拷贝：
    
    from copy from deepcopy
    
    d2 = deepcopy(dic)

###### 3.5 popitem() ######

#无参数
    #随机删除，但返回值是（key,value）
    print(dic)
    print(dic.popitem())  # ('f', 100)

###### 3.6 如何定义一个空字典 ######

d10 = {}.fromkeys(['a', 'b', 'c'])
    print(d10)  # {'c': None, 'a': None, 'b': None}
    
    # fromkeys(['a','b'],' ')  
    #第1个参数：keys = list |tuple|str  第2个参数：统一的默认value

###### 案例 ######

# 添加老师
    d11 = {'a': 10}
    
    # 如果有teas，在原teas基础上添加老师，如果没有，新建一个空teas
    if 'teas' not in d11:
        d11['teas'] = []
    d11['teas'].append('zhangsan')
    print(d11)

#### 4.字典循环与案例 ####

dic = {'a': 10, 'b': 20, 'c': 30}
    
    #直接for循环（遍历）字典得到的是key
    for obj in dic:
        print(obj)  # print(obj,dic[k])

# 能不能只循环值
    values = dic.values()
    
    # 存放key的集合
    keys = dic.keys()
    
    # 存放key-value的键值对关系
    k_vs = dic.items()
    
    print(k_vs)  # dict_items([('a', 10), ('c', 30), ('b', 20)])
    print(keys)  # dict_keys(['c', 'a', 'b'])
    print(values)  # dict_values([10, 30, 20])
        
    ps: dic.valuses、dic.keys()、dic.items()都不是原生list，不能直接索引取值，但可以for循环遍历

###### 案例：不区分大写、计数每一个名字出现的次数，记录在字典中 ######

ls = ['Owen','Owen',"Egon",'Liuxx','Liuxx','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)
    
    
    方法二：
    ls = ['Owen', 'Owen', "Egon", 'Liuxx', 'Liuxx', '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)
    
    # 结果：{'egon': 2, 'owen': 2, 'liuxx': 2}

## 三、集合 ##

#### 1.定义与声明 ####

1.1 什么是set？
       1.单列数据集合：str、list、tuple、set
       2.无序存储：无key，无index ,无法取值
       3.可变数据类型，内部可以存放任意类型数据，但数据具有唯一性
    
        # {}代表字典，用set()来创建空集合
        s1 = set()

#### 2.内置方法与使用 ---集合间的运算 ####

p_set = {'a','b','c','lisi'}
    l_set = {'x','y','z','lisi'}
    
    --- # 交集：& ---------------------------------------------------------
    res = p_set & l_set
    print(res)  #{'lisi'}
    res = p_set.intersection(l_set)
    print(res)  # {'lisi'}
    
    --- # 并集 ： | --------------------------------------------------------
    res = p_set | l_set
    print(res)  # {'z', 'b', 'lisi', 'a', 'y', 'x', 'c'} 一个无序集合
    res = p_set.union(l_set)
    print(res)  # {'x', 'y', 'z', 'b', 'c', 'a', 'lisi'} 一个无序集合
    
    --- # 差集 ： -  -------------------------------------------------------
    res = p_set - l_set
    print(res)  # {'b', 'a', 'c'}  去掉 egon ,剩下'a','b','c'
    res = p_set.difference(l_set)
    print(res)  # {'a', 'b', 'c'}
    
    --- # 对称差集 ：^ -----------------------------------------------------
    res = p_set ^ l_set
    print(res)  # {'z', 'c', 'y', 'a', 'x', 'b'}
    res = p_set.symmetric_difference(l_set)
    print(res)  # {'x', 'c', 'y', 'z', 'a', 'b'}

#### 3、案例与应用场景 ####

###### 选课： ######

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

###### 利用set去重 ######

classes = set()
    for _, cless in class_map:
        classes.add(cless)
    classes = list(classes)
    
    print(classes)  #['python', 'java', 'linux']

###### 了解： ######

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

## 四、后期添加内容 ##

菜鸟教程tuple：[元组][Link 1]

菜鸟教程dict：[字典][Link 2]

菜鸟教程set：[集合][Link 3]

转载于:https://www.cnblogs.com/xt12321/p/10597142.html

[Link 1]: http://www.runoob.com/python/python-tuples.html
[Link 2]: http://www.runoob.com/python/python-dictionary.html
[Link 3]: http://www.runoob.com/python/python-func-set.html