Python程序设计-第七章.ppt

1、2020/7/9,1,Python程序设计Programming in Python,主讲：庞胜利,2020/7/9,2,第七章 面向对象编程,面向对象的基本概念 类定义 类对象 实例对象 方法对象 继承 私有成员 运算符重载 Python的对象与名字绑定,2020/7/9,3,面向对象的基本概念,(1)对象 对象是人们要进行研究的任何事物，从最简单的整数到复杂的飞机等均可看作对象，它不仅能表示具体的事物，还能表示抽象的规则、计划或事件。 (2)对象的状态和行为 对象具有状态，一个对象用数据值来描述它的状态。 对象还有操作，用于改变对象的状态，对象及其操作就是对象的行为。 对象实现了数据和操作

2、的结合，使数据和操作封装于对象的统一体中,2020/7/9,4,面向对象的基本概念,(3)类 具有相同或相似性质的对象的抽象就是类。因此，对象的抽象是类，类的具体化就是对象，也可以说类的实例是对象。 类具有属性，它是对象的状态的抽象，用数据结构来描述类的属性。 类具有操作，它是对象的行为的抽象，用操作名和实现该操作的方法来描述。 (4)类的结构 在客观世界中有若干类，这些类之间有一定的结构关系。通常有两种主要的结构关系，即一般-具体结构关系，整体-部分结构关系。 一般-具体结构称为分类结构，也可以说是“或”关系，或者是“is a”关系。 整体-部分结构称为组装结构，它们之间的关系是一种“与”关

3、系，或者是“has a”关系。,2020/7/9,5,面向对象的基本概念,(5)消息和方法 对象之间进行通信的结构叫做消息。在对象的操作中，当一个消息发送给某个对象时，消息包含接收对象去执行某种操作的信息。 发送一条消息至少要包括说明接受消息的对象名、发送给该对象的消息名（即对象名、方法名）。一般还要对参数加以说明，参数可以是认识该消息的对象所知道的变量名，或者是所有对象都知道的全局变量名。 类中操作的实现过程叫做方法，一个方法有方法名、参数、方法体。,2020/7/9,6,面向对象的特征,(1)对象唯一性 每个对象都有自身唯一的标识，通过这种标识，可找到相应的对象。在对象的整个生命期中，它的

4、标识都不改变，不同的对象不能有相同的标识。 (2)抽象性 分类性是指将具有一致的数据结构(属性)和行为(操作)的对象抽象成类。一个类就是这样一种抽象，它反映了与应用有关的重要性质，而忽略其他一些无关内容。任何类的划分都是主观的，但必须与具体的应用有关。,2020/7/9,7,面向对象的特征,(3)继承性 继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。 继承性是面向对象程序设计语言不同于其它语言的最重要的特点，是其他语言所没有的。 在类层次中，

5、子类只继承一个父类的数据结构和方法，则称为单重继承。 在类层次中，子类继承了多个父类的数据结构和方法，则称为多重继承。 在软件开发中，类的继承性使所建立的软件具有开放性、可扩充性，这是信息组织与分类的行之有效的方法，它简化了对象、类的创建工作量，增加了代码的可重性。 采用继承性，提供了类的规范的等级结构。通过类的继承关系，使公共的特性能够共享，提高了软件的重用性。,2020/7/9,8,面向对象的特征,(4)多态性(多形性) 多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得不同的结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。 多态性允许每个对象以适合自身的

6、方式去响应共同的消息。 多态性增强了软件的灵活性和重用性,2020/7/9,9,类定义语法,最简单的类定义形式如下： 类的定义语句（class）和函数定义语句（def）一样，执行后才能生效；当然也可以放到if语句的某个分支，或一个函数的内部,class ClassName: . . . ,2020/7/9,10,类定义,习惯上，类定义语句的内容通常是函数定义，不过其它任何语句也可以 定义一个类的时候，会创建一个新的命名空间，将其作为局部作用域使用，因此，所有对局部变量的赋值都引入新的命名空间。特别是函数定义将新函数的命名绑定于此。 类定义完成时（正常退出），就创建了一个类对象。基本上它是对类定

