代码块小数据池集合的认识

---恢复内容开始---

### 代码块小数据池

1. id is ==

   1. id 就好比身份证号

      1. i = 100
         s = 'alex'
         print (id(i))
         print (id(s))
         

   2. == 比较的是两边的值是否相等

      1. l1 = [1,2,3]
         l2 = [1,2,3]
         print (l1 == l2)
         s1 = 'alex'
         s2 = 'alex'
         print (s1 == s2)
         

   3. is 判断的是内存地址是否相同

      1. l1 = [1,2,3]
         l2 = [1,2,3]
         print (id(l1))
         print (id(l2))
         print (l1 is l2)
         #id 相同，值一定相同
         #值相同的，id不一定相同
         

   4. 代码块

      1. 代码块：我们所有的代码都需要依赖代码块执行。
      2. 一个文件就是一个代码块
      3. 交互式命令下一行就是一个代码块

   5. 两个机制：同一代码块下，有一个机制。不同的代码块下，遵循另一个机制

   6. 同一代码块下的缓存机制。

      • 前提条件：同一代码块内。
      • 机制内容：Python在执行同一个代码块的初始化对象的命令时，会检查是否其值是否已经存在，如果存在，会将其重用。换句话说：执行同一个代码块时，遇到初始化对象的命令时，他会将初始化的这个变量与值存储在一个字典中，在遇到新的变量时，会先在字典中查询记录，如果有同样的记录那么它会重复使用这个字典中的之前的这个值。所以在你给出的例子中，文件执行时（同一个代码块）会把i1、i2两个变量指向同一个对象
      • 适用对象：int bool str
      • 具体细节：所有的数字，bool，几乎所有的字符串。
      • 优点：提升性能

   7. 不同代码块下的缓存机制：小主机池

      • 前提条件：不同代码块内。

      • 机制内容：Python自动将-5~256的整数进行了缓存，当你将这些整数赋值给变量时，并不会重新创建对象，而是使用已经创建好的缓存对象。

        python会将一定规则的字符串在字符串驻留池中，创建一份，当你将这些字符串赋值给变量时，并不会重新创建对象， 而是使用在字符串驻留池中创建好的对象。

      • 适用的对象：int bool str

      • 具体细则：-5~256数字，bool，满足规则的字符串。

      • 优点：提升性能，节省内存

      i1 = 1000
      i2 = 1000
      i3 = 1000
      l1 = [1,2,3]
      l2 = [1,2,3]
      print(id(i1))
      print(id(i2))
      print(id(i3))
      print(id(l1))
      print(id(l2))
      
      i = 800
      l1 = 800
      s1 = 'hfdjka6757fdslslgaj@!#fkdjlsafjdskl;fjds中国'
      s2 = 'hfdjka6757fdslslgaj@!#fkdjlsafjdskl;fjds中国'
      print(i is l1)
      print(s1 is s2)
      

   8. 总结代码块的缓存机制

      1. 回答的时候一定要分清楚：同一个代码块下适用一个缓存机制，不同代码下适用另一个缓存机制。
      2. 小数据池：数字的范围是-5~256.
      3. 缓存机制的优点：提升性能，节省内存。

2. Python基础数据类型之：集合 set。容器型的数据类型，它要求它里面的元素是不可变的数据类型，但是它本身是可变的数据类型。集合是无序的。

   1. 集合的作用：

      • 列表去重
      • 关系测试：交集，并集，差集

   2. 集合的创建

      #set1 = set({1,2,3,'barry','False'})
      #set1 = {1,2,3,'太白金星'，'alex'}
      print(set1)
      
      #空集合
      print({},type({}))#这样创建出来的是空字典
      set1 = set()
      print(set1)q
      
      #集合的有效性测试
      set1 = {[1,2,3],3,{'name':'laex'}}
      print(set1)#集合里面的数据类型必须是不可变的比如str，bool，int
      

   3. 集合的增删改查

      # set1 = {'太白金星', '景女神',  '武大', '三粗', 'alexsb', '吴老师'}
      
      #增  add
      set1.add('xx')
      print(set1)
      
      #迭代着增加 update
      set1.update('fhasoh')
      print(set)
      
      # 删除 remove按照元素删除
      set.remove('alexsb')
      print(set)
      
      #随即删除 pop
      set1.pop()
      print(set1)
      
      # 变相改值
      set1.remove('太白金星')
      set1.add('男神')
      print(set1)
      

   4. 集合关系测试

      #交集 &
      set1 = {1, 2, 3, 4, 5}
      set2 = {4, 5, 6, 7, 8}
      print(ste1&set2)
      
      #并集：|
      print(set1 | set2)
      
      #差集 -
      pring(set1 - set2)
      
      #反交集 ^
      print(set1 ^ set2)
      
      #子集
      set1 = {1,2,3}
      set2 = {1,2,3,4,5,6}
      print(set1<set2)
      
      #超集
      print(set2 > set1)
      
      # 列表的去重
      l1 = [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
      set1 = set(l1)
      l1 = list(set1)
      print(l1)
      

3. 深浅copy

   #赋值运算
   l1 = [1,2,3,[22,33]]
   l2 = l1
   l1.append(666)
   print(l1)
   print(l2)
   
   浅copy
   l1 = [1,2,3,[22,33]]
   l2 = l1.copy()
   l1.append(666)
   print(l1,id(l1))
   print(l2,id(l2))
   
   l1 = [1,2,3,[22,33]]
   l2 = l1.copy()
   l1[0] = 90
   print(l1)
   print(l2)
   
   #深copy
   import copy
   l1 = [1,2,3,[22,33]]
   l2 = copy.deepcopy(l1)
   print(id(l1))
   print(id(l2))
   l1[-1].append(666)
   print(l1)
   print(l2)
   

今日总结

1. id is == 三个方法要会用，知道是做什么的
2. 回答的时候一定要分清楚:同一代码块下适用的缓存机制。不同的代码块下适用另一个缓存机制（小数据池）
3. 小数据池：数字的范围是-5~256.
4. 缓存机制的优点：提升性能，节省内存。
5. 集合：列表去重，关系测试。
6. 深浅copy：理解浅copy，深copy。

---恢复内容结束---