Day-16 类

类和对象

class 类名：
说明文档
方法 - 声明在类中的方法（
静态方法 ： @staticmethod,没有自带对参数，类.方法()
对象方法 ： 直接声明在类中的方法，自带self参数，不用传参，指向谁调用谁，通过对象.方法() init创建对象对时候系统自动调用，通过构造方法给init方法传参
类方法 ： 声明前加@classmethod,自带cls参数，谁调用指向谁，cls.方法()
属性 - 声明在类中的变量
a.对象属性 - 会因为对象对不同而不同
声明在init中
self.属性 = 值
对象.值
b.类的字段 - 不会因为对象不同而不同
直接声明在变量中
变量名 = 值
对象.属性
slots魔法

私有化

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

2.python中属性和方法对的访问权限只有公开，但是提供了另外一种私有化的方式
在属性或者方法名前加__ ,就可以将属性或者方法变成私有的
在名字前是_对属性和方法前再加'类名'去保存属性和方法

class Person:
    num = 61
    __num2 = 60
    def __init__(self, name='zhangsan', age=0):
        self.name = name
        self.age = age

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

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

    @staticmethod
    def fun1():
        print('we should protect the environment')


def main():
    p1 = Person()

    print(Person.num)
    print(p1.name)
    p1.show_num()
    p1.fun1()
    print(Person._Person__num2)
结果如下:
61
zhangsan
人类的数量 61
we should protect the environment
60

setterAndGetter

1.应用场景
getter: 获取对象属性之前想要做一点别的事情就给这个属性添加getter
setter: 给对象属性赋值之前想要做点别的事情就给这个属性添加setter

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

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 week(self):
        if self._week < 7:
            return '星期%d' %self._week
        else:
            return '星期天'
    @week.setter
    def week(self, value):
        self._week = value

    @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

def main():
    p1 = Person('小明')
    # 通过步带_的属性给属性赋值对实质是在调用
    p1.age =3
    print(p1.age)
    # p1.age = 'zqm'

    # 调用@property week函数
    # 通过不带_的属性实际是在调用getter函数
    print(p1.week)

if __name__ == '__main__':
    main()
结果如下:
3
星期1
### 继承

1.什么是继承
一个类继承另外一个类，其中会产生继承者和被继承者，继承者叫子类，被继承者叫父类
继承者是让子类直接拥有父类的方法

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

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

class Person(object):
    num = 61
    __slots__ = ('name', 'age', 'sex', '__face')

    def __init__(self, name='zqm', 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.__dict__)
    print(stu.name)

    stu.eat('海底捞')
    # __slots__ 的值不会继承 在勒种给__slot__赋值后不能使用__dict__属性但是，这个类的子类可以使用，只是取不到从父类继承下来的属性
    # 如果父类没有slots赋值，直接给子类的slots无效
    stu.score = 11
    print(stu.score)
    # 不会有父类
    print(stu.__dict__)



if __name__ == '__main__':
    main()
结果如下:
20
{}
zqm
zqm在吃海底捞
11
{'score': 11}

addattrAndFunc

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

2.重写方法
在子类中重写父类的方法 - 完全重写

3.类中的函数调用过程
回到函数声明的位置；先看当前类中是否有方法，如果有就直接调用当前类的方法；没有就去父类中看这个方法；直到找到oject类

class Person(object):
    num = 61
    __slots__ = ('name', 'age', 'sex', '__face')

    def __init__(self, name='zqm', 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):
    # 添加方法
    def study(self):
        print('%s在写代码' % self.name)

    @classmethod
    def show_num(cls):
        print("111")

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

def main():
    p1 = Person('lss')
    stu1 = Student('ls')
    stu1.study()
    Person.show_num()
    stu1.show_num()


if __name__ == '__main__':
    main()
结果如下:
ls在写代码
61
111

多继承：

class 类名（父类1，父类2，...）
类的内容
多继承的时候，多个父类中的所有方法和字段都可以继承，只是对象属性只能继承第一个父类的

class Animal():
    def __init__(self,name ='123'):
        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()
    # bi.func1() return 是None
    print(b1.func1())
    print(b1.name)
    #    print(b1.height)
    #   AttributeError: 'Bird' object has no attribute 'height'

if __name__ == '__main__':
    main()
结果如下:
动物中的对象方法
飞行类对象方法
动物中的对象方法
None
123

运算符重载

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

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

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
        # 支持Student + int
        return self.age + 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('小花', age=20, score=89)
    stu2 = Student('小明', age=18, score=98)

    # 所有类的对象都支持 == != 运算

    # print(stu1 > stu2)      “学生”和“学生”实例之间不支持'>'
    print(stu1 == stu2)
    print(stu1 + 3.3)
    print(stu1 * 2)
    print(stu1 < stu2)
    print(stu1 > stu2)
    print(stu1.__repr__())


if __name__ == '__main__':
    main()
结果如下:
False
23.3
小花小花
True
False
<'score': 89, 'name': '小花', 'age': 20>

内存管理

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))
    #
    # func1(list1)

    print(getrefcount(list1))

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

    del list2
    # print(getrefcount(list2))   # UnboundLocalError

    # def getrefcount(obj):
    #     obj = list1
    #     获取obj的引用计数

    bullets = [{'x': 10, 'y': 20}, {'x': 30, 'y': 10}, {'x': 100, 'y': 200}]
    del bullets[2]

    bullets.pop(0)


if __name__ == '__main__':
    main()

结果如下:
2
3
3
3
2