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

---

---

---

02-私有化

1.属性和方法的访问权限

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

2.python的私有化

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

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

3.python私有化的原理

在名字前是__的属性和方法前再加'__类名'去保存属性和方法

class Person:
    num = 61

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

    def eat(self, food):
        print(food)

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

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


def main():
    p1 = Person()

    print(Person.num)
    print(p1.__dict__)
    print(p1.name)
    p1.eat('苹果')
    print(Person.show_num())
    print(Person.func1())

---

---

---

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

    # 添加getter
    @property
    def age(self):
        return self._age

    @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 = 100
    # p1.age = 'iuihiuhs'

    # 这个操作实质是在调用week函数
    # 通过不带下划线的属性给属性赋值实质是在调用getter对应的函数
    print(p1.week)
    p1.week = 4
    print(p1.week)

---

---

---

04-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='男', face=60):
        self.name = name
        self.age = age
        self.sex = sex
        self.__face = face

    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 = 48
    print(Student.num)

    stu = Student()
    print(stu.name)
    print(stu.__dict__)

    stu.eat('海底捞')

    Student.show_num()

---

---

---

05- 添加属性和方法

1.添加方法

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

2.重写方法

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

3.类中函数的调用过程

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

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

class Person(object):
    num = 61

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

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

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

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


class Student(Person):
    num2 = 200

    # 添加方法
    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()
    p1 = Student('里斯')
    print(p1.study())

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

    stu1 = Student('里斯')
    stu1.eat('饭')
    print(Student.num2)

---

---

---

06- 添加对象属性

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

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


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


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


class Student(Person):
    def __init__(self, stu, name='憨猜猜'):
        super().__init__(name)
        # self.name = name
        self.stu = stu
        # self.sex = '男'
        # self.age = 21
        self.score = 99


def main():
    # 情景1：直接继承，不添
    # dog1 = Dog()
    # print(dog1.age)
    dog2 = Dog('憨猜猜')
    print(dog2.name)
    print(dog2.age, dog2.color)

    s1 = Student(1235456)
    print(s1.__dict__)

---

---

---

07- 多继承

多继承：
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 fun2(self):
        print('飞行类的对象方法')


class Bird(Animal, Fly):
    pass


def main():
    b1 = Bird('憨猜猜')
    b1.fun1()
    b1.fun1()
    print(b1.name, b1.age)
    # print(b1.height)

---

---

---

08-运算符重载

1.什么是运算符重载

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

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

class Student:
    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

    # 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, 98)
    stu2 = Student('傻逼', 20, 88)
    stu3 = Student('剩菜', 21, 88)

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

    print(stu1 + stu2)

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

    print(stu1 > stu2)

    print(stu1 < stu2)

    students = [stu1, stu2, stu3]

    print(students)
    # 在类中写入大于符号的魔法方法可以直接使用 __gt__
    students.sort()
    print(students)

---

---

---

09- 内存管理机制

内容管理
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('函数内部：%d' % getrefcount(obj))  # 5

    func1(list1)
    print(getrefcount(list1))  # 3

    list1 = []
    print(getrefcount(list2))
    print(getrefcount(list1))

    del list2
    print(getrefcount(list1))
    # print(getrefcount(list2))