python_day22_面向对象编程4详解编程语言

私有变量 
 
#其实这仅仅这是一种变形操作 
#类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式： 
 
class Family: 
    __money=0  
# 类的数据属性就应该是共享的, 
# 但是语法上是可以把类的数据属性设置成私有的如__money,会变形为_Family__money 
 
    def __init__(self): 
        self.__x=10 # 变形为self._Family__X 
 
    def __foo(self): # 变形为_Family__foo 
        print('from Family') 
 
    def func(self): 
        self.__foo() # 只有在类内部才可以通过__foo的形式访问到. 
 
类外部使用._Family__money是可以访问到的， 
即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形。

定义一个私有的名字 ： 就是在私有的名气前面加两条下划线 __N = 'word' 
所谓私有，就是不能在类的外面去引用它。 
python就是把__名字当成私有的语法 
 
一个私有的名字 在存储的过程中仍然会出现在'类名字.__dict__'中，所以我们仍然可以调用到。 
python对其的名字进行了修改： _类名__名字 
只不过在类的外部调用 ：需要“_类名__名字”去使用 
在类的内部可以正常的使用名字。 
在类内 只要你的代码遇到__名字，就会被python解释器自动的转换成_类名__名字 
 
私有属性 
class B: 
    def __init__(self,name): 
        self.__name = name 
    def func(self): 
        print('in func : %s'%self.__name) 
b = B('alex') 
# print(b._B__name) 
b.func() 
 
私有方法 
在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的。 
class C: 
    def __wahaha(self): 
        print('wahaha') 
    def ADCa(self): 
        self.__wahaha() 
c = C() 
# c._C__wahaha() 
c.ADCa() 
 
在类中，静态属性，方法，对象属性都可以变成私有的，只需要在这些名字之前加上__ 
 
class D: 
    def __func(self):      # '_D__func' 
        print('in func') 
 
class E(D): 
    def __init__(self): 
        self.__func()      # '_E__func' 
e = E() 
 
私有的名字不能被子类继承 
 
class D: 
    def __init__(self): 
        self.__func() 
    def __func(self): 
        print('in D') 
 
class E(D): 
    def __func(self): 
        print('in E') 
e = E() 
 
私有的名字，在类内使用的时候，就是会变形成_该类名__方法名 
以此为例 ：没有双下换线会先找E中的func 
但是有了双下划线，会在调用这个名字的类D中直接找_D__func 
 
class F: 
    pass 
F.__name = 'alex'  # 不是在创建私有属性 
print(F.__name) 
print(F.__dict__) 
 
变形只在类的内部发生 
 
class F: 
    def ADCa(self): 
        self.__name = 'alex'   # _F__name 
 
f = F() 
f.ADCa() 
print(f._F__name)

这种自动变形的特点： 
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。 
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。 
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x, 
而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。 
 
这种变形需要注意的问题是： 
1.这种机制也并没有真正意义上限制我们从外部直接访问属性， 
知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N 
2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形。

#类的设计者 
class Room: 
    def __init__(self,name,owner,width,length,high): 
        self.name=name 
        self.owner=owner 
        self.__width=width 
        self.__length=length 
        self.__high=high 
    def tell_area(self): #对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积 
        return self.__width * self.__length 
 
#使用者 
>>> r1=Room('卧室','egon',20,20,20) 
>>> r1.tell_area() #使用者调用接口tell_area 
 
#类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码 
class Room: 
    def __init__(self,name,owner,width,length,high): 
        self.name=name 
        self.owner=owner 
        self.__width=width 
        self.__length=length 
        self.__high=high 
    def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了 
        return self.__width * self.__length * self.__high 
 
#对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能 
>>> r1.tell_area() 
 
property属性 
什么是特性property 
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值 
 
# 人体BMI指数 
# 体质指数（BMI）=体重（kg）÷身高^2（m） 
# 写一个类 描述人体BMI指数 
 
class Person: 
    def __init__(self,name,weight,height): 
        self.name = name 
        self.__height = height 
        self.__weight = weight 
        # self.bmi = self.__weight / self.__height ** 2 
        # self.bmi = self.cal_BMI() 
 
    def cal_BMI(self): 
        return self.__weight / self.__height ** 2 
 
    @property 
    def bmi(self): 
        return self.__weight / self.__height ** 2 
 
p = Person('大表哥',92,1.85) 
print(p.cal_BMI()) 
p.cal_BMI()   # bmi是一个名词 
print(p.bmi)   # bmi是一个名词 
p._Person__weight = 90 
print(p.bmi)

如下例： 
class Person: 
    def __init__(self,name,weight,height): 
        self.name = name 
        self.__height = height 
        self.__weight = weight 
        self.bmi = self.__weight / self.__height ** 2 
 
p = Person('大表哥',92,1.85)    
print(p.bmi)   # bmi是一个名词 
p._Person__weight = 90   # 修改了体重 
print(p.bmi)  # 而bmi的值并没有随之变化 
 
@property 能够将一个方法伪装成一个属性 
从原来的的对象名.方法名()，变成了对象名.方法名 
只是让代码变的更美观。 
 
如果proerty装饰方法的同时有重名的属性名字： 
会在实例化的时候就报错。 
被property装饰的bmi仍然是一个方法 存在Person.__dict__ 
对象的.__dict__中不会存储这个属性。 
在一个类加载的过程中，会先加载这个中的名字，包括被property装饰的 
在实例化对象的时候，python解释器会先到类的空间里看看有没有这个被装饰的属性， 
如果有就不能再在自己对象的空间中创建这个属性了。

