1.recode

1.1.类和对象的概念
类：拥有相同属性和相同功能的对象的集合
对象：类的实例
1.2.类的申明

class 类名：
    类的内容

1.3.创建对象
对象 = 类()
1.4.对象方法
a.直接申明在类中，并且自带一个self参数
b.通过对象来调用：对象.对象方法()
c.通过对象调用的时候，self不需要传参，系统会将当前对象传给self
1.5.构造方法和init方法
方法名和类名相同的方法就是构造方法，专门用来创建对象的
当创建对象的时候，会自动调用init方法
1.6.对象属性
a.申明在init方法中的
b.self.属性 = 值
c.对象.属性
1.7.对象属性的增删改查
对象.属性/getattr(对象,'属性名',默认值)
对象.属性 = 值/setsttr(对象，'属性名',值)
del 对象.属性 / delattr(对象，'属性名')
slots = ('属性名') - 约束当前类有哪些属性
注意：如果给类的slots赋了值，那么这个类的对象的dict就不能用了
1.8.类的字段
申明在类中，函数的外面的变量

2.类方法和静态方法

类中的方法分为：对象方法、类方法和静态方法
2.1.对象方法
a.申明在类中
b.有默认参数self
c.通过对象调用:对象.对象方法（）
2.2.类方法
a.在申明前添加@classmethod
b.有默认参数cls,调用的时候不需要给cls传参，系统会自动将调用当前类方法的类传给cls,cls最终指向的是一个类，类可以做的事情cls都可以做
c.通过类去调用：类.类方法（）
2.3.静态方法
a.在申明前添加@staticmethod
b.没有默认参数
c.通过类去调用:类.类方法（）
4.对象方法、类方法和静态方法的选择
a.什么时候使用对象方法：
当实现函数的功能需要用到对象的属性的时候就使用对象方法
b.什么时候使用类方法：
实现函数的功能不需要对象的属性，但是需要类的时候就使用类方法
c.社么时候使用静态方法：
实现函数的功能既不需要对象的属性，也不需要类的时候就使用静态方法

class Persons(object):
    num1 = 90
    def __init__(self, name):
        self.name = name
     # 对象方法
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))
    # 类方法

    @classmethod
    def destory(cls):
        print(cls)
        #可以用cls创建对象
        p1 = cls('小明')
        p1.eat('面包')
        print('人类破坏环境')
        #可以用cls使用类的字段
        print(cls.num1)
        #可以用cls调用类相关的方法
    @staticmethod
    def hit_animal():
        print('人类殴打小动物！')
#练习：数学类，属性是pi  功能求两个数的和，一个圆的面积


class Math(object):
    pi = 3.14

    @staticmethod
    def sum(n1, n2):
        return n1 + n2

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


sum1 = Math.sum(10, 20)
print(sum1)
area1 = Math.area(10)
print(area1)
# print(Persons)
# Persons.destory()
# Persons.hit_animal()

3.私有化

3.1.私有化
在类中，可以通过在属性名前，或者方法名前加两个下划线（注意：不能以两个下划线结尾），那么这个属性或者方法就会变成私有的，私有的属性和方法在类的外部不能使用
3.2.私有化原理
python中没有真正的私有化，不能从访问权限上控制属性和方法的使用，只是在名字前由两个下划线开头,但是没有以两个下划线结尾的名字前再加一个"_类名"，导致不能直接通过原属性名和方法名进行访问

class Person(object):
    __num = 100

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

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


# print(Person.__num)
p1 = Person()
print(p1.name)
p1.show_message()

4.对象属性的getter和setter

1.getter
如果希望在获取对象属性之前要做点儿别的事情，就给这个属性添加getter
2.setter
如果希望在给对象属性赋值之前做点别的事情，就给这个属性添加setter
3.给对象属性添加getter
a.给属性命名的时候，属性名前加一个下划线，例如： self._age = 0
b.申明一个函数，函数的名字是属性名（不要下划线），不需要额外的参数，有返回值并且函数前使用@property修饰，这个函数的返回值就是获取属性的结果

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

c.当需要获取属性的时候通过对象.不带下划线的属性。例如：对象.age
实质是在调用_age的getter方法
4.添加setter
想要给对象属性添加setter，必须先给它添加getter
a.属性命名的时候，属性名前加一个下划线，例如： self._age = 0
b.申明一个函数，函数的名字是属性名(不要下划线),需要一个额外的参数，不用返回值，并且函数前
使用@getter.setter名来修饰
例如：

