私有化

1. 属性和方法访问权限

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

2. python的私有化

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

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

3. python私有化的原理

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

class Person:
    num = 61
    __num2 = 61

    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()


if __name__ == '__main__':
    main()

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

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

    @age.setter
    def age(self,value):
        if 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 '星期天'


def main():
    p1 = Person('小明')
    # 通过不带_的属性给属性赋值实质是在调用setter对应的函数
    p1.age = 2333
    p1.age = 'sjd'
    # 这个操作实质是在调用week函数
    # 通过不带_的属性来获取属性的值实质是在调用setter对应的函数
    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,
只是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 = 60

    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__)
    # print(stu.__face)

    stu.eat('海底捞')

    Student.show_num()

    p1 = Person()
    # p1.score = 60

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


if __name__ == '__main__':
    main()

添加属性和方法

1. 添加方法

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

2. 重写方法

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

3. 类中函数的调用过程

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

1. 类的字段

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

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 = 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 main():
    p1 = Person('张三')
    stu1 = Student('李四')
    stu1.study()

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

    Person.show_num()
    Student.show_num()

    stu1.eat('包子')

    print(Student.num2)


if __name__ == '__main__':
    main()

添加对象属性：

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

class Animal:
    def __init__(self, age, color):
        self.age = 0
        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.name = name
        self.sex = sex
        self.age = 18


class Student(Person):
    def __init__(self, num, name='小明'):
        super().__init__(name)
        self.num = num
        self.score = 60





def main():
    # 情景1，直接继承，不添加
    #dog1 = Dog()
    #print(dog1.age)
    #dog2 = Dog('猜猜')
    #print(dog2.name, dog2.color)
    stu = Student(20, '小张')
    print(stu.name, stu.score, stu.num, stu.sex, stu.age)


if __name__ == '__main__':
    main()

多继承

多继承：

class 类名（父类1，父类2，...）：
类的内容

多继承的时候，多个父类中的所有方法和字段都可以继承，只是对象属性只能继承第一个父类的

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

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


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

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


class Bird(Animal, Fly):
    pass


def main():
    b1 = Bird()
    b1.func1()
    b1.func2()
    print(b1.name, b1.age)
   #  print(b1.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
    # 
    #     def __repr__(self):
    #         return str(self.__dict__)
    # 
    #     # 实现'+'对应的魔法方法，让两个学生对象能够进行+操作
    # self 和other的关系：self 指的是+前的对象，other指的是+后的对象
    # 返回值就是运算结果return
    def __add__(self, other):
        pass
        # a.支持Student+Student:
        # return self.age + other.age
        # b. 支持Student+数字
        # return self.age + other
    # 注意：大于和小于运算符是需要重载一个就行

    def __mul__(self, other):
        return self.name * 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 or stu2)
    # print(stu1 + 10)
    print(stu1 * 2)

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

if __name__ == '__main__':
    main()

内存管理

1. 数据的存储

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

a. python中变量本身是存在栈区间的，函数调用过程是在栈区间；对象都是存在堆区间（python中的所有数据都是对象）

b. 变量赋值过程：先在堆区间开辟空间将数据存起来，然后将数据对应的地址存到栈区间的变量中

数字和字符串比较特殊，赋值的时候不会直接开辟空间，而是先检测之前有没有存储过这个数据，如果有就用之前的数据的地址

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

python中的每个对象都有一个属性叫'引用计数'，表示当前对象的引用的个数，判断一个对象是否销毁就看对象的引用计数是否为0为0的就销毁，不为0的就不销毁。
使用不同的变量存对象地址会增加引用计数

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