首页手记 python面向对象

python面向对象

标签：

Python

--********************************************************************************************************************************

--Python 面向对象----------------------------------------------------------------------------

--********************************************************************************************************************************

Python从设计之初就已经是一门面向对象的语言，正因为如此，在Python中创建一个类和对象是很容易的。本章节我们将详细介绍Python的面向对象编程。

如果你以前没有接触过面向对象的编程语言，那你可能需要先了解一些面向对象语言的一些基本特征，在头脑里头形成一个基本的面向对象的概念，这样有助于你更容易的学习Python的面向对象编程。

接下来我们先来简单的了解下面向对象的一些基本特征。

面向对象技术简介

类(Class): 用来描述具有相同的属性和方法的对象的集合。它定义了该集合中每个对象所共有的属性和方法。对象是类的实例。

类变量: 类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

数据成员: 类变量或者实例变量用于处理类及其实例对象的相关的数据。

方法重写: 如果从父类继承的方法不能满足子类的需求，可以对其进行改写，这个过程叫方法的覆盖（override），也称为方法的重写。

实例变量: 定义在方法中的变量，只作用于当前实例的类。

继承: 即一个派生类（derived class）继承基类（base class）的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如，有这样一个设计: 一个Dog类型的对象派生自Animal类，这是模拟"是一个（is-a）"关系（例图，Dog是一个Animal）。

实例化: 创建一个类的实例，类的具体对象。

方法: 类中定义的函数。

对象: 通过类定义的数据结构实例。对象包括两个数据成员（类变量和实例变量）和方法。

创建类

使用class语句来创建一个新类，class之后为类的名称并以冒号结尾，如下实例:

class ClassName:

'类的帮助信息' #类文档字符串

class_suite #类体

类的帮助信息可以通过ClassName.__doc__查看。

class_suite 由类成员，方法，数据属性组成。

实例

以下是一个简单的Python类实例:

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'所有员工的基类'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

empCount 变量是一个类变量，它的值将在这个类的所有实例之间共享。你可以在内部类或外部类使用 Employee.empCount 访问。

第一种方法__init__()方法是一种特殊的方法，被称为类的构造函数或初始化方法，当创建了这个类的实例时就会调用该方法

self 代表类的实例，self 在定义类的方法时是必须有的，虽然在调用时不必传入相应的参数。

self代表类的实例，而非类

类的方法与普通的函数只有一个特别的区别——它们必须有一个额外的第一个参数名称, 按照惯例它的名称是 self。

class Test:

def prt(self):

print(self)

print(self.__class__)

t = Test()

t.prt()

以上实例执行结果为:

<__main__.Test instance at 0x10d066878>

__main__.Test

从执行结果可以很明显的看出，self 代表的是类的实例，代表当前对象的地址，而 self.class 则指向类。

self 不是 python 关键字，我们把他换成 runoob 也是可以正常执行的:

实例

class Test:

def prt(runoob):

print(runoob)

print(runoob.__class__)

t = Test()

t.prt()

以上实例执行结果为:

<__main__.Test instance at 0x10d066878>

__main__.Test

创建实例对象

实例化类其他编程语言中一般用关键字 new，但是在 Python 中并没有这个关键字，类的实例化类似函数调用方式。

以下使用类的名称 Employee 来实例化，并通过 __init__ 方法接受参数。

"创建 Employee 类的第一个对象"

emp1 = Employee("Zara", 2000)

"创建 Employee 类的第二个对象"

emp2 = Employee("Manni", 5000)

访问属性

您可以使用点(.)来访问对象的属性。使用如下类的名称访问类变量:

emp1.displayEmployee()

emp2.displayEmployee()

print "Total Employee %d" % Employee.empCount

完整实例:

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'所有员工的基类'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

"创建 Employee 类的第一个对象"

emp1 = Employee("Zara", 2000)

"创建 Employee 类的第二个对象"

