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 类的例子:

实例

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__': 'xe6x89x80xe6x9cx89xe5x91x98xe5xb7xa5xe7x9ax84xe5x9fxbaxe7xb1xbb', '__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 销毁

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

面向对象三大特性

面向对象的三大特性是指：封装、继承和多态。

一、封装

封装，顾名思义就是将内容封装到某个地方，以后再去调用被封装在某处的内容。

所以，在使用面向对象的封装特性时，需要：

将内容封装到某处
从某处调用被封装的内容

第一步：将内容封装到某处

每个对象中都有 name 和 age 属性，在内存里类似于下图来保存。

第二步：从某处调用被封装的内容

调用被封装的内容时，有两种情况：

通过对象直接调用
通过self间接调用

1、通过对象直接调用被封装的内容

上图展示了对象 obj1 和 obj2 在内存中保存的方式，根据保存格式可以如此调用被封装的内容：对象.属性名

2、通过self间接调用被封装的内容

执行类中的方法时，需要通过self间接调用被封装的内容

class Foo:

def __init__(self, name, age):

self.name = name

self.age = age

def detail(self):

print self.name

print self.age

obj1 = Foo('wupeiqi', 18)

obj1.detail()

# Python默认会将obj1传给self参数，即：obj1.detail(obj1)，所以，此时方法内部的 self ＝ obj1，即：self.name 是 wupeiqi ；self.age 是 18

obj2 = Foo('alex', 73)

obj2.detail()

# Python默认会将obj2传给self参数，即：obj1.detail(obj2)，所以，此时方法内部的 self ＝ obj2，即：self.name 是 alex ； self.age 是 78

综上所述，对于面向对象的封装来说，其实就是使用构造方法将内容封装到对象中，然后通过对象直接或者self间接获取被封装的内容。

二、继承

继承，面向对象中的继承和现实生活中的继承相同，即：子可以继承父的内容。

于面向对象的继承来说，其实就是将多个类共有的方法提取到父类中，子类仅需继承父类而不必一一实现每个方法。

注：除了子类和父类的称谓，你可能看到过派生类和基类，他们与子类和父类只是叫法不同而已。

类的继承

面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。

通过继承创建的新类称为子类或派生类，被继承的类称为基类、父类或超类。

继承语法

class 派生类名(基类名)
    ...

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

1、如果在子类中需要父类的构造方法就需要显示的调用父类的构造方法，或者不重写父类的构造方法。详细说明可查看：python 子类继承父类构造函数说明。
2、在调用基类的方法时，需要加上基类的类名前缀，且需要带上 self 参数变量。区别在于类中调用普通函数时并不需要带上 self 参数
3、Python 总是首先查找对应类型的方法，如果它不能在派生类中找到对应的方法，它才开始到基类中逐个查找。（先在本类中查找调用的方法，找不到才去基类中找）。

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

语法：

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

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

实例

#!/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)

序号	方法, 描述 & 简单的调用
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)

常⽤专有属性	说明	触发⽅式
__init__	构造初始化函数	创建实例后,赋值时使⽤, 在 __new__ 后
__new__	⽣成实例所需属性	创建实例时
__class__	实例所在的类	实例. __class__
__str__	实例字符串表示,可读性	print(类实例),如没实现，使⽤repr结果
__repr__	实例字符串表示,准确性	类实例回⻋或者 print(repr(类实例))
__del__	析构	del删除实例
__dict__	实例⾃定义属性	vars(实例.__dict__)
__doc__	类⽂档,⼦类不继承	help(类或实例)
__getattribute__	属性访问拦截器	访问实例属性时
__bases__	类的所有⽗类构成元素	类名.__bases__

标准库	说明
builtins	内建函数默认加载
os	操作系统接⼝
sys	Python⾃身的运⾏环境
functools	常⽤的⼯具
json	编码和解码 JSON 对象
logging	记录⽇志，调试
multiprocessing	多进程
threading	多线程
copy	拷⻉
time	时间
datetime	⽇期和时间
calendar	⽇历
hashlib	加密算法
random	⽣成随机数
re	字符串正则匹配
socket	标准的 BSD Sockets API
shutil	⽂件和⽬录管理
glob	基于⽂件通配符搜索

扩展库	说明
requests	使⽤的是 urllib3，继承了urllib2的所有特性
urllib	基于http的⾼层库
scrapy	爬⾍
beautifulsoup4	HTML/XML的解析器
celery	分布式任务调度模块
redis	缓存
Pillow(PIL)	图像处理
xlsxwriter	仅写excle功能,⽀持xlsx
xlwt	仅写excle功能,⽀持xls ,2013或更早版office
xlrd	仅读excle功能
elasticsearch	全⽂搜索引擎
pymysql	数据库连接库
mongoengine/pymongo	mongodbpython接⼝
matplotlib	画图
numpy/scipy	科学计算
django/tornado/flask	web框架
xmltodict	xml 转 dict
SimpleHTTPServer	简单地HTTP Server,不使⽤Web框架
gevent	基于协程的Python⽹络库
fabric	系统管理
pandas	数据处理库
scikit-learn	机器学习库

命令	简写命令	作⽤
break	b	设置断点
continue	c	继续执⾏程序
list	l	查看当前⾏的代码段
step	s	进⼊函数
return	r	执⾏代码直到从当前函数返回
quit	q	中⽌并退出
next	n	执⾏下⼀⾏
print	p	打印变量的值
help	h	帮助
args	a	查看传⼊参数
	回⻋	重复上⼀条命令
break	b	显示所有断点
break lineno	b lineno	在指定⾏设置断点
break file:lineno	b file:lineno	在指定⽂件的⾏设置断点
clear num		删除指定断点
bt		查看函数调⽤栈帧

python基础整理4——面向对象装饰器惰性器及高级模块

面向对象编程

面向对象技术简介

类和对象

1. 类

2. 对象

3. 类和对象之间的关系

5. 类的构成

<1> 举例：

6. 类的抽象

定义类

说明：

创建对象

总结：

Python 面向对象

面向对象技术简介

创建类

实例

实例

self代表类的实例，而非类

实例

创建实例对象

访问属性

实例

Python内置类属性

实例

python对象销毁(垃圾回收)

实例

实例

面向对象三大特性

一、封装

第二步：从某处调用被封装的内容

二、继承

类的继承

实例

方法重写

实例

基础重载方法

单继承

注意点

多继承

说明

Python的类如果继承了多个类，那么其寻找方法的方式有两种，分别是：深度优先和广度优先

重写父类方法与调用父类方法

1. 重写父类方法

2. 调用父类的方法

三：多态

为什么要用多态性（多态性的好处）

类属性、实例属性

类属性

通过实例(对象)去修改类属性

总结

类的成员

装饰器

python-----装饰器原理剖析

生成器

协程

高级模块

元类

1. 类也是对象

2. 动态地创建类

3. 使⽤type创建类

4. 使⽤type创建带有属性的类

注意：

6. 到底什么是元类（终于到主题了）

8. ⾃定义元类

python2中

python3中

python是动态语⾔

1. 动态语⾔的定义

2. 运⾏的过程中给对象绑定(添加)属性

3. 运⾏的过程中给类绑定(添加)属性

4. 运⾏的过程中给类绑定(添加)⽅法

5. 运⾏的过程中删除属性、⽅法

__slots__

迭代器

1. 可迭代对象

3.迭代器

4.iter()函数

总结

slots