2019-08-09面向对象

一、内置类属性

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

定制当前类的对象的打印：

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

#!/user/bin/env python
# -*- coding:utf-8 -*-


class Person:
    num = 61

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

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

    def __str__(self):
        return '<' + str(self.__dict__)[1:-1] + '>'


p1 = Person('王力', '男', '23')
print(p1.__str__())

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

#!/user/bin/env python
# -*- coding:utf-8 -*-


class Person:
    num = 61

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

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

    def __repr__(self):
        return '<' + str(self.__dict__)[1:-1] + '>'


p1 = Person('王力', '男', '24')
print(p1.__repr__())

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

1. __name__
   类的字段; 类.__name__ - 获取类的名字(字符串)

print(Person.__name__)

2. __doc__
   类的字段; 类.__doc__ - 获取类的说明文档

print(Person.__doc__)
print(int.__doc__)

3. __class__
   对象属性; 对象.__class__ - 获取对象对应的类,返回的是类 (和type(对象)功能一样)

print(p1.__class__)

4. __dict__ (将对象转换成字典)
   对象属性; 对象.__dict__ - 将对象所有的属性和对应的值转换成一个字典中的键值对(一个对象对应一个字典)
   类的字段; 类.__dict__ - 将类转换成一个字典,字典中的元素是类中所有的字段和对应的值

print(p1.__dict__)
print(Person.__dict__)

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

print(Person.__module__)
print(bool.__module__)

6. _\bases__
   类的字段; 类._\bases__ - 获取当前类的父类(返回的是一个元祖)

print(Person.__bases__)

练习：将字典转换成对象

with open('data', 'r', encoding='utf-8') as f:
    content = json.loads(f.read())
    datas = content['data']


class Data:
    def __init__(self, dict1: dict):
        for key in dict1:
            setattr(self, key, dict1[key])

    def __repr__(self):
        return '<'+str(self.__dict__)[1:-1]+'>'


for item in datas:
    data = Data(item)
    print(data.name, type(data))
    print(data)

二、私有化

1. 访问权限: 公开、保护、私有
   公开 - 公开的属性和方法在类的内部、外部能够使用，也能被继承
   保护 - 保护的属性和方法在类的内部能够使用、外部不能使用，可以被继承
   私有 - 私有的属性和方法只能在类的内部使用、外部不能使用，也不能被继承

2. python中属性和方法的访问权限
   python类中所有的属性和方法本质都是公开的；
   私有化是假私有化，只是提示程序员这个属性或者方法在外部不能要使用，也不要去继承
   怎么私有化: 在需要私有化的属性名或者方法名前加'__'(注意:不能以'__'结尾！)
   python私有化的原理: 在私有的属性和方法前加了'_类名'

三、属性的getter和setter

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

2. 给属性添加getter

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

3. 给属性添加setter
   属性添加setter之前必须先添加getter
   1)保证属性名前有'_'
   2)在@getter名.setter后面声明对象方法
   a.将属性去掉下划线作为方法名
   b.需要一个self以外的参数
   c.不需要返回值

3. 在外部使用属性的时候，通过'对象.不带下滑的属性'去使用
   注意: 当给属性赋值的时候，实质是调用setter对应的方法

class WriteError:
    def __str__(self):
        return WriteError

class Rect:
    def __init__(self, length, width):
        if isinstance(length, int) or isinstance(length, float):
            self._length = length
        else:
            raise ValueError
        self._width = width
        self._perimeter = None
        self._area = None

    @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 width(self):
        return self._width

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

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

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

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

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


p1 = Rect(10, 50)
print(p1.length, p1.width, p1.perimeter, p1.area)

p1.length = 20
print(p1.length, p1.width, p1.perimeter, p1.area)

四、类的方法和静态方法

1. 类中的函数
   类中的方法分为: 对象方法、类方法和静态方法

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

2)类方法
a.怎么声明: 声明在@classmethod后面
b.怎么调用: 用类来调用, '类.类方法()'
c.特点: 有自带的参数cls，表示当前类; 这个参数在调用的时候不用传参，系统会自动将当前类传给它；
cls:谁调用就指向谁（如果是对象指向的是对象对应的类）
d.什么时候用: 如果实现函数的功能不需要对象属性，但是需要类的字段, 就使用类方法

3)静态方法
a.怎么声明: 声明在@staticmethod后面
b.怎么调用: 通过类来调用, '类.静态方法()'
c.特点: 没有默认参数
d.什么时候用: 实现函数的功能既不需要类也不需要对象，就使用静态方法

五、继承

1. 什么是继承
   继承就是让子类直接拥有父类的属性和方法
   子类 - 继承者
   父类/超类 - 被继承者

2. 怎么继承
   1)语法
   class 类名(父类1,父类2,..):
   说明文档
   类的内容

2)说明:
() - 固定写法，如果省略相当于(object)
声明类的时候如果没有写父类，默认继承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()