07 list和dict for循环遍历索引问题以及深浅拷贝

# lst = ['杨宗纬', '李荣浩', 'Jason', 'karen']

# s = "_".join(lst)
# print(s)  # 杨宗纬_李荣浩_Jason_karen

# s = ""
# for el in lst:
#     s += el + '_'
# print(s.strip('_'))   # 杨宗纬_李荣浩_Jason_karen

字符串转化成列表:split()
列表转化成字符串:join()
x ->y 类型    y(x)
表示False的数据类型:False, 0, "", [], tuple(), dict(), set(), None

lst = ['王大锤', '王有才', '张小白', '刘大哥']
lst.clear()  # 清空这个列表

for el in lst:
     lst.remove(el)
 print(lst)      # ['王有才', '刘大哥'] 删除是不彻底的,原因是每次删除都会导致元素的移动,每次都会更新一次索引

 1.方案

for i in range(0,len(lst)):
    lst.pop()
print(lst)

 2方案把要删除的内容记录在一个新列表中

new_lst = []
for el in lst:
    new_lst.append(el)
# 循环这个新列表,删除原来的列表
for el in new_lst:
    lst.remove(el)
print(lst)      # [] 注意， 删除的是老列表

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

# 删除掉姓王的

new_lst = []
for el in lst:
    if el.startswith("王"):
        new_lst.append(el)
# 执行删除
for el in new_lst:
    lst.remove(el)
print(lst)

dict for循环遍历索引问题

dic = {"jay":'周杰伦', "jj":"林俊杰 ", "jack": "莱昂纳多迪卡普里奥"}
dic.clear()
print(dic)  # {}清空列表

for k in dic:
    dic["haha"] = "王大锤"
print(dic)          # RuntimeError: dictionary changed size during iteration

lst = []
for k in dic:
    lst.append(k)
for el in lst:
    dic["haha"] = "王大锤"
print(dic)

for k in list(dic):
    dic["哈哈"] = "王大锤"
print(dic)

# fromkeys()  帮我们创建字典
# d = dict.fromkeys("周杰伦", "王尼玛")
# print(d)    # {'周': '王尼玛', '杰': '王尼玛', '伦': '王尼玛'}

# 坑1
dic = {}
# fromkeys是创建新字典。 不是在原有的基础上给你增加键值对
d = dic.fromkeys("周杰伦", "王尼玛") # fromkeys是一个staticmethod  静态方法.
print(dic)  # {}
print(d)    # {'周': '王尼玛', '杰': '王尼玛', '伦': '王尼玛'}

# 坑2
你的value如果是可变的数据类型。 所有的key都可以改动这个数据。 一个改动， 所有的value都跟着改变
d = dict.fromkeys("周杰伦",["哇哈哈"])
print(d)        # {'周': ['哇哈哈'], '杰': ['哇哈哈'], '伦': ['哇哈哈']}
d["周"].append("爽歪歪")
print(d)        # {'周': ['哇哈哈', '爽歪歪'], '杰': ['哇哈哈', '爽歪歪'], '伦': ['哇哈哈', '爽歪歪']}

print(id(d["周"]), id(d["杰"]), id(d["伦"]))
2477155454536 2477155454536 2477155454536 id内存地址相等,变量指向同一个对象,

2.集合set

s = {1, 6, 1, 6, 1, 6,}
print(type(s))
print(s)
字典:{}
字典的key: 不可变,不能重复,底层存储是无序的,hash

集合:{}
集合里的元素:不可变,不能重复,底层也是无序的.hash

集合其实就是字典,集合里面不存value, 集合中之存储key
注意: set集合中的元素必须是可hash的, 但是set本⾝身是不可hash得. set是可变的.

# 应用(重点) 去重复
lst = ["周杰伦", "周杰伦", "王力宏", "王力宏", "胡辣汤"]
s = set(lst) # 集合
print(s)
# 转化成列表
print(list(s))

应用(重点) 去重复
lst = ["周杰伦", "周杰伦", "王力宏", "王力宏", "胡辣汤"]
s = set(lst) # 集合
print(s)
# 转化成列表
print(list(s))

s = {1, 2} # 本身是可变的,不可哈希,但是内部的元素是不可变的
s.add()
print(s)

list -> tuple
set -> frozenset

frozenset 可哈希的集合,不可变

s = {[1, 2, 3, 4]}
print(s)
for el in s:
    print(el)  TypeError: unhashable type: 'list'

s = frozenset([1, 2, 3, 4, 5])
print(s)        # frozenset({1, 2, 3, 4, 5})
for el in s:
    print(el)   # 1, 2, 3, 4, 5,

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.remove("关之琳") # 直接删除元素
# 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)

三.深浅拷贝

= 没有产生新对象。 都是内存地址的赋值

lst1 = ["孙悟空", "贝吉塔", "卡卡罗特"]
lst2 = lst1 # 赋值

lst1.append("短笛")
#
print(lst1)     # ['孙悟空', '贝吉塔', '卡卡罗特', '短笛']
print(lst2)     # ['孙悟空', '贝吉塔', '卡卡罗特', '短笛']
#
print(id(lst1), id(lst2))  # 2559667703368 2559667703368

copy 产生新的对象

lst1 = ["孙悟空", "贝吉塔", "卡卡罗特"]
# lst2 = lst1[:] # [:] 在原来的数据中获取到所有的数据组成新的列表
lst2 = lst1.copy() #  拷贝会帮我们创建新对象

lst1.append("短笛")

print(lst1)     # ['孙悟空', '贝吉塔', '卡卡罗特', '短笛']
print(lst2)     # ['孙悟空', '贝吉塔', '卡卡罗特']
print(id(lst1), id(lst2))   # 2314216574536 2314216592712

浅拷贝的问题
优点： 省内存.
缺点： 容易出现同一个对象被多个变量所引用

lst1.append("短笛")
lst1[3].append("巴啦啦小魔仙")
print(lst1)  # ['孙悟空', '贝吉塔', '卡卡罗特', ['七龙珠', '战斗陀螺', '巴啦啦小魔仙'], '短笛']
print(lst2)  # ['孙悟空', '贝吉塔', '卡卡罗特', ['七龙珠', '战斗陀螺', '巴啦啦小魔仙']]
print(id(lst1), id(lst2))  # 1645927978312 1645927979016

深拷贝

优点： 完全拷贝出一份两个对象之间除了数据相同。 没有任何关系
缺点： 占内存

import copy # 引入拷贝模块
lst1 = ["孙悟空", "贝吉塔", "卡卡罗特",["七龙珠","战斗陀螺"]]
lst2 = copy.deepcopy(lst1) # 会把这个对象相关的内部信息全部复制一份

lst1[3].append("巴啦啦小魔仙")
print(lst1)  #  ['孙悟空', '贝吉塔', '卡卡罗特', ['七龙珠', '战斗陀螺', '巴啦啦小魔仙']]
print(lst2)  #  ['孙悟空', '贝吉塔', '卡卡罗特', ['七龙珠', '战斗陀螺']]

print(id(lst1), id(lst2))  # 2051104469192 2051104470472

# 共同有点： 快速创建对象  -> 原型模式(设计模式)