7、义创建的命名空间进行了一个包装。原始的局部作用域（类定义引入之前生效的那个）得到恢复，类对象在这里绑定到类定义头部的类名。（参考class1.py),2020/7/9,11,类定义,class Class1: This is my first class! print class1 go #类定义中可以是任意语句 name = my class 1 #赋值语句会在当前类的命名空间中引入新的对象 def PrintName(self): #函数定义 print hello print type(Class1) print dir(Class1), class1 go PrintName, _do

8、c_, _module_, name,2020/7/9,12,类对象,类对象支持两种操作：属性引用和实例化。 属性引用使用和Python 中所有的属性引用一样的标准语法：。类对象创建后，类命名空间中所有的命名都是有效属性名。所以如果类定义如上页所示，则Class1.Name和Class1.PrintName都是有效的属性引用，分别返回一个整数和一个方法对象。也可以对类属性赋值，可以通过给C赋值来修改它。 _doc_也是一个有效的属性，返回类的文档字符串：类定义行下的第一个字符串“This is my first class!”。,2020/7/9,13,类对

9、象,类的实例化使用函数符号。只要将类对象看作是一个返回新的类实例的无参数函数即可： 以上创建了一个新的类实例并将该对象赋给局部变量x,x = Class1(),2020/7/9,14,类对象,上面这个实例化操作（“调用”一个类对象）来创建了一个空的对象。很多类都倾向于将对象创建为有初始状态的情况。因此类可能会定义一个名为_init_()的特殊方法，像下面这样： 类定义了_init_() 方法的话，类的实例化操作会自动为新创建的类实例调用_init_() 方法。,def _init_(self): self.data = ,2020/7/9,15,类对象,当然，出于弹性的需要，_init_()

10、方法可以有参数。事实上，参数通过_init_() 传递到类的实例化操作上。例如：,class Complex: def _init_(self, realpart, imagpart): self.r = realpart self.i = imagpart x = Complex(3.0, -4.5) print x.r, x.i,Dbg 3.0 -4.5,2020/7/9,16,实例对象,实例对象唯一可用的操作就是属性引用。有两种有效的属性名。 第一种称作数据属性。和局部变量一样，数据属性不需要声明，第一次使用时它们就会生成，并绑定到对象命名空间。例如，如果x是前面创建的Class1实例：

11、, = my complex print dir(x) print ,_doc_, _init_, _module_, i, name, r my complex,2020/7/9,17,实例对象,第二种为实例对象所接受的引用属性是方法。方法是属于一个对象的函数。 实例对象有效的方法名称依赖于它的类。按照定义，类中所有（用户定义）的函数对象对应到它的实例中的方法。所以在上面的例子中，x.PrintName是一个有效的方法引用，因为Class1.PrintName是一个函数定义。但不是，因为C不是函数。不过x.PrintName与Class

12、1.PrintName不同，它是一个方法对象，不是一个函数对象。,2020/7/9,18,方法对象,通常方法可以由对象直接调用： x.PrintName() 然而，也不是一定要直接调用方法。x.PrintName是一个方法对象，它可以存储起来以后调用。例如：,f = x.PrintName f(),2020/7/9,19,方法对象,调用方法时发生了什么？我们注意到调用x.PrintName()时并没有给出函数定义中所要求的self参数，但并没有出错。 这个参数怎么了？事实上如果函数调用中缺少参数，Python 会抛出异常甚至这个参数实际上没什么用 实际情况：方法的特别之处在于实例对象作为函数的

13、第一个参数传给了函数。在例子中，调用x.PrintName()相当于Class1.PrintName(x)。通常，以有n个参数的参数列表去调用一个方法就相当于将方法的实例对象插入到参数列表的最前面，然后再以这个列表去调用相应的函数。,2020/7/9,20,方法对象的实现,实例对象在实例化时，会从类拷贝(其实应该是继承)所有的数据属性；对于非数据属性，不是简单的拷贝，而是封装：即将实例对象和函数对象封装进一个抽象对象，这就是方法对象。 以一个参数列表调用方法对象时，它被重新拆封，用实例对象和原始的参数列表构造一个新的参数列表，然后函数对象调用这个新的参数列表。,2020/7/9,21,clas

