Python面向对象编程

Class ClassName(bases):          #不存在继承关系时，可以不提供bases
'class documentation string'   #类文档可选
Data = value                   #定义数据属性
def method(self , ...)         #定义方法属性
self.member = value

class MyClass():
"""A simple example class"""
i = 12345
def f(self):
return 'hello world'

In [1]: class MyClass():
...:         """A simple example class"""
...:         i = 12345
...:         def f(self):
...:                 return 'hello world'
...:
In [2]: x=MyClass()       #实例化一个类
In [3]: x.f()             #调用类的方法
Out[3]: 'hello world'
In [4]: x.i
Out[4]: 12345
In [5]: x.i=23456         #修改成员变量
In [6]: x.i
Out[6]: 23456

In [8]:  class Myclass(object):
...:    message='Hello,Developer'
...:    def show(self):
...:       print(self.message)
...:
In [9]:  class Myclass(object):
...:    message='Hello,Developer'
...:    def show(self):
...:       print(self.message)
...:    def __init__(self):                #构造函数
...:       print('Constructor is called')
...:
In [10]: inst=Myclass()       #当Myclass类实例化时，自动执行了构造函数
Constructor is called
In [11]: inst.show()
Hello,Developer

In [17]:  class Myclass1(object):
...:    message='Hello,Developer'
...:    def show(self):
...:       print(self.message)
...:    def __init__(self):
...:       print('Constructor is called')
...:    def __del__(self):
...:       print('Destructor is called!')
...:
In [18]: inst1=Myclass1()        #实例化类
Constructor is called
In [19]: inst1.show()
Hello,Developer
In [20]: del inst1               #析构函数
Destructor is called!

In [27]: dir(Myclass1)      #查看类所拥有的属性和方法
Out[27]:
['__class__',
'__del__',
'__delattr__',
'__dict__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__module__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'__weakref__',
'message',
'show']

In [31]: class Myclass2(object):
...:         message='Hello,Developer'            #类成员属性
...:         def show(self):
...:           print(self.message)                #实例成员变量
...:           print('Here is %s in %s' %(self.name,self.color))
...:         def __init__(self,name='unset',color='black'):
...:           print('Constructor is called with parms:',name,'',color)
...:           self.name=name
...:           self.color=color
...:
In [32]: Myclass2.message                #输出类变量
Out[32]: 'Hello,Developer'
In [33]: Myclass2.message='Hello Python' #更改类成员变量
In [34]: Myclass2.message
Out[34]: 'Hello Python'
In [35]: init3=Myclass2()                #实例化类Myclass2
Constructor is called with parms: unset  black
In [36]: init3.message                   #访问类成员变量
Out[36]: 'Hello Python'
In [37]: init3.message='Hello'           #更改类成员变量
In [39]: Myclass2.message                #可以发现，实例对象无法更改类成员对象
Out[39]: 'Hello Python'

class C:
classname = '公有变量'    #类的公有字段，即变量
__classfoo = "私有变量"   #类的私有字段，使用__开头声明的变量为私有变量
def __init__(self):
self.name = '公有变量'    #对象的公有字段，即变量
self.__foo = "私有变量"   #对象的私有字段，使用__开头声明的变量为私有变量

In [42]: class Myclass2(object):
...:         message='Hello,Developer'            #类成员
...:         __classname='Python'
...:         def show(self):
...:           print(self.message)
...:           print('Here is %s in %s' %(self.name,self.color))
...:         def __init__(self,name='unset',color='black'):
...:           print('Constructor is called with parms:',name,'',color)
...:           self.name=name
...:           self.__color=color
In [43]: inst4=Myclass2()             #实例化类
Constructor is called with parms: unset  black
In [44]: inst4.message                #实例化的对象可以访问类的公有变量
Out[44]: 'Hello,Developer'
In [45]: inst4.__classname            #实例化的对象无法访问类的私有变量
--------------------------------------------------------------------------
AttributeError                           Traceback (most recent call last)
<ipython-input-45-379f39c829cf> in <module>()
----> 1 inst4.__classname
In [47]: inst4.name                   #实例对象可以访问对象公有变量
Out[47]: 'unset'
In [48]: inst4.__color                #实例对象无法外部访问对象私有变量
--------------------------------------------------------------------------
AttributeError                           Traceback (most recent call last)
<ipython-input-48-5db61d225aac> in <module>()
----> 1 inst4.__color
AttributeError: 'Myclass2' object has no attribute '__color'

class Myclass(object):
message='Hello,Developer'
def show(self):
print('self.message')
print('Here is %s in %s !' %(self.name,self.color))

@staticmethod           #定义静态函数，可以访问类成员变量
def printMessage():
print('print Message is called ')
print(Myclass.message)

@classmethod            #定义类函数，第一个参数必须是cls
def creatobj(cls,name,color):
print('Object will be created: %s(%s,%s)' %(cls.__name__,name,color))
return cls(name,color)
def __init__(self,name='unset',color='black'):
print('Constructor is called with params:',name,'',color)
self.anme=name
self.color=color

def __def__(self):
print('Destructor is called for %s' %self.name)

Myclass.printMessage()     #直接调用静态函数
inst=Myclass.creatobj('Toby', 'Red')
print(inst.message)

输出结果：
print Message is called      #静态函数输出结果
Hello,Developer
Object will be created: Myclass(Toby,Red)     #类函数输出结果
Constructor is called with params: Toby  Red  #构造函数
Hello,Developer              #print输出

class BaseClass(object)           #父类定义
block_class
class SubClass(BaseClass)         #子类定义
block_class

class A:           #经典类
pass
class B(object):   #新式类
pass

class BaseA(object):
def move(self):
print('move called in BaseA')

class BaseB(object):
def move(self):
print('move called in BaseB')
class BaseC(BaseA):
def move(self):
print('move called in BaseC')

class Sub(BaseC,BaseB):
def move(self):
print('move called in Sub')
inst=Sub()
inst.move()

In [1]: class Person():
...:     def __init__(self,name):
...:         self.name=name
...:
In [2]: class EmailPerson(Person):
...:     def __init__(self,name,email):
...:         super.__init__(name)
...:         self.email=email