day14 类和对象

1.类中的方法

类中的方法分为：对象方法、类方法、静态方法

1.对象方法

• a.直接声明在类中
• b.有默认参数self
• c。通过对象去调用

2.类方法

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

3.静态方法

• a.在声明当前添加@staticmethod
• b.没有默认参数
• c.通过类调用，类.类方法

4.对象方法、类方法、静态方法的选择

• a.什么时候使用对象方法，当实现这个函数的功能，需要用到对象的属性的时候，就是请对象方法。
• b.当实现函数的功能，不需要对象的属性，但是需要类的时候，就使用类方法。
• c.实现函数的功能及不需要对象的属性，也不需要类的时候，就使用静态方法

class Person():
    num = 61
    def __init__(self,name):
        self.name = name
    #对象方法
    def eat(self,food):
        print("%s在吃%s"%(self.name,food))
    @classmethod
    def destroy(cls):
        print(cls)
        print("类方法|：破坏环境")
        # 可以用cls创建对象
        p1 = cls("小明")
        # 可以通过cls调用对象方法
        p1.eat("面包")
        #可以通过cls使用类的字段
        print(cls.num)
    #静态方法
    @staticmethod
    def hit_animal():
        print("静态方法：殴打小动物")
print(Person)
Person.destroy()      #
Person.hit_animal()   #静态方法

import math
class Math():
    num = math.pi
    @staticmethod
    def sum_two_num(num1,num2):
        return num1 + num2
    @classmethod
    def area(cls,r):
        return cls.num*r**2
print(Math().sum_two_num(1,2))
print(Math().area(10))

2.私有化

1.私有化定义

在类中，可以通过在属性名前或者方法名前加（注意不能以结尾，那么这个属性或者方法就会变成私有的）
私有的属性或者方法在类的外部不能使用。

class Person:
    __num = 100
    __num2__ = 200
    def __init__(self):
        self.name = "张三"
        self.__age = 100
        print(Person.__num)
    def __show_message(self):
        print("名字",self.name,"年龄",self.__age)
    def func1(self):
        self.__show_message()
p1 = Person()
print(p1.name)
p1.func1()
print(p1.__dict__)
print(Person.__num2__)

2.私有化原理

python中没有真正的私有化,不能从访问权限上控制属性和方法的使用，只是在名字前有
但是没有以结尾的名字前再加了“_类名”，导致不能直接通过原属性和方法进行访问。

class Dog:
    def __init__(self,name,color):
        self.__name = name
        self.__age = color
dog1 = Dog("大黄","黄色")
print(dog1.__dict__)
print(dog1._Dog__name) 

3.setter和getter

1.getter

如果希望在获取对象属性之前要做别的事情，就给这个属性添加getter：
a.属性命名的时候，属性名前加_线self._age = 0
b.声明一个函数，在函数名前加@property,函数名就是属性名，不需要额外参数，
有返回值，就是属性的结果。

@property
def age(self):
    return 年龄相关的值

c.当前需要获取属性的时候 通过 对象.不带下划线的属性。对象.age

2.setter

如果希望在给对象属性赋值之前做点儿别的事情，就给这个属性添加setter
想要给对象添加setter，必须先给他添加getter
a.属性命名的时候，属性名前加_线 self._age = 0
b.声明一个函数，函数名就是属性名（不要下划线），需要一个额外参数，不用返回值
并且函数前使用@getter.setter修饰

@age.setter
def age（sel，value）
    self._age = value

c.当需要给属性赋值的时候，通过对象，不带下划线的实行来赋值：例如：对象.age = 100

class Person:
    def __init__(self,name  = "小红"):
        self.name = name
        self._age = 0
        self.sex = "男"
        #这儿的age函数就是属性_age的getter方法。
    @property
    def age(self):
        print("========")
        if self._age < 1:
            return "婴儿"
        elif self._age <18:
            return "未成年"
        elif self._age < 50:
            return "中年"
        else:
            return "老年"
        #这儿age函数就是属性_age的setter方法
    @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()
#这儿实质是在调用_age的getter方法
print(p1.age)
# 这儿实质是在调用_age的seteer的方法
# p1.age = "a"   #ValueError
# p1.age = 150   #raise ValueError  ValueError.
p1.age = 80
print(p1.age)

练习：练习 声明一个时间类，有一个属性是保存以秒的形式保存时间,不断的输入时间：以xx：xx:xx的形式输入时间，输入多少个时间就保存多少个时间。

lorry方法：
class Time():
    def __init__(self):
        self._second = 0
    @property
    def second(self):
        print("转换成秒为：",self._second)
        return self._second
    @second.setter
    def second(self,value):
        for item in value:
            second1 = int(value[item])+int(item)*60
            self._second = second1
t = Time()
aaaa = []
flag = True
while flag:
    aa = []
    aaa = {}
    a = input("输入分：")
    aa.append(a)
    b = input("输入秒：")
    aa.append(b)
    aaa.update([aa])
    t.second = aaa
    aaaa.append(t.second)
    cont = input("是否继续Y\nN")
    if cont == "Y":
        flag = True
    else:
        flag = False
print("转换成秒为:",aaaa)

