python之封装
【摘要】 【封装】 隐藏对象的属性和实现细节，仅对外提供公共访问方式。【好处】 1. 将变化隔离； 2. 便于使用；3. 提高复用性； 4. 提高安全性；【封装原则】 1. 将不需要对外提供的内容都隐藏起来； 2. 把属性都隐藏，提供公共方法对其访问。1、私有变量和私有方法在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）1）、私有变量1234#其实...
【封装】
隐藏对象的属性和实现细节，仅对外提供公共访问方式。
【好处】
1. 将变化隔离；
2. 便于使用；
3. 提高复用性；
4. 提高安全性；
【封装原则】
1. 将不需要对外提供的内容都隐藏起来；
2. 把属性都隐藏，提供公共方法对其访问。
1、私有变量和私有方法
在python中用双下划线开头的方式将属性隐藏起来（设置成私有的）
1）、私有变量
|
1
2
3
4
|
#其实这仅仅这是一种变形操作#类中所有双下划线开头的名称如__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是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形
|
这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。
这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形
2）、私有方法
3.在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
#正常情况>>> class A:... def fa(self):
...
print
(
'from A'
)
...
def
test(
self
):
...
self
.fa()
... >>>
class
B(A):...
def
fa(
self
):
...
print
(
'from B'
)
... >>> b
=
B()>>> b.test()
from
B
#把fa定义成私有的，即__fa>>> class A:... def __fa(self): #在定义时就变形为_A__fa... print('from A')
...
def
test(
self
):
...
self
.__fa()
#只会与自己所在的类为准,即调用_A__fa... >>> class B(A):... def __fa(self):
...
print
(
'from B'
)
... >>> b
=
B()>>> b.test()
from
A
|
2、封装与扩展性
封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
#类的设计者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()
|
3、property属性
什么是特性property
property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值
|
1
2
3
4
5
6
7
8
9
10
|
例一：BMI指数（bmi是计算而来的，但很明显它听起来像是一个属性而非方法，如果我们将其做成一个属性，更便于理解）
成人的BMI数值：
过轻：低于
18.5
正常：
18.5
-
23.9
过重：
24
-
27
肥胖：
28
-
32
非常肥胖, 高于
32
体质指数（BMI）
=
体重（kg）÷身高^
2
（m）
EX：
70kg
÷（
1.75
×
1.75
）
=
22.86
|
|
1
2
3
4
5
6
7
8
9
10
|
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)
|
|
1
2
3
4
5
6
7
8
9
10
11
|
import
mathclass Circle:
def
__init__(
self
,radius):
#圆的半径radius self.radius=radius
@
property
def
area(
self
):
return
math.pi
*
self
.radius
*
*
2
#计算面积 @property
def
perimeter(
self
):
return
2
*
math.pi
*
self
.radius
#计算周长c=Circle(10)
print
(c.radius)
print
(c.area)
#可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值print(c.perimeter) #同上'''
输出结果:
314.1592653589793
62.83185307179586
'''
|
|
1
2
3
4
|
#注意：此时的特性area和perimeter不能被赋值c.area=3 #为特性area赋值'''
抛出异常:
AttributeError: can't
set
attribute
'''
|
为什么要用property
将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则
除此之外，看下
|
1
2
3
4
5
6
7
|
ps：面向对象的封装有三种方式:
【public】
这种其实就是不封装,是对外公开的
【protected】
这种封装方式对外不公开,但对朋友(friend)或者子类(形象的说法是“儿子”,但我不知道为什么大家 不说“女儿”,就像“parent”本来是“父母”的意思,但中文都是叫“父类”)公开
【private】
这种封装对谁都不公开
|
python并没有在语法上把它们三个内建到自己的class机制中，在C++里一般会将所有的所有的数据都设置为私有的，然后提供set和get方法（接口）去设置和获取，在python中通过property方法可以实现
|
1
2
3
4
5
6
7
8
9
10
11
12
|
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'
|
一个静态属性property本质就是实现了get，set，delete三种方法
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
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.deleterf1=Foo()
f1.AAA
f1.AAA
=
'aaa'
del
f1.AAA
|
|
1
2
3
4
5
6
7
8
|
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
|
怎么用？
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
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
# 删除商品原价
|
4、classmethod
|
1
2
3
4
|
class
Classmethod_Demo(): role
=
'dog'
@
classmethod
def
func(
cls
):
print
(
cls
.role)
Classmethod_Demo.func()
|
5、staticmethod
|
1
2
3
4
5
|
class
Staticmethod_Demo(): role
=
'dog'
@
staticmethod
def
func():
print
(
"当普通方法用"
)
Staticmethod_Demo.func()
|
练习1：
|
1
2
3
4
|
class
Foo:
def
func(
self
):
print
(
'in father'
)
class
Son(Foo):
def
func(
self
):
print
(
'in son'
)
s
=
Son()
s.func()
# 请说出上面一段代码的输出并解释原因？
|
练习2：
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
class
A: __role
=
'CHINA'
@
classmethod
def
show_role(
cls
):
print
(
cls
.__role)
@
staticmethod
def
get_role():
return
A.__role
@
property
def
role(
self
):
return
self
.__role
a
=
A()
print
(a.role)
print
(a.get_role())
a.show_role()
# __role在类中有哪些身份？# 以上代码分别输出哪些内容？# 这三个装饰器分别起了什么作用？有哪些区别？
|
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）