python摸爬滚打之day07----基本数据类型补充, 集合, 深浅拷贝

1、补充

　　1.1  join()字符串拼接.

 strs = "阿妹哦你是我的丫个哩个啷"
 nw_strs = "_".join(strs)
 print(nw_strs)  #  阿_妹_哦_你_是_我_的_丫_个_哩_个_啷

 lst = ["a","b","c","d"]
 nw_lst = "*".join(lst)
 print(nw_lst)   # a*b*c*d

join()拼接

　　1.2  不用clear()清空列表或字典 ----> 把要删除的元素放在新列表里,然后批量删除.

　　　　list: 在循环遍历时每次删除都会导致列表内部元素的位置前移发生变化.

　　　dict: 在循环遍历时不允许变更字典的长度(即不能增加或删除键值对).

 li = [11, 22, 33, 44, 55]
 while li:
     li.pop()
 print(li)         # 只要li不为空就一直删除最后一个,直到为空

 del_li = []
 for i in li:
     del_li.append(i)
 for j in del_li:        # 把要删除的元素放在另一个列表里,然后循环遍历新列表,删除旧列表
     li.remove(j)
 print(del_li)

清空列表

　　1.3  fromkeys(参1,参2)

　　　　创建新字典. 参1 为可迭代对象, 把参1 中的每一个元素作为key, 把参2 作为value, 生成新字典.

　　　　fromkeys()是一个静态方法,只能通过类名或字典对象来调用, 返回的是一个新字典, 和原来的字典没有关系.

 d = dict.fromkeys("ab", [1,2,3])
 print(d)      # {'a': [1, 2, 3], 'b': [1, 2, 3]}

 dic = {"a":1}
 d = dic.fromkeys("ab", [1,2,3])
 print(d)       # {'a': [1, 2, 3], 'b': [1, 2, 3]}

fromkeys()方法

2、set集合

　　2.1  集合本身是不可哈希(可变)的, 但是里面的元素是不可变的, 而且是不能重复的.

　　　　集合最大的作用就是去重.

 lst = [1,2,5,3,2,5,4,1]
 print(list(set(lst)))     # [1, 2, 3, 4, 5]

set去重

　　2.2  增删改查

　　　　增  　add(),update()

 sets = {"王祖贤","张曼玉","关之琳"}
 sets.add("刘嘉玲")
 print(sets)      #{'关之琳', '刘嘉玲', '张曼玉', '王祖贤'}

 sets.update(["张敏","刘嘉玲"])
 print(sets)      # {'刘嘉玲', '关之琳', '王祖贤', '张敏', '张曼玉'}

　　　　删　　remove(指定内容),    pop()不能指定

　　　　改　　集合是无序的,没有办法通过索引进行修改,只能先删除后添加.

　　　　查　　for循环遍历.

　　2.3  交集(&), 并集(|), 差集(-), 反交集(^)

　　　　s1 < or > s2    s1是s2的子集吗? ---->True or False

 s1 = {1,2,5,6,3,4,7}
 s2 = {2,6,4,8,12,29}
 print(s1 & s2)      # {2, 4, 6}
 print(s1 | s2)      # {1, 2, 3, 4, 5, 6, 7, 8, 12, 29}
 print(s1 - s2)      # {1, 3, 5, 7}    s1中单独存在的
 print(s1 ^ s2)      # {1, 3, 5, 7, 8, 12, 29}    两个集合中单独存在的数据 

3、深浅拷贝

　　= 赋值

　　　　lst2 = lst1    将lst1的内存地址 赋值给lst2, 所以lst1 增删改,lst2 也发生变化

 lst1 = ["大魔王","二魔王","大老三","刘老四"]
 lst2 = lst1        # 将lst1的内存地址赋值给lst2,所以lst1增删改,lst2也发生变化
 lst1.append("王老五")
 print(lst1)
 print(lst2)

　　浅拷贝  [:] 和 copy()----> 省内存.

　　　　只复制第一层的内存地址.

 lst1 = ["大魔王","二魔王","大老三","刘老四"]
 lst2 = lst1[:]      # 只复制第一层的内存地址
 lst1.append("王老五")
 print(lst1)     # ['大魔王', '二魔王', '大老三', '刘老四', '王老五']
 print(lst2)     # ['大魔王', '二魔王', '大老三', '刘老四']

 lst1 = ["大魔王","二魔王",["大","老","三"],"刘老四"]
 lst2 = lst1.copy()      #   只复制第一层的内存地址,lst1和lst2引用的都是["大","老","三"]的内存地址,
                         #   不是里面元素,所以在["大","老","三"]发生增删改时,lst1和lst2也发生
 变化.
 lst1[2].append("不老")
 print(lst1)     # ['大魔王', '二魔王', ['大', '老', '三', '不老'], '刘老四']
 print(lst2)     # ['大魔王', '二魔王', ['大', '老', '三', '不老'], '刘老四']

浅拷贝

　　深拷贝  deepcopy()  ---->占内存

　　　　复制一个对象,里面有lst1的所有的元素, lst1的增删改和lst2 再无任何瓜葛.

 import copy
 lst1 = ["大魔王","二魔王",["大","老","三"],"刘老四"]
 lst2 = copy.deepcopy(lst1)      # 深拷贝,把所有元素都copy过来,和lst2完全脱离,lst1的增删改和lst2无任何关系.
 lst1[2].append("不老")
 print(lst1)         #  ['大魔王', '二魔王', ['大', '老', '三', '不老'], '刘老四']
 print(lst2)         #  ['大魔王', '二魔王', ['大', '老', '三'], '刘老四']

深拷贝