14、s Class1: print class1 go #类定义中可以是任意语句 name = my class 1 #赋值语句会在当前类的命名空间中引入新的对象 def PrintName(self): #函数定义 print + :hello a = Class1() x = Class1() print (C, , ) = a name = x name print (C, , ) print Class1.PrintName print a.PrintNa

15、me print x.PrintName print id(Class1.PrintName), id(a.PrintName), id(x.PrintName) a.PrintName() x.PrintName() Class1.PrintName(),class1 go (my class 1, my class 1, my class 1) (my class 1, a name, x name) 46142488 46142488 46142488 a name:hello x name:hello Traceback (most recent call last): File ,

16、line 245, in run_nodebug File E:教学工作教案Python程序设计classmethod.py, line 30, in Class1.PrintName() TypeError: unbound method PrintName() must be called with Class1 instance as first argument (got nothing instead),2020/7/9,22,class Class1: print class1 go #类定义中可以是任意语句 name = my class 1 #赋值语句会在当前类的命名空间中引入

17、新的对象 def PrintName(self): #函数定义 print + :hello a = Class1() x = Class1() print (C, , ) = a name = x name print (C, , ) print Class1.PrintName print a.PrintName print x.PrintName print id(Class1.PrintName), id(a.PrintName), id(x.Prin

18、tName) a.PrintName() x.PrintName() Class1.PrintName(a),class1 go (my class 1, my class 1, my class 1) (my class 1, a name, x name) 46143408 46143408 46143408 a name:hello x name:hello a name:hello,2020/7/9,23,继承,派生类的定义如下： 基类名BaseClassName必须与派生类定义在一个作用域内。也可以使用表达式作为基类，这对于想用其他模块的类作为基类非常有用：,class Derive

19、dClassName(BaseClassName): . . . ,class DerivedClassName(modname.BaseClassName):,2020/7/9,24,继承,派生类定义的执行过程和基类是一样的。构造派生类对象时，就记住了基类。这在解析属性引用的时候尤其有用：如果在类中找不到请求调用的属性，就搜索基类。如果基类是由别的类派生而来，这个规则会递归的应用上去。,2020/7/9,25,继承,派生类的实例化没有什么特殊之处：DerivedClassName()创建一个新的类实例 方法引用按如下规则解析：搜索对应的类属性，必要时沿基类链逐级搜索，如果找到了函数对象这个方

20、法引用就是合法的,2020/7/9,26,重载,派生类可能会覆盖其基类的方法重载 派生类中的方法覆盖基类的方法可能是想要扩充而不是简单的替代基类中的重名方法。 有一个简单的方法可以直接调用基类方法，只要调用：BaseClassName.methodname(self,arguments) 有时这对于客户程序也很有用。（要注意的是只有基类在同一全局作用域定义或导入时才能这样用）,2020/7/9,27,重载,class BaseClass: def _init_(self): = base class def PrintName(self): print

21、+ :hello class ChildClass(BaseClass): def PrintName(self): BaseClass.PrintName(self) print Class2 hello x = ChildClass() x.PrintName(),Dbg base class:hello Class2 hello,2020/7/9,28,多重继承,在class语句中，首行括号内可以列出一个以上的基类，这就是多重继承：类和其实例继承了列出的所有基类的成员 搜索属性时，Python会由左至右搜索类首行中的基类，直到找到相符者。从严格意义上来说，搜索以深度优先法进行，一路走向继

22、承树顶端，而且由左至右，因为任何基类本身可能还有一些其他的基类,2020/7/9,29,私有成员,在C+等OOP语言中有私有成员的概念，私有成员只能被类的内部方法调用。 Python 对类的私有成员只提供了有限的支持。任何成员的名称如果以两个下划线开始，并且不是以两个下划线结束，则此成员就是私有的；其余成员都是公有的。 任何形如_spam的成员随即都被替代为_classname_spam，防止在类/对象外部以x._spam的形式访问,2020/7/9,30,class BaseClass: def _init_(self): = base class self._id= 1

