day07

1. 基础数据类型补充

1. 补充一个字符串的基本操作

    s = "abc"  # 字符串
    s1 = s.join("非常可乐")  # 把字符串s插入到"非常可乐"中
    print(s1)  # 非abc常abc可abc乐

    # .join()可以把列表变成字符串
    s = "_".join(["aelx","wuse","taibai","ritian"])  # 列表
    print(s)  # aelx_wuse_taibai_ritian

    # .split()把字符串变成列表
    s = "我_爱_你"
    lst = s.split("_")
    print(lst)  # ['我', '爱', '你']

2. 列表循环删除

    # list在循环的时候不能删. 因为会改变索引
    li = [11, 22, 33, 44]
    for e in li:
         li.remove(e)
    print(li)  # [22,44]

    li = [11, 22, 33, 44]
    for i in range(0, len(li)):
        del li[i]
    print(li)  # 报错

    for el in li:
        li.pop() # [11,22]
    print(li)
    
    # 要想循环删除列表,就把要删除的再添加的一个新列表,然后循环这个新列表,删除列表里的元素
    # 1.
    lst = ['我不是药神','西游记','西虹市首富','天龙八部']
    del_lst = []  # 新列表
    for el in lst:
        del_lst.append(el)  # 把要删除的添加到新列表中

    for el in del_lst:  # 循环新列表
        lst.remove(el)  # 删除原来的列表
    print(lst)  # []
    
    # 2.
    lst = ['周杰伦','周润发','周星星','马化腾','周树人']
    del_lst = []
    for el in lst:
        if "周" in el:
            del_lst.append(el)
    
    for el in del_lst:
        if "周" in el:
            lst.remove(el)
    print(lst)  # ['马化腾']
　　
　　# 3.
　　# 循环len(li)次, 然后从后往前删除
　　li =[11,22,33,44]
　　for i in range(0,len(li)):
　　　　li.pop()  # 删除最后一个元素
　　print(li)  # []

3. 字典在循环过程中不能更改大小
    (1 ) 删除
    # 字典循环过程中不能删除
    dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
    # 删除key中带有'k'的元素
    for k in dic:
        if 'k' in k:
            del dic[k]  # 在循环迭代的时候不允许进⾏删除操作
    print(dic)  # RuntimeError: dictionary changed size during iteration

    # dict中的元素在迭代过程中是不允许进⾏删除的,把要删除的元素暂时先保存在⼀个list中, 然后循环list, 再删除.
    dic = {'k1': 'alex', 'k2': 'wusir', 's1': '⾦⽼板'}
    dic_del_list = []
    # 删除key中带有'k'的元素
    for k in dic:
        if 'k' in k:
            dic_del_list.append(k)
    for el in dic_del_list:
        del dic[el]
    print(dic)

    (2) 增加
    # 字典循环过程中不能添加
    dic = {"易大师":"剑圣","大宝剑":"盖伦","暗夜猎手":"薇恩"}
    # 如果keyshi"易大师",就添加"潮汐海灵"和它对于的value值"小鱼人".
    for el in dic:
        if el == "易大师":
            dic.setdefault("潮汐海灵","小鱼人")
    print(dic)  # RuntimeError: dictionary changed size during iteration

    # dict中的元素在迭代过程中是不允许进⾏删除的,把要删除的元素暂时先保存在⼀个list中, 然后循环list, 再删除.
    dic = {"易大师":"剑圣","大宝剑":"盖伦","暗夜猎手":"薇恩"}
    lst = []
    for el in dic:
        lst.append(el)
   
    for i in lst:
        if i in dic:
            dic.setdefault("潮汐海灵","小鱼人")
    print(dic)  # {'易大师': '剑圣', '大宝剑': '盖伦', '暗夜猎手': '薇恩', '潮汐海灵': '小鱼人'}

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

4. fromkey()
    # dict中的fromkey(),可以帮我们通过list来创建⼀个dict,返回一个新的字典.

    a = dict.fromkeys(['jj','jay','taibai'],'sb')  # 静态方法
    print(a)  # {'jj': 'sb', 'jay': 'sb', 'taibai': 'sb'}
    
    dic = {'a':'123'}  # 没有用
    s = dict.fromkeys('王健林','思聪')  # 返回给你一个新的字典
    print(s)  # {'王': '思聪', '健': '思聪', '林': '思聪'}

