扫一扫
分享文章到微信
扫一扫
关注官方公众号
至顶头条
python是一种面向对象的编程语言。不过不象其它的面向对象的语言,python并不强迫你用面向对象的方法来写程序,它也允许你用面向过程的方式来写模块、函数等。
1.1 经典对象(classic class)
在2.1及其之前版本的python,只能用经典对象这种对象模型来编程。在2.2和2.3版本的python,经典对象也是默认的对象模型。
1.1.1 经典对象的一些特征:
l 你可以象调用函数一样的来调用一个对象。一旦调用,该对象的一个实例就被建立。
l 你可以随意地为对象内部的属性命名。
l 属性可以是数据类型,也可以是函数类型。
l 若属性(attribute)是函数类型,那么就把它看做对象的一个方法(method)。
l python为函数规定了一种特殊的命名方式,用前后两个下划线来包围函数名,例如:__methodName__。
l 对象可以继承。
1.1.2 对象声明
声明对象的语法:
class classname[(base-classes)]:
statement(s)
classname是函数名。
base-classes的值必须为对象,用逗号分隔,它相当于java中的超类(superclass)。
继承关系可以被传递,如果c1是c2的子类,c2是c3的子类,那么c1也是c3的子类。
内建函数issubclass(C1, C2)可以判断继承关系,若c1是c2的子类,那么函数返回true。由于任何类都被看作是自身的子类,所以若有类C,那么issubclass(C,C)返回true。
Def声明语法和class声明语法的区别:
Def声明时,冒号前面必须有括号,即使它本身没有任何参数;但class声明时,只有当class有其基类(base class)的时候,才需要在括号中写出其基类。
1.1.3 对象正文
1.1.3.1 对象内部的属性
在对象内部调用其属性,直接写其属性名称即可,如:
class C3:
x = 23
y = x + 22 # must use just x, not C3.x
但若在对象内部定义了方法,要在方法中调用对象中的其它属性,需要写属性的全名,如:
class C4:
x = 23
def amethod(self):
print C4.x # must use C4.x, not just x
当对象被声明的时候,其中的一些属性已经被隐式声明了。
__name__:类的名称
__base__:tuple对象,放置对象的所有基类
__dict__:dict对象,放置对象的所有属性
例如:对象C内部有属性S,那么C.S=x 等价于C._ _dict_ _['S']=x
1.1.3.2 对象内部的函数
对象内部的函数写法与普通的函数写法差不多,不过函数的第一个参数要写为self,如:
class C5:
def hello(self):
print "Hello"
1.1.3.3 私有变量
私有变量的声明,只需在变量名前面加两个下划线,如类C的内部有私有变量user,应声明为:__user。
事实上,当python编译的时候,会把__user改为_C__user(即_ClassName__VariableName的格式)。
无论是否在对象内部,以一个下划线开头的变量,都被看作私有变量。
1.1.4 实例
回顾一下前面的“经典对象的一些特征”中的第一点:“你可以象调用函数一样的来调用一个对象”。创建实例的时候,就是如此创建:
anInstance = C5( )
1.1.4.1 _ _init_ _
如果一个对象的内部,有或继承有_ _init_ _方法,那么当这个对象被调用(用java上的词可以叫实例化)时,_ _init_ _方法会自动地被调用。
_ _init_ _方法不能有返回值,如果一定需要跳出或返回,也只能返回None。
例如:
class C4:
def __init__(self):
return 'sss'
a = C4();
python会报错:
Traceback (most recent call last):
File "<pyshell#26>", line 1, in -toplevel-
a = C4();
TypeError: __init__() should return None
_ _init_ _方法的主要目的,是为了在创建对象实例的时候,对对象的属性赋值。这么做可以增加程序的可读性。如果对象内部没有_ _init_ _,那么你调用对象的时候就不能带上任何的参数。
1.1.4.2 实例中的属性
用点(.)来访问实例中的属性。
即使一个对象已经被实例化,仍可以个实例增加任意的属性,并对其赋值。
class C7: pass
z = C7( )
z.x = 23
实例被创建以后,该实例会被自动加上两个属性:
_ _class_ _:实例所属的对象
_ _dict_ _:实例的所有属性(实例自身的属性和其所属对象的属性)
如:
class C6:
def _ _init_ _(self,n):
self.x = n
a = C6(234)
a.y=213213
a.__dict__
#执行结果:{'y': 213213, 'x': 234}
1.1.4.3 工厂函数
遥想一下,设计模式中被用得最多得工厂模式(Factory),它被用于创建对象的实例。在python当中,最直接的用来实现工厂模式的方式,似乎是用_ _init_ _来返回不同的实例,但是,unfortunately,_ _init_ _最多也只能返回None。所以要实现工厂模式,最佳的方式就是专门写一个函数,用来返回不同的实例,这类函数,可以称之为工厂函数(Factory Function)。
如下例,appropriateCase就是一个工厂函数。
class SpecialCase:
def amethod(self): print "special"
class NormalCase:
def amethod(self): print "normal"
def appropriateCase(isnormal=1):
if isnormal: return NormalCase( )
else: return SpecialCase( )
aninstance = appropriateCase(isnormal=0)
aninstance.amethod( )
1.1.5 属性引用
假设x是对象C的实例,当引用x.name的时候,是如何来查找它的值呢?用最简单的话来概括,就是,由小到大由近到远,依次查找name的值。
再说得具体一些,是按下面的方式查找:
l 若x.name是x._ _dict_ _,中的key,那么返回x._ _dict_ _['name'] (查找自身)
l 否则,查找C._ _dict_ _中的key,是则返回C._ _dict_ _['name'] (查找所属对象)
l 否则,查找C的基类,在C._ _bases_ _中继续按上面的两步查找(查找所属对象的基类)
l 否则,抛出异常:AttributeError
1.1.6 方法的绑定与非绑定(Bound and Unbound)
上面讲了属性的引用,方法的绑定与非绑定实际上涉及到的是方法引用的问题。方法实际上使用函数来实现。当方法被引用时,并非直接返回其对应的函数,而是将这个函数,载入到了bound或者unbound方法上。
bound和unbound的区别在于:bound将特定的函数,与特定的实例相关联;而unbound则相反。
若没有同名属性,直接用函数名(函数名后不带括号),可以观察到其绑定状态。
假设有对象C和实例x:
class C:
a = 1
def g(self): print "method g in class C"
x = C()
print x.g
#执行结果:<bound method C.g of <__main__.C instance at 0x00BA2F58>>
print C.g
#执行结果:<unbound method C.g>
上面的执行结果表明:x.g被绑定到了C.g()函数上,所以执行x.g()会有结果返回;而C.g没有被绑定,所以执行C.g()没有结果。
1.1.6.1 细说非绑定
若处于非绑定状态,当一个函数被引用的时候,实际返回的是unbound方法,该方法内部载有该函数。Unbound方法有三个只读属性
im_class:被引用函数所在的对象
im_func:被引用的函数
im_self:总是为None
非绑定的方法也可以被调用,需要把im_class对象的实例名做为第一个参数,那么就会返回im_func的函数了。
例如上面的C.g()没有结果,但可以执行C.g(x),x为C的实例,就可以得到C.g()函数的正确执行结果了。
1.1.6.2 细说绑定
当执行x.g()时,返回的是bound 方法。bound方法和unbound方法类似,也有三个只读属性:im_class,im_func,im_self,但不同之处在于:im_self的值为x。
1.1.7 继承与重载
从前面说到的“属性引用”的查找方法,不难看出python继承的实现方式。若x为C的实例,当调用x.g()的时候,python先看x._ _dict_ _中有没有g,没有就查找C._ _dict_ _,若再没有就查找C._ _base_ _有没有g。C._ _base_ _中放置了C的基类,就实现了对象的继承。用这样的机制,也同样实现了重载。
1.1.7.1 超类代理
在子类中,有可能要用到超类的属性,那么就要使用到超类代理机制,实际上是用unbound方式调用超类的函数。例如:
class Base:
def greet(self, name): print "Welcome ", name
class Sub(Base):
def greet(self, name):
print "Well Met and",
Base.greet(self, name)
x = Sub( )
x.greet('Alex')
超类代理常用于_ _init_ _方法中,因为在python中,子类的_ _init_ _方法中并不会自动地调用其超类中的_ _init_ _方法,所以需要利用这种超类代理机制手动调用一下。 如果您非常迫切的想了解IT领域最新产品与技术信息,那么订阅至顶网技术邮件将是您的最佳途径之一。
现场直击|2021世界人工智能大会
直击5G创新地带,就在2021MWC上海
5G已至 转型当时——服务提供商如何把握转型的绝佳时机
寻找自己的Flag
华为开发者大会2020(Cloud)- 科技行者