一、review

1.声明⼀个人的类和狗的类:
狗的属性:名字、颜色、年龄
狗的⽅法:叫唤
人的属性:名字、年龄、狗
人的⽅法:遛狗
a.创建人的对象小明，让他拥有一条狗大黄，然后让小明去遛⼤黄

class Dog:
    def __init__(self, name, color, age=0):
        self.name = name
        self.age = age
        self.color = color

    def call_out(self):
        print('%s：嗷嗷叫!' % self.name)


class Person:
    def __init__(self, name: str, age=0, dog=None):
        self.name = name
        self.age = age
        self.dog = dog

    def walk_the_dog(self):
        if self.dog:
            print('%s牵着%s散步!' % (self.name, self.dog.name))
            self.dog.call_out()
        else:
            print('没有狗！遛自己！')


dog1 = Dog('大黄', '黄色')
p1 = Person('小明')
p1.dog = dog1
p1.walk_the_dog()

2.声明一个圆类，自己确定有哪些属性和方法
属性: 圆周率、半径、圆心坐标
方法: 获取面积、周长

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance(self, other):
        a = self.x - other.x
        b = self.y - other.y
        return (a**2 + b**2) ** 0.5


class Circle:
    pi = 3.1415926

    def __init__(self, radius: float, center: Point):
        self.radius = radius
        self.center = center

    def area(self):
        return Circle.pi * self.radius ** 2

    def perimeter(self):
        return 2 * Circle.pi * self.radius

    def is_intersect(self, other):
        """两个圆是否相交"""
        distance = self.center.distance(other.center)
        if distance >= self.radius + other.radius:
            return False
        return True

二、内置类属性

——申明类的时候，系统自动添加的属性（可能是字段也可能是对象属性）

1）类的字段：类.name

——获取类的名字（字符串）

2）类的字段：类.doc

——获取类的说明文档

3）对象属性：对象.class

——获取对象对应的类,返回的是类

4）对象属性：对象.dict

——将对象所有的属性和值转换成一个字典中的键值对（一个对象一个字典）

5）类的字段：类.dict

——将类转换成一个字典，字典中的元素是类中所有的字段和对应的值
注意：如果设置了slots的值，那么当前类的对象就不能使用dict属性

6）类的字段：类.module

——获取申明当前类所在的模块（返回模块的名字）

7）类的字段：类.bases

——获取当前类的父类（返回的是一个元祖）

class Person:
    """
    人类
    """
    num = 61
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
    def eat(self, food):
        print('%s在吃%s' % (self.name, food))
    def __str__(self):      # 定制当前类的对象的打印
        return '<' + str(self.__dict__)[1:-1] + '>'       # 返回值就是对应的打印结果
                                                           （类型必须是字符串）
    def __repr__(self):     # 定制当前类的对象的打印
        return '<' + str(self.__dict__)[1:-1] + '>'     # 返回值就是对应的打印结果
                                                           （类型必须是字符串）
p1 = Person('小明', '18', '男')
p2 = Person('小白', '16', '女')
print(Person.__name__)
print(Person.__doc__)
print(p1.__class__)
print(type(p1))
type1 = p1.__class__  # 当做类来用
print(p1.__dict__)
print(Person.__dict__)
print(p1)
print([p1, p2])
# 定制当前类的对象的打印
"""
1）重写__str__方法
2）重写__repr__方法
"""
# 补充：将字典转换成对象
class Data:
    def __init__(self, dict1: dict):
        for key in dict1:
            setattr(self, key, dict1[key])

三、私有化

1.访问权限：公开、保护、私有

公开：公开的属性和方法在类的内部、外部能够使用，也能被继承
保护：保护的属性和方法在类的内部能够使用，外部不能使用，但可以被继承
私有：私有的属性和方法只能在类的内部使用，外部不能使用，也不能被继承

2.Python中属性和方法的访问权限

