01-14类和对象2

一：属性和方法的访问权限

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

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

2.Python的私有化

Python中的属性和方法的访问权限只有公开，但是提供了另一种私有化的方式。
Python中在属性或者方法名前加 _ ,就可以将属性或者方法变成私有的。
（注意：只能两个下划线 _ _ 开头，不能 _结尾。）
私有的属性和方法只能在类的内部使用，不能在类的外面使用

3.python私有化的原理

在名字前是 _ _ 的属性和方法前再加‘_类名’去保护属性和方法

class Person:
    num = 13
    __num2 = 15  #在类的外面不能用
    def __init__(self,name='楚中',age=0):
        self.mame = name
        self.age = age
    def eat(self,food):
        print(food)
    @classmethod
    def show_num(cls):
        print('人类的数量：%d' % cls.num)
    @staticmethod
    def __func1():    #私有化。_Person__func1在外面也可以用
        print('人类要保护大自然！')
def main():
    p1 = Person()
if __name__ == '__main__':
    main()

二：getter和setter

1.应用场景

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

2.getter

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

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

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

class Person:
    def __init__(self,name=''):
        self.name = name
        self._age = 0
        self._week = 1  #属性名前有_ ,不要直接使用。这代表有**ter函数
    @property  #age的getter 。。加setter的前置条件
    def age(self):
        return self.age
    @age.setter #先要有getter,才能声明。
    def age(self,value):
        if not isinstance(value,int):
            raise ValueError
        if not 0 <= value <= 150:
            raise ValueError
        self._age = value
    @property  #week添加getter  .有@property，调取这个函数不加（括号）
    def week(self):
        if self._week < 7:
            return "星期%d" % self._week
        else:
            return '星期天'
def main():
    p1 = Person('小明')
    p1.age = 140  #通过不带_的属性给属性赋值，实质是在调用setter对应的函数
    #p1.age = 'sdf'  #这句本来可以用。但加了setter之后就会报错了

    #通过不带_的属性给属性来获取属性的值，实质是在调用getter对应的函数
    print(p1.week)  #实质是在调用week函数。（gettter的用法）
if __name__ == '__main__':
    main()

三：类的继承

1.什么是继承

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

2.怎么继承

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

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

注意：
1. __slots__的值继承后没有效果
2. 在类中给__slots__赋值后，当前类的对象不能使用__dict__.但是这个类的子类对象可以使用__dict__， 只是__dict__中没有从父类中继续的对象属性，只有在子类中添加的对象属性
3. 如果父类没有给__slots__赋值，直接给子类设置__slots__无效。

class Person(object):
    num = 23
    __slots__ = ('name','age')  #这行不能继承
    def __init__(self,name='张三',age=0):
        self.name = name
        self.age = age
    def eat(self,food):
        print('%s在吃%s' % (self.name,food))
    @classmethod
    def show_num(cls):
        print('人类的数量：%d' % cls.num)
class Student(Person):   #继承类Person
    pass
def main():
    Student.num = 20
    stu = Student()
    print(stu.name)
if __name__ == '__main__':
    main()

四：继承的添加属性和方法

1.添加方法

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

2.重写方法

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

3.类中函数调用过程

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

1.类的字段

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

class Person(object):
    num = 23
    __slots__ = ('name','age')  #这行不能继承
    def __init__(self,name='张三',age=0):
        self.name = name
        self.age = age
    def eat(self,food):
        print('%s在吃%s' % (self.name,food))
    @classmethod
    def show_num(cls):
        print('人类的数量：%d' % cls.num)
class Student(Person):   #继承类Person
    def study(self):
        print('%s在写代码' % self.name)
    de eat(self,food):
        super().eat(food)   #子类部分重写。先调用父类的这个函数
（调用别的函数也可以），再继续下面的函数。
        print('吃饱了')
    @classmethod
    def show_num(cls):  #子类重写
        print('学生数量：%d' % cls.num)
def main():
    p1 = Person('楚留香')
    stu1 = Student('周铁')
    #子类可以使用父类的属性和方法，但父类不可以使用子类中添加的属性和方法
if __name__ == '__main__':
    main()

五：添加对象属性

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

class Animal:
    def __init__(self):
        self.age = 0
        self.typy = '爬行'
class Dog(Animal):
    def __init__(self):
        super().__init__() #调用父类的init方法，来继承父类的对象属性
        # 父类init(age)括号里有参数，子类这里也要传参
        self.name = '大黑'

练习：声明人类有属性：名字、年龄、性别
学生类有属性：名字、年龄、性别、学号、分数
要求：创建人的对象的时候名字必须赋值，性别可以赋也可以不赋，年龄不能赋值创建学生对象的时候名字可以赋值可以不赋值，学号必须赋值，分数和性别年龄不能赋值

class Ren:
    def __init__(self,name,sex='男'):
        self.name = name
        self.age = 0
        self.sex = sex
class Stu(Ren):
    def __init__(self,num2,name='张三'):
        super().__init__(name)  #括号里的name是给父类传参
        self.num = num2
        self.chenji = 89
def main():
    #直接继承不添加
    dog1 = Dog()
    print(dog1.age)
    print(dog1.name)
    print(dog1.name,dog1.age)
if __name__ == '__main__':
    main()

六：多继承

多继承：
class 类名（父类1，父类2……）：
多继承可以继承多个类的所有方法和字段，但对象属性只继承第一个父类的

class Animal:
    def __init__(self):
        self.name = '花儿'
class Fly:
    def __init__(self):
        self.height = 100
class Bird(Animal,Fly):   #同时继承两个类
    pass
def main():
    pass
if __name__ == '__main__':
    main()

七：运算符的重载

1.什么是运算符重载

通过实现类中相应的魔法方法来让当前类的对象支持相应的运算符
注意：python中所有的数据类型都是类；所有的数据都是对象

class Student(object):
    def __init__(self,name='',age =4):
        self.name = name
        self.age = age
    # 实现'+'对应的魔法方法，让两个学生对象可以进行+操作
    # self和other的关系：self+other ==>self。__add__（other）
    #返回值就是运算结果
    def __add__(self, other):
        return self.age +other.age
        #return self.age + other    (这里other传数字。)
    #self * other  #字符串乘法
    def __mul__(self, other):
        return self.name * other
`注意：大于和小于运算符只需要重载1个就行。`
    def __gt__(self, other):
        return self.age > other.age
# 所有类的对象都支持‘==’和‘!=’运算
def main():
    stu1 = Student('张',12)
    stu2 = Student('工基',16)
    print(stu1+stu2)
    #print(stu1 + 4)   #（只有other那里。）
    print(stu1*2)  #学生乘法
    print(stu1 > stu2)
if __name__ == '__main__':
    main()

八：内存管理

1.数据的存储

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

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

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

python中的每个对象都有一个属性叫’引用计数‘，表示当前对象引用的个数。判断一个对象是否销毁，就看对象的引用计数是否为零；
为0的就销毁，不为0的就不销毁。

getrefcount函数：
getrefcount（对象）  -->获取对象的引用计数                
from sys import getrefcount
def main():
    list1 = [1,2]
    print(getrefcount(list1))  #计数是2，调用函数时会赋值一次。实际要先减1次 。
    #使用不同的变量存对象地址会增加引用计数
    list2 = list1
if __name__ == '__main__':
    main()