一 ，复习昨天的内容

"""
类和对象

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
没有自带参数
类.方法()
实现函数的功能既不需要对象属性，也不需要类的字段
"""

二，privatization(私有化)

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

2.python的私有化
python中属性和方法的访问权限只有公开, 但是提供了另一种私有化的方式

python中在属性或者方法名前加， 就可以将属性或者方法变成私有的(注意: 只能两开头, 不能__结尾)
私有的属性和方法只能在类的内部使用, 不能在类的外面使用

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

"""

class Person:
    num = 61
    __num2 = 62

    def __init__(self, name='张三', age=0):
        self.name = name
        self.age = age
        self.__sex = '男'

    def eat(self, food):
        print(self.__sex)
        print(self.name, food)
        self.__run()

    def __run(self):
        print('%s在跑步' % self.name)

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

    @staticmethod
    def func1():
        print('人类要保护大自然!')


def main():
    p1 = Person()

    print(Person.num)
    # print(Person.__num2) # 因为被保护了，在类的外部不可以使用

    print(p1.name)
    # print(p1.__sex)   # 被保护了，在类的外部不可以使用
    print(p1._Person__sex)

    p1.eat('面条')
    # p1.run()

    Person.show_num()
    Person.func1()

    print(p1.__dict__)


if __name__ == '__main__':
    main()

三， getterAndSetter

"""
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 = 5  # 属性名前有_, 使用属性的时候不要直接使用

    # 先要有getter
    @ 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(就是一个getter函数)
    @property
    def week(self):
        print('======================')
        if self._week < 7:
            return '星期%d' % self._week
        else:
            return '星期天'

def main():
    p1 = Person('小明')

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

    # 这个操作实质是在调用week函数
    # 通过不带_的属性来获取属性的值实质是在调用getter对应的函数
    print(p1.week)  # 不要加下划线, 因为用了getter或者setter
    # p1.week = 4  # AttributeError: can't set attribute, 因为通过不带_的属性给属性赋值实质是在调用setter对应的函数，但是week没有setter


if __name__ == '__main__':
    main()

四，inherit(继承)

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

2.怎么继承
语法:
class 类名(父类列表):
类的内容

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

3.能继承哪些东西: 所有的属性和方法都能继承
注意: a.slots的值继承后没有效果
b.在类中给slots赋值后, 当前类的对象不能使用dict, 但是这个类的子类对象可以使用dict,
只是dict中没有从父类继承下来的属性, 只有在子类中添加的对象属性
c.如果父类没有给slots赋值, 直接给子类的slots, 直接无效!
"""

class Person(object):
    num = 61

    __slots__ = ('name', 'age', 'sex', '__face')

    def __init__(self, name='张三', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
        self.__face = 90

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

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


class Student(Person):
    pass





def main():
    Student.num = 20
    print(Student.num)

    stu = Student()
    print(stu.name)  # 张三
    print(stu.__dict__)  # {'name': '张三', 'age': 0, 'sex': '男', '_Person__face': 90}
    # print(stu.__face)  # 会报错,在类的外部不可以使用

    stu.eat('海底捞')

    Student.show_num()  # 人类的数量:20

    p1 = Person()
    # print(p1.__dict__)
    # p1.score = 100

    stu.score = 100
    print(stu.score)
    print(stu.__dict__)


if __name__ == '__main__':
    main()

五，继承后添加属性和方法

"""
================添加方法============================
1.添加方法
直接在子类中声明新的方法

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

3.类中函数的调用过程
回到函数声明的位置: 先看当前类中是否有方法, 如果有就直接调用当前类中的方法； 没有就去看父类中有没有这个方法；
如果父类中也没有就看父类的父类....直接找到基类(object), 如果object中也没有就报错!