23、00 def PrintName(self): print + :hello print str(self._id) x = BaseClass() print x._dict_.keys() x.PrintName() print x._id,Dbg name, _BaseClass_id base class:hello 100 Traceback (most recent call last): File , line 129, in run File D:Python26Libbdb.py, line 372, in run exec cmd in globals,

24、 locals File E:教学工作教案Python程序设计classprivate.py, line 14, in print x._id AttributeError: BaseClass instance has no attribute _id,2020/7/9,31,运算符重载,虽然我们可以把所有类行为实现为方法函数，运算符重载则让对象和Python的对象模型更紧密的结合起来 使用运算符重载，可以让对象行为就像内置对象那样，这可促进对象接口更为一致并更易于学习，而且可让类对象由预期的内置类型接口的代码处理,2020/7/9,32,运算符重载的主要概念,以双下划线开始和结束命名的函数

25、方法（_x_)是特殊钩子 Python运算符重载的实现是提供特殊命名的方法来拦截运算。Python语言替每种运算和特殊命名的方法之间，定义了固定不变的映射关系 当实例对象出现在内置运算时，对应的运算符重载方法会自动调用 如，如果实例对象实现了_add_方法，当对象出现在+表达式内时，该方法就会调用，而该方法的返回值会变成相应表达式的结果,2020/7/9,33,运算符重载的主要概念,类可覆盖多数内置类型运算 有几十种特殊运算符重载的方法的名称，几乎可拦截并实现内置类型的所有运算，它不仅包括了表达式，而且像打印和对象建立这类基本运算也包括在内 运算符覆盖方法没有默认值，而且也不需要 如果类没有定

26、义或继承运算符重载方法，就是说如果相应的运算在类实例中并不支持。例如，如果没有_add_方法，+表达式就会引发异常 运算符可让类和Python的对象模型集成 重载类型运算时，以类实现的用户定义对象的行为就像内置对象一样，因此，提供了操作的一致性，以及与期望的接口的兼容性,2020/7/9,34,2020/7/9,35,_add_和_str_,_add_(self, other) _str_(self),class BaseClass: def _init_(self, data): self.data = data def _add_(self, data): return BaseClass

27、(self.data + data) def _str_(self): return data: + str(self.data) x = BaseClass(10) x1 = x + 100 print x1.data print x1, 110 data:110,2020/7/9,36,_getitem_和_setitem_,_getitem_(self, key) _setitem_(self, key, value), 9 3: 100 9,class BaseClass: def _init_(self): self.data = def _getitem_(self, key):

28、return key*2 def _setitem_(self, key, value): self.datakey = value x = BaseClass() print x3 x3 = 100 print x.data print x3,2020/7/9,37,_getattr_,_getattr_(self, name),class BaseClass: data = def _getattr_(self, name): return BaseClass def _setattr_(self, name, value): self.data.append(name:value) x

29、= BaseClass() print print x.id = Python print x.data, BaseClass BaseClass name: Python,2020/7/9,38,_call_,_call_(self, args),class BaseClass: def _call_(self, arg): return arg*2 x = BaseClass() print x(3) print x(4), 9 16,2020/7/9,39,Python的对象与名字绑定,i = 1 这是一个再简单不过的赋值语句，即便是才开始学习编程的新手也能脱

30、口而出它的含义 - “设置变量i的值为1”。 i = 2 “将变量i的值改为2”，当看到接下来这行代码时，你脑海中肯定会立即浮现这样的念头。 这难道会有问题嘛？这简简单单的一行赋值语句其实包含了python中的三个重要概念：名字、绑定和对象。 python对赋值语句作出了自己的定义： “赋值语句是用来将名字绑定（或重新绑定）到某个对象的操作，而且它也可用来修改可变对象的属性或对象中所包含的成员。” 名字绑定到对象这个概念在python中随处可见，可以说是python的最基本而且最重要的概念之一。如果没有很好理解这一点，一些意想不到的结果就会在您的代码中悄然出现。,2020/7/9,40,1.对

