笔记：python基础之面向对象特性——封装

封装能实现代码保护，面向对象的思想本身就是一种只让自己的对象能调用自己类中的方法，狭义理解：属性和方法都藏起来，不让看见。

class Person:
    __key = 123  # 私有静态属性
    def __init__(self,name,passwd):
        self.name = name
        self.__passwd = passwd   # 私有属性，不能用于信息安全

    def __get_pwd(self):         # 私有方法
        return self.__passwd   #只要在类的内部使用私有属性，就会自动的带上_类名（只有在类的内部，在外部就没用）

    def login(self):          # 正常的方法调用私有的方法，是在内部调用私有方法
        self.__get_pwd()

alex = Person('alex','alex3714')
print(alex._Person__passwd)   # _类名__属性名：调用私有属性
print(alex..login())

#输出：
alex3714
None

所有的私有 都是在变量的左边加上双下划綫

• 对象的私有属性
• 类中的私有方法
• 类中的静态私有属性

所有的私有的 都不能在类的外部使用
封装 —— 私有的

• 在python中只要__名字 在python中只要__名字，就把这个名字私有化了
• 私有化了之后 就不能能从类的外部直接调用了
• 静态属性 方法 对象属性 都可以私有化 这种私有化只是从代码级别做了变形，并没有真的约束 变形机制 _类名__名字
• 在类外用这个调用，在类的内部直接__名字调用

私有化属性

class Room:
    def __init__(self,name,length,width):
            self.__name = name
            self.__length = length
            self.__width = width
    def get_name(self):
         return self.__name
    def set_name(self,newName):
        if type(newName) is str and newName.isdigit() == False:
            self.__name = newName
        else:
            print('不合法的姓名')
    def area(self):
         return self.__length * self.__width

jin = Room('金老板',2,1)
print(jin.area())
jin.set_name('2')
print(jin.get_name())

#输出：
2
不合法的姓名
金老板

父类的私有属性不能被子类继承

class Foo:
    __key = '123'       # _Foo__key

class Son(Foo):
    print(Foo.__key)     # _Son__key
    #报错

会用到私有的这个概念de场景
1.隐藏起一个属性 不想让类的外部调用
2.我想保护这个属性，不想让属性随意被改变
3.我想保护这个属性，不被子类继承

装饰器1——property
内置装饰器函数 只在面向对象中使用
用property将类里面的函数伪装成属性，但这样就不能再跟参数

from math import pi
class Circle:
    def __init__(self,r):
        self.r = r
    @property
    def perimeter(self):
        return 2*pi*self.r
    @property
    def area(self):
        return self.r**2*pi
c1 = Circle(5)
print(c1.area)     # 圆的面积
print(c1.perimeter) # 圆的周长
#输出：
78.53981633974483
31.41592653589793

@name.setter

class Person:
    def __init__(self,name):
        self.__name = name
    @property
    def name(self):
        return self.__name + 'sb'
    @name.setter
    def name(self,new_name):
        self.__name = new_name
tiger = Person('泰哥')
print(tiger.name)
tiger.name = '全班'
print(tiger.name)#通过装饰函数来修改属性

#输出：
泰哥sb
全班sb

私有化与property一起用

class Goods:
    discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.discount
apple = Goods('苹果',5)
print(apple.price)

#输出：
4.0

属性：查看 修改 删除
@函数名.setter:只能跟一个参数，能实现对象修改
@函数名.deleter:删除某属性→del 对象.函数名，只要是del就会触发deleter机制，则删除其函数内删除的属性

class Person:
    def __init__(self,name):
        self.__name = name
        self.price = 20
    @property
    def name(self):
        return self.__name
    @name.deleter
    def name(self):
        del self.__name
    @name.setter
    def name(self,new_name):
        self.__name = new_name

装饰器2——method
classmethod 类方法
当这个方法的操作只涉及静态属性的时候 就应该使用classmethod来装饰这个方法。

class Goods:
    __discount = 0.8
    def __init__(self,name,price):
        self.name = name
        self.__price = price
    @property
    def price(self):
        return self.__price * Goods.__discount
    @classmethod   # 把一个方法 变成一个类中的方法，这个方法就直接可以被类调用，不需要依托任何对象
    def change_discount(cls,new_discount):  # 修改折扣
        cls.__discount = new_discount
apple = Goods('苹果',5)
print(apple.price)
Goods.change_discount(0.5)   # Goods.change_discount(Goods)
print(apple.price)

#输出：
4.0
2.5

在完全面向对象的程序中，
如果一个函数 既和对象没有关系 也和类没有关系 那么就用staticmethod将这个函数变成一个静态方法,无默认参数，不用传self参数

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

    @staticmethod
    def get_usr_pwd():   # 静态方法
        usr = input('用户名 ：')
        pwd = input('密码 ：')
        Login(usr,pwd)

Login.get_usr_pwd()#调用：类名+静态方法

• 类方法和静态方法 都是类调用的
• 对象可以调用类方法和静态方法， 一般情况下 推荐用类名调用
• 类方法 有一个默认参数 cls 代表这个类cls
• 静态方法 没有默认的参数 就象函数一样