pyton 封装

定义：在类中将方法和属性隐藏起来

一、私有化

1、格式

__名字，在名字前加双下划线

2、私有化对象

对象属性

静态属性

普通方法

3、作用

1)在类的外面不能直接调用类的方法和属性

2)类的属性值不能随意更改

3)子类不能通过继承获取父类的私有化属性和方法

4、实质

在代码层次做了变形，在类的外部仍可通过 　对象名或类命_类命__名字，来调用，不推荐使

class Person:
    __country = 'china'

    def __init__(self, name, sex, age):
        self.__name = name
        self.__sex = sex
        self.__age = age

    def get_age(self):
        """
        对象属性__age，私有化无法直接调用
        通过get_age方法实现
        :return: self.__age
        """
        # print(self.__dict__)
        return self.__age

    def set_age(self, new_age):
        """
        对象属性__age，私有化无法直接修改
        通过set_age方法实现，并规定属性值只能是数字
        :param new_age:
        :return:赋值类型不符合规定，返回的内容
        """
        if new_age.isdigit():
            self.__age = new_age
        else:
            return '输入错误，请输入年龄'


class Worker(Person):
    def __init__(self, name, sex, age, job):
        super().__init__(name, sex, age)
        self.job = job

    def test(self):
        print(self.name)


w1 = Worker('tom', 'm', '22', 'joker')
print(w1.test())    # AttributeError: 'Worker' object has no attribute 'name'
p1 = Person('tom', 'm', '22')
print(p1.get_age())     # 22
print(p1.set_age('wt'))     # 输入错误，请输入年龄
print(p1.get_age())     # 22
p1.set_age('24')
print(p1.get_age())     # 24
print(p1._Person__age)      # 私有化的实质是在代码层次进行变形，格式p1.name-> p1._Person__name, 不推荐使用
print(Person._Person__country)      # 静态属性私有化，不推荐使用

二、property

1、property是内置装饰函数，只在面向对象中使用

2、作用

方法属性，给方法加上装饰器，可以在类的外部直接调用方法名而不是调用方法名（）

动词：方法，名词：属性

from math import pi


class Circle:
    def __init__(self, r):
        self.__r = r

    @property       # 方法->属性
    def area(self):
        return round(pi * pow(self.__r, 2), 2)


c1 = Circle(5)
print(c1.area)  

3、修改

属性私有化，在类的外部不改变该属性的调用方法

class Phone:
    """
    price私有化
    使用property装饰price方法，在类的外部调用，和没有私有化做比较，不会感到明显的差异
    使用方法名.setter装饰同名方法，来修改
    """
    def __init__(self, name, price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price

    @price.setter
    def price(self, new_price):
        self.__price = new_price


red_mi = Phone('mi', 1500)
print(red_mi.price)     # 1500
red_mi.price = 2000     # 修改价格
print(red_mi.price)     # 2000

3、删除

不常用

class Phone:
    """
    price私有化
    使用property装饰price方法，在类的外部调用，和没有私有化做比较，不会感到明显的差异
    使用方法名.setter装饰同名方法，来修改
    """
    def __init__(self, name, price):
        self.name = name
        self.__price = price

    @property
    def price(self):
        return self.__price

    @price.setter
    def price(self, new_price):
        self.__price = new_price

    @price.deleter
    def price(self):
        del self.__price


red_mi = Phone('mi', 1500)
print(red_mi.price)     # 1500
red_mi.price = 2000     # 修改价格
print(red_mi.price)     # 2000
del red_mi.price        # 根据 del 到 price.deleter, 实质是执行price.deleter装饰器下的price方法
print(red_mi.price)     # 报错，因为已经被删除

4、总结

1)property是内置装饰器

2)查

私有化属性，可以通过定义同名方法和property装饰器，而不改变在类外部的调用方法

3)改

查实现后，才能实现删

私有化属性，可以通过定义同名方法和property装饰器，而不改变在类外部的调用方法

 通过同方法.setter装饰器，装饰同名方法来修改私有化属性，而不改变在类外部的修改方法

4)删

不常用

三、classmethod

类方法

作用：把一个对象方法，变成类方法，调用该方法可以直接通过类，而不需要对象

格式：有一个默认参数，cls

什么时候用到：一个方法与私有化静态属性产生联系

class Student:
    __country = 'china'

    def __init__(self, name):
        self.__name = name

    @property
    def info(self):
        return '%s is %s' % (self.__name, Student.__country)

    @classmethod        # classmethod有一个默认参数，cls
    def con(cls, new_country):
        cls.__country = new_country


Student.con('USA')
s1 = Student('tom')
print(s1.info)      # tom is USA

四、staticmethod

静态方法

1)作用

在完全面向对象的程序中，若果一个函数，即和对象没有关系，也和类没有关系，那么就可以用staticmethod装饰该函数，作为类的静态方法

2)细节

静态方法在类的内部，在静态方法中可以直接调用类，在类的外部可以通过类名调用静态方法

class Login:
    def __init__(self, name, pwd):
        self.name = name
        self.pwd = pwd

    def login(self):
        if self.name == 'tom' and self.pwd == 'abc-123':
            print('登录成功！')

    @staticmethod
    def name_pwd():
        name = input('请输入用户名:')
        pwd = input('请输入密码：')
        Login(name, pwd)        # 在静态方法中可以直接调用类


Login.name_pwd()    # 用类调用静态方法

类方法和静态方法小结

1、都通过类名调用

2、类方法有一个默认参数，静态方法没有

3、类方法：和静态属性有关，通过类直接调用方法，不需要通过对象

4、静态方法：和类及对象没有关系，但又是必要的方法，python可以不用（面向对象和面向函数），完全面向对象必须用