Python类中所有的属性和方法本质都是公开的，私有化只是提示程序员该属性或方法在外部不要使用和继承
如何私有化：在需要私有化的属性名或者方法名前加双下划线（注意不能以双下划线结尾）
私有化原理：在私有的属性和方法前加了‘_类名‘

class Person:
    __num = 61
    def __init__(self, name, __age):
        self.name = name
        self.__age = __age
    def eat(self, food='米饭'):
        print('%s在吃%s' % (self.name, food))
p1 = Person('小明', 20)
p1.eat()
print(p1.__dict__)
print(Person._Person__num)

四、getter、setter

1）概念

当我们需要在获取属性值之前做点别的事情就需要给这个属性添加getter
当需要给属性赋值之前做别的事情，就需要给这个属性添加setter

2）给属性添加getter

a、属性命名的时候前面加 ’_‘
b、在装饰器@property的后面申明一个对象方法
1将属性去掉下划线作为方法名，
2方法除了self以外不需要其他函数，
3函数的返回值就是获取这个属性的时候得到的值
c、在外部使用属性的时候，通过’对象.不带下划线的属性‘去使用
注意：获取属性值的时候，就会自动去调用getter对应的函数

3）给属性添加setter

注意：属性在添加setter之前必须先添加getter
a、保证属性名前有’_‘
b、在@getter名.setter后面申明对象方法
1将属性去掉下划线作为方法名
2需要一个self以外的参数
3不需要返回值
c、在外部使用属性的时候，通过’对象.不带下划线的属性‘去使用
注意：当给属性赋值的时候，实质是调用setter对应的方法

class Person:
    def __init__(self, name, age):
        self.name = name
        self._age = age
        self._gender = 0
        self._week = 1
    # 添加getter
    @property
    def week(self):
        if self._week == 0:
            return '星期天'
        elif self._week == 1:
            return '星期一'
    @property
    def age(self):
        return self._age
    @age.setter
    def age(self, value):
        print('年龄值被修改！')
        if not isinstance(value, int):
            raise ValueError
        if not 0 <= value <= 55:
            raise ValueError
        self._age = value
    @property
    def gender(self):
        if self._gender == 1:
            return '女'
        return '男'

    @gender.setter
    def gender(self, value):
        raise ValueError

p1 = Person('小明', 18)
print(p1.name, p1.age, p1.gender, p1.week)
print(p1.week)    # 这儿实质是在调用week方法获取返回值
p2 = Person('小花', 16)
p2._week = 0
print(p2.week)
print(p1.age)        # p1.age()
# age1 = p1.age
print(p2.age)     # p2.age()
p1.age = 31
print(p1.gender)


# 练习：写一个矩形类，有属性：长、宽、面积、周长
class WriteError(Exception):
    def __str__(self):
        return '修改只读属性!'
class Rect:
    def __init__(self, length, width):
        if isinstance(length, int) or isinstance(length, float):
            self._length = length
        else:
            raise ValueError
            # self._length = 0
        self._width = width
        self._area = 0
        self.perimeter = 0
    @property
    def length(self):
        return self._length
    @length.setter
    def length(self, value):
        if not (isinstance(value, int) or isinstance(value, float)):
            raise ValueError
        if value < 0:
            raise ValueError
        self._length = value
    @property
    def area(self):
        self._area = self._length * self._width
        return self._area
    @area.setter
    def area(self, value):
        raise WriteError
r1 = Rect(100, 300)
print(r1.area)
r1.length = 20
print(r1.area)
# r1.area = 100
# r2 = Rect('abc', 'ui')

五、对象方法、类方法、静态方法

1）对象方法

a、怎么申明：直接申明
b、怎么调用：用对象调用
c、特点：有指向当前对象的self
d、什么时候用：如果实现函数的功能需要用到对象属性就用对象方法

2）类方法

