recode

1.类的声明

class 类名：
　　类的内容

2.属性---声明在类中的变量

a.对象属性 - 值会因为对象而不同
声明在init方法中 位置
self.属性 = 值 赋值
对象.属性 调用
对象属性的增删改查
slots __
b.类的字段---值不会因为对象不同而不同
直接声明在类中 位置
变量名 = 值 赋值
类.属性 '调用'
c.内置属性
类. name__ 获取类的名字 （结果是字符串）
对象.__ class__ 获取对象对应的类 （结果是类）
对象.__ dict__ 将对象的属性内容转换为字典，属性名为key,值为value
类.__ doc__ 获取类的说明文档（结果是字符串）
类.__ module__ 获取当前类所在的模块名（结果是字符串）
类.__ base__ 获取当前类的父类/支持多继承（结果是一个元组）

3.方法 - 说明在类中的函数

a.对象方法
位置：直接声明在类中
特征：自带self参数，调用的时候不用传参，谁调用指向谁
调用方式：对象.方法()
何时使用：实现函数的功能需要对象属性
b.类方法
位置：声明前加@classmethod
特征：自带cls参数，调用的时候不用传参，谁调用指向谁
调用方式：类.方法()
何时使用：实现函数的功能不需要对象属性的前提下，需要类的字段
c.静态方法
位置：声明前加@staticmethod
特征：没有自带参数
调用方式：类.方法()
何时调用：实现函数的功能既不需要对象属性，也不需要类的字段

---

私有化

1.属性和方法的访问权限（其他语言中）

私有的：在类的外部不可以使用，也不可以被继承
保护的：在类的外部不可以被使用，但可以被继承
公开的：在类的外部可以使用，也可以继承

2.python的私有化

a.python中属性和方法的访问权限只有公开状态，但是提供了另一种私有化的方式。
b.方式：python中在属性或者方法名前加__，就可以将属性或者方法编程私有的（注意：只能两 __ 开头，不能 __结尾）
c.私有的属性和方法只能在类的内部使用，不能在类的外部使用。

3.python私有化的原理

在名字前是__ 的属性和方法前再加'类名'去保存属性和方法。
在类中声明一个对象属性为 __ age，python会将这个对象属性保存为 _ 类 __ age，所以在类的外部无法使用_ age，若要使用得以_ 类__ age的格式使用。
注意：如果这个私有化的属性或方法是在类中的函数里使用，在类的外部调用这个函数，能够使用这个私有化的属性或方法。

---

---

getter和setter

1.应用场景

getter：获取对象属性的值之前想要做点儿别的事情，就给这个属性添加getter
setter：给对象属性赋值之前想要做点儿别的事情，就给这个属性添加setter

2.getter

第一步：声明属性的时候在属性名前加_
第二步：声明函数（函数没有除了self以外的参数，但是要有返回值。返回值就是获取对象属性拿到的值）
@property
def 去掉_ 的属性名(self)：
　　做点别的事情
　　返回属性的值
第三步：在类的外部通过对象.(去掉_的属性)去获取相关属性。

3.setter - 想要添加setter必须先要有getter

第一步：声明属性的时候在属性名前加_
第二步：声明函数（函数除了self以外还需要一个参数，没有返回值。这儿的参数代表给属性赋的值）
@属性名去掉＿.setter
def 去掉＿的属性名（self，参数）：
　　　做点别的事情
　　　给属性赋值
第三步：在类的外部通过对象.去掉＿的属性去给相关属性赋值
代码：

class Person:
    def __init__(self, name=''):
        self.name = name
        self._age = 0
        self._week = 7    # 属性名前有_，使用属性的时候不要直接用

    @property
    def age(self):
        return self._age

    # 给age添加setter
    @age.setter
    def age(self, value):
        if not isinstance(value, int):
            raise ValueError
        if not (0 <= value <= 150):
            raise ValueError
        self._age = value

    # 给week添加getter
    @property
    def week(self):
        if self._week < 7:
            return '星期%d' % self._week
        else:
            return '星期天'

    @week.setter
    def week(self, value):
        self._week = value


def main():


    p1 = Person('小明')

    # 通过不带_的属性给属性赋值实质是在调用setter对应的函数
    p1.age = 45
    p1.age = 3

    # 这个操作实质是在调用week函数
    # 通过不带_的属性来获取属性的值实质是在调用getter对应的函数
    print(p1.week)
    p1.week = 4


if __name__ == '__main__':
    main()

---

继承

1.什么是继承

一个类继承另外一个类，其中会产生继承者和被继承者。这儿的继承者叫子类，被继承者叫父类/超类。

2.怎么继承

语法：
class 类名（父类列表）：
　　类的内容
说明：
a.python中所有的类都是直接或者间接地继承自基类object
class 类名： ===> class 类名（object）：
b.python中的继承支持多继承，父类列表中可以有多个类，多个类之间用逗号隔开。

3.能继承哪些东西：所有的属性和方法都能够被继承

注意：
a.__ slots __ 的值继承后没有效果
b.在类中给__ slots __ 赋值后，当前类的对象不能使用__ dict __ ；但是这个类的子类对象可以使用 __ dict __ 。
c.如果父类没有给 __ slots __ 赋值，直接给子类的 __ slots __，无效！

---

添加方法

1.添加方法

直接在子类中声明新的方法

2.重写方法

在子类中实现父类的方法 --- 完全重写
保留父类的功能在子类中添加新的功能 --- 部分重写（在子类方法中通过'super().'的方式调用父类方法）

3.类中函数的调用过程

回到函数声明的位置：先看当前类中是否有方法，如果有就直接调用当前类中方法；没有就去看父类中有没有这个方法；如果父类中也没有就看父类的父类中有没有···直到找到object类，如果还是没有就报错。

添加属性

1.类的字段

直接在子类中声明新的字段

2.添加对象属性

对象属性其实是通过继承init方法继承下来的
super().__ init __(从父类继承来的属性)

运算符重载

1.什么是运算符重载

通过实现类中相应的魔法方法来让当前类的对象支持相应的运算符
注意：python中所有的数据类型都是类；所有的数据都是对象。
步骤：
第一步：先知道运算符的函数名
第二步：在类中声明一个运算符函数

内存管理

1.数据的存储

内存分为栈区间和堆区间
从底层来看：栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存是由程序员通过代码（malloc）开辟和释放的。
从python语言角度看：栈区间的内存的开辟和释放是由系统自动管理的，堆区间的内存关键也已经封装好了，程序员也不需要写代码来开辟空间和释放空间。
a.python中变量本身是存在栈区间的，函数调用过程是在栈区间；对象都是存在堆区间（python中所有数据都是对象）
b.变量赋值过程：先在堆区间开辟空间将数据存起来，然后将数据对应的地址存到栈区间的变量中。数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是先检测之前有没有存储过这个数据，如果有就用之前的数据的地址。

2.内存释放（垃圾回收机制）原理：

python中的每个对象都有一个叫'引用计数'，当前对象的引用的个数。判断一个对象是否销毁就看引用计数是否为0，为0就销毁，不为0就不销毁。

3.getrefcount函数

getrefcount（对象） --- 获取对象的引用计数
注意：使用不同的变量存对象地址，就会增加引用计数，函数调用只是暂时增加引用计数，函数结束后就会复原。