emp2 = Employee("Manni", 5000)

emp1.displayEmployee()

emp2.displayEmployee()

print "Total Employee %d" % Employee.empCount

执行以上代码输出结果如下:

Name : Zara ,Salary: 2000

Name : Manni ,Salary: 5000

Total Employee 2

你可以添加，删除，修改类的属性，如下所示:

emp1.age = 7 # 添加一个 'age' 属性

emp1.age = 8 # 修改 'age' 属性

del emp1.age # 删除 'age' 属性

你也可以使用以下函数的方式来访问属性:

getattr(obj, name[, default]) : 访问对象的属性。

hasattr(obj,name) : 检查是否存在一个属性。

setattr(obj,name,value) : 设置一个属性。如果属性不存在，会创建一个新属性。

delattr(obj, name) : 删除属性。

hasattr(emp1, 'age') # 如果存在 'age' 属性返回 True。

getattr(emp1, 'age') # 返回 'age' 属性的值

setattr(emp1, 'age', 8) # 添加属性 'age' 值为 8

delattr(emp1, 'age') # 删除属性 'age'

--Python内置类属性

__dict__ : 类的属性（包含一个字典，由类的数据属性组成）

__doc__ :类的文档字符串

__name__: 类名

__module__: 类定义所在的模块（类的全名是'__main__.className'，如果类位于一个导入模块mymod中，那么className.__module__ 等于 mymod）

__bases__ : 类的所有父类构成元素（包含了一个由所有父类组成的元组）

Python内置类属性调用实例如下:

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Employee:

'所有员工的基类'

empCount = 0

def __init__(self, name, salary):

self.name = name

self.salary = salary

Employee.empCount += 1

def displayCount(self):

print "Total Employee %d" % Employee.empCount

def displayEmployee(self):

print "Name : ", self.name, ", Salary: ", self.salary

print "Employee.__doc__:", Employee.__doc__

print "Employee.__name__:", Employee.__name__

print "Employee.__module__:", Employee.__module__

print "Employee.__bases__:", Employee.__bases__

print "Employee.__dict__:", Employee.__dict__

执行以上代码输出结果如下:

Employee.__doc__: 所有员工的基类

Employee.__name__: Employee

Employee.__module__: __main__

Employee.__bases__: ()

Employee.__dict__: {'__module__': '__main__', 'displayCount': <function displayCount at 0x10a939c80>, 'empCount': 0, 'displayEmployee': <function displayEmployee at 0x10a93caa0>, '__doc__': '\xe6\x89\x80\xe6\x9c\x89\xe5\x91\x98\xe5\xb7\xa5\xe7\x9a\x84\xe5\x9f\xba\xe7\xb1\xbb', '__init__': <function __init__ at 0x10a939578>}

python对象销毁(垃圾回收)

Python 使用了引用计数这一简单技术来跟踪和回收垃圾。

在 Python 内部记录着所有使用中的对象各有多少引用。

一个内部跟踪变量，称为一个引用计数器。

当对象被创建时，就创建了一个引用计数，当这个对象不再需要时，也就是说，这个对象的引用计数变为0 时，它被垃圾回收。但是回收不是"立即"的，由解释器在适当的时机，将垃圾对象占用的内存空间回收。

a = 40 # 创建对象 <40>

b = a # 增加引用， <40> 的计数

c = [b] # 增加引用. <40> 的计数

del a # 减少引用 <40> 的计数

b = 100 # 减少引用 <40> 的计数

c[0] = -1 # 减少引用 <40> 的计数

垃圾回收机制不仅针对引用计数为0的对象，同样也可以处理循环引用的情况。循环引用指的是，两个对象相互引用，但是没有其他变量引用他们。这种情况下，仅使用引用计数是不够的。Python 的垃圾收集器实际上是一个引用计数器和一个循环垃圾收集器。作为引用计数的补充，垃圾收集器也会留心被分配的总量很大（及未通过引用计数销毁的那些）的对象。在这种情况下，解释器会暂停下来，试图清理所有未引用的循环。

