Day7--Python--基础数据类型补充,集合,深浅拷贝

一.基础数据类型补充
    1.join() 把列表中的每一项(必须是字符串)用字符串拼接   与split()相反
        lst = ["汪峰", "吴君如", "李嘉欣", "陈慧琳", "关之琳"]
        # 遍历列表. 把列表中的每一项用"_" 做拼接
        s = "_".join(lst) # 把列表转化成字符串
        print(s)

        s1 = "汪峰_吴君如_李嘉欣_陈慧琳_关之琳"
        ls = s1.split("_") # 把字符串转化成列表
        print(ls)

        print("*".join("马化腾"))  #迭代着加入  马*化*腾
    2.关于删除(重点)
        1.循环迭代过程中不能删除
        2.创建新列表,把要删除的内容保存在新列表中,循环新列表,删除老列表
        3.字典在循环中不能改变键值对数量

        lst = ["渣渣辉", "古天绿", "陈小春", "彭佳慧", "郑中基", "胡辣汤"]
        # lst.clear()
        for el in lst: # for 内部有一个变量来记录当前被循环的位置, 索引.
             lst.remove(el) # 直接删除. 是删不干净的. 原因是每次删除都设计到元素的移动. 索引在变.

        先把要删除的内容保存在一个新列表中. 循环这个新列表. 删除老列表
        new_lst = []
        for el in lst:
            new_lst.append(el)
        for el in new_lst:
            lst.remove(el)
        print(lst)

        lst = ["张无忌", "张三丰", "张翠山", "张嘉译", '刘嘉玲', "刘能", '刘老根']
        # 删除姓张的人
        new_lst = []
        for el in lst:
            if el.startswith("张"):
                new_lst.append(el)

        for el in new_lst:
            lst.remove(el)
        print(lst)

        dic = {"谢逊": '金毛狮王', "韦一笑":"青翼蝠王","殷天正":"白眉鹰王","金花婆婆":"紫衫龙王"}
        for k in dic:
            dic['谢逊'] = "张无忌他爹"
        print(dic)

    3.fromkeys
        dict.fromkeys(k, v) 把key迭代,和value组合成k:v创建新字典,所有v是同一个地址
　　　　
　　　　 d = dict.fromkeys('abc', 666)
　　　　 print(d)    #创建新字典

        d = {}
        # fromkeys正常来说应该是类名来访问的.
        dd = d.fromkeys(["胡辣汤","are you 确定?"], "周芷若") # fromkeys是一个类中的静态方法.作用是创建新字典
        print(d) # 原字典没有改变
        print(dd) # 新的字典是通过第一个参数的迭代. 和第二个参数组合成key:value创建新字典

        d = dict.fromkeys(["哇哈哈", "爽歪歪"], []) # 所有的key用的value都是同一个内存地址.都是同一个列表，改变其中一个。 另一个也跟着改变
        d["哇哈哈"].append("张无忌")
        print(d)

        print(id(d['哇哈哈']), id(d["爽歪歪"]))
    4.类型转换
        元组 => 列表 list(tuple)
        列表 => 元组 tuple(list)
        list => str  str.join(list)
        str => list  str.split()
        转换成False的数据:
        0,'',None,[],(),{},set() ==> False

　　## 交换值
　　　　a = 10
　　　　b = 20
      a, b = b, a
　　　　print(a, b)
二.set集合
    1.特点: 无序,去重,内部元素可哈希
        lst = []
        list(set(lst))  #去重复, 因为集合是无序的,所以去重后顺序会打乱.

# 看一个对象里面的元素是否可修改
print('__setitem__' in dir(set))  # False  set中的元素不可修改,不可变.

    数据类型:不重复,无序,它里面的元素是可哈希的.它本身是不可哈希的,因此不能作为字典的 key
    set相当于不存value的字典,只存key    空集合 set()
    作用:

        1.去重 (重点)
            li = [11,11,22,22,33,33,44,44]
            li = list(set(li))
            print(li)

         2.数据关系的测试
            增:
            set1 = {'alex', 'wusir', 'egon', 'barry', 'ritian'}
            set1.add('女神')
            set1.update('abc')   #迭代着增加
            set1.update([1, 2, 3])

            删:
            set1.remove('alex')    #如果对象不存在,则报错KeyError
