您的位置：首页 > 编程语言 > Python开发

python学习笔记1---class

2017-03-27 23:16 302 查看
Python 的 Class 比较特别，和我们习惯的静态语言类型定义有很大区别。

1. 使用一个名为 __init__ 的方法来完成初始化。

2. 使用一个名为 __del__ 的方法来完成类似析购操作。

3. 所有的实例方法都拥有一个 self 参数来传递当前实例，类似于 this。

4. 可以使用 __class__ 来访问类型成员

>>>>>> class MyClass: 
def __init__(self): 
print "initialize

." 
def Foo(self): 
print id(self) 

>>>>>> a = MyClass() 

initialize

. 
>>>>>> a.Foo() 
14412576 
>>>>>> id(a) 
14412576
 


 

Class 有一些特殊的属性，便于我们获得一些额外的信息。

>>>>>> class MyClass(object): 
"""This is MyClass's Docoment""" 
def __init__(self): 

self.i = 1234 
>>>>>> MyClass.__doc__ # 类型帮助信息 
"This is MyClass's Docoment""This is
MyClass's Docoment" 
>>>>>> MyClass.__name__ # 类型名称 
'MyClass' 
>>>>>> MyClass.__module__ # 类型所在模块 
'__main__' 
>>>>>> MyClass.__bases__ # 类型所继承的基类(Python
支持多继承) 
(<type 'object'>,) 
>>>>>> MyClass.__dict__ # 类型字典，存储所有类型成员信息 
<dictproxy object at 0x00DC1AD0> 
>>>>>> #以下是实例拥有的属性 
>>>>>> MyClass().__class__ # 实例的类型 
<class '__main__.MyClass'> 
>>>>>> MyClass().__module__ # 实例类型所在模块 
'__main__' 
>>>>>> MyClass().__dict__ # 对象字典，存储所有实例成员信息 
{'i': 1234} 
>>>>>>
 



 


继承

Python 支持多继承，但有几点需要注意：

1. 基类 __init__ / __del__ 需显示调用。
2. 继承方法的调用和基类声明顺序有关。

>>>>>> class Base1: 
def __init__(self): 
print "Base1" 
def test(self): 
print "Base1 test

" 

>>>>>> class Base2: 
def __init__(self): 
print "Base2" 
def test(self): 
print "Base2 test

" 

>>>>>> class MyClass(Base2,Base1): 
def __init__(self): 

Base1.__init__(self) 

Base2.__init__(self) 
print "MyClass" 
>>>>>> a = MyClass() 

Base1 

Base2 

MyClass 
>>>>>> a.test() 

Base2 test

 
>>>>>> # 下面把 Base1 放在前面 
>>>>>> class MyClass(Base1,Base2): 
def __init__(self): 

Base1.__init__(self) 

Base2.__init__(self) 
print "MyClass" 
>>>>>> a = MyClass() 

Base1 

Base2 

MyClass 
>>>>>> a.test() 

Base1 test

 
>>>>>>
 


 


成员

Python Class 同样包含类型和实例两种成员。

>>>>>> class Class1: 

i = 123 # 类成员 
def __init__(self): 

self.i = 100 # 实例成员 

>>>>>> print Class1.i 
123 
>>>>>> print Class1().i 
100 
>>>>>>
 


 

有几个很 "特殊" 的 "规则" 需要注意。

(1) 我们可以通过实例引用访问类型成员。因此下面的例子中 self.i 实际指向 Class1.i，直到我们为实例新增了一个成员 i。
>>>>>> class Class1: 

i = 123 
def __init__(self): 
print self.i 
print hex(id(self.i)) 

>>>>>> hex(id(Class1.i)) # 显示 Class1.i
的地址 
'0xab5860' 
>>>>>> a = Class1() # 创建
Class1 实例，我们会发现 self.i 实际指向 Class1.i 
123 
0xab5860 
>>>>>> Class1.__dict__ # 显示
Class1 成员 
{'i': 123, '__module__': '__main__', '__doc__':
None, '__init__': <function __init__ at 0x012911B0>} 
>>>>>> a.__dict__ # 显示实例成员 
{} 
>>>>>> a.i = 100 # 为实例新增加一个成员i 
>>>>>> hex(id(a.i)) # 显示新成员i的地址 
'0xab5974' 
>>>>>> a.__dict__ # 显示实例成员 
{'i': 100} 
>>>>>>