a、怎么申明：申明在@classmethod后面
b、怎么调用：用类来调用，‘类.类方法（）’
c、特定：有自带的参数cls，表示当前类，这个参数在调用的时候不用传参，
系统自动将当前类传给它，谁调用就指向谁，如果是对象指向对象对应的类
d、什么时候用：如果实现函数功能不需要对象属性，但是需要类的字段，就用类方法

2）静态方法

a、怎么申明：申明在@staticmethod后面
b、怎么调用：通过类来调用，’类.静态方法（）‘
c、特定：没有默认参数
d、什么时候用：实现函数的功能既不需要类也不需要对象属性就使用静态方法

class Person:
    num = 61
    def __init__(self, name: str, age: int, gender: str):
        self.name = name
        self.age = age
        self.gender = gender
    def eat(self, food: str):
        # 对象能做的事情，self都能做
        print(self.name+'在吃'+food)
    @classmethod
    def func1(cls):
        # 类能做的事情，cls都能做
        print(cls)
        t = cls('a', 10, 'b')
        print('t:',t)
        print(cls.num)
        print('这是一个类方法!')
    @staticmethod
    def func2():
        print('这是一个静态方法!')
        print(Person.num)
    def func3(self):
        print('这是一个函数!', self.name)
    def func4(self):
        print(self.age, Person.num)


Person.func1()
print(Person)
# p1 = Person('夏明', 90, '男')
# p1.func1()
Person.func2()
p1 = Person('夏明', 90, '男')
p1.func4()
class Student(Person):
    num = 10
    @staticmethod
    def func2():
        print('这是一个静态方法!')
        print(Student.num)
print('============1=============')
Student.func1()
Person.func1()
print('=============2============')
Student.func2()
Person.func2()

六、继承

1.概念

继承就是让子类直接拥有父类的属性和方法
子类——继承者
父类（超类）——被继承者

2.怎么继承

1）语法：

class 类名（父类1，父类2，...）
    说明文档
    类的内容

2）说明：

（）——固定写法，如果省略相当于（object）
申明类的时候如果么有父类，默认继承object（基类）
父类——可以有一个也可以多个，一般情况只有一个（支持多继承）

class Person:
    num = 61
    def __init__(self):
        print('Person中init')
        self.name = '小明'
        self.age = 18
        self.gender = '男'
        self.__a = 10
    def eat(self, food='米饭'):
        print('{}在吃{}'.format(self.name, food))
    @classmethod
    def show(cls):
        print('人类的数量:%d' % cls.num)
    @staticmethod
    def func1():
        print('人类')
    def func2(self):
        print('我是'+self.name)
class Student(Person):
    num = 10
    def __init__(self):
        # 在子类中添加对象属性，需要先通过super()去调用父类的__init__来继承父类的对象属性
        super().__init__()
        print('Student中init')
        self.study_id = '001'
        self.class1 = 'py1904'
    # 添加功能
    def study(self):
        print(self.name+'在好好学习!')
    @staticmethod
    def func1():
        print('学生')
    def func2(self):
        print('我是学生!')
        # 在子类中可以通过super()可以去调用父类的方法
        # 注意: super()只能在对象方法和类方法中使用
        super().func2()


stu1 = Student()
print(Student.num)
print(stu1.name, stu1.age, stu1.gender)
stu1.eat()
Student.show()
print(stu1.__dict__)
Student.func1()
stu1.func2()

继承相关试题（矩形）

class Rect:
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def area(self):
        print('面积：', self.width * self.height)
    def perimeter(self):
        print('周长：', 2 * (self.width + self.height))
class PlainRect(Rect):
    def __init__(self, width, height):
        super().__init__(width, height)
        self.start_x = 0
        self.start_y = 0
    def is_inside(self, x, y):
        if self.start_x <= x <= self.start_x + self.width and self.start_y - self.height <= y <= self.start_y:
            return True
        else:
            return False

r1 = Rect(10, 5)
r1.area()
r1.perimeter()
p1 = PlainRect(5, 5)
print(p1.is_inside(3, -3))