老师方法：
def __repr__(self):
    return str(self.second)
class Time():
    def __init__(self):
        self._second = 0
    @property
    def second(self):
        return self._second
    @second.setter
    def second(self,value:str):
        times = value.split(":")
        self.second = int(times[0])*60+int(times[1])
timess = []
while True:
    value = input("时间：")
    if value == "end":
        break
    t = Time()
    t.second = value
    timess.append(t)
print(timess)

4.repr(self)

打印自己声明类的对象的时候，默认打印的是：<模块名.类名 objeck at 对象地址>
如果不希望以默认方法去打印对象，可以实现__repr__魔法方法，打印对象就会打印这个对象的返回值

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __repr__(self):
        return ">>"+self.__class__.__module__+"."+self.__class__.__name__+"object at "+hex(id(self))
stu1 = Student("小明",18)
stu2 = Student("小❀",18)
print(stu1,stu2)

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __repr__(self):
        return "name:%s,age:%s"%(self.name,self.age)
stu1 = Student("小明",18)
stu2 = Student("小❀",18)
print(stu1, stu2)

class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def __repr__(self):
        return str(self.__dict__)[1:-1]
stu1 = Student("小明",18)
stu2 = Student("小❀",18)
print(stu1, stu2)

6.继承

1.类的继承基操

python中的类支持继承，并且支持多继承
python中默认情况是继承自objeck（objeck是python所有类的基类）
一个类可以继承另外一个类，继承者我们叫子类，被继承者叫父类，继承者就是让子类直接拥有父类中内容
#注意：slots对应的值不会被继承
** slots = ("age","name","sex")**

class Person(object):
    num = 61
    #注意：slots对应的值不会被继承
    # __slots__ = ("age","name","sex")
    def __init__(self):
        self.name = "张三"
        self.age = 0
        self.sex = "男"
    def show_message(self):
        print("名字：%s，年龄：%s,性别：%s"%(self.name,self.age,self.sex))
p1  = Person()
# p1.color = "green"  #已经被约束，不能再添加
class Student(Person):
    pass
stu1= Student()
print(stu1.name)
print(stu1.num)
stu1.show_message()

2.子类中添加方法

1.在子类中添加方法

• a.添加一个新的方法
  直接在子类中声明其他的方法，添加后，子类可以调用自己的方法也可以调用父类的方法
  但是父类不能调用子类的方法
• b.重写父类的方法 - 重新实现父类的方法
  • a.完全重写 -覆盖父类的功能，直接在子类中重新实现父类的功能
  • b.部分重写 - 保留父类的功能，添加新的功能，在子类中实现父类方法的时候通过super去调用父类的方法，然后再添加新的功能
    注意：可以在子类的方法中通过super（）取调用父类的方法
    super（类，对象） - 获取对象中父类的部分（要求对象是这个指定的对象）
• c.类中方法的调用的过程
  通过对象或者类调用方法的时候，先看当前类中是否声明过这个方法，如果声过就直接调用
  当前类对应的方法，如果当前类中没有生命果，去找父类中有没有声明过这个方法，声明过就调用父类的方法
  如果父类中也没有声明，就去找父类的父类，一次类推，知道objeck中也没有声明过，程序才会报错
  注意：静态方法中不能使用super（）

class Person:
    #类的字段
    num = 61
    #对象属性
    def __init__(self):
        self.name = "张三"
        self.age = 0
        self.sex = "男"
    def show_messaage(self):
        print("%s,你好吗"%self.name)
    @staticmethod
    def info():
        print("我是人类")
    def func1(self):
        print("Person的对象方法")
class Student(Person):
    def study(self):
        print("%s在学生"%self.name)
    @classmethod
    def message(cls):
        print("我是学生")
    @staticmethod
    def info():
        print("我是学生！！！")
    def show_messaage(self):
        super().show_messaage()
        print("我去炸学校！")
        super().func1()

stu1 = Student()
p1 = Person()
stu1.show_messaage()
p1.show_messaage()
p1.info()
stu1.info()
stu1.show_messaage()

3.子类中添加字段、添加属性

1.添加子类的字段

直接添加类的字段

2.添加对象属性

继承对象属性是通过继承父类的init的方法继承下来的。
如果想要保留父类继承下来的对象属性的前提下，添加新的对象属性，
需要在子类的init方法中，通过super（）调取用父类的init方法

class Person:
    num = 61
    def __init__(self,name):
        self.name = name
        self.age = 0
class Student(Person):
    number = 100
    def __init__(self,name):
        super().__init__(name)
        self.study_id = "001"
stu1 = Student("lorry")
print(Student.number,Student.num,stu1.study_id)

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

class Animal:
    def __init__(self,type,color,age = 0):
        self.type = type
        self.color = color
        self.age = age
class Cat(Animal):
    def __init__(self,color,age = 0,hobby = ""):
        super().__init__("猫科",color,age)
        self.hobby = hobby
an1 = Animal("犬科","黄色")
an2 = Animal("犬科","黄色",52)
cat1 = Cat("白色")
cat2 = Cat("白色",50)
cat3 = Cat("灰色",hobby= "晒太阳" )