(2) 调用类型内部方法，需要省略 self 参数。

>>>>>> class Class1: 
def __init__(self): 

self.__test("Hello Python") 
def __test(self, s): 
print s 
>>>>>> Class1() 

Hello Python 
<__main__.Class1 instance at 0x00DC3800> 
>>>>>>

我们可以在成员名称前添加 "__" 使其成为私有成员。

>>>>>> class Class1: 
__i = 123 
def __init__(self): 

self.__x = 0 
def __test(self): 
print id(self) 
>>>>>> Class1.i 

Traceback (most recent call last): 

File "", line 1, in <module> 

Class1.i 

AttributeError: class Class1 has no attribute 'i' 
>>>>>> Class1().__x 

Traceback (most recent call last): 

File "", line 1, in <module> 

Class1().__x 

AttributeError: Class1 instance has no attribute '__x' 
>>>>>> Class1().__test() 

Traceback (most recent call last): 

File "", line 1, in <module> 

Class1().__test() 

AttributeError: Class1 instance has no attribute '__test' 
>>>>>>

事实上这只是一种规则，并不是编译器上的限制。我们依然可以用特殊的语法来访问私有成员。

>>>>>> Class1._Class1__i 
123 
>>>>>> a = Class1() 
>>>>>> a._Class1__x 

0 
>>>>>> a._Class1__test() 
14432256 
>>>>>>

除了静态(类型)字段，我们还可以定义静态方法。

>>>>>> class Class1: 

@staticmethod 
def test(): 
print "In Static method

" 
>>>>>> Class1.test() 

In Static method

 
>>>>>>

从设计的角度，或许更希望用属性(property)来代替字段(field)。

>>>>>> class Class1: 
def __init__(self): 

self.__i = 1234 
def getI(self): return self.__i 
def setI(self, value): self.__i = value 
def delI(self): del self.__i 

