DAY21、面向对象

一、内存管理与正则语法
1、内存管理：
引用计数：垃圾回收机制工作原理
    引用就 +1 ，释放就 -1 ，当计数为0时，就会被垃圾回收机制回收
标记清除：解决循环导入引用导致的内存泄漏
    标记：GC roots 可以直接或间接访问到的数据，都被标记为存活状态
    清除：触发标记清除动作后，将所有存活状态的变量复制到新空间，将老空间中的所有值清空
分代回收：提高回收效率的优化策略
    分代：将长期存活的变量移至更高代，检查频率降低
    回收：回收的依据还是采用引用计数
2、正则:import re
方法：findall | match | split| sub
findall :全文匹配，返回值是列表
    res = re,findall('','')
分组：通过分组加（），拿到匹配到的结果中的指定信息
    res = re.findall('((\w*?)>)', '<a>abc</a>')
    print(res)  # [('a>', 'a'), ('a>', 'a')]
操作分组的方法:
(？P<name>...):有名分组
返回值是match匹配的结果对象，可以.group（组序号|组名）来取具体组的信息
    res = re.match('(\d{3})(?P<center>\d{3})(\d{3})', '123456789')
    print(res.group('center')     # center就是组名
compile：传入一个有正则语法的普通字符串，得到一个可以调用正则方法的正则字符串中
    r = re.compile('(\w*?)>')
    print(r.findall('<a>abc</a>'))
sub：替换
    res = re.sub('(\d{3})(?P<center>\d{3})(\d{3})', r'\2\1\3', '<123456789>')
    print(res)
二、面向对象
1、面向过程：
        重过程：解决问题，考虑的是解决问题的流程
        解决问题的思路清晰，但拓展性不强
    面向对象：
        重对象：解决问题，找到解决问题的对象
        解决问题的思路可能不止一条（理解解决问题的难度增加），即编程的复杂度高于面向过程，但扩展性强
        重点：面向对象的核心体现是将数据和处理数据的程序封装到对象中
    Ptyhon语言：面向对象的语言
        Python用面向过程与面向对象两种方式解决问题
    函数与方法
        函数：通过函数名直接调用
        方法：通过附属者.语法来调用
2、名称空间操作：内置 | 全局 | 局部
    所有能产生名称空间对应的对象（存放地址的变量）有__dict__值
        __dict__指向的就是附属对象的名称空间
        def func():
            a = 10
            print(locals())
            pass
        func()
        print(func.__dict__)
    能产生名称空间的有：文件 | 函数 | 类
        能产生名称空间的对象有__dict__这个值，通过这个值访问到名字与地址的对应关系
    名称空间的使用：
        def func():
            pass

        func.__dict__['index'] = 10000
        print(func.__dict__)
        print(func.__dict__['index'])
        print(func.index)

        func.add = lambda n1, n2: n1 + n2
        print(func.__dict__)
        print(func.add(10, 20))
3、类与对象
    寻求一个类似函数与文件对象，可以额外添加功能与属性的对象
        类：具有相同特征与行为个体集合的抽象
        对象：有特征、行为的具体个体，就是类的具体体现
    语法：
        类的声明：class
            class 类名：      #class定义类语法的关键字
                pass
        对象的产生：对象的实例化
            对象1 = 类名（）
            对象2 = 类名（）
            对象3 = 类名（）
        学习重点：自定义类的实例化对象
            class Student:
                pass
            stu = Student()

            print(id(Student))
            print(id(stu))

            print(Student.__dict__)
            print(stu.__dict__)

            stu.__dict__['name'] = 'Bob'
            print(stu.name)

            def fn():
                print('学习')
            stu.study = fn
            stu.study()

            # 实例化一个Egon同学，有学习功能
            # 实例化一个Liu某同学，有学习功能
            s1 = Student()
            s2 = Student()
            print(id(s1), id(s2), id(Student))
            s1.name = 'Egon'
            s1.study = fn
            s2.name = 'Liu某'
            s2.study = fn
            print(s1.__dict__, s2.__dict__)
            print(s1.name, s2.name)
4、小结：
    重点：类一旦被加载（随着所属文件的加载就加载），就会进入类的内部执行类中的所有代码
    类拥有自己的名称空间，类的对象也有自己的名称空间
    可以通过.语法添加或使用属性和方法
    属性的访问顺序：优先加载自身的名字，如果没有再考虑类的