实例

析构函数 __del__ ，__del__在对象销毁的时候被调用，当对象不再被使用时，__del__方法运行:

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Point:

def __init__( self, x=0, y=0):

self.x = x

self.y = y

def __del__(self):

class_name = self.__class__.__name__

print class_name, "销毁"

pt1 = Point()

pt2 = pt1

pt3 = pt1

print id(pt1), id(pt2), id(pt3) # 打印对象的id

del pt1

del pt2

del pt3

以上实例运行结果如下:

3083401324 3083401324 3083401324

Point 销毁

注意: 通常你需要在单独的文件中定义一个类，

--类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。

需要注意的地方: 继承语法 class 派生类名（基类名）: //... 基类名写在括号里，基本类是在类定义的时候，在元组之中指明的。

在python中继承中的一些特点:

1: 在继承中基类的构造（__init__()方法）不会被自动调用，它需要在其派生类的构造中亲自专门调用。

2: 在调用基类的方法时，需要加上基类的类名前缀，且需要带上self参数变量。区别在于类中调用普通函数时并不需要带上self参数

3: Python总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

如果在继承元组中列了一个以上的类，那么它就被称作"多重继承" 。

语法:

派生类的声明，与他们的父类类似，继承的基类列表跟在类名之后，如下所示:

class SubClassName (ParentClass1[, ParentClass2, ...]):

'Optional class documentation string'

class_suite

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent: # 定义父类

parentAttr = 100

def __init__(self):

print "调用父类构造函数"

def parentMethod(self):

print '调用父类方法'

def setAttr(self, attr):

Parent.parentAttr = attr

def getAttr(self):

print "父类属性 :", Parent.parentAttr

class Child(Parent): # 定义子类

def __init__(self):

print "调用子类构造方法"

def childMethod(self):

print '调用子类方法'

c = Child() # 实例化子类

c.childMethod() # 调用子类的方法

c.parentMethod() # 调用父类方法

c.setAttr(200) # 再次调用父类的方法 - 设置属性值

c.getAttr() # 再次调用父类的方法 - 获取属性值

以上代码执行结果如下:

调用子类构造方法

调用子类方法

调用父类方法

父类属性 : 200

你可以继承多个类

class A: # 定义类 A

.....

class B: # 定义类 B

.....

class C(A, B): # 继承类 A 和 B

.....

你可以使用issubclass()或者isinstance()方法来检测。

issubclass() - 布尔函数判断一个类是另一个类的子类或者子孙类，语法: issubclass(sub,sup)

isinstance(obj, Class) 布尔函数如果obj是Class类的实例对象或者是一个Class子类的实例对象则返回true。

方法重写

如果你的父类方法的功能不能满足你的需求，你可以在子类重写你父类的方法:

实例:

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class Parent: # 定义父类

def myMethod(self):

print '调用父类方法'

class Child(Parent): # 定义子类

def myMethod(self):

print '调用子类方法'

c = Child() # 子类实例

c.myMethod() # 子类调用重写方法

执行以上代码输出结果如下:

调用子类方法

基础重载方法

下表列出了一些通用的功能，你可以在自己的类重写:

序号方法, 描述 & 简单的调用

1 __init__ ( self [,args...] )

构造函数

简单的调用方法: obj = className(args)

2 __del__( self )

析构方法, 删除一个对象

简单的调用方法 : del obj

3 __repr__( self )

转化为供解释器读取的形式

简单的调用方法 : repr(obj)

4 __str__( self )

用于将值转化为适于人阅读的形式

简单的调用方法 : str(obj)

5 __cmp__ ( self, x )

对象比较

简单的调用方法 : cmp(obj, x)

运算符重载

Python同样支持运算符重载，实例如下:

实例

