20 Python - 面对对象 基础 中

Python 面对对象 基础 中

一. 内置类属性

python在定义类的时候系统自动添加的属性(从基类中继承下来的属性)就是内置属性
这里定义了两个简单的类,来帮助我们更好的了解类中的属性

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

    # 重写了repr方法,实现:xxx模块.xxx类的对象:属性1=值1,属性2=值2 方式打印对象
    def __repr__(self):
        c = self.__class__
        return '<{}模块,{}的对象,name={}>'.format(c.__module__, c.__name__, self.name)
		

class Dog:
    # 类属性
    num = 100

    # 对象属性
    def __init__(self, name, age='1', color='白色'):
        self.name = name
        self.age = age
        self.color = color

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

    @classmethod
    def show_num(cls):
        print('狗的数量:{}'.format(cls.num))

    @staticmethod
    def bark():
        print('狗嗷嗷叫')

    def __repr__(self):
        c = self.__class__
        return '<{}模块,{}的对象,name={}>'.format(c.__module__, c.__name__, self.name)


dog1 = Dog('花花')

下面列出了一些常见的类属性获取操作：
1.__module__

类.__module__ - 获取定义的模块的模块名

print(Dog.__module__)  # __main__ 表示在当前模块定义的
print(int.__module__)  # builtins

2.__class__

对象.__class__ - 获取对象对应的类

print(dog1.__class__)  # <class '__main__.Dog'>
print(type(dog1))  # <class '__main__.Dog'>  其实就相当于type的作用

3.__name__

类.__name__ - 获取类名,返回的是一个字符串

print(Dog.__name__)  # 'Dog'

4.__dict__

类.__dict__ - 将类转换成字典（类的类属性名作为key,类属性的值作为值）

对象.__dict__ - 将对象转换成字典(对象的属性名作为key,属性的值作为值)

print(Dog.__dict__) 
print(dog1.__dict__) #   {'name': '花花', 'age': '1', 'color': '白色'}

5.__doc__

类.__doc__ - 获取类的说明文档

6.__base__ __bases__

类.__base__ - 获取当前类的父类

类.__bases__ - 获取当前类的所有父类

注意：所有类的父类 都继承自 object ，可以理解成object是初代

所以我们在打印类.__bases__的时候一定会有 object

7.__slots__

class Person:
    # __slots__可以约束当前类的对象能够拥有哪些对象属性
    __slots__ = ('name', 'age', 'height')

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


p1 = Person('小明')
p1.height = 180 

注意：如果给类属性slots赋值了,那么这个类的对象不能再使用dict属性

二.私有化属性

1.访问权限:

• 公开的：在类的内部和外部都可以使用，也能被继承
• 保护的：在类的内部可以使用，类的外部不能使用，可以被继承
• 私有的：只能在类的内部使用，不能被继承

严格来说，python中的所有的属性和方法都是公开的，这儿说的私有化其实是假的私有化

2.私有化属性

__双下划线表示私有化属性

只能在类的内部使用，其它地方都不能使用

实现原理：重命名，python 内部自动把双下划线属性，更名为_类名__属性，所以外部调用不成功，如果非要实线，也可以使用 _类名__属性调用，不建议！！！

3.私有化使用场景

保护属性： 比如银行存款等，存款直接外放非常危险，就可以私有化，然后通过类提供的方法增加删减铅笔的金额，对存款进行保护。

内部过滤：过滤一下不符合属性的数据，数据不对，不进行操作，比如银行存款，取出比银行存款还多的钱，可以通过方法内部进行过滤，不用在外部进行对比。

class Person:
    num = 100
    __num2 = 61  # num2 即是一个私有属性

    def __init__(self):
        self.name = '小明'
        self.age = 10
        self.__gender = '男'  # 对象的gender也是私有属性

    def eat(self):
        print(f'{self.name}在吃饭')
        print(self.__gender)


p1 = Person()

print(Person.num)
print(p1.name, p1.age)
p1.eat()

# print(p1.__gender)	
# print(Person.__num2)
# 私有化的原理：
print(p1.__dict__)     # {'name': '小明', 'age': 10, '_Person__gender': '男'}   # 这里可以看到 Person.__gender 变成了 _Person__gender 即实现原理
print(p1._Person__gender)

三. getter 和 setter

1.getter 和 setter 的作用

getter的作用：在获取某个属性值之前想要做别的事情,就给这个属性添加getter

setter的作用：在给属性赋值之前想要做别的事情,就给这个属性添加setter

2.怎么添加 getter 和 setter

①getter

第一步:在需要添加getter的属性名前加_
第二步:定义getter对应的函数(1.需要@property装饰器 
                         2.函数名就是不带_的属性名
                         3.函数需要一个返回值)
第三步:获取属性值 通过 对象.不带_属性名(本质就是调用getter对应的函数,
                                  取到的属性值就是函数的返回值)

②setter

如果想要给属性添加setter必须先给属性添加getter
第一步:添加getter
第二步:定义setter对应的函数(1.需要@getter函数名.setter装饰器
                         2. 函数名就是不带_的属性名
                         3.需要一个参数不需要返回值,这个参数就是舱室给属性赋的值)
第三步:给属性赋值:对象.不带_属性名 = 值 (本质就是在调用setter对应的函数)

所以getter和setter到底有什么作用呢？我们直接上代码

class Rect:
    # 定义一个矩形类 
    def __init__(self, length=0, width=0):
        self.length = length
        self.width = width
        self.area = length*width  # 根据矩形的长和宽得到矩形的面积  

上面这段代码定义了一个简单的矩形类,我们可以根据矩形的长和宽得到矩形的面积

r1 = Rect(3,4)
print(r1.area)  # 12

但是我们直接修改r1矩形的面积为20，我们再打印矩形的属性,得到下面的结果：

r1.area = 20
print(r1.__dict__) # {'length': 3, 'width': 4, 'area': 20}

矩形r1的length为3，width为4,面积却是20.这显然有问题，那么问题在哪呢?问题就在于我们在外部修改了矩形r1的面积，像矩形面积，周长这类定义在类中如果是根据其他属性得到的结果,我们就要避免在外部修改它的属性值.而getter和setter的存在就可以帮助我们避免此类问题的发生：

class Rect:
    # 定义一个矩形类 
    def __init__(self, length=0, width=0):
        self.length = length
        self.width = width
        self._area = length*width  # 根据矩形的长和宽得到矩形的面积   

    @property
    def area(self):     
        print('area属性值被获取')
        self._area = self.width * self.length
        return self._area
    # 如果想要获取矩形的面积,就会先调用area函数,重新返回矩形长和宽的乘积，这样就能保证我们获取到的矩形面积是根据矩形的长和宽得到的 

    @area.setter
    def area(self, value):
        # print(f'value:{value}')
        # self._area = value
        raise ValueError
	# 如果在外部想跟根据矩形直接更改矩形的面积,就会报错

r1 = Rect(4, 5)
print(r1.area)


# 不能让矩形直接修改面积属性值
r1.area = 100 
print(r1.__dict__)  # ValueError 

好了,今天的分享就到这里啦。大家记得好好学习哟！