5. 类型转换
    元组 => 列表    list(tuple)
    列表 => 元组    tuple(list)
    
    list => str     str.join(list)
    str => list     str.split()
    
    转换成False的数据:
    0,'',None,[],(),{}.set() => False

2. set集合

1. set集合简介
    set中的元素是不重复的(去重), 无序的.里面的元素必须是可hash(不可变)的(int,str,tuple,bool)
    set就是dic类型的数据但是不保存value,只保存key. set也用{}表示
    注意: set集合中的元素必须是可hash(不可变)的,但是set本身是不可hash(可变)的.
　　

　　s = set() # 空集合
　　dic = dict() # 空字典
　　s = str()  # 空字符串
　　i = int()  # 0
　　lst = list()  # 空列表

　　s = {'a'}
　　print(type(s))  # <class 'set'>

2. 去重 和 frozenset()
    (1) 去重
    # set本身就可以去重
    s = {'王者荣耀','英雄联盟','王者荣耀', 123, True, True}
    print(s)  # {123, True, '英雄联盟', '王者荣耀'}

    # 其他数据可以先转换成set类型,再转换回去,就可以去重.
    lst = ['张强','李强','王磊','刘伟','张伟','张伟','刘洋','刘洋']
    s = set(lst)  # 去重复
    print(s)  # {'张强', '李强', '王磊', '刘伟', '刘洋', '张伟'}
    lst = list(s)  # 变回来
    print(lst)  # ['张强', '李强', '王磊', '刘伟', '刘洋', '张伟']

    (2) frozenset
    # 冻结了的set集合. 可哈希(不可变)的.
    s = frozenset([1,3,6,6,9,8])    # 可以去重复
    print(s)  # frozenset({1, 3, 6, 8, 9})
    
    ss = {'a',s}
    print(ss)  # {frozenset({1, 3, 6, 8, 9}), 'a'}

3. set集合的增删改查
    (1) 增加
        s = {"刘嘉玲", '关之琳', "王祖贤"}
        s.add("郑裕玲")
        print(s)
        s.add("郑裕玲") # 重复的内容不会被添加到set集合中
        print(s)

        s = {"刘嘉玲", '关之琳', "王祖贤"}
        s.update("麻花藤") # 迭代更新
        print(s)  # {'王祖贤', '花', '关之琳', '藤', '麻', '刘嘉玲'}
        s.update(["张曼⽟", "李若彤","李若彤"])
        print(s)  # {'王祖贤', '花', '关之琳', '藤', '张曼⽟', '李若彤', '麻', '刘嘉玲'}
    (2) 删除
        s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
        item = s.pop() # 随机弹出⼀个.
        print(s)  # {'关之琳', '张曼⽟', '李若彤', '王祖贤'}
        print(item)  # 刘嘉玲
    
        s = {"刘嘉玲", '关之琳', "王祖贤","张曼⽟", "李若彤"}
        s.remove("关之琳") # 直接删除元素
        print(s)  # {'王祖贤', '刘嘉玲', '李若彤', '张曼⽟'}
        s.remove("⻢⻁疼") # 不存在这个元素. 删除会报错
        print(s)  # KeyError: '⻢⻁疼'

        s.clear() # 清空set集合.需要注意的是set集合如果是空的. 打印出来是set()         
        因为要和dict区分的.
        print(s) # set()

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

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

4. set集合的常用操作
    s1 = {"刘能", "赵四", "⽪⻓⼭"}
    s2 = {"刘科⻓", "冯乡⻓", "⽪⻓⼭"}
    
    # 交集
    # 两个集合中的共有元素
    print(s1 & s2) # {'⽪⻓⼭'}
    print(s1.intersection(s2)) # {'⽪⻓⼭'}

    # 并集
    print(s1 | s2) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}
    print(s1.union(s2)) # {'刘科⻓', '冯乡⻓', '赵四', '⽪⻓⼭', '刘能'}

    # 差集
    print(s1 - s2) # {'赵四', '刘能'} 得到第⼀个中单独存在的
    print(s1.difference(s2)) # {'赵四', '刘能'}

    # 反交集
    print(s1 ^ s2) # 两个集合中单独存在的数据 {'冯乡⻓', '刘能', '刘科⻓', '赵 
    四'}
    print(s1.symmetric_difference(s2)) # {'冯乡⻓', '刘能', '刘科⻓', '赵四'}
    s1 = {"刘能", "赵四"}
    s2 = {"刘能", "赵四", "⽪⻓⼭"}

    # ⼦集
    print(s1 < s2) # set1是set2的⼦集吗? True
    print(s1.issubset(s2))

    # 超集
    print(s1 > s2) # set1是set2的超集吗? False
    print(s1.issuperset(s2))