31、象,“万物皆对象”(Everything is object)，这是python这种面向对象语言所倡导的理念。在C+中，1只是一个整型数，而不是一个对象。但在python中，1却是一个实实在在的对象，可以用dir(1)来显示它的属性。 在python中，所有对象都有下面三个特征： * 唯一的标识码(identity) * 类型 * 内容（或称为值） 一旦对象被创建，它的标识码就不允许更改。对象的标识码可以由内建函数id()获取，它是一个整型数。可以将它想象为该对象在内存中的地址，其实在目前的实现中标识码也就是该对象的内存地址。,2020/7/9,41,1.对象,46746200 = 0 x02

32、C94A58 这就是前面提到的1这个对象的标识码，也就是它在内存中的地址。, class c1: . pass . obj = c1() obj id(obj) 46746200, id(1) 44882312,2020/7/9,42,1.对象,当用is操作符比较两个对象时，就是在比较它们的标识码。更确切地说，is操作符是在判断两个对象是否是同一个对象 1 is 1 其结果是False，是因为这是两个不同的对象，存储在内存中的不同地方。 1 = 1 其结果是True，是因为这两个不同的对象有着相同的值。,2020/7/9,43,1.对象,与对象的标识码类似，对象的类型也是不可更改的。可以用内建

33、函数type()取得对象的类型。 有的对象的值是可以改变的，这类对象叫作可变对象；而另外一些对象在创建后其值是不可改变的（如1这个对象），这类对象叫作恒定对象（不可变对象）。对象的可变性是由它的类型决定的，比如数值型(number)、字符串型(string)以及序列型(tuple)的对象是恒定对象；而字典型(dictionary)和列表型(list)的对象是可变对象。 除了上面提到的三个特征外，一个对象可能： * 没有或者拥有多个方法 * 没有或者有多个名字,2020/7/9,44,2.名字,名字是对一个对象的称呼，一个对象可以只有一个名字，也可以没有名字或取多个名字。但对象自己却不知道有多少

34、名字，叫什么，只有名字本身知道它所指向的是个什么对象。给对象取一个名字的操作叫作命名，Python将赋值语句认为是一个命名操作（或者称为名字绑定）。 名字在一定的名字空间内有效，而且唯一，不可能在同一个名字空间内有两个或更多的对象取同一名字。 让我们再来看看第一个例子：i = 1。在Python中，它有如下两个含义： * 创建一个值为1的整型对象 * i是指向该整型对象的名字（而且它是一个引用）,2020/7/9,45,3.绑定,如上所述，绑定就是将一个对象与一个名字联系起来。更确切地讲，就是增加该对象的引用计数。众所周知，C+中一大问题就是内存泄漏，即动态分配的内存没有能够回收，而解决这一问

35、题的利器之一就是引用计数。Python就采用了这一技术实现其垃圾回收机制。 python中的所有对象都有引用计数，引用计数为零则清除此对象 i=i+1 * 这创建了一个新的对象，其值为i+1。 * i这个名字指向了该新建的对象，该对象的引用计数加一，而i以前所指向的老对象的引用计数减一。 * i所指向的老对象的值并没有改变。 * 这就是为什么在python中没有+、-这样的单目运算符的一个原因。,2020/7/9,46,4.引用计数,对象的引用计数在下列情况下会增加： * 赋值操作 * 在一个容器（列表，序列，字典等等）中包含该对象 对象的引用计数在下列情况下会减少： * 离开了当前的名字空间

