1.类方法和静态方法

类中的方法分为：对象方法，类方法和静态方法
1.对象方法
a.直接声明在类中
b.有默认参数self
c.通过对象调用

2.类方法
a.在声明前添加@classmathod
b.有默认参数cls,调用的时候不需要给cls传参，系统会自动将调用当前类方法的类传给cls
cls最终指向一个类，类可以做的事情cls都可以做
c.通过类来调用：类.类方法()

class Person:
    num = 61

    def __init__(self, name):
        self.name = name

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

    @classmethod
    def destory(cls):
        print('cls:', cls)
        print('人类破坏环境')

        # 可以使用cls来创建对象
        p1 = cls('小明')
        p1.eat('面包')

        # 可以通过cls使用类的字段
        print(cls.num)

        # 可以通过cls调用类相关的方法
    @staticmethod
    def beat_animal():
        print('人类殴打小动物！')


print('Person:', Person)
Person.destory()

3.静态方法
a.在声明前添加@staticmethod
b.没有默认参数
c.通过类去调用:类.静态方法()

Person.beat_animal()

4.对象方法、类方法和静态方法的选择
a.什么时候使用对象方法：
当实现函数功能需要用到对象的属性的时候，就使用对象方法

b.什么时候使用类方法：
实现函数的功能不需要对象的属性，需要类的时候就使用类方法

c.什么时候使用静态方法：
实现函数的功能既不需要对象属性，也不需要类的时候，就使用静态方法

• 练习：声明一个数学类，属性：pi 功能：求两个数的和 ，求一个圆的面积

class Math:
    pi = 3.14

    @classmethod
    def area(cls, r):
        return cls.pi * r ** 2

    @staticmethod
    def sum(num1, num2):
        return num1 + num2


print(Math.area(3))
print(Math.sum(5, 9))

2.私有化

1.私有化
在类中，可以通过在属性名前，或者方法名前加 __ (注意不能以 __ 结尾)，那么这个属性或者方法就会变成私有的
私有的属性和方法在类的外部不能使用

class Person:
    __num = 100
    __num__ = 200

    def __init__(self):
        self.name = '张三'

    def __show_message(self):
        print(Person.__num)
        print('名字：', self.name)

    def func(self):
        self.__show_message()


p1 = Person()
p1.func()
print(Person.__num__)

2.私有化原理
python中并没有真正的私有化，不能从访问权限上控制属性和方法的使用，
只是在名字前有两 __但是没有以 __结尾的名字前再加 _类名，导致不能直接通过原属性名和方法名访问

class Dog:
    def __init__(self, name, color):
        self.__name = name
        self.__color = color


dog1 = Dog('大黄', '黄色')
print(dog1.__dict__)
# print(dog1.__name)
print(dog1._Dog__name)

3.对象属性的getter和setter

• 打印类的时候默认打印的是:<模块名.类名 object at 地址>
• 如果不希望以默认的方式打印对象，可以实现 __ repr __ 魔法方法。
• 打印对象的时候就会打印这个方法的返回值，这个方法的返回值必须是字符串

def __repr__(self):
    return 'aaa'

"""
1.getteer和setter（都是给对象属性添加）
如果希望在获取对象属性之前要做点别的事情，就给这个属性添加getter
如果希望在给对象属性赋值之前做点别的事情，就给这个属性添加setter

2.添加getter
a.属性命名的时候，属性名前加 _
b.声明一个函数,函数的名字是去掉下划线的属性名，不需要self以外的额外的参数，
有返回值（就是获取属性的结果），并且函数前使用@property修饰
c.当需要获取属性的时候，通过对象.去掉下划线的属性名

3.添加setter
想要给对象属性添加setter必须先给它添加getter
a.属性命名的时候，属性名前加 _
b.声明一个函数,函数的名字是去掉下划线的属性名，需要一个额外的参数，
不用设置返回值；并且函数前使用@去掉下划线的属性名.setter修饰
c.当需要给属性赋值的时候，通过 对象.去掉下划线的属性名 = 值 来赋值

class Person:
    def __init__(self, name='小红'):
        self.name = name
        self._age = 0
        self.sex = '男'

    # 这儿的age函数就是属性_age的getter方法
    @property
    def age(self):
        if self._age < 1:
            return '婴儿'
        elif 1 <= self._age < 18:
            return '未成年'
        elif 18 <= self._age < 50:
            return '中年'
        else:
            return '老年'

    @age.setter
    def age(self, value):
        if not isinstance(value, int):
            print('年龄必须是整数!')
            raise ValueError

        if not 0 <= value <= 100:
            print('年龄超出范围')
            raise ValueError

        self._age = value


p1 = Person()
# print(p1.age)  # 这儿就是在调用_age的getter方法
p1.age = 80
print(p1._age)
print(p1.age)

• 练习：声明一个时间类，有一个属性是以秒的形式保存时间，
• 不断地输入时间：以'xx':'xx'的形式输入，输入多少个时间就保存多少个时间对象，直到输入end为止

class Time:
    def __init__(self):
        self._second = 0

    @property
    def second(self):
        return str(self._second) + '秒'

    @second.setter
    def second(self, value1):
        if ':' in value1:
            list1 = value1.split(':')
            try:
                self._second = int(list1[0]) * 60 + int(list1[1])
                print(t1.second)
                list_time.append(t1)
            except ValueError:
                print("请输入'XX:XX形式的时间！(XX为整数)'")
        else:
            print("请输入'XX:XX形式的时间！(XX为整数)'")


while True:
    value = input('请输入时间：')
    if value == 'end':
        break
    else:
        list_time = []
        t1 = Time()
        t1.second = value

4.类的继承

"""
继承
一个类可以继承另外一个类，继承者我们叫子类，被继承者叫父类，继承就是让子类直接拥有使用父类内容的权限
slots魔法 对应的值不会被继承
python中的类支持继承，并且支持多继承。
python中的类默认情况是继承自object(object是python中所有的基类)