I = property(getI, setI, delI, "Property
I") 

>>>>>> a = Class1() 
>>>>>> a.I 
1234 
>>>>>> a.I = 1000 
>>>>>> a.I 
1000 

如果只是 readonly property，还可以用另外一种方式。

>>>>>> class Class1: 
def __init__(self): 

self.__i = 1234 

@property 
def I(self): 
return self.__i 
>>>>>> a = Class1() 
>>>>>> a.I 
1234 

用 __getitem__ 和 __setitem__ 可以实现 C# 索引器的功能。

>>>>>> class Class1: 
def __init__(self): 

self.__x = ["a", "b", "c"] 
def __getitem__(self, key): 
return self.__x[key] 
def __setitem__(self, key, value): 

self.__x[key] = value 

>>>>>> a = Class1() 
>>>>>> a[1] 
'b' 
>>>>>> a[1] = "xxx" 
>>>>>> a[1] 
'xxx' 
>>>>>>

Python-类变量，成员变量，静态变量，类方法，静态方法，实例方法，普通函数

#coding:utf-8

class class_name(object):
class_var = 'I am a class variable' #类变量
def __init__(self):
self.instance_var = 'I am a instance varibale'  #成员变量（实例变量）

def instance_method(self,  formal_parameter):
local_var_in_function = formal_parameter    #实例方法局部变量
self.local_var_also_in_function = formal_parameter  #实例方法局部变量

def ordinary_function(formal_parameter):
print "I am an ordinary function, I can't vist class var and intance var"
print self.instance_var #报错，因此普通函数无法访问成员函数
print clacc_var#报错，因此普通函数无法访问类变量

@classmethod
def class_method(cls, formal_parameter): #类方法
print 'I am class method, I can visit class var and instance var'

print 'I am class method, I am modifying the instance var'
cls.instance_var = formal_parameter
print cls.instance_var

print 'I am class method, I am modifying the class var'
class_var = formal_parameter
print class_var

@staticmethod
def static_method(formal_parameter):
print 'I am static method, I am the Adopted son(干儿子) for this class!!'

print "I can't modify anything in the class "
#print class_var
#print self.instance_var

print 'Get a class instance'
class_instance = class_name()
print '\r'
print "My name is class_instance, I can call class_method, " \
"statics_method, instance_method and instance_method, but I can't call ordinary_function"
print "I can show you:"
print '\r'
class_instance.class_method('class method is calling!!')
print '\r'
class_instance.static_method('static method in calling!!')
print '\r'
class_instance.instance_method('instance method is calling!!')
print '\r'
print 'class var is calling!!'
print class_instance.class_var
print '\r'
print 'instance var is calling!!'
print class_instance.instance_var
print '\r'
print 'Get a class!!'
print '\r'
print 'My name is class_name, I can call class_method, statics_method, instance_method, instance_method, and ordinary_function'
print "I can show you:"
print '\r'
class_name.class_method('class method is calling!!')
print '\r'
class_name.static_method('static method in calling!!')
print '\r'
#class_name.instance_method("instance method can't be calling!!")
print '\r'
print 'class var is calling!!'
print class_name.class_var
print '\r'
print 'instance var is calling!!'
print class_name.instance_var
print 'END!!'

Result:

Get a class instance

My name is class_instance, I can call class_method, statics_method, instance_method and instance_method, but I can't call ordinary_function

I can show you:

I am class method, I can visit class var and instance var

I am class method, I am modifying the instance var

class method is calling!!

I am class method, I am modifying the class var

class method is calling!!

I am static method, I am the Adopted son(干儿子) for this class!!

I can't modify anything in the class

class var is calling!!

I am a class variable

instance var is calling!!

I am a instance varibale

Get a class!!

My name is class_name, I can call class_method, statics_method, instance_method, instance_method, and ordinary_function

I can show you:

I am class method, I can visit class var and instance var

I am class method, I am modifying the instance var

class method is calling!!

I am class method, I am modifying the class var

class method is calling!!

I am static method, I am the Adopted son(干儿子) for this class!!

I can't modify anything in the class

class var is calling!!

I am a class variable

instance var is calling!!

class method is calling!!

END!!

 

类变量：

　　　　　　　　类定义内部定义的变量（愚见，可以认为类内部没有self开头定义的变量，可以认为是类变量）

e.g. class_name中的class_var = 'I am a class variable' #类变量


 

成员变量：

　　　　　　　　　类定义内部__init__函数内以self开头定义的变量

　　　　　　　　　　

e.g. self.instance_var = 'I am a instance varibale'  #成员变量（实例变量）


 

 

静态变量：

　　　　　　　　　　因为Python是动态语言，不存在完全静态的变量，这个概念查阅相关资料后认为指的就是类内部定义的类变量（欢迎指正）

类方法：

　　　　　　　　　　类内部定义的以@classmethod装饰的函数是类方法，类方法的调用关系可以通过print后的表述得知。

e.g.
@classmethod
def class_method(cls, formal_parameter): #类方法
print 'I am class method, I can visit class var and instance var'

print 'I am class method, I am modifying the instance var'
cls.instance_var = formal_parameter
print cls.instance_var

print 'I am class method, I am modifying the class var'
class_var = formal_parameter
print class_var


 

静态方法：

　　　　　　　　　　类内部定义的以@staticmethod装饰的函数，类方法的调用关系可以通过print后的表述得知。

e.g.
@staticmethod
def static_method(formal_parameter):
print 'I am static method, I am the Adopted son(干儿子) for this class!!'

print "I can't modify anything in the class "
#print class_var
#print self.instance_var


实例方法：

　　　　　　　　　　类内部定义的没有装饰器且第一个参数为self的函数，类方法的调用关系可以通过print后的表述得知。

e.g.
def instance_method(self,  formal_parameter):
local_var_in_function = formal_parameter    #实例方法局部变量
self.local_var_also_in_function = formal_parameter  #实例方法局部变量


普通函数：

　　　　　　　　　　类内部定义的既没有装饰器，也没有参数self的函数，类方法的调用关系可以通过print后的表述得知。

e.g.
def ordinary_function(formal_parameter):
print "I am an ordinary function, I can't vist class var and intance var"
print self.instance_var #报错，因此普通函数无法访问成员函数
print clacc_var#报错，因此普通函数无法访问类变量



1.变量

_xxx
，单下划线开头的变量，标明是一个受保护(protected)的变量，原则上不允许直接访问，但外部类还是可以访问到这个变量。这只是程序员之间的一个约定，用于警告说明这是一个私有变量，外部类不要去访问它。

class Student(object):
def __init__(self, name):
self._name = name
>>> sd = Student('Tom')
>>> sd._name
'Tom'


__xxx
，双下划线开头的，表示的是私有类型(private)的变量。只能是允许这个类本身进行访问了,
连子类也不可以,用于命名一个类属性（类变量），调用时名字被改变（在类Student内部，
__name
变成
_Student__name
,如 
self._Student__name
)

