python 基础复习 07

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

  1 # set2 = {1,2,3,[1,2,3],{"name": "lizy"}} # 报错 里面内容必须是不可变的
  2 # print(set2)
  3 
  4 # set1 = {"qaz", "qwe", "rfv"}
  5 
  6 # 增加
  7 #  add
  8 # set1.add("lizy")
  9 # print(set1)
 10 
 11 # update
 12 # set1.update("abcd")  # {'d', 'qaz', 'c', 'rfv', 'b', 'a', 'qwe'}
 13 # print(set1)                #  把字符串‘abcd’无序的添加到字典当中
 14 
 15 # 删除
 16 # set1 = {"123", "456", "qaz"}
 17 # set1.pop()  # 随机删除
 18 # print(set1.pop())  # 有返回值
 19 # print(set1)
 20 
 21 # 按元素去删
 22 # set1.remove("123")
 23 # print(set1)
 24 
 25 #  清空列表
 26 # set1 = {"123", "456", "qaz"}
 27 # set1.clear()
 28 # print(set1)
 29 
 30 
 31 # 面试题
 32 # 把列表里重复的元素去掉  li = [1, 2, 33, 44, 33, 44, 5, 5]
 33 
 34 # li = [1, 2, 33, 44, 33, 44, 5, 5]
 35 # set1 = set(li)
 36 # print(set1)
 37 # li = list(set1)
 38 # print(li)
 39 
 40 
 41 #  set 本身是可变的数据类型
 42 #  可以用 frozenset  变成不可变的
 43 
 44 # s = frozenset("lizy")
 45 # print(s, type(s))  # frozenset({'y', 'l', 'z', 'i'}) <class 'frozenset'>
 46 
 47 # s1 = {1, 2, 3, 4}
 48 # print(s1, type(s1))
 49 
 50 
 51 
 52 # 删除列表下标为奇数的元素
 53 # lis = [1, 2, 3, 4, 5, 6, 7, 8, 9]
 54 # lis1 = []
 55 # for i in lis:
 56 #     if i % 2 != 0:
 57 #         lis1.append(i)
 58 # lis = lis1
 59 # print(lis)
 60 
 61 # 删除字典里面有"k"的键
 62 # dic = {"k1": "v1", "k2": "v2", "a3": "v3"}
 63 # dic1 = {}
 64 # for i in dic:
 65 #     if "k" not in i:
 66 #         dic1.setdefault(i, dic[i])
 67 # dic = dic1
 68 # print(dic)
 69 # !!! 注意  在列表和字典循环的时候 不要去删除它们里面的元素！！
 70 
 71 # 面试题
 72 # 元祖
 73 # tu = (1)
 74 # tu1 = (1,)
 75 # print(tu, type(tu))   # <class 'int'>
 76 # print(tu1, type(tu1))  # <class 'tuple'>
 77 
 78 
 79 # tu = ([1])
 80 # tu1 = ([1],)
 81 # print(tu, type(tu))  # [1] <class 'list'>
 82 # print(tu1, type(tu1))  # ([1],) <class 'tuple'>
 83 # 总结： 如果元祖里只有一个元素，只有加上“，逗号” ，它才是元祖，否则，元素是什么类型，就是什么类型
 84 
 85 
 86 # ===========================================
 87 # python中的深浅拷贝
 88 
 89 # python当中对于拷贝，分为两种类型。一种是数字和字符串，另外一种就是字典 列表 元祖等其它类型。
 90 
 91 # 对于数字和字符串的拷贝
 92 # 数字和字符串在 赋值 浅拷贝 深拷贝 在内存当中用的都是同一块地址。
 93 
 94 
 95 # 对于字典 列表 元祖 等其他类型的拷贝
 96 
 97 # 赋值：字典、列表、元祖等其他类型用的内存地址不会变化 都是同一块内存地址。
 98 # 浅拷贝：字典、列表、元祖等类型，它们只拷贝第一层地址。
 99 # import copy
