面向对象

一、内置类属性

1. 声明类属性

声明类的时候系统自动添加的属性(可能是字段也可能是对象属性)

class Person:
    def __init__(self, name, gender, age):
        self.name = name
        self.gender = gender
        self.age = age

    def eat(self, food):
        print('{}在吃{}'.format(self.name, food))


p1 = Person('小明', '男', 18)

1)__name__

类的字段;类名.__name__:获取当前类名(字符串)

print(type(Person))  # <class 'type'>
print(Person.__name__)  # Person
print(type(Person.__name__))  # <class 'str'>

2)__doc__

类的字段;类名.__doc__:获取类的说明文档

print(Person.__doc__)
"""
    说明文档: 人类
    name - 名字
    gender - 性别
    age - 年龄
"""

3)__class

对象属性;对象.__class__:获取对象对应的类,返回的是类(和type功能相同)

print(p1.__class__)  # <class '__main__.Person'>

4)__dict__

对象属性;对象.__dict__:将对象中所有的属性和对应的值转换成一个字典中的键值对(一个对象一个字典)

类的字段;类.dict:将类转换成一个字典,字典中的元素是类中所有的字段和对应的值

print(p1.__dict__)  # {'name': '小明', 'gender': '男', 'age': 18}

print(Person.__dict__)
'''
{'__module__': '__main__', '__doc__': '\n\t说明文档: 人类\n\tname - 名字\n\tgender - 性别\n\tage - 年龄\n\t', '__init__': <function Person.__init__ at 0x1007ac400>, 'eat': <function Person.eat at 0x1007ac510>, '__dict__': <attribute '__dict__' of 'Person' objects>, '__weakref__': <attribute '__weakref__' of 'Person' objects>}
'''

定制当前对象的打印

a. 重写str方法,这个方法的返回值就是对应的打印结果(类型必须是字符串)

class Person:
...
    def __str__(self):
        return ''.join(['<', str(self.__dict__)[1:-1], '>'])


print(p1)  # <'name': '小明', 'gender': '男', 'age': 18>

b. 重写repr方法,这个方法的返回值就是对应的打印结果(类型必须是字符串)

class Person:
...
    def __repr__(self):
        return ''.join(['<', str(self.__dict__)[1:-1], '>'])


print(p1)  # <'name': '小明', 'gender': '男', 'age': 18>

注意:如果设置了slots的值,当前类的对象就不能使用dict属性

5)__module__

类的字段;类.__module__:获取当前类是在哪个模块中声明的(返回的是模块的名字)

print(Person.__module__)  # __main__
print(bool.__module__)  # builtins

6)__bases__

类的字段;类.__bases__:获取当前类的父类(返回的是一个元组)

print(Person.__bases__)  # (<class 'object'>,)

2.私有化

1)访问权限:公开、保护、私有

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

2)python中属性和方法的访问权限

python中类的所有属性和方法本质都是公开的;

私有化是假私有化,只是提示程序员这个属性或者方法在外部不要使用,也不要去继承

怎么私有化:在需要私有化的属性名或者方法名前加__(注意:不能以__结尾)

python私有化的原理:在私有的属性和方法前加了'_类名'

3.属性的getter和setter

1)什么是getter和setter

当我们需要在获取属性值之前对其进行其他操作,则需要对其添加getter;

当我们需要在给属性值之前对其进行其他操作,则需要对其添加setter

2)给属性添加getter

a. 属性命名时前面加下划线'_'

b. 在@property装饰器的后面声明一个对象方法

第一,将属性去掉下划线作为方法名
第二,方法除了self外不需要其他参数
第三,函数的返回值就是获取这个属性时得到的值

c. 在外部使用属性时,通过 '对象.不带下划线的属性名' 去使用

注意:获取属性指定值的时候, 就会自动去调用getter对应的方法

3)给属性添加getter

属性添加setter之前必须先添加getter

a. 保证属性名前有下划线

b. 在@getter名.setter装饰器的后面声明一个同名对象方法,需要一个self以外的参数,不需要返回值

c. 在外部使用属性时,通过 '对象.不带下划线的属性名' 去使用

注意:当给属性赋值时, 实质是调用setter对应的方法

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self._age = self.age = age
        self.__gender = self.gender = gender

    @property
    def age(self):
        print('年龄被访问!')
        return self._age

    @age.setter
    def age(self, value):
        print('年龄被修改!')
        if not isinstance(value, int):
            raise ValueError
        if not 0 <= value <= 120:
            raise ValueError
        self._age = value

    @property
    def gender(self):
        if self.__gender == 1:
            return 'male'
        elif self.__gender == 2:
            return 'female'
        else:
            return 'unknown'

    @gender.setter
    def gender(self, value):
        if value == 'male':
            self.__gender = 1
        elif value == 'female':
            self.__gender = 2
        else:
            self.__gender = 0

    def __repr__(self):
        return 'Person<name: {}, age: {}, gender: {}>'.format(self.name, self.age, self.gender)

练习：写一个矩形类

# 有属性长、宽、面积、周长
# 要求从生活的角度考虑