3. 深浅拷贝

(1) = 不会产生新的对象
    # ,一个变量改变,另一个也跟着变,因为两个变量指向一个数据
    lst1 = ["金毛狮王", "紫衫龙王", "白眉鹰王", "青衣服往"]
    lst2 = lst1  # 列表. 进行赋值操作实际上是引用内存地址的赋值. 内存中此时只有一 
    个列表. 两个变量指向一个列表,所以内存地址一样.

    lst2.append('杨做事')  # 对其中的一个进行操作. 两个都跟着变
    print(lst2)  # ['金毛狮王', '紫衫龙王', '白眉鹰王', '青衣服往', '杨做事'] 
    print(id(lst2))  # 2939242504776
    print(lst1)  # ['金毛狮王', '紫衫龙王', '白眉鹰王', '青衣服往', '杨做事']
    print(id(lst1))  # 2939242504776

(2) 浅拷贝
    #  copy 创建新对象
    lst1 = ['赵本山','刘能','赵四']
    lst2 = lst1.copy()  # lst2 和list1 不是一个对象了,内存地址不一样.
    print(id(lst2),id(lst1))  # 1737898025608 1737898025544
    
    lst1.append("谢大脚")  # lst1添加'谢大脚",lst2不会变.
    print(lst1)  # ['赵本山', '刘能', '赵四', '谢大脚']
    print(lst2)  # ['赵本山', '刘能', '赵四']
    
    # 切片会产生新的对象
    lst1 = ['赵本山','刘能','赵四']
    lst2 = lst1[:]  # 产生新对象, 内存地址不一样
    print(id(lst2),id(lst1))  # 2403266159240 2403266159176

    # 浅拷贝只拷贝第一层,第二层的内容不会被拷贝.
    lst1 = ['超人','七龙珠',"葫芦娃",'山中小猎人',['金城武','王力宏','渣渣辉']]
    lst2 = lst1.copy()  # 浅拷贝只拷贝第一层, 第⼆层的内容不会拷⻉. 所以被 
    称为浅拷⻉

    lst1.append("aelx")  # 第一层被拷贝了,列表1和2各自有一个第一层,所以列表1添加"alex",列表2第一层就不会改变.
    
    lst1[4].append("大阳哥")  # 第二层没有被拷贝,列表1和2共用的痛一个第二层,
    所以第二层的元素改变,列表1和2的第二层都一起改变
    
    print(lst1)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉', '大阳哥'], 'aelx']
    print(lst2)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉', '大阳哥']]

(3) 深拷贝
    # 深度拷贝会把内部的所有内 容进行拷贝
    import copy

    lst1 = ['超人','七龙珠',"葫芦娃",'山中小猎人',['金城武','王力宏','渣渣辉']]
    lst2 = copy.deepcopy(lst1)  # 把lst1扔进去进行深度拷贝, 包括内部的所有内 
    容进行拷贝
    lst1[4].append("大阳哥")  # 深度拷贝,列表1和2的第二层列表也是不共用的,各自拥有各自的第二层,所以改变列表1的第二层,列表2的第二层不会改变.
    print(lst1)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉', '大阳哥']]
    print(lst2)  # ['超人', '七龙珠', '葫芦娃', '山中小猎人', ['金城武', '王力宏', '渣渣辉']]

　　总结:
　　　　1. = 不会产生新的对象
　　　　2. 浅拷贝. 只拷贝第一层. 创建新对象
　　　　3. 深拷贝. 把这个对象完全的进行拷贝. 创建出全新的对象