#!/usr/bin/python

class Vector:

def __init__(self, a, b):

self.a = a

self.b = b

def __str__(self):

return 'Vector (%d, %d)' % (self.a, self.b)

def __add__(self,other):

return Vector(self.a + other.a, self.b + other.b)

v1 = Vector(2,10)

v2 = Vector(5,-2)

print v1 + v2

以上代码执行结果如下所示:

Vector(7,8)

--类属性与方法

类的私有属性

__private_attrs: 两个下划线开头，声明该属性为私有，不能在类的外部被使用或直接访问。在类内部的方法中使用时 self.__private_attrs。

类的方法

在类的内部，使用 def 关键字可以为类定义一个方法，与一般函数定义不同，类方法必须包含参数 self,且为第一个参数

类的私有方法

__private_method: 两个下划线开头，声明该方法为私有方法，不能在类地外部调用。在类的内部调用 self.__private_methods

实例

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class JustCounter:

__secretCount = 0 # 私有变量

publicCount = 0 # 公开变量

def count(self):

self.__secretCount += 1

self.publicCount += 1

print self.__secretCount

counter = JustCounter()

counter.count()

print counter.publicCount

print counter.__secretCount # 报错，实例不能访问私有变量

Python 通过改变名称来包含类名:

Traceback (most recent call last):

File "test.py", line 17, in <module>

print counter.__secretCount # 报错，实例不能访问私有变量

AttributeError: JustCounter instance has no attribute '__secretCount'

Python不允许实例化的类访问私有数据，但你可以使用 object._className__attrName 访问属性，将如下代码替换以上代码的最后一行代码:

.........................

print counter._JustCounter__secretCount

执行以上代码，执行结果如下:

--单下划线、双下划线、头尾双下划线说明:

__foo__: 定义的是特殊方法，一般是系统定义名字，类似 __init__() 之类的。

_foo: 以单下划线开头的表示的是 protected 类型的变量，即保护类型只能允许其本身与子类进行访问，不能用于 from module import *

__foo: 双下划线的表示的是私有类型(private)的变量, 只能是允许这个类本身进行访问了。

Python 内置函数 Python正则表达式

object._className__attrName 实例及解析

#!/usr/bin/python

# -*- coding: UTF-8 -*-

class JustCounter:

__secretCount = 0 # 私有变量

publicCount = 0 # 公开变量

def count(self):

self.__secretCount += 1

self.publicCount += 1

print self.__secretCount

def count2(self):

print self.__secretCount

counter = JustCounter()

counter.count()

# 在类的对象生成后,调用含有类私有属性的函数时就可以使用到私有属性.

counter.count()

#第二次同样可以.

print counter.publicCount

print counter._JustCounter__secretCount # 不改写报错，实例不能访问私有变量

try:

counter.count2()

except IOError:

print "不能调用非公有属性!"

else:

print "ok!" #现在呢!证明是滴!

新式类和经典类的区别:

class A:

def foo(self):

print('called A.foo()')

class B(A):

pass

class C(A):

def foo(self):

print('called C.foo()')

class D(B, C,object):

pass

if __name__ == '__main__':

d = D()

d.foo()

D 继承了 object 和不继承程序输出不一样，继承 object 会调用 C 类的 foo，否则会调用Ａ的。

使用 super 进行父类构造调用那么必须使用 object 继承的新式类，否则报错。

--5-----------Python 包------------------------------------------------------------------------------------------------------------------

包是一个分层次的文件目录结构，它定义了一个由模块及子包，和子包下的子包等组成的 Python 的应用环境。

简单来说，包就是文件夹，但该文件夹下必须存在 __init__.py 文件, 该文件的内容可以为空。__int__.py用于标识当前文件夹是一个包。

考虑一个在 package_runoob 目录下的 runoob1.py、runoob2.py、__init__.py 文件，test.py 为测试调用包的代码，目录结构如下:

