• Day 07


    元祖tuple

    作用

    相当于一个只可取不能更改的列表, 在创建时就被写死了.

    定义

    ()内用逗号隔开多个元素(可以为任意数据类型)

    tup = (1, 2, 3)
    tup = tuple((1, 2, 3))
    
    # 注意: 如果定义只有一个元素的元祖, 必须要加逗号, 否则为字符串
    tup = (1,) # 元祖
    tup = (1) # 字符串
    

    使用方法

    tup = (1, 2, 3)
    
    # 1. 索引取值
    print(tup[0])
    
    # 2. 索引切片
    print(tup[0:2])
    
    # 3. for循环
    for i in tup:
        print(i)
        
    # 4. 成员运算
    print(0 in tup)
    
    # 5. len长度
    print(len(tup))
    
    # 6. index获取元素索引
    print(tup.index(1))
    
    # 7. count计数
    print(tup.count(2))
    

    集合(set)

    作用

    进行集合之间关系运算/去重/无序

    定义方式

    {}内用逗号隔开多个元素(不可变数据类型)

    s = {1, 2, 3}
    s = set({1, 2, 3})
    

    使用方法

    s1 = {1, 2, 3}
    s2 = {2, 3, 4}
    
    # 1. 交集
    print(s1 & s2)  # {2, 3}
    
    # 2. 并集
    print(s1 | s2)  # {1, 2, 3, 4}
    
    # 3. 补集
    print(s1 ^ s2)  # {1, 4}
    
    # 4. 差集
    print(s1 - s2)  # {1}
    
    s = {1, 2, 3}
    
    # 1. add添加元素
    s.add(4)
    print(s)
    
    # 2. remove移除元素, 没有会报错
    s.remove(1)
    print(s)
    
    # 3. discard丢弃元素, 没有不会报错
    s.discard(1)
    print(s)
    
    # 4. pop随机删除一个元素
    s.pop()
    print(s)
    

    集合是无序/可变数据类型

    字典内置方法

    dic = {'a': 1, 'b': 2, 'c': 3}
    
    # 1. 按key取值/按key修改值/按key增加值
    print(dic['a']) # 1
    
    dic['a'] = 0
    print(dic) # {'a': 0, 'b': 2, 'c': 3}
    
    dic['d'] = 4
    print(dic) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    
    # 2. 成员运算(比较的是key)
    print('a' in dic) # True
    print('e' not in dic) # True
    
    # 3. for循环(对key循环)
    for i in dic:
        print(i) # a b c
        
    # 4. len长度
    print(len(dic)) # 3
    
    # 5. del删除
    del dic['a']
    print(dic)  # {'b': 2, 'c': 3}
        
    # 6. keys()/values()/items() -- 返回列表
    print(dic.keys()) # 所有的key
    print(dic.values()) # 所有的值
    print(dic.items()) # 所有的键值对
    
    # 7. get() 取值
    print(dic.get('a', 0)) # 找到了就返会a在字典中对应的值, 没找到就返回None, 如果给定了0, 没找到就返回0
    
    # 8. update() 扩展字典
    dic1 = {'d': 4}
    dic.update(dic1) 
    print(dic) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    
    # 9. fromkeys() 按key创建字典
    dic = dict.fromkeys(['name','age','gender'], None)
    print(dic)  # {'name': None, 'age': None, 'gneder': None}
    
    # 10. setdefault() 有则不变,无则增加
    dic.setdefault('a', 2)
    print(dic)  # {'a': 1, 'b': 2, 'c': 3}
    dic.setdefault('d', 4)
    print(dic)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
    

    深浅拷贝

    拷贝/浅拷贝/深拷贝都是针对可变数据类型而言的.

    拷贝

    如果lis2 是lis1的拷贝对象, 则1内部的元素变化, 则lis2内部的元素也跟着改变.

    lis1 = ['a', 'b', 'c', ['d','e','f']] 
    lis2 = lis1
    
    lis1[-1].append('g')
    lis1.append('h')
    
    print(lis1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
    print(lis2)  # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
    
    

    浅拷贝

    如果lis2是lis1的浅拷贝对象, 则l1内的不可变元素发生了变化, lis2不变; 如果lis1内的可变可变元素发生了改变, 则lis2会跟着改变.

    import copy
    lis1 = ['a', 'b', 'c', ['d','e','f']] 
    lis2 = copy.copy(lis1) 
    
    lis1[-1].append('g')
    lis1.append('h')
    
    print(lis1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
    print(lis2)  # ['a', 'b', 'c', ['d', 'e', 'f', 'g']]
    

    深拷贝

    如果lis2是lis1的深拷贝对象, lis2永远不会因为lis1的变化而变化.

    import copy
    lis1 = ['a', 'b', 'c', ['d','e','f']] 
    lis2 = copy.deepcopy(lis1) 
    
    lis1[-1].append('g')
    lis1.append('h')
    
    print(lis1)  # ['a', 'b', 'c', ['d', 'e', 'f', 'g'], 'h']
    print(lis2)  # ['a', 'b', 'c', ['d', 'e', 'f']]
    
  • 相关阅读:
    读书小记--<态度>
    frp 使用基础笔记
    ACM ICPC 2018 青岛赛区 部分金牌题题解(K,L,I,G)
    简单粗暴!解决锐捷强制关闭VMware NAT Service的问题(图文教程)
    杜教筛使用心得
    在阿里云的轻量级服务器上装桌面
    2018多校第三场 hdu6331 M :Walking Plan
    数论题集合
    hihoCoder挑战赛34 B题(快速求第k轮冒泡排序的结果)
    一阶微分边缘检测算子
  • 原文地址:https://www.cnblogs.com/bigb/p/11529013.html
Copyright © 2020-2023  润新知