引言
提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）
和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python 对面向对象的支持。
在讨论Python的OOP之前，先看几个OOP术语的定义：
类：对具有相同数据和方法的一组对象的描述或定义。
对象：对象是一个类的实例。
实例(instance)：一个对象的实例化实现。
标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。
实例属性（instance attribute）：一个对象就是一组属性的集合。
实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。
类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上
发生变化
类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。中的类与对象
Python中定义类的方式比较简单：
class 类名：
类变量
def __init__(self,paramers):
def 函数(self,...)
其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self 作为第一个参数。
举例：
class MyFirstTestClass:
classSpec="it is a test class"
def __init__(self,word):
print "say "+word
def hello(self,name):
print "hello "+name
在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法
不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。
class MethodTest():
count= 0
def addCount(self):
+=1
print "I am an instance method,my count is" + str, self
@staticmethod
defstaticMethodAdd():
+=1
print"I am a static methond,my count is"+str
@classmethod
defclassMethodAdd(cls):
+=1
print"I am a class method,my count is"+str,cls
a=MethodTest()
()
'''I am an instance method,my count is 1 < instanceat 0x011EC990>
'''
() ;#I am a static methond,my count is2
() ;#I am a static methond,my count is3
() ;#I am a class method,my count is4
() ;#I am a class method,my count is5
()
'''Traceback(most recent call last):
File"
()
TypeError:unbound method addCount() must be called with MethodTest instance asfirst argument (got nothing instead)
'''
从上面的例子来看，静态方法和类方法基本上区别不大，特别是有Java编程基础的人会
简单的认为静态方法和类方法就是一回事，可是在Python中事实是这样的吗看下面的例子：() ;#I am a class method,my count is5
class subMethodTest(MethodTest):
pass
b=subMethodTest()
() ;#I am a static methond,my count is6
() ;#I am a class method,my count is7
() ;#Iam a class method,my count is8
如果父类中定义有静态方法a(),在子类中没有覆盖该方法的话，()仍然指的是父类的a （）方法。而如果a()是类方法的情况下，()指向的是子类。@staticmethod只适用于不想定义全局函数的情况。
看看两者的具体定义：
@staticmethod function is nothing morethan a function defined inside a class. It is callable withoutinstantiating the class first. It’s definition is immutable viainheritance.
@classmethod function also callablewithout instantiating the class, but its definition follows Subclass, not Parent class, via inheritance. That’s because the firstargument for @classmethod function must always be cls (class).
封装和访问控制
与Java不同，Python的访问控制相对简单，没有public，private，protected等属性，python认为用户在访问对象的属性的时候是明确自己在做什么的，因此认为私有数据不是必须的，但是如果你必须实现数据隐藏，也是可以的，具体方法就是在变量名前加双下划线。如__privatedata=0，定义私有方法则是在方法名称前加上__下划线。但即使对于隐藏的数据，也是有一定的方法可以访问的。方法就是__className__attrName。Python对于私有变量会进行Namemangling是Python中为了方便定义私有的变量和方法，防止和继承类以及其他外部的变量或者方法冲突而采取的一种机制。在python中通过__spam定义的私有变量为最终被翻译成_classname__spam，其中classname为类名，当类名是以_开头的时候则不会发生
Namemangling。Namemangling 存在的一个问题是当字符串长度超过255的时候则会发生截断。class PrivateTest:
__myownedata=12
def __myownmethod(self):
print"can you see me"
def sayhi(self):
print"say hi"
class subPrivateTest(PrivateTest):
pass
Traceback(most recent call last):
File"
AttributeError:class subPrivateTest has no attribute '__myownedata'
构造函数和析构函数
Python的构造函数有两种，__init__和__new__,__init__的调用不会返回任何值，在继承关系中，为了保证父类实例正确的初始化，最好显示的调用父类的__init__方法。与__init__不同，__new__实际是个类方法，以cls作为第一个参数。
如果类中同时定义了__init__和__new__方法，则在创建对象的时候会优先使用__new__. class A(object):
def __init__(self):
print("in init")
def __new__(self):
print("in new")
A()
如果__new__需要返回对象，则会默认调用__init__方法。利用new创建一个类的对象的最
常用的方法为：super(currentclass,cls).__new__(cls[, ...])
class A(object):
def __new__(cls):
Object = super(A,cls).__new__(cls)
print "in New"
return Object
def __init__(self):
print "in init"
class B(A):
def __init__(self):
print "in B's init"
B()
__new__构造函数会可变类的定制的时候非常有用，后面的小节中会体现。
Python由于具有垃圾回收机制，通常不需要用户显示的去调用析构函数，即使调用，实例也不
会立即释放，而是到该实例对象所有的引用都被清除掉后才会执行。
class P:
def __del__(self):
print"deleted"
class S(P):
def __init__(self):
print'initialized'
def __del__(self):
(self)
print"child deleted"
a=S() #initialized
b=a
c=a
id(a),id(b),id(c) #(,, )
del a
del b
del c #deleted #childdeleted
绑定与非绑定
在前面的例子中我们讨论过类的实例方法必须通过实例调用，如果直接通过类去访问会抛出异常，这种通过实例来访问方法就叫绑定，调用的时候不需要显示传入self参数，而调用非绑定方法需要显示传入self参数，比如当子类继承父类定义构造函数的时候，需要显示调用父类的构造函数，但此时该方法并未与任何实例绑定，调用的时候需要使用(self)。
静态方法可以直接被类或类实例调用。它没有常规方法那样的特殊行为（绑定、非绑定、默认的第一个参数规则等等）。完全可以将静态方法当成一个用属性引用方式调用的普通函数来看待。任何时候定义静态方法都不是必须的（静态方法能实现的功能都可以通过定义一个普通函数来实现）
3. Python中的继承
继承
Python同时支持单继承与多继承，继承的基本语法为class新类名（父类1，父类2,..）,当只有一个父类时为单继承，当存在多个父类时为多继承。子类会继承父类的所有的属性和方法，子类也可以覆盖父类同名的变量和方法。在传统类中，如果子类和父类中同名的方法或者属性，在查找的时候基本遵循自左到右，深度优先的原则。如下列：
>>>class A:
defsayhi(self):
print'I am A hi'
>>>class B:
defsayhi(self):
print'I am B Hi'
>>>class C(A,B):
pass
>>>d=C()
>>>()
Iam A hi
>>>(d)
Iam B Hi
如果想调用父类B的sayhi方法则需要使用(d).而在python引入新式类后，在继承关系中，方法和属性的搜索有所改变，使用C3算法。具体将在MRO中详细讨论。
关于继承的构造函数：
1.如果子类没有定义自己的构造函数，父类的构造函数会被默认调用，但是此时如果
要实例化子类的对象，则只能传入父类的构造函数对应的参数，否则会出错classAddrBookEntry(object):
'addressbook entry class'
def__init__(self, nm, ph):
= nm
= ph
print'Created instance for:',
defupdatePhone(self, newph):
= newph
print'Updated phone# for:',
classEmplAddrBookEntry(AddrBookEntry):
'EmployeeAddress Book Entry class'
defupdateEmail(self, newem):
= newem
print'Updated e-mail address for:',
john= EmplAddrBookEntry('John Doe', '408-555-1212')
2.如果子类定义了自己的构造函数，而没有显示调用父类的构造函数，则父类的属性
不会被初始化
classAddrBookEntry(object):
'addressbook entry class'
def__init__(self, nm, ph):
= nm
= ph
print'Created instance for:',
defupdatePhone(self, newph):
= newph
print'Updated phone# for:',
classEmplAddrBookEntry(AddrBookEntry):
'EmployeeAddress Book Entry class'
def__init__(self, nm, ph, id, em):
#(self, nm,ph)
= id
= em
defupdateEmail(self, newem):
= newem
print'Updated e-mail address for:',
john= EmplAddrBookEntry('John Doe', '408-555-1212',42, '')
输出
42
Traceback(most recent call last):
AttributeError:'EmplAddrBookEntry' object has no attribute 'name'
3.如果子类定义了自己的构造函数，显示调用父类，子类和父类的属性都会被初始化classAddrBookEntry(object):
'addressbook entry class'
def__init__(self, nm, ph):
= nm
= ph
print'Created instance for:',
defupdatePhone(self, newph):
= newph
print'Updated phone# for:',
classEmplAddrBookEntry(AddrBookEntry):
'EmployeeAddress Book Entry class'
def__init__(self, nm, ph, id, em):
(self, nm,ph)
= id
= em
defupdateEmail(self, newem):
= newem
print'Updated e-mail address for:',
john= EmplAddrBookEntry('John Doe', '408-555-1212',42, '')
MRO
MRO：即methodresolutionorder.简单的说就是python针对多继承查找一个属性或者方法的一种算法。在引入新型类之前，MRO比较简单，采取自左到右，深度优先的原则。比如有如下关系的类和属性：
要查找对象x的attr属性，其根据自左到右，深度优先的原则，其搜索顺序为D,B,A,C,位于树结构底层的节点具有较高的level，当从高的level向低的level查找的时候遇到第一个属性则不再继续查找，因此上面的例子x的属性值为1.
>>> classA: attr=1
>>> classB(A):pass
>>> classC(A):attr=2
>>> classD(B,C):pass
>>> x=D()
>>>
1
>>>
但按照多继承的理解，level高的属性应该覆盖了level低的属性，D同时继承于B,C，而C 是A的子类，那么D的实例的属性值理应为attr=2而不是1，产生这个问题的主要原因是在继承关系中产生了菱形，针对经典类的MRO算法有一定的局限性，特别是在中加入了新型类后，由于object是所有对象之母，很容易形成菱形。因此采用改进的C3MRO算法进行搜索。
算法描述：
假设https://www.doczj.com/doc/736555443.html,表示类节点[C1,C2,https://www.doczj.com/doc/736555443.html,)；
head=C1；
tail=https://www.doczj.com/doc/736555443.html,
C+(C1 https://www.doczj.com/doc/736555443.html,)=C https://www.doczj.com/doc/736555443.html,
若c继承于B1，B2..BN,那么在节点C的搜索顺序L[C]=C加上其所有父节点的搜索顺序和各个父节点的列表之和，也即
L[C(B1, ... , BN)]= C + merge(L[B1], ... ,L[BN], B1 ... BN)
其中merge的计算方法为:
如果B1不在其它列表的tail中，则将其并入C的搜索列表中，同时将其从merge列表中移除，否则跳过改节点，继续B2.。。如此重复知道merge为空。
如果C是object对象或者没有其他的父节点，则L[object]= object.。
对于单继承，则L[C(B)]= C + merge(L[B],B) = C + L[B]
假设有如下继承关系：
则：
L[O]= O
L[D]= D O
L[E]= E O
L[F]= F O
L[B]= B + merge(DO, EO, DE)
= B+D+merge(O,EO,E)
=B+D+merge(O,EO,E)
=B+D+E+merge(O,O)
=B D E O
L[A]= A + merge(BDEO,CDFO,BC)
=A + B + merge(DEO,CDFO,C)
=A + B + C + merge(DEO,DFO)
=A + B + C + D + merge(EO,FO)
=A + B + C + D + E + merge(O,FO)
=A + B + C + D + E + F + merge(O,O)
=A B C D E F O
针对上面的计算方法，利用Python的mro函数也可以说明该搜索顺序：
>>>class F(object):pass
>>>class E(object):pass
>>>class D(object):pass
>>>class C(D,F):pass
>>>class B(D,E):pass
>>>class A(B,C): pass
>>>()
[
[
>>>
对于C3的MRO算法也可以简单的理解为：深度优先，从左到右遍历基类，先遍历高level的，再遍历低level的，如果任何类在搜索中是重复的，只有最后一个出现的位置被保留，其余会从MROlist中删除。也就是说类的共同的祖先只有在其所有的子类都已经被check之后才会check。对于A，其搜索顺序应该是AB (D) (O) C D (O) E (O) F O
当然即使C3的MRO，也有其无法处理的情况，看下面的例子：
>>>class X(object):pass
>>>class Y(object):pass
>>>class A(X,Y):pass
>>>class B(Y,X):pass
>>>class C(A,B):
pass
Traceback(most recent call last):
File"
classC(A,B):
TypeError:Error when calling the metaclass bases Cannotcreate a consistent method resolution order(MRO) for bases X, Y
4.自省与反射
对于熟悉Java的人来说，自省和反射并不是一个陌生的概念，自省可以查看内存中以对象形式
存在的其它模块和函数，获取它们的信息，并对它们进行操作。用这种方法，你可以定义没有名称的函数，不按函数声明的参数顺序调用函数，甚至引用事先并不知道名称的函数。Python提供了一些内置函数，可以方便的或者对象本省的信息。
dir([object])：查看对象的属性和函数列表。如果对象是个模块，则返回模块的所有属性，如
果object是一个类对象，返回类和其父类的所有属性。
>>>class dirTest(object):
value='1'
defsayhi(self):
='cat'
print"hi"
>>>dir(dirTest)
['__class__','__delattr__', '__dict__', '__doc__',
'__format__','__getattribute__', '__hash__', '__init__', '__module__',
'__new__','__reduce__', '__reduce_ex__', '__repr__', '__setattr__','__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'sayhi','value']
>>>
dir不带参数时，显示调用者的局部变量，作用在模块上时候，显示模块的__dict__内容，显示在类上，显示类和基类的__dict__内容
issubclass(sub,sup):判断一个类是另一个类的子类或子孙类
isinstance(obj1,obj2):在判定一个对象是否是另一个给定类的实例
callable()是一个布尔函数，确定一个对象是否可以通过函数操作符(())来调用。如果函数可
调用便返回True，否则便是False.
模块inspect:
inspect模块提供了一系列自省函数，它可以获取模块，类，方法，函数，traceback，帧对象，代码对象的信息。常用的方法getmembers，ismodule，getcallargs，isclass等，更多详细信息参见>>>import inspect
>>>(abs)
>>>(abs)
True
>>>(inspect)
True
5.新型类与元类
对于新型类来说，其默认的元类为type，而对于传统的类，其默认类型为
>>>class Classic: pass
>>>class Newstyle(object): pass
>>>print type(Classic)
>>>print type(Newstyle)
比如>>>class TypeTestClass:
pass
>>>TypeTestClass =type('TypeTestClass',(),{})
>>>print TypeTestClass
>>>print TypeTestClass()
< at 0x011F3A30>
>>>
新型类是在中引入的，其在语法和行为上基本和经典类兼容，主要差别在于所有的新式类必须继承至少一个父类，Object是所有类之母，如果类没有继承任何其他父类，则object将作为默认的父类，新型类还支持从内置类型如list,dict, file等创建子类。
新型类的实例在具有传统类实例的特性，但在__init__的基础上加入的新的构造函数
__new__，同时支持静态方法@staticmethod和类方法@classmethod.(上面的章节已经阐述)，同时增加了Property和__slot__，__getattribute_ _等属性，。Python对Property 的定义如下Aproperty is an attribute that is defined by get/set methods.其对应的内建函数有四个参数：property(fget=None,fset=None, fdel=None,doc=None)，其中fget,fset,fdel必须有一个方法被申明，否则进行对应的操作会产生AttributeError异常。如果只需要定义只读属性，则只需要实现fget方法，而不实现fset方法即可。
10.>>>class PropertyTest(object):
11.def__setProperty(self,value):
12.=value
13.print"setting property"
14.def__getProperty(self):
15.print"getting property"
16.
17.def__delProperty(self):
18.print"del proerty"
19.
20.TestProperty=property(fget=__getProperty,fset=__setProperty,fdel=__delPr
operty,doc="propertytest")
21.
22.
23.>>>
24.>>>p=PropertyTest()
25.>>>=1
26.settingproperty
27.>>>
28.>>>
29.gettingproperty
30.1
31.>>>del
32.delproerty
Property提供灵活的机制来读取、编写或计算私有字段的值。可以像使用公共数据成员一样使用属性，但实际上它们是称作“访问器”的特殊方法。这使得可以轻松访问数据，此外还有助于提高方法的安全性和灵活性。
__slots__类属性：
在Python中可以用__dict__属性来跟踪所有实例属性，而事实上__dict__会占用大量的内存，从开始可以用类变量__slots__代替__dict__.,它是一个由具有合法标识的实例属性构成的集合。在定义了__slots__属性的类中不会在存在__dict__，因此可以节约内存，同时它能防止动态增加实例属性，从某种程度上讲更为安全。
>>>class SlotTest(object):
__slots__=('name','age')
>>>class Test(object):
pass
>>>s=SlotTest()
>>>="carol"
>>>="12"
>>>="64"
Traceback(most recent call last):
File"
="64"
AttributeError:'SlotTest' object has no attribute 'score'
>>>
>>>dir(s)
['__class__','__delattr__', '__doc__', '__format__',
'__getattribute__','__hash__', '__init__', '__module__', '__new__',
'__reduce__','__reduce_ex__', '__repr__', '__setattr__',
'__sizeof__','__slots__', '__str__', '__subclasshook__', 'age', 'name']
>>>
>>>s1=test()
>>>="65"
>>>dir(s1)
['__class__','__delattr__', '__dict__', '__doc__',
'__format__','__getattribute__', '__hash__', '__init__', '__module__',
'__new__','__reduce__', '__reduce_ex__', '__repr__', '__setattr__','__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'score']
>>>
元类：
对于万物皆是对象的Python，对于定义类的一段代码其本身也是对象，那么这个类对象的类型就是元类，它用来描述类的类。在元类用于创建类的时候，解释器先查找__metaclass__属性，该属性的值便是类的元类，如果没有找到该属性的定义，则会查找其父类的
__metaclass__.如果仍然没有找到，对于新型类则会以type(object)作为其元类，如果当前模块有全局变量名为metaclass，则将其值作为其元类，而对于传统的类，其元类类型为.
可以有多种方法来创建一个元类，如利用type函数，类工厂模式，或者设置__metaclass__属性等
1利用传统工厂函数返回类：
>>>def class_creator(func):
classinternal:pass
setattr(internal,,func)
returninternal
>>>def alive(self):print 'Hi,I am here'
>>>ChildClass = class_creator(alive)
>>>cc=ChildClass()
>>>()
Hi,Iam here
>>>
2通过type创建类
>>>def __init__(self):
='metaclass test'
>>>def alive(self):
>>>attrs={'__init__':__init__,'alive':alive}
>>>bases=()
>>>
>>>ClassTep=type('MetaTestClass',bases,attrs)
>>>
>>>t=ClassTep()
>>>()
metaclasstest
>>>
3设置__metaclass__属性：只要在类定义中把__metaclass__设置为任意有着与type相同参数的可调用对象，就能够提供自定义的元类。通常继承type
>>>class Meta(type):
def__init__(cls,name,bases,attrs):
print"I am a meta class templete,Class will be created by me"
super(Meta,cls).__init__(name,bases,attrs)
defWelcome(cls): print "welcome",
>>>class MetaTest(object):
__metaclass__=Meta
defsayhi(self):
print"Hi"
Iam a meta class templete,Class will be created by me
>>>()
welcomeMetaTest
>>>MetaTest().sayhi()
Hi
4利用new模块中的类工厂：
(name,baseclasses, dict)
Thisfunction returns a new class object, with name name, derived frombaseclasses (which should be a tuple of classes) and with namespacedict.
>>>from new import classobj
>>>metatest=classobj('Meta',(object,),{'Hello':lambda self:'hello'})
>>>metatest().Hello()
'hello'
>>>
在元类中也可以定义类方法，一般叫做元方法，元方法和普通的类方法在使用上存在一定的区别，元方法能够被元类或者元类对象（类）直接调用，但不能没类的实例调用，而类方法可以被类或者类的实例直接调用。
>>>class Meta(type):
def__init__(cls,name,bases,attrs):
super(Meta,cls).__init__(name,bases,attrs)
defWelcome(cls): print "welcome",#元方法
>>>class MetaTest(object):
__metaclass__=Meta
defsayhi(self):
print"Hi"
defgetName(cls):#类方法
print"what is your name"
>>>d=MetaTest()
>>>(MetaTest)
welcomeMetaTest
>>>()
welcomeMetaTest
>>>()
whatis your name
>>>(d)
whatis your name
>>>()
Traceback(most recent call last):
File"
()
AttributeError:'MetaTest' object has no attribute 'Welcome'
>>>
在继承关系中，元类和普通的超类存在一定的区别，元类属性的可用性是不会传递的，也就是说，元类的属性是对它的实例是可用的，但是对它的实例的实例是不可用的。
>>>class SuperC(object):
attr='name','age'
>>>class Child(SuperC):
pass
>>>
('name','age')
>>>
>>>a=Child()
>>>
('name','age')
>>>
>>>class SuperMeta(type):
attr=('name','age')
>>>class ChildMeta(object):
__metaclass__=SuperMeta
>>>class Child2Meta(ChildMeta):pass
>>>
('name','age')
>>>
('name','age')
>>>
('name','age')
>>>b=Child2Meta()
>>>
Traceback(most recent call last):
File"
AttributeError:'Child2Meta' object has no attribute 'attr'
在元类的多继承中，通常会产生冲突，比如A，B都是带有元类的类，C多继承于A和B时会产生冲突。如下例：
>>>class MetaA(type):pass
>>>class MetaB(type):pass
>>>class A(object):
__metaclass__=MetaA
>>>class B(object):
__metaclass__=MetaB
>>>class C(A,B):pass
Traceback(most recent call last):
File"
classC(A,B):pass
TypeError:Error when calling the metaclass bases
metaclassconflict: the metaclass of a derived class must be a (non-strict)subclass of the metaclasses of all its bases
>>>
解决冲突的方法从利用type重新定义一个中间的元类。
AB=type("AB",(MetaA,MetaB),{})
classC(A,B):__metaclass__=AB
面向对象及练习题 1.面向对象 1.1面向对象概念 面向对象是一种编程思想，是对现实世界中的事物进行抽象的方式。应用到代码编程设计中，是一种建立现实世界事物模型的方式。 1.2 面向对象和面向过程区别 面向过程关注的是完成工作的步骤，面向对象关注的是谁能完成工作。 面向对象是在完成工作的时候关注哪些个体能够完成对应的工作，找到对应的个体即可完成对应任务。 2.类 2.1类的概念 类是一系列事物的统称，同类事物必定具有相同的特征。日常事物的特征根据特性分为状态和行为，对应到类中是变量和方法。 特征分类： 状态→变量（成员变量） 行为→方法（成员方法） 统称：类的成员 2.2类定义语法格式 class类名： pass
说明：pass是空语句，不具有任何意义，仅为了保持程序结构完整性 2.3类名的命名规则 类名命名规范：满足大驼峰命名规则 3.对象 3.1对象的概念 对象是类的具体表现形式，是实际存在的个体。（类是一系列事物的统称） 3.2创建对象语法格式 对象名 = 类名() 3.3 注意事项 对象的创建不限制数量，一个类可以创建任意个数的对象 4.成员变量 4.1成员变量的概念 成员变量用于描述对象的固有状态或属性。
4.2定义成员变量语法格式（公有属性/公有变量） class 类名： def __init__(self): self.变量名1 = 值1 self.变量名2 = None 4.3成员变量定义语法格式（独有属性/独有变量） 对象名.变量名 = 值 4.4公有变量与独有变量的区别 ●公有变量在__init__方法中声明，每个对象都具有该变量 ●独有变量在创建对象后声明，只有当前对象具有此变量 ●定义对象的独有变量时，如果独有变量名与公有变量名相同，视为 修改公有变量的值；如果独有变量名与公有变量名不相同，视为定 义新的独有属性 ●None含义是为空，表示没有具体的数据
引言 提到面向对象，总是离不开几个重要的术语：多态（Polymorphism），继承（Inheritance）和封装（Encapsulation）。Python也是一种支持OOP的动态语言，本文将简单阐述Python 对面向对象的支持。 在讨论Python的OOP之前，先看几个OOP术语的定义： ?类：对具有相同数据和方法的一组对象的描述或定义。 ?对象：对象是一个类的实例。 ?实例(instance)：一个对象的实例化实现。 ?标识(identity)：每个对象的实例都需要一个可以唯一标识这个实例的标记。 ?实例属性（instance attribute）：一个对象就是一组属性的集合。 ?实例方法(instance method)：所有存取或者更新对象某个实例一条或者多条属性的函数的集合。 ?类属性（classattribute）：属于一个类中所有对象的属性，不会只在某个实例上发生变化 ?类方法（classmethod）：那些无须特定的对性实例就能够工作的从属于类的函数。 1.Python中的类与对象 Python中定义类的方式比较简单： class类名： 类变量 def __init__(self,paramers): def函数(self,...) 其中直接定义在类体中的变量叫类变量，而在类的方法中定义的变量叫实例变量。类的属性包括成员变量和方法，其中方法的定义和普通函数的定义非常类似，但方法必须以self 作为第一个参数。 举例： class MyFirstTestClass: classSpec="itis a test class" def__init__(self,word): print"say "+word defhello(self,name): print"hello "+name 在Python类中定义的方法通常有三种：实例方法，类方法以及静态方法。这三者之间的区别是实例方法一般都以self作为第一个参数，必须和具体的对象实例进行绑定才能访问，而类方法以cls作为第一个参数，cls表示类本身，定义时使用@classmethod；而静态方法不需要默认的任何参数,跟一般的普通函数类似.定义的时候使用@staticmethod。 class MethodTest(): count= 0
第6章面向对象编程 教案 课程名称：Python编程基础 课程类别：必修 适用专业：大数据技术类相关专业 总学时：48学时（其中理论24学时，实验24学时） 总学分：3.0学分 本章学时：8学时 一、材料清单 （1）《Python编程基础》教材。 （2）配套PPT。 （3）代码。 （4）引导性提问。 （5）探究性问题。 （6）拓展性问题。 二、教学目标与基本要求 1.教学目标 介绍Python面向对象程序设计的发展及其思想，何时及怎样运用面向对象编程；实现了面向对象的核心“类与对象”的创建和使用，并拓展了面向对象常用的功能和方法。 2.基本要求 （1）认识面向对象编程的发展、实例、优点。
（2）了解使用面向对象编程的情形。 （3）掌握类的定义、使用和专有方法。 （4）掌握self参数的使用。 （5）掌握对象的创建（实例化）、删除。 （6）掌握对象的属性、方法引用和私有化方法。 （7）掌握迭代器和生成器。 （8）掌握类的继承、重载、封装等其他方法。 三、问题 1.引导性提问 引导性提问需要教师根据教材内容和学生实际水平，提出问题，启发引导学生去解决问题，提问，从而达到理解、掌握知识，发展各种能力和提高思想觉悟的目的。 （1）用于练习的所有资料都放在您面前了吗？如果不是，缺少哪些？ （2）面向对象与面向过程有什么不同？ （3）类和对象分别是什么？有什么关系？ （4）生成器与迭代器是什么？ （5）继承、重载、封装是什么？ 2.探究性问题 探究性问题需要教师深入钻研教材的基础上精心设计，提问的角度或者在引导性提问的基础上，从重点、难点问题切入，进行插入式提问。或者是对引导式提问中尚未涉及但在课文中又是重要的问题加以设问。 （1）面向对象编程语言有哪些？ （2）为什么要使用面向对象编程？ （3）self参数有什么特点？ （4）类的专有方法与普通的方法有何不同？ （5）对象的创建与调用函数相似吗？
慎用面向对象：开始之前，请阅读《面向对象编程已死》 实际上我并不喜欢面向对象，使用Python以来，我仅仅在wxpython中用过比较多的面向对象。面向对象的设计方式，对我来讲有些繁琐了。 此次教程基本都是网上找来的内容，面向对象的短小的例子一时想不出比较好的。 简介 到目前为止，都是根据操作数据的函数或语句块来设计程序的。这被称为面向过程的编程。还有一种把数据和功能结合起来，用称为对象的东西包裹起来组织程序的方法。 这种方法称为面向对象的编程理念。在大多数时候你可以使用过程性编程，但是有些时候当你想要编写大型程序或是寻求一个更加合适的解决方案的时候，你就得使用面向对象的编程技术。 类和对象是面向对象编程的两个主要方面。类创建一个新类型，而对象这个类的实例。这类似于你有一个int类型的变量，这存储整数的变量是int类的实例（对象）。
注意，即便是整数也被作为对象（属于int类）。这和C++、Java（1.5版之前）把整数纯粹作为类型是不同的。通过help(int)了解更多这个类的详情。C#和Java 1.5程序员会熟悉这个概念，因为它类似与封装与解封装的概念。 对象可以使用普通的属于对象的变量存储数据。属于一个对象或类的变量被称为域。对象也可以使用属于类的函数来具有功能。这样的函数被称为类的方法。这些术语帮助我们把它们与孤立的函数和变量区分开来。域和方法可以合称为类的属性。 域有两种类型——属于每个实例/类的对象或属于类本身。它们分别被称为实例变量和类变量。 类使用class关键字创建。类的域和方法被列在一个缩进块中。 self关键字 类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称，但是在调用这个方法的时候你不为这个参数赋值，Python会提供这个值。这个特别的变量指对象本身，按照惯例它的名称是self。 虽然你可以给这个参数任何名称，但是强烈建议你使用self这个名称——其他名称都是不赞成你使用的。使用一个标准的名称有很多优点——你的程序读者可以迅速识别它，如果使用self的话，还有些IDE（集成开发环境）也可以帮助你。 Python中的self等价于C++中的self指针和Java、C#中的this参考。 这也意味着如果你有一个不需要参数的方法，你还是得给这个方法定义一个self参数。类
p y t h o n面向对象概念 及练习题
面向对象及练习题 1.面向对象 1.1面向对象概念 面向对象是一种编程思想，是对现实世界中的事物进行抽象的方式。应用到代码编程设计中，是一种建立现实世界事物模型的方式。 1.2 面向对象和面向过程区别 面向过程关注的是完成工作的步骤，面向对象关注的是谁能完成工作。 面向对象是在完成工作的时候关注哪些个体能够完成对应的工作，找到对应的个体即可完成对应任务。 2.类 2.1类的概念 类是一系列事物的统称，同类事物必定具有相同的特征。日常事物的特征根据特性分为状态和行为，对应到类中是变量和方法。 特征分类： 状态→变量（成员变量） 行为→方法（成员方法） 统称：类的成员
2.2类定义语法格式 class类名： pass 说明：pass是空语句，不具有任何意义，仅为了保持程序结构完整性 2.3类名的命名规则 类名命名规范：满足大驼峰命名规则 3.对象 3.1对象的概念 对象是类的具体表现形式，是实际存在的个体。（类是一系列事物的统称） 3.2创建对象语法格式 对象名 = 类名()
3.3 注意事项 对象的创建不限制数量，一个类可以创建任意个数的对象4.成员变量 4.1成员变量的概念 成员变量用于描述对象的固有状态或属性。 4.2定义成员变量语法格式（公有属性/公有变量） class 类名： def __init__(self): self.变量名1 = 值1 self.变量名2 = None 4.3成员变量定义语法格式（独有属性/独有变量） 对象名.变量名 = 值
4.4公有变量与独有变量的区别 ●公有变量在__init__方法中声明，每个对象都具有该变量 ●独有变量在创建对象后声明，只有当前对象具有此变量 ●定义对象的独有变量时，如果独有变量名与公有变量名相同，视为 修改公有变量的值；如果独有变量名与公有变量名不相同，视为定 义新的独有属性 ●None含义是为空，表示没有具体的数据 4.5变量的调用格式 取值：对象名.变量名 赋值：对象名.变量名 = 值 5.成员方法 5.1成员方法概念 成员方法用于描述对象的固有行为 5.2定义成员方法语法格式 格式一（无参方法）：
Python 面向对象 Python从设计之初就已经是一门面向对象的 语言，正因为如此，在Python中创建一个类 和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。 如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一 些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。 接下来我们先来简单的了解下面向对象的一 些基本特征。 面向对象技术简介 ?类(Class): 用来描述具有相同的属性和方法的 对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。 ?类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。
?数据成员：类变量或者实例变量用于处理类及其实例对象的相关的数据。 ?方法重写：如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。 ?实例变量：定义在方法中的变量，只作用于当前实例的类。 ?继承：即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计：一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。 ?实例化：创建一个类的实例，类的具体对象。 ?方法：类中定义的函数。 ?对象：通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。 创建类 使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例:
Python面向对象程序设计 Python编程课程教师:工作:Python面向对象编程课程描述面向对象编程是Python采用的基本编程思想。它可以集成属性和代码来定义类，从而使编程更简单。 本章介绍如何在Python中使用类和对象。 本章介绍了面向对象编程的基本定义以及类类的继承和多态性的使用。面向对象编程的基本概念概述了面向对象编程的基本概念。面向对象编程的基本概念概述了面向对象编程的基本概念。面向对象编程可以将一组数据和与这组数据相关的操作结合起来形成一个实体。这个实体是一个对象。 ()类:具有相同或相似属性的对象的抽象是一个类。 因此，对象的抽象是类的具体化，类就是对象。 例如，如果人类是一个类，那么特定的人就是一个对象。 ()封装:绑定数据和操作来定义新类的过程就是封装。 ()继承:一个类共享一个或多个其他类定义的结构和行为的类之间的关系。 继承描述了类之间的关系。 子类可以扩展基类的行为、覆盖、重定义。 如果人类是一个阶级，那么人类的子类就可以被定义。 男性可以继承人类的属性(例如，姓名、身高、年龄等)。)和方法(即动作)。 例如，吃饭和走路)不需要在子类中重复定义。
从同一个类继承的子类也有多态性，也就是说，同一个函数名在不同的子类中有不同的实现。 正如儿童从父母那里继承了人类的共同特征一样，儿童也有自己的特征。 ()方法:也称为成员函数，是指对定义为类声明一部分的对象的操作。 方法定义了可以在对象上执行的操作。 ()构造函数:创建对象时初始化对象的成员函数。 构造函数通常与其所属的类具有完全相同的名称。 ()析构函数:析构函数与构造函数相反。当对象超出其范围时(例如，对象所在的函数已被调用)，系统自动执行析构函数。 析构函数经常被用来清理混乱。 定义和使用类声明类静态变量静态方法类方法使用实例()函数判断对象类型声明类定义一个函数sum()来计算和打印两个参数的和。 函数sum()包含两个参数。 参数num和num代码如下:defsum(num，num):print(numnumnum num)面向对象编程中的基本概念()对象:面向对象编程思想可以将一组数据和与这组数据相关的操作集合起来形成一个实体，这就是对象。 ()类:具有相同或相似属性的对象的抽象是一个类。 因此，对象的抽象是类的具体化，类就是对象。