标签：扩展性 can let discount pen none assm setter 1.7
隐藏对象的属性和实现细节，仅对外提供公共访问方式。
【好处】
1. 将变化隔离；
2. 便于使用；
3. 提高复用性；
4. 提高安全性；
【封装原则】
1. 将不需要对外提供的内容都隐藏起来；
2. 把属性都隐藏，提供公共方法对其访问。
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
私有变量
#其实这仅仅这是一种变形操作 #类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式： class A: __N=0 #类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N def __init__(self): self.__X=10 #变形为self._A__X def __foo(self): #变形为_A__foo print(‘from A‘) def bar(self): self.__foo() #只有在类内部才可以通过__foo的形式访问到. #A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
__author__ = ‘Administrator‘ class Person: def __init__(self,name,age,height,weight): self.name=name self.age=age self.__height=height self.__weight=weight def bmi(self): return self.__weight/(self.__height**2) def getHeight(self): print(self.__height) def getWight(self): print(self.__weight) def setWeight(self,newWeight): self.__weight=newWeight p=Person("ctz",21,1.72,63) print(p.name) #print(p.__weight)报错 print(p._Person__weight)#外部调用私有方法 p.getHeight() p.setWeight(62) p.getWight()
__author__ = ‘Administrator‘ class Good: __discount=0.8 def __init__(self,name,price): self.name=name self.price=price def good_price(self): return self.price*Good.__discount good=Good("a",10) print(good.good_price()) #print(Good.__dicount)#baocuo print(good.__dict__) print(Good.__dict__) print(good._Good__discount)
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的定义是发生一次,在定义后的赋值操作，不会变形
3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
__author__ = ‘Administrator‘ class Person: def __init__(self,name,height,weight): self.name=name self.height=height self.weight=weight def dmi(self): return self.weight/self.__hpow() def __hpow(self): return self.height**2 p=Person("ctz",1.73,64) print(p.dmi()) #p.__hpow baocuo print(p._Person__hpow())
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
#类的设计者 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是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
圆的面积和周长
__author__ = ‘Administrator‘ from math import pi class Circle: def __init__(self,radius): self.radius=radius @property def raea(self): return self.radius**2*pi @property def perometer(self): return self.radius*2*pi c=Circle(5) print(c.radius)
class People: def __init__(self,name,weight,height): self.name=name self.weight=weight self.height=height @property def bmi(self): return self.weight / (self.height**2) p1=People(‘egon‘,75,1.85) print(p1.bmi)
BMI指数
__author__ = ‘Administrator‘ class Num: def __init__(self,*args): if len(args)==1and(type(args[0]) is list or type(args[0]) is tuple ): self.members=args[0] else: self.members=args @property def sum(self): return sum(self.members) @property def avg(self): return self.sum/len(self.members) @property def min(self): return min(self.members) @property def max(self): return max(self.members) n=Num(1,9,6) print(n.max) print(n.avg) print(n.min) print(n.sum) print("*"*50) n2=Num([1,5,3,4]) print(n2.max) print(n2.avg) print(n2.min) print(n2.sum)
为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
除此之外，看下
ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
class Foo: def __init__(self,val): self.__NAME=val #将所有的数据属性都隐藏起来 @property def name(self): return self.__NAME #obj.name访问的是self.__NAME(这也是真实值的存放位置) @name.setter def name(self,value): if not isinstance(value,str): #在设定值之前进行类型检查 raise TypeError(‘%s must be str‘ %value) self.__NAME=value #通过类型检查后,将值value存放到真实的位置self.__NAME @name.deleter def name(self): raise TypeError(‘Can not delete‘) f=Foo(‘egon‘) print(f.name) # f.name=10 #抛出异常‘TypeError: 10 must be str‘ del f.name #抛出异常‘TypeError: Can not delete‘
__author__ = ‘Administrator‘ class Good: __discount=0.8 def __init__(self,name,price): self.name=name self.__price=price @property def goodMoney(self): return self.__price*Good.__discount @goodMoney.setter def changeprice(self,newprice): self.__price=newprice g=Good("a",10) print(g.goodMoney) g.changeprice=20 print(g.goodMoney)
一个静态属性property本质就是实现了get，set，delete三种方法
class Foo: @property def AAA(self): print(‘get的时候运行我啊‘) @AAA.setter def AAA(self,value): print(‘set的时候运行我啊‘) @AAA.deleter def AAA(self): print(‘delete的时候运行我啊‘) #只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter f1=Foo() f1.AAA f1.AAA=‘aaa‘ del f1.AAA
class Foo: def get_AAA(self): print(‘get的时候运行我啊‘) def set_AAA(self,value): print(‘set的时候运行我啊‘) def delete_AAA(self): print(‘delete的时候运行我啊‘) AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应 f1=Foo() f1.AAA f1.AAA=‘aaa‘ del f1.AAA
怎么用？
class Goods: def __init__(self): # 原价 self.original_price = 100 # 折扣 self.discount = 0.8 @property def price(self): # 实际价格 = 原价 * 折扣 new_price = self.original_price * self.discount return new_price @price.setter def price(self, value): self.original_price = value @price.deleter def price(self): del self.original_price obj = Goods() obj.price # 获取商品价格 obj.price = 200 # 修改商品原价 print(obj.price) del obj.price # 删除商品原价
__author__ = ‘Administrator‘ from urllib.request import urlopen class WeBpage: def __init__(self,url): self.url=url self.__content=None @property def content(self): if self.__content: return self.__content else: self.__content=urlopen(self.url).read() return self.__content mypage=WeBpage("http://www.baidu.com") print(mypage.content)
#staticmethod #classmethod class Student: f = open(‘student‘, encoding=‘utf-8‘) def __init__(self): pass def func(self): pass @classmethod #类方法：默认参数cls，可以直接用类名调用，可以与类属性交互 def show_student_info_class(cls): for line in cls.f: name, sex = line.strip().split(‘,‘) print(name, sex) @staticmethod #静态方法 ： 让类里的方法直接被类调用，就像正常的函数一样 def show_student_info_static(): f = open(‘student‘, encoding=‘utf-8‘) for line in f: name, sex = line.strip().split(‘,‘) print(name, sex) print(Student.func) print(Student.show_student_info_class) print(Student.show_student_info_static) # 海娇 = Student() # 海娇.show_student_info() #Student.show_student_info(海娇) # Student.show_student_info() # class Teacher: # pass #classmethod和staticmethod #相同：都可以直接被类调用，不需要实例化 #不同: #类方法必须有一个cls参数表示这个类，可以使用类属性 #静态方法不需要，静态方法不能直接使用 # def show_student_info(): # f = open(‘student‘, encoding=‘utf-8‘) # for line in f: # name, sex = line.strip().split(‘,‘) # print(name, sex) #绑定方法 #非绑定方法 #普通方法 默认有一个self对象传进来，并且只能被对象调用——绑定到对象 #类方法 默认有一个cls传进来表示本类，并且可以被类和对象（不推荐）调用——绑定到类 #静态方法 没有默认参数，并且可以被类和对象（不推荐）调用——非绑定
#stu 宝宝,男 博博,女 海娇,男 海燕,女 海东,男 海峰,男
标签：扩展性 can let discount pen none assm setter 1.7
原文地址：http://www.cnblogs.com/ctztake/p/7367004.html
