python学习笔记5

python学习笔记5

一、集合

1. 集合是一种容器型数据类型，里面的元素是不可变的数据，但它本身是可变的数据类型。集合是无序的。

2. 集合常用于列表的去重和关系测试（交集，并集，差集...）

   # 集合的创建
   set_1 = set({1,2,3,'A','abc','中国',False})
   print(set_1) # {False, 1, 2, 3, '中国', 'A', 'abc'}
   # 从打印出的结果可以看出集合是无序的
   

3. 空集合

   # 创建一个空集合
   # 一种错误的创建方式
   set_0 = {} 
   print(type(set_0)) # <class 'dict'>  # 说明这实际上创建的是一个空字典
   
   # 正确的创建方式
   set_1 = set()
   print(type(set_1)) # <class 'set'>
   

4. 集合元素的增加

   # 使用add方法
   set_1 = {'name','age','sex'}
   set_1.add('hobby')
   print(set_1) # {'age', 'name', 'hobby', 'sex'} 
   # 又一次看出集合的无序性
   
   # update方法，迭代着增加
   set_1.update('abc')
   print(set_1) # {'age', 'b', 'c', 'a', 'hobby', 'name', 'sex'}
   

5. 集合元素的删除

   # remove按照元素删除
   set_1 = {'name','age','sex'}
   set_1.remove('age')
   print(set_1) # {'name', 'sex'}
   
   # 随机删除pop
   set_2 = {'name','age','sex'}
   set_2.pop()
   print(set_2) # {'name', 'sex'}
   

6. 集合元素的修改

   # 只能作一种变相的修改
   # 将sex改成hobby
   set_1 = {'name','age','sex'}
   set_1.remove('sex')
   set_1.add('hobby')
   print(set_1) # {'age', 'name', 'hobby'}
   

7. 集合的交集操作

   # &或者intersection
   set_1 = {1,2,3,4,5,6}
   set_2 = {4,5,6,7,8,9}
   print(set_1&set_2) # {4, 5, 6}
   

8. 集合的并集操作

   # |或者union
   set_1 = {1,2,3,4,5,6}
   set_2 = {4,5,6,7,8,9}
   print(set_1|set_2) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
   

9. 集合的差集

   # -或者difference
   set_1 = {1,2,3,4,5,6}
   set_2 = {4,5,6,7,8,9}
   print(set_1 - set_2) # {1, 2, 3}
   print(set_2 - set_1) # {8, 9, 7}
   

10. 反交集

    # ^或者symmetric_difference
    set_1 = {1,2,3,4,5,6}
    set_2 = {4,5,6,7,8,9}
    print(set_1^set_2) # {1, 2, 3, 7, 8, 9}
    # 相当于set_1|set_2 - (set_1&set_2)
    

11. 子集和超集

    # 用 < 判断一个集合是否是另一个集合的子集
    set_1 = {1,2,3}
    set_2 = {1,2,3,4,5,6,7,8,9}
    print(set_1<set_2) # True    # 也可以用issubset
    print(set_2>set_1) # True    # 也可以用issuperset
    # 此时set_1是子集,set_2是超集
    

12. 列表的去重

    # 用集合对列表li进行去重
    li = [1,1,2,3,4,4,5,3,6,6,7,7,7,7]
    li = list(set(li))
    print(li) # [1, 2, 3, 4, 5, 6, 7]
    

二、代码块下的两种缓存机制（节省内存，提升性能）

1. 同一代码块下的缓存机制：适用对象为所有的数字,布尔型和几乎所有的字符串。在同一代码块下，系统会检查内存中数据字典有无已经创建好的相同数据，如果有相同数据则会共用同一个内存地址。
2. 不同代码块间的缓存机制（小数据池）：适用对象为-5~256之间的数字以及满足规则的字符串。

三、深浅copy

1. 从一个例子出发

   # 例1
   li_1 = [1,2,[3,4]]
   li_2 = li_1
   li_1.append(5)
   print(li_1) # [1,2,[3,4],5]
   print(li_2) # [1,2,[3,4],5]
   # 这里体现了python中'='的意义，它代表把变量指向一个已有的内存地址
   # 相当于变量li_1存储的其实只是列表[1,2,[3,4]]在内存中的地址
   # 而li_2指向了li_1
   # 调用li_1,li_2时读取了存储的地址从而引用了实际的列表[1,2,3]
   # 而列表的append操作时对于[1,2,[3,4]]进行的，所以li_1和li_2都会相应的变化
   

2. 浅copy（只copy了一个外壳）

   # 例2
   li_1 = [1,2,[3,4]]
   li_2 = li_1.copy()
   li_1.append(5)
   print(li_1) # [1, 2, [3, 4], 5]
   print(li_2) # [1, 2, [3, 4]]
   # 这里li_2其实将li_1的数据复制一份并重新分配了一部分内存进行存储
   # 即li_1,li_2分别指向[1,2,[3,4]]的地址
   

   # 例3
   li_1 = [1,2,[3,4]]
   li_2 = li_1.copy()
   # 对列表中嵌套的列表进行元素添加
   li_1[-1].append(5)
   print(li_1) # [1, 2, [3, 4, 5]]
   print(li_2) # [1, 2, [3, 4, 5]]
   # 原理跟例1一样，内部嵌套的列表没有经过copy的操作
   # li_1和li_2中指向的内存地址是一样的
   

3. 深copy

   # 深copy需要加载一个模块
   import copy
   
   li_1 = [1,2,[3,4]]
   li_2 = copy.deepcopy(li_1)
   print(li_1,id(li_1)) # [1, 2, [3, 4]] 2273744785224
   print(li_2,id(li_2)) # [1, 2, [3, 4]] 2273744784712
   # 储存的内容相同,指向的id地址也不同
   # 随意改变一个列表的内容，另一个列表不改变
   li_1[-1].append(5)
   print(li_1) # [1, 2, [3, 4, 5]]
   print(li_2) # [1, 2, [3, 4]]
   

4. python对深copy做了一个优化，将不可变的数据类型沿用同一个，而可变的数据类型重新创建一份。