class WriteError(Exception):
    def __str__(self):
        return 'Modify read-only properties!'


class Rectangle:
    def __init__(self, length, width):
        self._length = self.length = length
        self._width = self.width = width
        self._area = self.length * self.width
        self._perimeter = 2 * (self.length + self.width)

    @property
    def length(self):
        return self._length

    @length.setter
    def length(self, value):
        if not (isinstance(value, int) or isinstance(value, float)) or value <= 0:
            raise ValueError
        self._length = value

    @property
    def width(self):
        return self._width

    @width.setter
    def width(self, value):
        if not (isinstance(value, int) or isinstance(value, float)) or value <= 0:
            raise ValueError
        self._width = value

    @property
    def area(self):
        self._area = self.length * self.width
        return self._area

    @area.setter
    def area(self, value):
        raise WriteError

    @property
    def perimeter(self):
        self._perimeter = 2 * (self.length + self.width)
        return self._perimeter

    @perimeter.setter
    def perimeter(self, value):
        raise WriteError

    def __repr__(self):
        return '<length:{}, width: {}, area: {}, perimeter: {}>'. \
            format(self._length, self._width, self.area, self.perimeter)


r1 = Rectangle(10, 20)
print(r1.area, r1.perimeter)  # 200 60
print(r1)  # <length:10, width: 20, area: 200, perimeter: 60>
r1.length = 20
print(r1.area)  # 400
print(r1)  # <length:20, width: 20, area: 400, perimeter: 60>
# r1.area = 100  # __main__.WriteError: Modify read-only properties!

二、类方法和静态方法

1. 类中的函数

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

class Person:
    num = 61

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

    def ear(self, food):
        # 对象能做的事情self都能做
        print('{}在吃{}'.format(self.name, food))

    @classmethod
    def func1(cls):
        # 类能做的事情cls都能做
        # a = cls('a', 18, 'b')
        # print(a)
        print('这是一个类方法!')

    @staticmethod
    def func2():
        print('这是一个静态方法!')

    def __repr__(self):
        return 'Person<name: {}, age: {}, gender: {}>' \
            .format(self.name, self.age, self.gender)


Person.func1()
Person.func2()

三、继承

1. 什么是继承

继承就是让子类直接拥有父类的属性和方法

子类:继承者

父类/超类:被继承者

2. 如何继承

1)语法

class 类名(父类1, 父类2, 父类3...):
    说明文档
    类的内容

2)说明:

():固定写法,如果省略相当于(object),声明类的时候如果没有写父类,默认继承object(object又称基类)

父类:一个类的父类可以有多个,但是一般情况下只有一个父类(支持多继承)

class Person:
    num = 61

    def __init__(self):
        self.name = '小明'
        self.age = 18
        self.gender = '男'
        self.__a = 10

    def eat(self, food='米饭'):
        print('{}在吃{}'.format(self.name, food))

    @classmethod
    def show(cls):
        print('人类的数量:{}'.format(cls.num))

    @staticmethod
    def func1():
        print('人类')

    def func2(self):
        print('我是{}'.format(self.name))


class Student(Person):
    num = 10

    def __init__(self):
        # 在子类中添加对象属性,需要先通过super().__init__()来继承父类的对象属性
        super().__init__()
        self.study_id = '001'
        self.class1 = 'py1904'

    # 重写
    @staticmethod
    def func1():
        print('学生')

    def func2(self):
        print('我是学生', end=', ')
        # 在子类中可以通过super().方法()可以调用父类的方法
        # 注意:super()只能在对象方法和类方法中使用
        super().func2()

    # 添加功能
    def study(self):
        print('{}在学习'.format(self.name))


stu1 = Student()
print(stu1.num)  # 61
print(stu1.name, stu1.age, stu1.gender)  # 小明 18 男
stu1.eat()  # 小明在吃米饭
Student.show()  # 人类的数量:61
print(stu1.__dict__)  # {'name': '小明', 'age': 18, 'gender': '男', '_Person__a': 10, 'study_id': '001', 'class1': 'py1904'}
stu1.func1()  # 学生
stu1.func2()  # 我是学生, 我是小明

3. 多继承

python中的类支持多继承(让一个类同时继承多个类)

多继承的时候子类只能继承第一个父类所有的属性和方法

后面的父类中只有字段和方法可以被继承

class Animal(object):
    num = 100

    def __init__(self):
        self.age = 0
        self.gender = 'female'

    @classmethod
    def func1(cls):
        print('动物类的类方法')

    def func2(self):
        print('动物类的对象方法')


class Fly(object):
    name = 'fly'

    def __init__(self):
        self.height = 100
        self.time = 5
        self.speed = 100

    def func2(self):
        print('飞行的对象方法')


class Bird(Animal, Fly):
    pass


bird = Bird()

# 字段都能继承
print(Bird.num, Bird.name)  # 100 fly

Bird.func1()  # 动物类的类方法
bird.func2()  # 飞行的对象方法

print(bird.age, bird.gender)
print(bird.speed, bird.height, bird.time)  # AttributeError: 'Bird' object has no attribute 'speed'