双下划线开头的实例变量是不是一定不能从外部访问呢？其实也不是。仍然可以通过
_Student__name
来访问
__name
变量：

class Student(object):
def __init__(self, name):
self.__name = name
>>> sd = Student('Tom')
>>> sd.__name
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'Student' object has no attribute '__name'
>>> sd._Student__name
'Tom'


__xxx__
，以双下划线开头，并且以双下划线结尾的，是内置变量，内置变量是可以直接访问的，不是
private 变量，如
__init__
，
__import__
或是
__file__
。所以，不要自己定义这类变量。

xxx_
，单下划线结尾的变量一般只是为了避免与
Python 关键字的命名冲突。

USER_CONSTANT
，大写加下划线，对于不会发生改变的全局变量，使用大写加下划线。


2.函数和方法

总体而言应该使用，小写和下划线。但有些比较老的库使用的是混合大小写，即首单词小写，之后每个单词第一个字母大写，其余小写。但现在，小写和下划线已成为规范。

私有方法 ： 小写和一个前导下划线

def _secrete(self):
print "don't test me."


这里和私有变量一样，并不是真正的私有访问权限。同时也应该注意一般函数不要使用两个前导下划线(当遇到两个前导下划线时，Python 的名称改编特性将发挥作用)。特殊函数后面会提及。

特殊方法 ： 小写和两个前导下划线，两个后置下划线

def __add__(self, other):
return int.__add__(other)


这种风格只应用于特殊函数，比如操作符重载等。

函数参数 : 小写和下划线，缺省值等号两边无空格

def connect(self, user=None):
self._user = user


一、实例方法

实例方法就是类的实例能够使用的方法。如下：

复制代码代码如下:

class Foo:

    def __init__(self, name):

        self.name = name

    def hi(self):

        print self.name

if __name__ == '__main__':

    foo01 = Foo('letian')

    foo01.hi()

    print type(Foo)

    print type(foo01)

    print id(foo01)

    print id(Foo)

运行结果为：

复制代码代码如下:

letian

<type 'classobj'>

<type 'instance'>

40124704

31323448[code]

可以看到，Foo的type为classobj（类对象，python中定义的类本身也是对象），foo01的type为instance（实例）。而hi()是实例方法，所以foo01.hi()会输出'letian'。实例方法的第一个参数默认为self，代指实例。self不是一个关键字，而是约定的写法。init()是生成实例时默认调用的实例方法。将Foo的定义改为以下形式：

[code]class Foo:

    def __init__(this, name):

        this.name = name

    def hi(here):

        print here.name

运行依然正确。 内置函数id用来查看对象的标识符，下面是其doc内容：

复制代码代码如下:

>>> print id.__doc__

id(object) -> integer

Return the identity of an object.  This is guaranteed to be unique among

simultaneously existing objects.  (Hint: it's the object's memory address.)

二、静态方法

静态方法是一种普通函数，就位于类定义的命名空间中，它不会对任何实例类型进行操作。使用装饰器@staticmethod定义静态方法。类对象和实例都可以调用静态方法：

复制代码代码如下:

