python魔术方法详解--转自Python中文开发者社区

于 2017-04-01 17:10:02 发布
阅读量705 收藏 1
点赞数
分类专栏： Python 文章标签： python 魔术方法 __init__

早就想学带下划线的Python方法，但一直苦于不知道这个怎么称呼。今天在CSDN上才知道这个叫做“魔术方法”（名字像语法糖一样诱人），就百度了一下，发现了下面这篇自己能看懂的（其他的讲的比较深入），存档至此。原文链接如下：

http://www.pythontab.com/html/2013/pythonjichu_0508/387.html


准备工作

为了确保类是新型类，应该把 _metaclass_=type 入到你的模块的最开始。

1
2
3
4
class  NewType( Object ):
　　mor_code_here
class  OldType:
　　mor_code_here


在这个两个类中NewType是新类，OldType是属于旧类，如果前面加上 _metaclass_=type ，那么两个类都属于新类。

 

构造方法

构造方法与其的方法不一样，当一个对象被创建会立即调用构造方法。创建一个python的构造方法很简答，只要把init方法，从简单的init方法，转换成魔法版本的_init_方法就可以了。

1
2
3
4
5
6
7
class  FooBar:
     def  __init__( self ):
         self .somevar  =  42
          
>>> f  = FooBar()
>>> f.somevar
42

 

重写一个一般方法

每一个类都可能拥有一个或多个超类（父类），它们从超类那里继承行为方法。

1
2
3
4
5
6
7
8
9
class  A:
     def  hello( self ):
         print  'hello . I am A.'
class  B(A):
　　 pass
>>> a  =  A()
>>> b  =  B()
>>> a.hello()
hello . I am A.


因为B类没有hello方法，B类继承了A类，所以会调用A 类的hello方法。

在子类中增加功能功能的最基本的方式就是增加方法。但是也可以重写一些超类的方法来自定义继承的行为。如下：

1
2
3
4
5
6
7
8
9
class  A:
     def  hello( self ):
         print  'hello . I am A.'
class  B(A):
     def  hello( self ):
         print  'hello . I am  B'
>>> b  =  B()
>>> b.hello()
hello . I am  B

 

特殊的和构造方法

重写是继承机制中的一个重要内容，对一于构造方法尤其重要。看下面的例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class  Bird:
     def  __init__( self ):
         self .hungry  =  True
     def  eat( self ):
         if  self .hungry:
             print  'Aaaah...'
             self .hungry  =  False
         else :
             print  'No, thanks!'
>>> b  =  Bird()
>>> b.eat()
Aaaah...
>>> b.eat()
No, thanks!


这个类中定义了鸟有吃的能力， 当它吃过一次后再次就会不饿了，通过上面的执行结果可以清晰的看到。

那么用SongBird类来继承Bird 类，并且给它添加歌唱的方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
class  Bird:
     def  __init__( self ):
         self .hungry  =  True
     def  eat( self ):
         if  self .hungry:
             print  'Aaaah...'
             self .hungry  =  False
         else :
             print  'No, thanks!'
              
class  SongBird(Bird):
          def  __init__( self ):
                  self .sound  =  'Squawk!'
          def  sing( self ):
                  print  self .sound
>>> s  =  SongBird()
>>> s.sing()
Squawk!
>>> s.eat()
Traceback (most recent call last):
   File  "<pyshell#26>" , line  1 ,  in  <module>
     s.eat()
   File  "C:/Python27/bird" , line  6 ,  in  eat
     if  self .hungry:
AttributeError:  'SongBird'  object  has no attribute  'hungry'


异常很清楚地说明了错误：SongBird没有hungry特性。原因是这样的：在SongBird中，构造方法被重写，但新的构造方法没有任何关于初始化hungry特性的代码。为了达到预期的效果，SongBird的构造方法必须调用其超类Bird的构造方法来确保进行基本的初始化。

两种方法实现：

一 、调用未绑定的超类构造方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class  Bird:
     def  __init__( self ):
         self .hungry  =  True
     def  eat( self ):
         if  self .hungry:
             print  'Aaaah...'
             self .hungry  =  False
         else :
             print  'No, thanks!'
              
class  SongBird(Bird):
          def  __init__( self ):
                  Bird.__init__( self )
                  self .sound  =  'Squawk!'
          def  sing( self ):
                  print  self .sound
>>> s  =  SongBird()
>>> s.sing()
Squawk!
>>> s.eat()
Aaaah...
>>> s.eat()
No, thanks!


在SongBird类中添加了一行代码Bird.__init__(self) 。 在调用一个实例的方法时，该方法的self参数会被自动绑定到实例上（这称为绑定方法）。但如果直接调用类的方法，那么就没有实例会被绑定。这样就可以自由地提供需要的self参数（这样的方法称为未绑定方法）。

通过将当前的实例作为self参数提供给未绑定方法，SongBird就能够使用其超类构造方法的所有实现，也就是说属性hungry能被设置。

二、使用super函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
__metaclass__  =  type   #表明为新式类
class  Bird:
     def  __init__( self ):
         self .hungry  =  True
     def  eat( self ):
         if  self .hungry:
             print  'Aaaah...'
             self .hungry  =  False
         else :
             print  'No, thanks!'
              
class  SongBird(Bird):
          def  __init__( self ):
                  super (SongBird, self ).__init__()
                  self .sound  =  'Squawk!'
          def  sing( self ):
                  print  self .sound
>>> s.sing()
Squawk!
>>> s.eat()
Aaaah...
>>> s.eat()
No, thanks!


super函数只能在新式类中使用。当前类和对象可以作为super函数的参数使用，调用函数返回的对象的任何方法都是调用超类的方法，而不是当前类的方法。那就可以不同在SongBird的构造方法中使用Bird,而直接使用super(SongBird,self)。

 

属性

访问器是一个简单的方法，它能够使用getHeight 、setHeight 之样的名字来得到或者重绑定一些特性。如果在访问给定的特性时必须要采取一些行动，那么像这样的封装状态变量就很重要。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class  Rectangle:
     def  __init__( self ):
         self .width  =  0
         self .height  =  0
     def  setSize( self ,size):
         self .width ,  self .height  =  size
     def  getSize( self ):
         return  self .width ,  self .height
>>> r  =  Rectangle()
>>> r.width  =  10
>>> r.height  =  5
>>> r.getSize()
( 10 ,  5 )
>>> r.setSize(( 150 , 100 ))
>>> r.width
150


在上面的例子中，getSize和setSize方法一个名为size的假想特性的访问器方法，size是由width 和height构成的元组。

 

property 函数

property函数的使用很简单，如果已经编写了一个像上节的Rectangle 那样的类，那么只要增加一行代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
__metaclass__  =  type
class  Rectangle:
     def  __int__( self ):
         self .width  =  0
         self .height  =  0
     def  setSize( self ,size):
         self .width,  self .height  =  size
     def  getSize( self ):
         return  self .width , self .height
     size  =  property (getSize ,setSize)
>>> r  =  Rectangle()
>>> r.width  =  10
>>> r.height  =  5
>>> r.size
( 10 ,  5 )
>>> r.size  =  150 , 100
>>> r.width
150


在这个新版的Retangle 中，property 函数创建了一个属性，其中访问器函数被用作参数（先取值，然后是赋值），这个属性命为size 。这样一来就不再需要担心是怎么实现的了，可以用同样的方式处理width、height 和size。

LucyGill
关注
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值