python 基础复习 07

# 集合
"""
集合是一个可变的数据类型,但是它里面的元素必须是不可
变的数据类型，无序，不重复（去重）
也是{} 大括号
"""

# set2 = {1,2,3,[1,2,3],{"name": "lizy"}} # 报错 里面内容必须是不可变的
# print(set2)

# set1 = {"qaz", "qwe", "rfv"}

# 增加
#  add
# set1.add("lizy")
# print(set1)

# update
# set1.update("abcd")  # {'d', 'qaz', 'c', 'rfv', 'b', 'a', 'qwe'}
# print(set1)                #  把字符串‘abcd’无序的添加到字典当中

# 删除
# set1 = {"123", "456", "qaz"}
# set1.pop()  # 随机删除
# print(set1.pop())  # 有返回值
# print(set1)

# 按元素去删
# set1.remove("123")
# print(set1)

#  清空列表
# set1 = {"123", "456", "qaz"}
# set1.clear()
# print(set1)


# 面试题
# 把列表里重复的元素去掉  li = [1, 2, 33, 44, 33, 44, 5, 5]

# li = [1, 2, 33, 44, 33, 44, 5, 5]
# set1 = set(li)
# print(set1)
# li = list(set1)
# print(li)


#  set 本身是可变的数据类型
#  可以用 frozenset  变成不可变的

# s = frozenset("lizy")
# print(s, type(s))  # frozenset({'y', 'l', 'z', 'i'}) <class 'frozenset'>

# s1 = {1, 2, 3, 4}
# print(s1, type(s1))



# 删除列表下标为奇数的元素
# lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# lis1 = []
# for i in lis:
#     if i % 2 != 0:
#         lis1.append(i)
# lis = lis1
# print(lis)

# 删除字典里面有"k"的键
# dic = {"k1": "v1", "k2": "v2", "a3": "v3"}
# dic1 = {}
# for i in dic:
#     if "k" not in i:
#         dic1.setdefault(i, dic[i])
# dic = dic1
# print(dic)
# !!! 注意  在列表和字典循环的时候 不要去删除它们里面的元素！！

# 面试题
# 元祖
# tu = (1)
# tu1 = (1,)
# print(tu, type(tu))   # <class 'int'>
# print(tu1, type(tu1))  # <class 'tuple'>


# tu = ([1])
# tu1 = ([1],)
# print(tu, type(tu))  # [1] <class 'list'>
# print(tu1, type(tu1))  # ([1],) <class 'tuple'>
# 总结： 如果元祖里只有一个元素，只有加上“，逗号” ，它才是元祖，否则，元素是什么类型，就是什么类型


# ===========================================
# python中的深浅拷贝

# python当中对于拷贝，分为两种类型。一种是数字和字符串，另外一种就是字典 列表 元祖等其它类型。

# 对于数字和字符串的拷贝
# 数字和字符串在 赋值 浅拷贝 深拷贝 在内存当中用的都是同一块地址。


# 对于字典 列表 元祖 等其他类型的拷贝

# 赋值：字典、列表、元祖等其他类型用的内存地址不会变化 都是同一块内存地址。
# 浅拷贝：字典、列表、元祖等类型，它们只拷贝第一层地址。
# import copy

# n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
# n2 = copy.copy(n1)  # 浅拷贝
# print("第一层字典的内存地址：")
# print(id(n1))
# print(id(n2))
# print("第二层嵌套的列表的内存地址：")
# print(id(n1["k3"]))
# print(id(n2["k3"]))

# 输出结果：
# 第一层字典的内存地址：
# 2596105783768
# 2596105783840
# 第二层嵌套的列表的内存地址：
# 2596108135560
# 2596108135560


# 深拷贝：字典、列表、元祖等类型，它里面嵌套多少
# 层，就会拷贝多少层出来，但是最底层的数字和字符串地址不变。
# import copy
#
# n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 567]}
# n3 = copy.deepcopy(n1)  # 深拷贝
# print("第一层字典的内存地址：")
# print(id(n1))
# print(id(n3))
# print("第二层列表的内存地址：")
# print(id(n1["k3"]))
# print(id(n3["k3"]))

# 输出结果：
# 第一层字典的内存地址：
# 2268266269144
# 2268295394648
# 第二层列表的内存地址：
# 2268296866952
# 2268296867144

# 通过例子发现，进行深浅拷贝时，字典里面的第一层和里面嵌套的列表的地址
# 都已经改变了。对于深拷贝，它会拷贝多层，将第二层的列表也拷贝一份，如
# 果还有第三层嵌套，那么第三层的也会拷贝，但是对于里面的最小元素，比如
# 数字和字符串，这里就是"wu", 123, "alex", 567之类的，按照python的机
# 制，它们会共同指向同一个内存地址。


# 举个实际应用场景的栗子。

# 我们在维护服务器信息的时候，经常会要更新服务器信息，这时我们
# 重新一个一个添加是比较麻烦的，我们可以把原数据类型拷贝一份，
# 在它的基础上做修改。


# 例子一：

# import copy
#
# dic = {
#     "cpu": [70, ],
#     "mem": [70, ],
#     "disk": [70, ]
# }
# # 定义了一个字典，存储服务器信息。
# print("before", dic)
# new_dic = copy.copy(dic)
# new_dic["cpu"][0] = 30   # 更新cpu为 30
# print(dic)
# print(new_dic)

# 输出结果为：
# before {'cpu': [70], 'mem': [70], 'disk': [70]}
# {'cpu': [30], 'mem': [70], 'disk': [70]}
# {'cpu': [30], 'mem': [70], 'disk': [70]}

# 使用浅拷贝时，咱们修改新的字典的值后，旧的字典的值也被修改了，
# 这不是我们希望看到的


# 例子二：使用深拷贝
# import copy
#
# dic = {
#     "cpu": [70, ],
#     "mem": [70, ],
#     "dis": [70, ]
# }
# print("before", dic)
# new_dic = copy.deepcopy(dic)
# new_dic["cpu"][0] = 60
# print(dic)
# print(new_dic)

#  输出结果：
# before {'cpu': [70], 'mem': [70], 'dis': [70]}
# {'cpu': [70], 'mem': [70], 'dis': [70]}
# {'cpu': [60], 'mem': [70], 'dis': [70]}

#  注：本文是根据老男孩课程内容整理与引自 doublexi 的博客园而成。
#  下面特附上他的博客园网址，
# 本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。
# https://www.cnblogs.com/doublexi/