class Foo:

    def __init__(self, name):

        self.name = name

    def hi(self):

        print self.name

    @staticmethod

    def add(a, b):

        print a + b

if __name__ == '__main__':

    foo01 = Foo('letian')

    foo01.hi()

    foo01.add(1,2)

    Foo.add(1, 2)

    运行结果如下：

复制代码代码如下:

letian

3

3

注意，很多编程语言不允许实例调用静态方法。

三、类方法

类方法是将类本身作为对象进行操作的方法。类方法使用@classmethod装饰器定义，其第一个参数是类，约定写为cls。类对象和实例都可以调用类方法：

复制代码代码如下:

class Foo:

    name = 'letian '

    @classmethod

    def hi(cls, x):

        print cls.name * x

if __name__ == '__main__':

    foo01 = Foo()

    foo01.hi(2)

    Foo.hi(3)

运行结果如下：

复制代码代码如下:

letian letian 

letian letian letian

注意，很多其他的编程语言不允许实例调用类方法。

四、super

super用来执行父类中的函数，例如：

复制代码代码如下:

class Foo(object):

    def hi(self):

        print 'hi,Foo'

class Foo2(Foo):

    def hi(self):

        super(Foo2, self).hi()

if __name__ == '__main__':

    foo2 = Foo2()

    foo2.hi()

运行结果：

复制代码代码如下:

hi,Foo

注意，Foo类必须继承某个类（并且这个继承链开始于object类），否则会报错。如果改成下面的形式：

复制代码代码如下:

class Foo:

    def hi(self):

        print 'hi,Foo'

class Foo2(Foo):

    def hi(self):

        super(Foo2, self).hi()

if __name__ == '__main__':

    foo2 = Foo2()

    foo2.hi()

运行时报错如下：

复制代码代码如下:

......

TypeError: must be type, not classobj

关于super，具体请见http://docs.python.org/2/library/functions.html?highlight=super#super以及super.doc。

五、类变量和实例变量

类变量定义在类的定义之后，实例变量则是以为self.开头。例如：

复制代码代码如下:

class Foo(object):

    val = 0

    def __init__(self):

        self.val = 1

if __name__ == '__main__':

    foo = Foo()

    print foo.val

    print Foo.val

运行结果为：

复制代码代码如下:

1

0

实例也能够访问类变量，如下：

复制代码代码如下:

class Foo(object):

    val = 0

    def __init__(self):

        pass

if __name__ == '__main__':

    foo = Foo()

    print foo.val

    print Foo.val

运行结果如下：

复制代码代码如下:

0

0

另外，可以通过以下方式访问类变量：

复制代码代码如下:

class Foo(object):

    val = 3

    def __init__(self):

        print self.__class__.val

if __name__ == '__main__':

    foo = Foo()

运行结果：

复制代码代码如下:

3

还可以这样：

复制代码代码如下:

class Foo(object):

    val = 3

    def __init__(self):

        pass

    @classmethod

    def echo(cls):

        print cls.val

if __name__ == '__main__':

    Foo.echo()

运行结果：

复制代码代码如下:

3

六、如何调用父类的构造函数

子类（派生类）并不会自动调用父类（基类）的init方法，例如：

复制代码代码如下:

class Foo(object):

    def __init__(self):

        self.val = 1

class Foo2(Foo):

    def __init__(self):

        print self.val

if __name__ == '__main__':

    foo2 = Foo2()

运行时报错。

调用父类的init方法有两种，第一种：

复制代码代码如下:

class Foo(object):

    def __init__(self):

        self.val = 1

class Foo2(Foo):

    def __init__(self):

        Foo.__init__(self)

        print self.val

if __name__ == '__main__':

    foo2 = Foo2()

第二种：

复制代码代码如下:

class Foo(object):

    def __init__(self):

        self.val = 1

class Foo2(Foo):

    def __init__(self):

        super(Foo2,self).__init__()

        print self.val

if __name__ == '__main__':

    foo2 = Foo2()

这两种方法的运行结果均为：

复制代码代码如下:

1

不过这两种方法是有区别的。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息
标签： 
相关文章推荐
新的分享
章节导航