　　　　　　　set1.discard()  #如果删除对象不存在,也不会报错
            set1.pop() #随机删除
            set1.clear() #清空   空集合 set()
            del set1 删除整个集合

            改:
            删除后增加
            set1.remove('alex')
            set1.add('elsa')

            查:
            for i in set1:
                print(i)

　　　　　　　s = {1, 2, 3, 4}
　　　　　　　print(2 in s)   #存在返回True,不存在返回False

          3.求交集:
                set1 = {1,2,3,4,5}
                set2 = {4,5,6,7,8}
                print(set1 & set2)   #{4, 5}
                print(set1.interscetion(set2))

            反交集:
                print(set1 ^ set2)
                print(set.symmetric_difference(set2))

            并集:
                print(set1 | set2)
                print(set1.union(set2))

            差集:
                print(set1 - set2)
                print(set2 - set1)

            子集与超集:
            set1 = {1,2,3}
            set2 = {1,2,3,4,5,6,}
            print(set1.issubset(set2))  #子集  set1是set2的子集
            print(set2.issuperset(set1)) #超集 set2是set1的超集

            set1 = {'barry', 'wusir'}
            set2 = frozenset(set1)   # 冻集合不能进行添加和删除操作
            print(set2,type(set2))

            ---------------------------------------------------------
            dic = {"a":"哇哈哈", "a":"爽歪歪"}
            print(dic) # key 不会重复
            dic[[1,2,3]] = "哇哈哈" # 必须是可哈希的

            s = set() # 空集合
            s = {1,2,3,6,3,4,6,4, [4,5,6]} # 不重复, 必须是可哈希的
            print(s)

            set其实就是不存value的字典. 只存key
            去重复
            lst = [1,2,3,4,4,4,4,5,5,6,7,7,7]
            s = set(lst)
            lst = list(s)
            print(lst)

            s = {"赵本山", "范伟", "小沈阳", "高秀敏", "宋小宝"}
            s.add("赵铁柱")
            s.add("李小花")
            s.add("王尼玛")
            s.add("张全蛋")
            print(s)

            s.update(("刘伟", '张伟', "张三丰")) # 迭代更新   [],(),{}里面可以放空列表,空元组,空集合,空字典,字典提取key迭代加入

            item = s.pop()
            s.remove("小沈阳")
            print(s)
            print(item)

            for el in s:
                print(el)

三.深浅拷贝   #不是指向一个内存地址,而是在内存中开辟了一个内存空间
    1.赋值
        赋值使用同一个内存地址,多个变量共享一个对象
    2.浅拷贝
        对于浅copy来说, 第一层创建的是新的内存地址,
        而从第二层开始, 指向的都是同一个内存地址,
        所以, 对于第二层以及更深的层数来说, 保持一致性.

　　　　　lst= lst[:]  #切片是浅拷贝

        l1 = [1, 2, 3]
        l2 = l1.copy()
        l1.append(111)
        print(l1, l2)
        print(id(l1), id(l2))

        l1 = [1, 2, 3, [1, 2, 3], 4]
        l2 = l1.copy()
        l1[3].append(5)
        print(l1, l2)
    3.深拷贝
        对于深copy来说,两个对象是完全独立的,
        改变任意一个元素(无论多少层),另一个绝对不改变

        import copy   #导入拷贝模块
        l1 = [1,2,3,[1,2,3],4]
        l2 = copy.deepcopy(l1)
        l1[3].append(666)
        print(l1, l2)

        l1 = [1,2,3,[22,33]]
        l2 = l1[:]     #切片相当于浅copy
        l1[3].append(666)
        print(l2)