迪三
0%

6.类的系统成员

发表于 分类于 Valine：

Python 原创基础教程

第六章 类的系统成员(内置属性)

__ name__和 __ main__

Python使用缩进对齐组织代码的执行，所有没有缩进的代码，都会在载入时自动执行。每个文件（模块）都可以任意写一些没有缩进的代码，并在载入时自动执行。为了区分 主执行代码和被调用文件，Python引入了变量：__ name__。

  • 当文件是被调用时，__ name__的值为模块名

  • 当文件被执行时，__ name__的值为 ‘__ main__’

__ init__和__ new__和__ call__

__ new__： 对象的创建，是一个静态方法，第一个参数是cls。(想想也是，不可能是self，对象还没创建，哪来的self)

__ init__ ： 对象的初始化， 是一个实例方法，第一个参数是self。

1
2
3
4
5
6
7
class Foo(object):  
    def __new__(cls, *args, **kwargs):  
        print('a')
  
Foo()
#输出a

__ call__ ： python中函数是一个对象，类也是一个对象，可以通过__ call__方法调用对象(如调用函数一样)

例1

1
2
3
4
5
6
7
class Foo(object):  
    def __call__(self):  
        print('b')  
  
f = Foo()#类Foo可call  
f()#对象f可call

例2

1
2
3
4
5
6
7
8
9
10
11
12
13
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender

    def __call__(self, friend):
        print（'My name is %s...'%self.name）
        print（'My gender is %s...'%self.gender
        print（'My friend is %s...'%friend）

p = Person('anda','male')
p('Tim') #call方法调用对象(函数的方法)

在python中，类的行为就是这样，__new__、__init__、__call__等方法不是必须写的，会默认调用，如果自己定义了，就是override,可以custom。既然override了，通常也会显式调用进行补偿以达到extend的目的。

__ str__ & __ rept__ &__ repr__

__ str__让对象返回字符串的形式

1
2
3
4
5
6
7
8
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return '(Person: %s, %s)'%(self.name, self.gender)
p = Person('anda','male')
print(p) # __str__()

__ repr__ 返回一个可以用来表示对象的可打印字符串：

1
2
3
4
5
6
7
8
9
10
class Person(object):
    def __init__(self, name, gender):
        self.name = name
        self.gender = gender
    def __str__(self):
        return '(Person: %s, %s)'%(self.name, self.gender)
    __repr__=__str__
p = Person('anda','male')
p #__repr__()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Fib(object):
    def __init__(self):
        pass
    def __call__(self,num):
        a,b = 0,1;
        self.l=[]
        
        for i in range (num):
            self.l.append(a)
            a,b= b,a+b
        return self.l
    def __str__(self):
        return str(self.l)
    __repr__=__str__
    
f = Fib()
f(10)

__ setitem__&__ getitem__&__ delitem()

使得对象和字典功能对应

  • __ setitem__:每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环

  • __ getitem__:当访问不存在的属性时会调用该方法

  • __ delitem__:当删除属性时调用该方法

  • __ dict__:对象的字典值

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
26
27
28
29
30
31
32
33
class A(object):  
    def __init__(self):  
        self['B'] = "BB"  
        self['D'] = "DD"  
        del self['D']  
      
    def __setitem__(self,name,value):  
        ''''' 
        @summary: 每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环 
        '''  
        print "__setitem__:Set %s Value %s"%(name,value)  
        self.__dict__[name] = value  
      
    def __getitem__(self,name):  
        '''''  
        @summary: 当访问不存在的属性时会调用该方法 
        '''  
        print "__getitem__:No attribute named '%s'"%name  
        return None  
      
    def __delitem__(self,name):  
        '''''  
        @summary: 当删除属性时调用该方法 
        '''  
        print "__delitem__:Delect attribute '%s'"%name  
        del self.__dict__[name]  
        print self.__dict__  
      
      
X = A()
X['a']='aa'
X['b']='bb'
X.__dict__