Day 06 代码块：缓存：深浅copy：集合：id is ==

01 今日内容大纲

1. is == id 用法
2. 代码块
3. 同一代码块下的缓存机制
4. 不同代码块下的缓存机制(小数据池)
5. 总结
6. 集合（了解）
7. 深浅copy

02 昨日回顾以及作业讲解

1. 字典：
   • 查询速度快，{'name':'taibai'}，存储大量的关联型数据。
   • 键：不可变的数据类型（可哈希）（int str bool tuple），唯一的
   • 值：任意数据类型，对象。
   • 3.5x之前无序，3.6x按照初始的顺序排列，3.7之后有序
2. 增删改查：
   • 增：setdefault（）有则不变，无则增加，dic['age'] = 18 有则改值，无则增加
   • 删：pop（）键 ，可以设置返回值，clear ，de
   • 改：dic['age'] = 18 有则改值，无则增加
   • 查：dic.['name'] dic.get('name') dic.keys(),dic.values(),dic.items()
3. 字典的嵌套

03 具体内容

1. id is ==
   #id 身份证号
   i = 100
   s = 'alex'
   print(id(i))
   print(id(s))
   print(id(i) == id(s)) #比较两边的值是否相等 #False
   l1 = [1,2,3]
   l2 = [1,2,3]
   print(id(l1) == id(l2)) #False

   s1 = 'alex'
   s2 = 'alex'
   print(id(s1) == id(s2))       #True
   
   # is 判断的是内存地址是否相同
   l1 = [1,2,3]
   l2 = [1,2,3]
   print(id(l1))
   print(id(l2))
   print(l1 is l2)
   
   s1 = 'alex'
   s2 = 'alex'
   print(id(s1))
   print(id(s2))
   print(s1 is s2)
   
   # id值相同，值一定相同
   # 值相同，id不一定相同
   

2. 代码块：

   • 代码块： 我们所有的代码都需要以来代码块来执行。
   • 一个文件就是一个代码块。
   • 交互式命令下，一行就是一个代码块

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

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

   • 前提条件：同一个代码块内。
   • 机制内容：pass
   • 适用的对象：int bool str
   • 具体细则：所有的数字，bool，几乎所有的字符串
   • 优点：提升性能，节省内存。

5. 不同代码块下的缓存机制：小数据池

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

   • 机制内容：pass

   • 适用的对象：int bool str

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

   • 优点：提升性能，节省内存
     i1 = 1000
     i2 = 1000
     i3 = 1000
     l1 = [1,2,3] #不适用
     l2 = [1,2,3] #不适用
     print(id(l1))
     print(id(l2))
     print(id(i1))
     print(id(i2))
     print(id(i3))

     i = 800    #所有数字
     i1 = 800
     s1 = 'askjdlkajdkjaskl;djalksdjgdshjfk12039-0127645z中国'    #大多数字符串
     s2 = 'askjdlkajdkjaskl;djalksdjgdshjfk12039-0127645z中国'
     print(i is i1)     #True
     print(s1 is s2)    #True
     

     1. 总结：+
        1. 面试题考
        2. 回答的时候一定要分清楚：同一个代码块下适用一个缓存机制。不同的代码块下适用另一个缓存机制（小数据池）
        3. 小数据池：数字的范围是-5~256.
        4. 缓存机制的优点：提升性能，节约内存。
     2. Python基础数据类型之：集合set。 容器型数据类型，集合set中的元素是不可变数据，但他本身是可变的数据类型。集合是无序的。{1, 3, '太白金星', 4, 'alex', False, '武大'}
        • 集合的作用：

          • 列表的去重

          • 关系测试：交/并/差集

          • pass
            # 集合的创建：
            set1 = set({1,3,'barry',False})
            set1 = {1,3,'taibai',False,'alex'}
            print(set1)
            #
            #空集合：
            print({},type({})) #空字典
            set1 = set() #空集合
            print(set1)

            #集合的有效性测试：
            set1 = {[1, 2, 3], 3, {'name': 'alex'}}
            print(set1)  #有字典
            set1 = {'太白金星', '景女神', '武大', '三粗', 'alexsb', '吴老师'}
            print(set1)
            
            #增：add
            set1.add('xxxx')
            print(set1)
            
            #update 迭代着增加
            set1.update('asdkjahsgfkjagkfg')
            print(set1)
            
            #删 remove 按照元素删
            set1.remove('alexsb')
            print(set1)
            
            #pop 随机删除
            set1.pop()
            print(set1)
            
            #变相改值
            set1.remove('太白金星')
            set1.add('武大郎买')
            print(set1)
            
            # 关系测试 ***
            set1 = {1, 2, 3, 4, 5}
            set2 = {4, 5, 6, 7, 8}
            #交集
            print(set1 & set2)
            
            #并集
            print(set1 | set2)
            
            #差集
            print(set1 - set2)
            
            #反交集
            print(set1 ^ set2)
            
            #子集
            set1 = {1, 2, 3, 4, 5}
            set2 = {1,2,3,4,5,6,7,8,9,0}
            print(set1 < set2)      #True
            
            #超集
            print(set2 > set1)
            
            #列表的去重***
            l1 =  [1,'太白', 1, 2, 2, '太白',2, 6, 6, 6, 3, '太白', 4, 5, ]
            set1 = set(l1)
            l1 = list(set1)
            print(l1)
            #用处：数据之间的关系，列表去重。
            

6. 深浅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,id(l1))
   print(l2,id(l2))
   
   #深copy   #python对深copy做了一个优化，将不可变的数据类型沿用同一个。
   import copy
   l1 = [1,2,3,[22,33]]
   l2 = copy.deepcopy(l1)
   print(l1,id(l1))
   print(l2,id(l2))
   l1[-1].append(666)
   print(l1,id(l1))
   print(l2,id(l2))
   
   #相关面试题：
   l1 = [1,2,3,[22,33]]
   l2 = l1[:]
   l1[-1].append(666)
   print(l1)
   print(l2)
   # 浅copy： list dict: 嵌套的可变的数据类型是同一个
   # 深copy： list dict: 嵌套的可变的数据类型不是同一个
   

04 今日总结

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

05 预习内容

• 数据类型的补充与编码的进阶数据类型的补充以及编码的进阶：https://www.cnblogs.com/jin-xin/articles/10577131.html