• set集合,深浅拷⻉


      set集合,深浅拷⻉

    ⼀. 基础数据类型补充

      将列表转换成字符串. 每个元素之间用_拼接

       字符串转换成列表: split()

       把列表转换成字符串: join()       join(可迭代对象)

    1 li = ["李嘉诚", "麻花藤", "⻩海峰", "刘嘉玲"]
    2 s = "_".join(li)
    3 print(s)
    4 li = "⻩花⼤闺⼥"
    5 s = "_".join(li)
    6 print(s)

      列表:

      循环删除列表中的每⼀个元素

      

    1 li = [11, 22, 33, 44]
    2 for e in li:
    3   li.remove(e)
    4 print(li)
    5 结果:
    6 [22, 44]

      分析原因:

      for的运⾏过程. 会有⼀个指针来记录当前循环的元素是哪⼀个, ⼀开始这个指针指向第0 个. 然后获取到第0个元素. 紧接着删除第0个. 这个时候. 原来是第⼀个的元素会⾃动的变成 第0个. 然后指针向后移动⼀次, 指向1元素. 这时原来的1已经变成了0, 也就不会被删除了

    经过分析发现. 循环删除都不⾏. 不论是⽤del还是⽤remove,pop也不行. 都不能实现.

      ⽤另⼀个列表来记录你要删除的内容. 然后循环删除

     1 lst = ["紫云", "大云", "玉溪", "紫钻","a","b"]
     2 # lst.clear()
     3 # new_lst = [] # 准备要删除的信息
     4 # for el in lst: # 有一个变量来记录当前循环的位置
     5 #     new_lst.append(el)
     6 # # 循环新列表, 删除老列表
     7 # for el in new_lst:
     8 #     lst.remove(el)
     9 # # 删除的时候, 发现. 剩余了一下内容. 原因是内部的索引在改变.
    10 # # 需要把要删除的内容记录下来. 然后循环这个记录. 删除原来的列表
    11 #
    12 # print(lst)
    13 # print(new_lst)
     1 # lst = ["张国荣", '张铁林', '张国立', "张曼玉", "汪峰"]
     2 # # 删掉姓张的
     3 # # 记录姓张的.
     4 # zhangs = []
     5 # for el in lst:
     6 #     if el.startswith("张"):
     7 #         zhangs.append(el)
     8 # for el in zhangs:
     9 #     lst.remove(el)
    10 # print(lst)
    11 # print(zhangs)

      由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要再循环中直接去删 除元素. 可以把要删除的元素添加到另⼀个集合中然后再批量删除.

      综上. 列表和字典都不能再循环的时候进行删除. 字典再循环的时候不允许改变大小

      dict中的fromkey(),可以帮我们通过list来创建⼀个dict 

    1 dic = dict.fromkeys(["jay", "JJ"], ["周杰伦", "麻花藤"])
    2 print(dic)
    3 结果:
    4 {'jay': ['周杰伦', '麻花藤'], 'JJ': ['周杰伦', '麻花藤']}

      返回新字典. 和原来的没关系,直接用字典去访问fromkeys不会对字典产生影响。

    1  ret = dict.fromkeys("abc",["哈哈","呵呵", "吼吼"]) # fromkeys直接使用类名进行访问
    2  print(ret)
    3 a = ["哈哈","呵呵", "吼吼"]
    4 ret = dict.fromkeys("abc", a) # fromkeys直接使用类名进行访问
    5 a.append("嘻嘻")
    6 print(ret)

    二  集合

      set集合是python的⼀个基本数据类型. ⼀般不是很常⽤. set中的元素是不重复的.⽆序的.⾥ ⾯的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记. set就是dict类型的数据但 是不保存value, 只保存key. set也⽤{}表⽰。

      set集合中的元素必须是可hash的, 但是set本⾝是不可hash得. set是可变的.

      set中的元素是不重复的, 且⽆序的.

      

    1 # 给list去重复
    2 lst = [45, 5, "哈哈", 45, '哈哈', 50]
    3 lst = list(set(lst)) # 把list转换成set, 然后再转换回list
    4 print(lst)

      set集合增删改查

      1. 增加

    1 s = {"刘嘉玲", '关之琳', "王祖贤"}
    2 s.add("郑裕玲")
    3 print(s)
    4 s.add("郑裕玲") # 重复的内容不会被添加到set集合中
    5 print(s)
    6 s = {"刘嘉玲", '关之琳', "王祖贤"}
    7 s.update("麻花藤") # 迭代更新
    8 print(s)

      2. 删除

     1 s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
     2 item = s.pop() # 随机弹出⼀个.
     3 print(s)
     4 print(item)
     5 s.remove("关之琳") # 直接删除元素
     6 # s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错
     7 print(s)
     8 s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set() 因为要和
     9 dict区分的.
    10 print(s) # set()

      3. 修改

    1 # set集合中的数据没有索引. 也没有办法去定位⼀个元素. 所以没有办法进⾏直接修改.
    2 # 我们可以采⽤先删除后添加的⽅式来完成修改操作
    3 s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
    4 # 把刘嘉玲改成赵本⼭
    5 s.remove("刘嘉玲")
    6 s.add("赵本⼭")
    7 print(s)

      4. 查询

    1 # set是⼀个可迭代对象. 所以可以进⾏for循环
    2 for el in s:
    3  print(el)

      5. 常⽤操作

     1 # 交集
     2 # 两个集合中的共有元素
     3 print(s1 & s2) # {'⽪⻓⼭'}
     4 print(s1.intersection(s2)) # {'⽪⻓⼭'}
     5 # 并集
     6 print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
     7 print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
     8 # 差集
     9 print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
    10 print(s1.difference(s2)) # {'赵四', '刘能'}
    11 # 反交集
    12 print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
    13 print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
    14 s1 = {"刘能", "赵四"}
    15 s2 = {"刘能", "赵四", "⽪⻓⼭"}
    16 # ⼦集
    17 print(s1 < s2) # set1是set2的⼦集吗? True
    18 print(s1.issubset(s2))
    19 # 超集
    20 print(s1 > s2) # set1是set2的超集吗? False
    21 print(s1.issuperset(s2))

    三. 深浅拷⻉

      对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量. 并不是复制⼀份内容. 所以. lst1的内存指向和lst2是⼀样的. lst1改变了, lst2也发⽣了改变

      浅拷贝

     1 lst1 = ["何炅", "杜海涛","周渝⺠"]
     2 lst2 = lst1.copy()
     3 lst1.append("李嘉诚")
     4 print(lst1)
     5 print(lst2)
     6 print(id(lst1), id(lst2))
     7 结果:
     8 两个lst完全不⼀样. 内存地址和内容也不⼀样. 发现实现了内存的拷⻉
     9 lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]]
    10 lst2 = lst1.copy()
    11 lst1[3].append("⽆敌是多磨寂寞")
    12 print(lst1)
    13 print(lst2)
    14 print(id(lst1[3]), id(lst2[3]))
    15 结果:
    16 ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
    17 ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
    18 4417248328 4417248328

    浅拷⻉. 只会拷⻉第⼀层. 第⼆层的内容不会拷⻉. 所以被称为浅拷⻉。

      深拷贝

     1 import copy      #引入copy模块
     2 lst1 = ["何炅", "杜海涛","周渝⺠", ["麻花藤", "⻢芸", "周笔畅"]]
     3 lst2 = copy.deepcopy(lst1)
     4 lst1[3].append("⽆敌是多磨寂寞")
     5 print(lst1)
     6 print(lst2)
     7 print(id(lst1[3]), id(lst2[3]))
     8 结果:
     9 ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅', '⽆敌是多磨寂寞']]
    10 ['何炅', '杜海涛', '周渝⺠', ['麻花藤', '⻢芸', '周笔畅']]
    11 4447221448 4447233800

    深度拷⻉. 把元素内部的元素完全进⾏拷⻉复制. 不会产⽣⼀个改变另⼀个跟着 改变的问题

  • 相关阅读:
    linux 程序后台运行
    小型网站架构技术点(简要)
    rsync安装与配置使用 数据同步方案(centos6.5)
    nfs的原理 安装配置方法 centos6.5
    centos 6.5 升级到 python2.7
    ntpdate 设置时区(注意本地时区要设置正确)
    关于umask的计算方式(简单任性)
    No space left on device(总结)
    lsof 查看打开了一个文件的有哪些进程 统计那个进程打开的文件最多
    作用域是什么?
  • 原文地址:https://www.cnblogs.com/chenxi67/p/9414671.html
Copyright © 2020-2023  润新知