set集合、深浅拷贝

时间:2021-06-18 19:51:40

1.基础数据类型补充:

  1.把列表用join转换成字符串

    li = ['我是谁','我在哪','我在干什么']

    s = '_'.join(li)

    print(s)

    # 我是谁_我在哪_我在干什么

 

    li = ['成龙演的我是谁']

    s = '_'.join(li)

    print(s)

    # 成_龙_演_的_我_是_谁

 

 

    split()可以把字符串切割成列表

    s = '成_龙_演_的_我_是_谁'

    s.split('_')

    print(s)

    #  ['成','龙','演','的','我','是','谁']

 

2. 列表的循环删除

    for的运行过程. 会有一个指针来记录当前循环的元素是哪一个,

    一开始这个指针指向第0 个. 然后获取到第0个元素. 紧接着删除第0个.

    这个时候. 原来是第一个的元素会自动的变成第0个. 然后指针向后移动

    一次, 指向1元素. 这时原来的1已经变成了0, 也就不会被删除了.

 

  办法1.

    用一个新列表记录要删除的内容,然后循环老列表删除新列表里内容。

    li = ['1','2','3','4','5','6','7']

    lst = [] # 新建一个列表

    for el in li:  # 循环遍历列表的每一项

    lst.append(el)  # 把老列表中想要删除的每一项装进新列表里。

    for el in lst:     #  循环遍历新列表,拿到要删除的每一项。

    li.remove(el)  # 老列表指定删除新列表里想要删除的每一项。

    print(li)          #  打印老列表

    # []  空列表     

 

 

  办法2.

    用range 循环列表(len)次,用pop从最后一位开始删除。

    li = ['1','2','3','4','5','6','7']

    for el in range(0,len(el)): # 循环遍历列表的长度,拿到列表中的每一项。

    li.pop() # 然后用pop从最后一位开始删除。

    print(li)    #  打印列表

    #  []    空列表

 

    注意: 由于删除元素会导致元素的索引改变, 所以容易出现问题. 尽量不要

    再循环中直接去删除元素. 可以把要删除的元素添加到另一个集合中然后再批

    量删除.

 

 

    feomkeys

    dic = dict.fromkeys(['我是谁','我在哪'])

    print(dic)

    # {'我':'我在哪','是':'我在哪','谁':'我在哪'

    注:新的字典是通过第一个参数的迭代,和第二个参数组合成key:value创建新字典

 

3.类型转换

    元组 => 列表    list(tuple)

    列表 => 元组    tuple(list)

 

    liat => str      str.join(list)

    str  => list     str.split()

 

    转换成False的数据:

    0,'',Nien,[],(),{},set() ==> False

 

2.set集合

    set集合是python的一个基本数据类型. 一般不是很常用. set中的元素是不重复的.

    无序的.里面的元素必须是可hash的(int, str, tuple,bool), 我们可以这样来记.

    set就是dict类型的数据但是不保存value, 只保存key. set也用{}表示

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

 

  1.增

    s = {'我是谁','我在哪','我在干什么'}

    s.add('演电影')  

    print(s)

    # {'我是谁','我在哪','我在干什么','演电影'}

    注: 重复的内容不会添加到set集合中。

 

 

    s = {'我是谁','我在哪','我在干什么'}

    s.update('鬼知道')  #  迭代添加

    print(s)

    # {'我是谁','我在哪','我在干什么','鬼','知','道'}

 

  2.删

    s = {'我是谁','我在哪','我在干什么'}

    s.pop()  # 随机删除一个

    print(s)

    # {'我是谁','我在干什么'}

 

    s = {'我是谁','我在哪','我在干什么'}

    s.remove('我是谁')  # 指定元素删除

    print(s)

    # {'我在哪','我在干什么'}

 

    s = {'我是谁','我在哪','我在干什么'}

    s.clear()  # 默认清空

    print(s)

    # {}

 

  3.改

    注: set集合中的数据没有索引. 也没有办法去定位一个元素. 所以没有

    办法进行直接修改.我们可以采用先删除后添加的方式来完成修改操作。

 

    s = {'我是谁','我在哪','我在干什么'}

    s.remove('我在干什么')  # 先指定删除

    s.add('我是演员') # 再添加

    print(s)

    # {'我是谁','我在哪','我是演员'}

 

  4.查

    注:set是一个可迭代对象. 所以可以进行for循环。

    s = {'我是谁','我在哪','我在干什么'}

    for el in s:

    print(el)  # 打印set中的每一项

    # 我是谁

      我在干什么

      我在哪

  

  5.常用操作

    交集

      s = {'我是谁','我在哪','我在干什么'}

      s1 = {'我是谁','我在哪','我在干什么','鬼','知','道'}

      print(s & s1)  # 两个集合*有的

      print(s.intersection(s1))

 

    并集

      s = {'我是谁','我在哪','我在干什么'}

      s1 = {'我是谁','我在哪','我在干什么','鬼','知','道'}

      print(s | s1) # 综合两个集合共有的(不重复)

      print(s.union(s1))

 

 

    差集

      s = {'我是谁','我在哪','我在干什么'}

      s1 = {'我是谁','我在哪','我在干什么','鬼','知','道'}

      print(s1 - s)   # 谁-谁,就得到第一个单独存在的。

      print(s1.difference(s))

 

    反交集

      s = {'我是谁','我在哪','我在干什么'}

      s1 = {'我是谁','我在哪','我在干什么','鬼','知','道'}

      print(s ^ s1)   # 两个集合中单独存在的。

      print(s.symmetric_difference(s1))

 

    子集(判断)

      s = {'我是谁','我在哪','我在干什么'}

      s1 = {'我是谁','我在哪','我在干什么','鬼','知','道'}

      print(s < s1)  # s在s1中,所以s是s1的子集。

      print(s.issubset(s1))

 

   超集(判断)

      s = {'我是谁','我在哪','我在干什么'}

      s1 = {'我是谁','我在哪','我在干什么','鬼','知','道'}

      print(s1 > s)  # s1包含s,所以s1是s的超集。

      print(s1.issuperset(s))

 

 