=================添加属性==================
1.类的字段
直接在子类中声明新的字段
"""

class Person(object):
    num = 61

    def __init__(self, name='张三', age=0, sex='男'):
        self.name = name
        self.age = age
        self.sex = sex
        self.__face = 90

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

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


class Student(Person):
    num2 = 100  # 添加属性，但是上面的Person不能用

    # 添加方法
    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()  # 人类的数量:61
    Student.show_num()  # 学生的数量:61

    stu1.eat('包子')   # 李四在吃包子(在父类中调用)
                       # 吃饱了 (在Student中调用)
    print(Student.num2)  # 100


if __name__ == '__main__':
    main()

六， 添加对象属性

"""
添加对象属性:
对象属性其实是通过继承init方法继承下来的
"""

class Animal:
    def __init__(self, age):
        self.age = age
        self.color = '灰色'


class Dog(Animal):
    def __init__(self, name, age):
        # 调用父类的init方法来继承父类的对象属性
        super().__init__(age)
        self.name = name

# 练习:
# 声明人类有属性:名字，年龄，性别
# 声明学生类有属性:名字,年龄,性别,学号,分数
# 要求:创建人的对象的时候名字必须赋值,性别可以赋值也可以不赋值,年龄不能赋值;  # 判断是否有参数
#     创建学生对象的时候名字可以赋值可以不赋值,学号必须赋值, 分数和性别,年龄不能赋值
class Person:
    def __init__(self, name, sex='男'):
        self.age = 0
        self.name = name
        self.sex = sex


class Student(Person):
    def __init__(self, id,name='张三'):
        self.id = id
        self.score = 0   # 因为不用传参
        super().__init__(name, '女')  # 因为super在父类__init__执行了self.age = 0，self.name = name，self.sex = sex, 所以不用再传age和sex了
        # self.sex = sex       #  name 'sex' is not defined  会报错







def main():
    # 情景一 ： 直接继承, 不添加
    # dog1 = Dog(Animal)
    # print(dog1.age)  # 在Dog类中没有,所以去父类找init,所以能用
    dog2 = Dog('菜菜', 3)
    print(dog2.name)
    print(dog2.age, dog2.color)


if __name__ == '__main__':
    main()

七 多继承(了解)

"""
多继承:
class 类名(父类1, 父类2, ....)
类的内容

多继承的时候, 多个父类中的所有方法和字段都可以继承, 只是对象属性只能继承第一个父类(记住这个结论就行)
"""

class Animal:
    def __init__(self, name=''):
        self.name = name
        self.age = 0
        self.color = '黑色'

    def fun1(self):
        print('动物中的对象方法')


class Fly:
    def __init__(self):
        self.height = 1000

    def func2(self):
        print('飞行类的对象方法')


class Bird(Animal, Fly):
    pass


def main():
    b1 = Bird()
    print(b1.fun1())
    b1.func2()
    print(b1.name, b1.age)
    # print(b1.height)  # 'Bird' object has no attribute 'height'

if __name__ == '__main__':
    main()

八 运算符重载

"""
1.什么是运算符重载
通过实现类中相应的魔法方法来让当前类的对象支持相应的运算符

注意: python中所有的数据类型都是类；所有的数据都是对象
"""

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

    # 实现'+'对应的魔法方法, 让两个学生对象能够进行+操作
    # self和other的关系: self + other ==> self.__add__(other)
    # 返回值就是运算结果
    def __add__(self, other):
        # 支持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 __repr__(self):
        return '<' + str(self.__dict__)[1:-1] + '>'


def main():
    stu1 = Student('小花', 19, 90)
    stu2 = Student('小明', 18, 78)
    stu3 = Student('小红', 25, 88)

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

    print(stu1 + stu2)  # 单独写会报错, 用__add__魔法方法就行 37

    print(stu1 > stu2)  # 单独写会报错, 用__ge__魔法方法就行 True
    print(stu1 < stu2)  # 也能用,因为已经用了__ge__

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

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


if __name__ == '__main__':
    main()

九， 内存管理

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

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

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

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

from sys import getrefcount


def main():
    list1 = [1, 2]
    print(getrefcount(list1))  # 2次

    list2 = list1
    print(getrefcount(list1))  # 3次

    [1, list1]
    print(getrefcount(list1))  # 3次

    def func1(obj):
        print(getrefcount(list1))  # 5次

    func1(list1)
    # 因为函数引用回来会消失
    print(getrefcount(list1))  # 3次

    list1 = []
    print(getrefcount(list2))  # 2次

    del list2
    # print(getrefcount(list2))  # local variable 'list2' referenced before assignment因为删了


if __name__ == '__main__':
    main()