36、（该名字空间中的本地名字都会被销毁） * 对象的一个名字被绑定到另外一个对象 * 对象从包含它的容器中移除 * 名字被显示地用del销毁（如：del i） 当对象的引用计数降到0后，该对象就会被销毁，其所占的内存也就得以回收。,2020/7/9,47,5.名字绑定的奇特现象,这里li1与li2都指向同一个列表对象7, 8, 9, 10，“li1 = 16”是改变该列表中的第2个元素，所以通过li2时同样会看到这一改动。, li1 = 7, 8, 9, 10 li2 = li1 li11 = 16 print li2 7, 16, 9, 10,2020/7/9,48,5.名字绑定的奇特现象,例1

37、 例2 在有的Python书中讲到乘法符号（*）就相当于几个加法的重复，即认为上面两个例子的结果一致。 其实不然。例1中的b这个列表中的每一个元素g: 1其实都是同一个对象，可以用id(bn)进行验证。而例2中则是四个不同的对象。 上面都是针对于列表或字典可变对象，对于恒定对象而言，“*”和连续加法的效果一样。比如，b=1 * 4 就等同于 b=1+1+1+1。, b = g:1*4 print b g: 1, g: 1, g: 1, g: 1 b0g = 2 print b g: 2, g: 2, g: 2, g: 2, b = g:1 + g:1 + g:1 + g:1 print b g

38、: 1, g: 1, g: 1, g: 1 b0g = 2 print b g: 2, g: 1, g: 1, g: 1,2020/7/9,49,5.函数的传参问题,函数的参数传递也是一个名字与对象的绑定过程，而且是绑定到另外一个名字空间（即函数体内部的名字空间）。 Python对赋值语句的独特看法又会对函数参数的传递造成什么影响呢？,2020/7/9,50,5.1 传值？传址？,在学习C+的时候我们都知道有两种参数传递方式：传值和传址。而在Python中所有的参数传递都是引用传递（pass reference），也就是传址。这是由于名字是对象的一个引用这一Python的特性而自然得来的，在函

39、数体内部对某一外部可变对象作了修改肯定会将其改变带到函数以外。让我们来看看下面这个例子： 因此，在python中，我们应该抛开传递参数这种概念，时刻牢记函数的调用参数是将对象用另外一个名字空间的名字绑定。在函数中，不过是用了另外一个名字，但还是对这同一个对象进行操作。, a = 1, 2, 3 def foo(par): . par1 = 10 . foo(a) print a 1, 10, 3,2020/7/9,51,5.2 缺省参数,使用缺省参数，是我们喜爱的一种做法。这可以在调用该函数时节省不少的击键次数，而且代码也显得更加简洁。更重要的是它从某种意义上体现了这个函数设计的初衷。 但是P

40、ython中的缺省参数，却隐藏着一个玄机，初学者肯定会在上面栽跟头，而且这个错误非常隐秘。先看看下面这个例子：,2020/7/9,52,5.2 缺省参数,出了什么问题？这个参数par好像类似于C中的静态变量，累计了以前的结果。是这样吗？当然不是，这都是“对象、名字、绑定”这些思想惹的“祸”。“万物皆对象”，这里，函数foo当然也是一个对象，可以称之为函数对象（与一般的对象没什么不同）。先来看看这个对象有些什么属性。, def foo(par=): . par.append(0) . print par . foo() 0 foo() 0, 0 ,2020/7/9,53, dir(foo) _c

41、all_, _class_, _closure_, _code_, _defaults_, _delattr_, _dict_, _doc_, _format_, _get_, _getattribute_, _globals_, _hash_, _init_, _module_, _name_, _new_, _reduce_, _reduce_ex_, _repr_, _setattr_, _sizeof_, _str_, _subclasshook_, func_closure, func_code, func_defaults, func_dict, func_doc, func_globals, func_name,2020/7/9,54,5.2 缺省参数,单从名字上看，“func_defaults”很可能与缺省参数有关，查看它的值： 果不其然，就是这个序列对象（tuple)包含了所有的缺省参数，而且它是函数对象的属性，函数对象产生的时候它就一直存在, foo.func_defaults # 显示这个属性的内容 (0, 0,) foo() # 第三次调用 0, 0, 0 foo.func_defaults # 再来看看这个属性 (0, 0, 0,),2020/7/9,55,5.2 缺省