3.深浅拷贝

  赋值:

    lst1 = ["金毛狮王", "紫衫龙王", "白眉鹰王", "青翼蝠王"]

    lst2 = lst1

    print(lst1)

    print(lst2)

    lst1.append("杨逍")

    print(lst1)

    print(lst2)

    结果:

    ['金毛狮王', '紫衫龙王', '白眉鹰王', '青翼蝠王', '杨逍']

    ['金毛狮王', '紫衫龙王', '白眉鹰王', '青翼蝠王', '杨逍']

 

    dic1 = {"id": 123, "name": "谢逊"}

    dic2 = dic1

    print(dic1)

    print(dic2)

    dic1['name'] = "范瑶"

    print(dic1)

    print(dic2)

    结果:

    {'id': 123, 'name': '谢逊'}

    {'id': 123, 'name': '谢逊'}

    {'id': 123, 'name': '范瑶'}

    {'id': 123, 'name': '范瑶'}

     注:对于list, set, dict来说, 直接赋值. 其实是把内存地址交给变量.

      并不是复制一份内容. 所以.lst1的内存指向和lst2是一样的. lst1改变了,

      lst2也发生了改变

 

浅拷贝:

    lst1 = ["何炅", "杜海涛","周渝民"]

    lst2 = lst1.copy()

    lst1.append("李嘉诚")

    print(lst1)

    print(lst2)

    print(id(lst1), id(lst2))

 

    结果:

    两个lst完全不一样. 内存地址和内容也不一样. 发现实现了内存的拷贝

 

    lst1 = ["何炅", "杜海涛","周渝民", ["麻花藤", "马芸", "周笔畅"]]

    lst2 = lst1.copy()

    lst1[3].append("无敌是多磨寂寞")

    print(lst1)

    print(lst2)

    print(id(lst1[3]), id(lst2[3]))

    结果:

    ['何炅', '杜海涛', '周渝民', ['麻花藤', '马芸', '周笔畅', '无敌是多磨寂寞']]

    ['何炅', '杜海涛', '周渝民', ['麻花藤', '马芸', '周笔畅', '无敌是多磨寂寞']]

    4417248328 4417248328

   注:浅拷贝. 只会拷贝第一层. 第一层的内容不会拷贝. 所以被称为浅拷贝。

   

深拷贝:

    import copy

     lst1 = ["何炅", "杜海涛","周渝民", ["麻花藤", "马芸", "周笔畅"]]

    lst2 = copy.deepcopy(lst1)

    lst1[3].append("无敌是多磨寂寞")

    print(lst1)

    print(lst2)

    print(id(lst1[3]), id(lst2[3]))

 

    结果:

    ['何炅', '杜海涛', '周渝民', ['麻花藤', '马芸', '周笔畅', '无敌是多磨寂寞']]

    ['何炅', '杜海涛', '周渝民', ['麻花藤', '马芸', '周笔畅']]

    4447221448 4447233800

 

    注:深度拷贝. 把元素内部的元素完全进行拷贝复制. 不会产生一个改变另

    一个跟着改变的问题。