test.py

package_runoob

|-- __init__.py

|-- runoob1.py

|-- runoob2.py 源代码如下:

package_runoob/runoob1.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def runoob1():

print "I'm in runoob1"

package_runoob/runoob2.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

def runoob2():

print "I'm in runoob2"

现在，在 package_runoob 目录下创建 __init__.py:

package_runoob/__init__.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

if __name__ == '__main__':

print '作为主程序运行'

else:

print 'package_runoob 初始化'

然后我们在 package_runoob 同级目录下创建 test.py 来调用 package_runoob 包

test.py

#!/usr/bin/python

# -*- coding: UTF-8 -*-

# 导入 Phone 包

from package_runoob.runoob1 import runoob1

from package_runoob.runoob2 import runoob2

runoob1()

runoob2()

以上实例输出结果:

package_runoob 初始化

I'm in runoob1

I'm in runoob2

如上，为了举例，我们只在每个文件里放置了一个函数，但其实你可以放置许多函数。你也可以在这些文件里定义Python的类，然后为这些类建一个包。

--Python类、模块、包的区别

类

类的概念在许多语言中出现，很容易理解。它将数据和操作进行封装，以便将来的复用。

模块

模块，在Python可理解为对应于一个文件。在创建了一个脚本文件后，定义了某些函数和变量。你在其他需要这些功能的文件中，导入这模块，就可重用这些函数和变量。一般用module_name.fun_name，和module_name.var_name进行使用。这样的语义用法使模块看起来很像类或者名字空间，可将module_name 理解为名字限定符。模块名就是文件名去掉.py后缀。

client.py

def func():

print "hello world!"

main.py

import client

if __name__ == '__main__':

print __name__

client.func()

print client.__name__

>>python main.py ---> result:

__main__

hello world!

client

模块属性__name__，它的值由Python解释器设定。如果脚本文件是作为主程序调用，其值就设为__main__，如果是作为模块被其他文件导入，它的值就是其文件名。

每个模块都有自己的私有符号表，所有定义在模块里面的函数把它当做全局符号表使用。

模块可以导入其他的模块。通常将import语句放在模块的开头，被导入的模块名字放在导入它的模块的符号表中。

from module import names 可以直接从模块中导入名字到符号表，但模块名字不会被导入。

from module import * 可以把模块中的所有名字全部导入，除了那些以下划线开头的名字符号。不建议使用，不清楚导入了什么符号，有可能覆盖自己定义的东西

内建函数dir()可以查看模块定义了什么名字（包括变量名，模块名，函数名等）: dir(模块名)，没有参数时返回所有当前定义的名字

模块搜索路径

当导入一个模块时，解释器先在当前包中查找模块，若找不到，然后在内置的built-in模块中查找，找不到则按sys.path给定的路径找对应的模块文件(模块名.py)

sys.path的初始值来自于以下地方:

包含脚本当前的路径，当前路径

PYTHONPATH

默认安装路径

sys.path初始化完成之后可以更改

编译过的Python文件: .pyc文件

built-in 模块

上面的例子中，当client被导入后，python解释器就在当前目录下寻找client.py的文件，然后再从环境变量PYTHONPATH寻找，如果这环境变量没有设定，也不要紧，解释器还会在安装预先设定的的一些目录寻找。这就是在导入下面这些标准模块，一切美好事情能发生的原因。

这些搜索目录可在运行时动态改变，比如将module1.py不放在当前目录，而放在一个冷僻的角落里。这里你就需要通过某种途径，如sys.path，来告知Python了。sys.path返回的是模块搜索列表，通过前后的输出对比和代码，应能理悟到如何增加新路径的方法了吧。非常简单，就是使用list的append()或insert()增加新的目录。

#module2.py

import sys

import os

print sys.path

workpath = os.path.dirname(os.path.abspath(sys.argv[0]))

