【封装】
隐藏对象的属性和实现细节，仅对外提供公共访问方式。
【好处】
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
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‘
setter
__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
#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 宝宝,男 博博,女 海娇,男 海燕,女 海东,男 海峰,男
时间： 2024-08-02 02:46:32