@age.setter
def age(self,value):
    self._age = value

c.当需要给属性赋值的时候，通过对象.不带下划线的属性来赋值；例如：对象.age = 100
补充：打印自己申明的类的对象的时候，默认打印的是<模块名.类名 object at 对象地址>
如果不希望以默认的方式去打印对象，可以试想repr魔法方法。打印对象的时候就会打印这个方法的返回值这个函数的返回值必须是字符串

5.类的继承

5.1.继承
python中的类支持继承，并且支持多继承
python中的类默认情况下是继承自0bject(object是python中所有类的基类)
a.什么是继承
一个类可以继承另外一个类，继承者叫子类，被继承者叫父类。继承就是让子类直接拥有父类中的内容
b.可以继承哪些内容
所有的属性和方法都可以继承
注意：__slots__对应的值不会被继承

class Person(object):
    num1 = 89

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

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

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

6.添加方法

子类除了拥有从父类继承下来的属性和方法，还拥有属于自己的属性和方法
6.1.在子类中添加方法
a.添加一个新的方法
直接在子类中申明其他的方法,添加后子类可以调用自己的方法也可以调用父类的方法，但是父类不能调用子类的方法
b.重写父类的方法:重新实现父类的方法
完全重写 - 完全覆盖父类的功能 - 直接在子类中重新实现父类的方法
部分重写 - 保留父类的功能，添加新的功能 - 在子类中实现父类方法的时候通过super().去调用父类的方法然后再添加新的功能
注意：可以在子类的方法中通过super()去调用父类的方法
super(类，对象) - 获取对象中父类的部分（要求对象是这个指定的类的对象）
c.类中方法的调用过程
通过对象或者类调用方法的时候，先看当前类中是否申明过这个方法，如果申明过就直接调用当前类的方法，如果当前类中没有申明过，会去找父类中有没有申明过这个方法，申明过就调用父类的方法；如果父类中也没有申明过，就去找父类的父类...知道object中也没有申明过，程序才会报错
注意：静态方法中，不能使用super()

class Person:
    num1 = 30

    def __init__(self):
        self.name = '人才'
        self.age = 0
        self.sex = '男'

    def fun1(self):
        print('========')

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

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

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

    @classmethod
    def message(cls):
        super().info()
        print('我是学生！')
# 完全重写
    @staticmethod
    def info():
        # super().info()    # RuntimeError: super(): no arguments
        print('我是学生')
# 保留父类的功能
    def show_message(self):
        super().show_message()
        print('我去上学')
        super().fun1()


stu1 = Student()
p1 = Person()
stu1.show_message()
stu1.study()
p1.show_message()
Student.info()
# p1.study()AttributeError: 'Person' object has no attribute 'study'
print('=============')
Student.message()
# super()

7.添加属性

7.1.添加类的字段
直接在子类中添加新的字段
7.2.添加对象属性
继承对象属性是通过继承父类的__init__方法继承下来的
如果想要在保留父类继承下来的对象属性的前提下，添加新的对象属性，需要在子类的init方法中通过super()去调用父类的init方法

class Person:
    num1 = 89

    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 = 100


print(Student.number,Student.num1)
stu1 = Student()
print(stu1.name, stu1.age, stu1.study_id)
# 练习：申明一个动物类，有属性：年龄、颜色、类型，要求在创建动物对象的时候类型和颜色必须赋值
#年龄可以赋值，也可以不赋值
# 申明一个猫类，属性：年龄，颜色、类型，爱好
# 要求创建猫的对象的时候，颜色必须赋值，年龄和爱好可以赋值也可以不赋值，类型不能赋值
class Animals():
    def __init__(self, type1, color, age=0):
        self.age = age
        self.color = color
        self.type = type1

class Cats(Animals):
    def __init__(self, color, age=0, hobby='mouse'):
        super().__init__('猫科', color, age)
        self.hobby = hobby


a1 = Animals('犬科', '黄色')
s2 = Animals('犬科', 'heise ', 10)
c1 = Cats('baise')
c2 = Cats('huise', 3)
c3 = Cats('hu', hobby='睡觉')
print(c1.hobby)