所有的属性和方法都可以继承

class Person(object):
    num1 = 18
    __slots__ = ('name', 'age', 'sex')

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

    def show_message(self):
        print('%s你好吗？' % self.name)

# Student类继承自Person类
class Student(Person):
    pass


stu1 = Student()
print(stu1.name, stu1.num1)
stu1.show_message()

stu1.color = '白色'
print(stu1.color)

5.添加属性和方法

子类除了拥有从父类继承下来的属性和方法，还拥有属于自己的属性和方法

1.在子类中添加方法
直接在子类中声明其他的方法
父类不能调用子类的方法

2.重写父类的方法：重新实现父类的方法
完全重写 - 覆盖父类的功能 - 直接在子类中重新实现父类的方法
部分重写 - 保留父类的功能，添加新的功能
— 在子类中实现父类的方法时，通过super().父类方法,再添加新的功能
注意：可以在子类的方法中通过super()去调用父类的方法
super(类, 对象) - 获取对象中父类的部分（要求对象是这个指定的类的对象）
静态方法中不能使用super(),因为传不了参数

3.类中方法的调用过程
通过对象或者类调用方法的时候，先看当前类中是否声明过这个方法，如果声明过就直接调用当前类对应的方法
如果当前类中没有声明过，会去找父类中有没有声明过这个方法，声明过就调用父类的方法；
如果父类中也没有声明过，就去找父类的父类...直到找object中也没有声明过才会报错

class Person:
    def __init__(self):
        self.name = '张三'
        self.age = 0
        self.sex = '男'

    def show_message(self):
        print('%s你好吗' % self.name)

    @staticmethod
    def info():
        print('我是人类')


class Student(Person):
    def study(self):
        print('%s在学习' % self.name)

    @staticmethod
    def info():
        print('我是学生')

    def show_message(self):
        super().show_message()
        print('我去上学')


stu1 = Student()
stu1.show_message()
Student.info()

6.添加属性

"""
1.添加类的字段
直接在子类中添加新的字段

2.添加对象属性
继承对象属性是通过继承父类的init方法继承下来的

如果想要在保留父类继承下来的对象属性的前提下，添加新的对象属性，
需要在子类的init方法中,通过super()去调用父类的init方法

class Person:
    num = 61

    def __init__(self):
        self.name = ''
        self.age = 0


class Student(Person):
    number = 100

    def __init__(self):
        super().__init__()
        self.study_id = '001'


stu1 = Student()
print(stu1.study_id)

• 练习：声明一个动物类，属性：年龄、颜色、类型。
• 要求创建动物对象的时候，类型和颜色必须赋值，年龄可以赋值也可以不赋值
• 声明一个猫类，属性：年龄、颜色、类型、爱好
• 要求创建猫的对象的时候，颜色必须赋值，年龄爱好可以赋值也可以不赋值，类型不能赋值

class Animal:
    def __init__(self, color, type1, age=0):
        self.age = age
        self.color = color
        self.type1 = type1


class Cat(Animal):
    def __init__(self, color, like='', age=0):
        super().__init__(color, '猫科', age)
        self.like = like


a1 = Animal('白色', '猫科')
c1 = Cat('黄色', '吃鱼')
print(c1.color, c1.type1, c1.like, c1.age)