sys.path.insert(0, os.path.join(workpath, 'modules'))

print sys.path

其他的要点

模块能像包含函数定义一样，可包含一些可执行语句。这些可执行语句通常用来进行模块的初始化工作。这些语句只在模块第一次被导入时被执行。这非常重要，有些人以为这些语句会多次导入多次执行，其实不然。

模块在被导入执行时，python解释器为加快程序的启动速度，会在与模块文件同一目录下生成.pyc文件。我们知道python是解释性的脚本语言，而.pyc是经过编译后的字节码，这一工作会自动完成，而无需程序员手动执行。

包

通常包总是一个目录，可以使用import导入包，或者from + import来导入包中的部分模块。包目录下为首的一个文件便是 __init__.py。然后是一些模块文件和子目录，假如子目录中也有 __init__.py 那么它就是这个包的子包了。

在创建许许多多模块后，我们可能希望将某些功能相近的文件组织在同一文件夹下，这里就需要运用包的概念了。包对应于文件夹，使用包的方式跟模块也类似，唯一需要注意的是，当文件夹当作包使用时，文件夹需要包含__init__.py文件，主要是为了避免将文件夹名当作普通的字符串。__init__.py的内容可以为空，一般用来进行包的某些初始化工作或者设置__all__值，__all__是在from package-name import *这语句使用的，全部导出定义过的模块。

可以从包中导入单独的模块。

1). import PackageA.SubPackageA.ModuleA,使用时必须用全路径名

2). 变种: from PackageA.SubPackageA import ModuleA, 可以直接使用模块名而不用加上包前缀。

3). 也可以直接导入模块中的函数或变量: from PackageA.SubPackageA.ModuleA import functionA

import语句语法:

1. 当使用from package import item时，item可以是package的子模块或子包，或是其他的定义在包中的名字（比如一个函数、类或变量）

首先检查item是否定义在包中，不过没找到，就认为item是一个模块并尝试加载它，失败时会抛出一个ImportError异常。

2. 当使用import item.subitem.subsubitem语法时，最后一个item之前的item必须是包，最后一个item可以是一个模块或包，但不能是类、函数和变量

3. from pacakge import *

如果包的__init__.py定义了一个名为__all__的列表变量，它包含的模块名字的列表将作为被导入的模块列表。

如果没有定义__all__，这条语句不会导入所有的package的子模块，它只保证包package被导入，然后导入定义在包中的所有名字。

python包是:

包是一个有层次的文件目录结构，它定义了由n个模块或n个子包组成的python应用程序执行环境。

通俗一点: 包是一个包含__init__.py 文件的目录，该目录下一定得有这个__init__.py文件和其它模块或子包。

常见问题:

引入某一特定路径下的模块

使用sys.path.append(yourmodulepath)

将一个路径加入到python系统路径下，避免每次通过代码指定路径

利用系统环境变量 export PYTHONPATH=$PYTHONPATH:yourmodulepath，

直接将这个路径链接到类似/Library/Python/2.7/site-packages目录下

好的建议

经常使用if __name__ == '__main__'，保证你写包既可以import又可以独立运行，用于test。

多次import不会多次执行模块，只会执行一次。可以使用reload来强制运行模块，但不提倡。

包（package）

为了组织好模块，将多个模块分为一个包。包是python模块文件所在的目录，且该目录下必须存在__init__.py文件。常见的包结构如下:

package_a

├── __init__.py

├── module_a1.py

└── module_a2.py

package_b

├── __init__.py

├── module_b1.py

└── module_b2.py

main.py

如果main.py想要引用packagea中的模块modulea1，可以使用:

from package_a import module_a1

import package_a.module_a1

如果packagea中的modulea1需要引用packageb，那么默认情况下，python是找不到packageb。我们可以使用sys.path.append('../'),可以在packagea中的__init__.py添加这句话，然后该包下得所有module都添加* import __init_即可。

点击查看更多内容