02--常见内容、垃圾回收机制、可变不可变类型、条件、逻辑与成员运算符、深浅拷贝

详见知乎与博客-liaohaifeng

1.常见内容

# 1.小整数池（了解）
    python解释器 会自动在内存中生成[-5, 256]的常用数值，为节省内存空间，提高效率。也会有部分字母。
        注：pycharm 扩大了常用数值和字母，但实际以解释器为准

        
# 2.常量
    python中没有常量的概念，但是大家都约定熟成，变量名全为大写的 代表常量，值不变。

    
# 3.字符串
    a.可以为单引号，双引号，三引号； 三引号常用来注释，但是被赋值给变量时，就是字符串。
    b.字符串可以 加号操作，表示字符串的拼接，但实际开发不推荐使用，因为效率很低。  * 号同理

    
# 4.用户输入函数 input()
    会将所有输入的内容，保存为字符串类型。

    
# 6.运算符相关
    /  ：相除，
    %  ：取余数
    // ：取商 相除后，只保留整数部分

    赋值运算符：
        增量赋值
            a += 1
        交叉赋值
            m,n = n,m
        链式赋值
            x=y=z=10
        解压赋值
            x,y,z =[1,2.3]  # 一一对应
            x,y,*_ = [1,2,3,4]  #  * 表示剩下的所有， _ 表示变量，该变量常被默认临时的东西
            x,y,*_，z= [1,2,3,4]  #  该方法常用取容器两端的数值

2.内存管理机制--垃圾回收机制GC

# 1.什么是垃圾回收机制
    Python解释器自带一种机制，专门用来回收不可用的变量值所占用的内存空间
    
# 2.为什么要用垃圾回收机制
    程序运行过程中会申请大量的内存空间，
    而对于一些无用的内存空间如果不及时清理的话会导致内存使用殆尽（内存溢出），
    导致程序崩溃，因此管理内存是一件重要且繁杂的事情，
    而python解释器自带的垃圾回收机制把程序员从繁杂的内存管理中解放出来。


# a.引用计数 （主要）
    当某个值的引用计数为0时，会被python解释器自动清除。
    引用为 直接引用（值直接赋值给变量）和间接引用（值通过变量，再被传递到其他地方赋值或使用）
    
# b.标记-清除  为了解决循环引用带来的内存泄露问题

   变量 ---> 栈区              ---> 堆区
         内存地址(总大小固定)        对应值

        
    从 内存的栈区 中的变量 开始出发，能在堆区中找到对应值
    且值被直接引用或者间接引用，则 该变量标记为激活状态
    然后删除没有被标记的。
    
    简单来说，就是堆区的值，必须要在 栈区 找到 某一个对应关系，否则就删除
    例：python是引用传递
        l1 = [111,222]
        l2 = [333,444]
        l1.append(l2)
        l2.append(l1)

        del l1
        del l2

    这时候，l1 与 l2 之间存在循环引用，但是l1 与 l2 变量 被删除了
    原则来说 两个对应列表内存空间也应该被删除，但是
    因为 他们之间存在相互的间接引用，所以 不会被 引用计数 删除掉
    
# c.分代回收  用来降低引用计数的扫描频率，提升垃圾回收的效率
    因为引用计数和标记-清除会一直不停对所有变量进行全体扫描，但太消耗内存，且效率低
    原理就是
    先全部遍历，然后将设置频率
    分成重点照顾对象的组和不常被清理的组等，就精准按照某种频率进行扫描

3.可变不可变类型

# 1.可变类型：
值改变，id不变，说明改的是原值，原值是可以被改变的。
--list 列表，dict 字典（但字典内部的 key 是不可变类型），

# 2.不可变类型：
值改变，id也变 ，说明是产生新的值，压根没有改变原值，原值是不可以被改变的。
--整型，浮点型，字符串，布尔类型 （都是被设计成不可分割的整体，不能够被改变）

4.什么是条件？什么可以当做条件？为何要用条件？

# 条件可以是：
    比较运算符；
    布尔类型（True，False）；
    隐式布尔值（所有的值都可以当成条件去用）
        其中 0，None，空（空字符串，空列表，空字典）代表False，其余都是True

5.逻辑运算符

# 1.基本使用（单独使用时，多个条件，从左到右依次判断）
    not ：逻辑非，就是将紧跟其后的条件结果取反（not与其后的条件 是一个不可分割的整体)
    and ：逻辑与，就是用来连接左右两个条件（两个同时为真，其整体结果为真），可以连接多个条件（有一个为假，就为假）
    or  ：逻辑或，就是用来连接左右两个条件（两个同时为假，其结果为假），可以连接多个条件（有一个为真时，就为真）
    
# 2.混合使用
    优先级：not > and > or
    eg：3 > 4 and not 4 > 3 or 1 ==3 and 'x' == 'x' or 3 > 3
                false                       false           false
        (3 > 4 and (not 4 > 3)) or (1 ==3 and 'x'== 'x') or 3 > 3
    注：实际开发不这样复杂使用，因为不能第一眼就判断出来，
        若必须使用，就将其中条件用（）包起来，外层只剩 and 或者 or 进行单一判断，方便短路运算

# 3.短路运算
    偷懒原则，偷懒到哪个位置，就把当前位置的值返回

    注意：在短路运算中，若偷懒到隐式布尔值的位置，返回的值不会直接显示布尔类型，会是该隐式布尔值，实际还是代表其布尔值。
    eg： 10 > 3 and None and True  -----> 结果：None ( 虽然不是直接显示布尔类型，但实际还是 false）

6.成员运算符

# A in B
  判断A 是否在B中

# A not in B 
  判断A 是否不在B中
    
# 注：字典 in 运算时，是判断字典的key

7.深浅拷贝

# 1.浅拷贝
    只是拷贝了第一层（就是新建一个不同地址的列表），然后剩下层里的（就是列表中的元素），
    不管是可变类型，还是不可变类型，都还是指向原列表中 元素的地址
    
# 2.深拷贝
    拷贝了第一层（就是新建一个不同地址的列表），然后剩下层里的（就是列表中的元素），
    将可变与不可变类型做了区分，若是不可变类型，就指向原列表中 元素的地址；若是可变类型，就新建地址

    
# 总结：
    1.要想原列表与拷贝的列表，相互完全独立开来（就是原列表修改时，拷贝的列表不会受影响，反之一样）-----深拷贝
      引用 copy模块， copy.deepcopy()
        
    2.浅拷贝，当原列表的元素全是不可变类型时，两个列表也独立开了，但是有可变类型时，且发生修改时，会产生影响，一样被修改。
      直接 .copy()