1.recode

1.类的声明
class 类名:
类的内容

2.属性 - 声明在类中的变量
a.对象属性 - 值会因为对象不同而不同
声明在init方法中
self.属性 = 值
对象.属性
对象属性的增删改查
slots

b.类的字段 - 值不会因为对象不同而不同
直接声明在类中
变量名 = 值
类.属性

c.内置属性
name
class
dict
doc
module
base

3.方法 - 声明在类中的函数
a.对象方法
直接声明在类中
自带self参数， 调用的时候不用传参， 谁调用指向谁
对象.方法()
实现函数的功能需要对象属性

1）init方法
创建对象的时候系统自动调用
需要通过构造方法来给init方法传参

b.类方法
声明前加@classmethod
自带cls参数， 调用的时候不用传参， 谁调用指向谁
类.方法()
实现函数的功能不需要对象属性，需要类的字段

c.静态方法
声明前加@staticmethod
没有自带参数
类.方法()
实现函数的功能既不需要对象属性，也不需要类的字段

2.私有化

1.属性和方法的访问权限
私有的：在类的外部不可以使用，也不可以继承
保护的：在类的外部不可以使用，可以继承
公开的：在类的外部可以使用，也可以被继承

2.python的私有化
python中属性和方法的访问权限只有公开，但是提供了另一种私有化的方式。
python中在属性或者方法名前加，就可以将属性或者方法变成私有的(注意：只能两开头，不能__结尾)
私有的属性和方法只能在类的内部使用，不能在类的外面使用

3.python私有化的原理
在名字前是_的属性和方法前再加'类名'去保存属性和方法

3.继承

1.什么是继承

一个类继承另外一个类，其中会产生继承者和被继承者。这儿的继承者叫子类，被继承者叫父类/超类
继承就是让子类直接拥有父类的方法和属性

2.怎么继承

语法：
class 类名(父类列表):
类的内容

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

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

注意：a.slots的值继承后没有效果
b.在类中给slots赋值后，当前类的对象不能使用dict;但是这个类的子类对象可以使用dict,
只是dict中没有从父类继承下来的对象属性，只有在子类中添加的对象属性
c.如果父类没有给slots赋值，直接给子类的slots，无效！

4.添加属性和方法

1.添加方法

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

2.重写方法

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

3.类中函数的调用过程

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

1.添加属性

1.类的字段
直接在子类中声明新的字段
2.添加对象属性:
对象属性其实是通过继承init方法继承下来的

class Person(object):
    num = 61

    def __init__(self, name='zhangsan', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
        self.__face = 60

    def eat(self, food):
        print('%s在吃%s' % (self.name, food))

    @classmethod
    def show_num(cls):
        print('人类的数量:%d' % cls.num)


class Student(Person):
    num2 = 100

    # 添加方法
    def study(self):
        print('%s在写代码' % self.name)

    @classmethod
    def func1(cls):
        print('我是学生类的类方法')

    @staticmethod
    def func2():
        print('我是学生类的静态方法')

    @classmethod
    def show_num(cls):
        print('学生数量:%d' % cls.num)

    def eat(self, food):
        super().eat(food)
        print('吃饱了')


def main():
    p1 = Person('张三')
    stu1 = Student('李四')
    stu1.study()

    Student.func1()
    # 子类可以使用父类的属性和方法，但是父类不能使用子类中添加的属性和方法
    # Person.func2()

    Person.show_num()
    Student.show_num()

    stu1.eat('包子')

    print(Student.num2)

5.运算符重载

1.什么是运算符重载

通过实现类中相应的魔法方法来让当前类的对象支持相应的运算符

注意：python中所有的数据类型都是类; 所有的数据都是对象

class Student(object):
    def __init__(self, name='', age=0, score=0):
        self.name = name
        self.age = age
        self.score = score

    def __repr__(self):
        return '<' + str(self.__dict__)[1:-1] + '>'

    # 实现'+'对应的魔法方法，让两个学生对象能够进行+操作
    # self和other的关系： self+other    ==> self.__add__(other)
    # 返回值就是运算结果
    def __add__(self, other):
        # a.支持Student+Student:
        return self.age + other.age
        # b.支持Student+数字
        # return self.age + other

    # self * other
    # 将other当成数字
    def __mul__(self, other):
        return self.name * other

    # self和other都是学生对象
    # 注意：大于和小于运算符是需要重载一个就行
    def __gt__(self, other):
        return self.score > other.score


def main():
    stu1 = Student('小花', 18, 90)
    stu2 = Student('夏明', 20, 78)
    stu3 = Student('小红', 17, 99)

    # 所有类的对象都支持'=='和'!='运算
    print(stu1 == stu2)

    print(stu1 + stu2)     # print(stu1.__add__(stu2))

    # print(stu1 > stu2)
    # print(stu1 < stu2)

    print(stu1 * 2)   # print(stu1.__mul__(2))

    students = [stu1, stu2, stu3]
    print(students)
    students.sort()
    print(students)

6.内存管理

1.数据的存储

内存分为栈区间和堆区间；从底层来看，栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存是由程序员通过代码开辟(malloc)和释放的
从python语言角度，栈区间的内存的开辟和释放是系统自动管理的，堆区间的内存关键也已经封装好了,
程序员也不需要写代码来开辟空间和释放空间

a.python中变量本身是存在栈区间的，函数调用过程是在栈区间; 对象都是存在堆区间(python中所有数据都是对象)
b.变量赋值过程：先堆区间开辟空间将数据存起来， 然将数据对应的地址存到栈区间的变量中。
数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是先检测之前有没有存储过这个数据，
如果有就用之前的数据的地址

2.内存释放(垃圾回收机制)原理：
python中的每个对象都有一个属性叫'引用计数',表示当前对象的引用的个数。判断一个对象是否销毁就看对象的引用计数是否为0；
为0的就销毁，不为0的就不销毁

getrefcount函数：
getrefcount(对象) -> 获取对象的引用计数