from math import pi 
class Circle: 
def __init__(self,r): 
self.r = r 
def cal_area(self): 
return self.r**2*pi 
def cal_perimeter(self): 
return 2*pi*self.r 
c = Circle(10) 
print(c.cal_area()) 
print(c.cal_perimeter()) 
将方法伪装成属性，方法中一般涉及的都是一些计算过程 
from math import pi 
class Circle: 
def __init__(self,r): 
self.r = r 
@property 
def area(self): 
return self.r**2*pi 
@property 
def perimeter(self): 
return 2*pi*self.r 
c = Circle(10) 
print(c.area) 
print(c.perimeter) 
c.r = 15 
print(c.area) 
print(c.perimeter) 
一个静态属性property本质就是实现了get，set，delete三种方法 
__属性 setter deleter方法 
class Person: 
def __init__(self,name): 
self.__name = name  # 私有的属性 
@property 
def name(self): 
return self.__name 
def set_name(self,new_name): 
if type(new_name) is str: 
self.__name = new_name 
else: 
print('您提供的姓名数据类型不合法') 
p = Person('alex') 
print(p.name) 
# 和直接定义name属性有什么区别？？？--区别是不能直接修改 
p.set_name('alex_sb') 
print(p.name) 
p.set_name(123) 
print(p.name) 
方法伪装成的属性的修改 
class Person: 
def __init__(self,n): 
self.__name = n  # 私有的属性了 
@property 
def name(self): 
return self.__name 
@name.setter        # 重要程度 *** 
def name(self,new_name): 
if type(new_name) is str: 
self.__name = new_name 
else: 
print('您提供的姓名数据类型不合法') 
p = Person('alex') 
print(p.name)       #def name(self): 
p.name = 'alex_sb' #def name(self,new_name): 
print(p.name)       #def name(self): 
p.name = 123 #def name(self,new_name): 
print(p.name)       #def name(self): 
方法伪装成的属性的删除 
class Person: 
def __init__(self,n): 
self.__name = n  # 私有的属性 
@property            # 重要程度 **** 
def name(self): 
return self.__name 
@name.deleter 
def name(self): 
print('name 被删除了') 
@name.deleter         # 重要程度* 
def name(self): 
del self.__name 
p = Person('alex') 
print(p.name) 
del p.name  # [email protected] 
print(p.name) 
@property --> func     将方法伪装成属性，只读的权限 
@func.setter --> func  对伪装的属性进行赋值的时候调用这个方法 一般情况下用来做修改 
@func.deleter --> func 在执行del 对象.func的时候调用这个方法 一般情况下用来做删除 基本不用 
例：商店商品的折扣促销活动 
有一个商品 ： 原价 折扣 
当我要查看价格的时候 我想看到的是折后价格。 
class Goods: 
def __init__(self,name,origin_price,discount): 
self.name = name 
self.__price = origin_price 
self.__discount = discount 
@property 
def price(self): 
return self.__price * self.__discount 
@price.setter 
def price(self,new_price): 
if type(new_price) is int or type(new_price) is float: 
self.__price = new_price 
apple = Goods('apple',5,0.8) 
print(apple.price) 
# 修改苹果的原价 
apple.price = 8 
print(apple.price) 
将一些需要随着一部分属性的变化而变化的值的计算过程从方法伪装成属性 
将私有的属性保护起来，让修改的部分增加一些约束，来提高程序的稳定性和数据的安全性 
[email protected]： 
例：店庆 全场八折 
class Goods: 
__discount = 0.8 
def __init__(self,name,origin_price): 
self.name = name 
self.__price = origin_price 
@property 
def price(self): 
return self.__price * Goods.__discount 
@classmethod 
def change_discount(cls,new_discount):      
# 类方法 可以直接被类调用 不需要默认传对象参数 只需要传一个类参数就可以了 
cls.__discount = new_discount 
Goods.change_discount(1)  # 不依赖对象的方法 就应该定义成类方法 类方法可以任意的操作类中的静态变量 
apple = Goods('apple',5) 
banana = Goods('banana',8) 
print(apple.price) 
print(banana.price) 
# 折扣变了 店庆结束 恢复折扣 
# apple.change_discount(1)    
# 如果要改变折扣 是全场的事情 不牵扯到一个具体的物品 所以不应该使用对象来调用这个方法 
# print(apple.price) 
# print(banana.price) 
@staticmethod 
# 当一个方法要使用对象的属性时 就是用普通的方法 
# 当一个方法要使用类中的静态属性时 就是用类方法 
# 当一个方法要既不使用对象的属性也不使用类中的静态属性时，就可以使用staticmethod静态方法 
例：登录 
# def login(): 
#     user= input('user :') 
#     if user == 'alex':print('success') 
#     else :print('faild') 
# 
# login() 
class Student: 
def __init__(self,name):pass 
@staticmethod 
def login(a):                    
# login就是一个类中的静态方法 静态方法没有默认参数 就当成普通的函数使用即可 
user = input('user :') 
if user == 'alex': 
print('success') 
else: 
print('faild') 
Student.login(1) 
# 完全面向对象编程 
# 先登录 后 实例化 
# 还没有一个具体的对象的时候 就要执行login方法