100 
101 # n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 456]}
102 # n2 = copy.copy(n1)  # 浅拷贝
103 # print("第一层字典的内存地址：")
104 # print(id(n1))
105 # print(id(n2))
106 # print("第二层嵌套的列表的内存地址：")
107 # print(id(n1["k3"]))
108 # print(id(n2["k3"]))
109 
110 # 输出结果：
111 # 第一层字典的内存地址：
112 # 2596105783768
113 # 2596105783840
114 # 第二层嵌套的列表的内存地址：
115 # 2596108135560
116 # 2596108135560
117 
118 
119 # 深拷贝：字典、列表、元祖等类型，它里面嵌套多少
120 # 层，就会拷贝多少层出来，但是最底层的数字和字符串地址不变。
121 # import copy
122 #
123 # n1 = {"k1": "wu", "k2": 123, "k3": ["alex", 567]}
124 # n3 = copy.deepcopy(n1)  # 深拷贝
125 # print("第一层字典的内存地址：")
126 # print(id(n1))
127 # print(id(n3))
128 # print("第二层列表的内存地址：")
129 # print(id(n1["k3"]))
130 # print(id(n3["k3"]))
131 
132 # 输出结果：
133 # 第一层字典的内存地址：
134 # 2268266269144
135 # 2268295394648
136 # 第二层列表的内存地址：
137 # 2268296866952
138 # 2268296867144
139 
140 # 通过例子发现，进行深浅拷贝时，字典里面的第一层和里面嵌套的列表的地址
141 # 都已经改变了。对于深拷贝，它会拷贝多层，将第二层的列表也拷贝一份，如
142 # 果还有第三层嵌套，那么第三层的也会拷贝，但是对于里面的最小元素，比如
143 # 数字和字符串，这里就是"wu", 123, "alex", 567之类的，按照python的机
144 # 制，它们会共同指向同一个内存地址。
145 
146 
147 # 举个实际应用场景的栗子。
148 
149 # 我们在维护服务器信息的时候，经常会要更新服务器信息，这时我们
150 # 重新一个一个添加是比较麻烦的，我们可以把原数据类型拷贝一份，
151 # 在它的基础上做修改。
152 
153 
154 # 例子一：
155 
156 # import copy
157 #
158 # dic = {
159 #     "cpu": [70, ],
160 #     "mem": [70, ],
161 #     "disk": [70, ]
162 # }
163 # # 定义了一个字典，存储服务器信息。
164 # print("before", dic)
165 # new_dic = copy.copy(dic)
166 # new_dic["cpu"][0] = 30   # 更新cpu为 30
167 # print(dic)
168 # print(new_dic)
169 
170 # 输出结果为：
171 # before {'cpu': [70], 'mem': [70], 'disk': [70]}
172 # {'cpu': [30], 'mem': [70], 'disk': [70]}
173 # {'cpu': [30], 'mem': [70], 'disk': [70]}
174 
175 # 使用浅拷贝时，咱们修改新的字典的值后，旧的字典的值也被修改了，
176 # 这不是我们希望看到的
177 
178 
179 # 例子二：使用深拷贝
180 # import copy
181 #
182 # dic = {
183 #     "cpu": [70, ],
184 #     "mem": [70, ],
185 #     "dis": [70, ]
186 # }
187 # print("before", dic)
188 # new_dic = copy.deepcopy(dic)
189 # new_dic["cpu"][0] = 60
190 # print(dic)
191 # print(new_dic)
192 
193 #  输出结果：
194 # before {'cpu': [70], 'mem': [70], 'dis': [70]}
195 # {'cpu': [70], 'mem': [70], 'dis': [70]}
196 # {'cpu': [60], 'mem': [70], 'dis': [70]}
197 
198 #  注：本文是根据老男孩课程内容整理与引自 doublexi 的博客园而成。
199 #  下面特附上他的博客园网址，
200 # 本文仅供个人笔记使用，如果有侵犯，请联系我，我立即撤销。
201 # https://www.cnblogs.com/doublexi/

 

转载于:https://www.cnblogs.com/pioneerLee/p/10176219.html