Python程序设计第8章-程序开发进阶课件.pptx

1、2022-6-9第第8章章 程序开发进阶程序开发进阶目录目录2022-6-928.1. 面向对象程序开发进阶8.2. 函数式编程8.3. 多线程编程2022-6-98.1 面向对象程序设计进阶在这一节中，我们将更深入地学习Python对面向对象的支持，学习一些技术以合理减少必须编写的代码总量，并扩展程序功能。2022-6-98.1 面向对象程序设计进阶8.1.1 控制属性存取有时候，类属性的值在运算时被计算出来要比预先存储更加方便，下面给出一个这种类的完整实现。 class Ord:def _getattr_(self, char):return ord(char) ord()是以个Pytho

2、n内置函数，返回代表一个Unicode字符的数字值。当Ord类被定义后，我们可以创建一个实例，ord = Ord()，这样我们就得到了内置ord()函数的替代品。例如，ord.a返回97，ord.A返回65。（但ord.!以及类似的用法会出现语法错误。）2022-6-98.1 面向对象程序设计进阶8.1.1 控制属性存取如果直接在Python运行环境，如IDLE中输入Ord类的定义，之后试图执行ord = Ord()，则不能正确工作。这是因为实例与Ord类中使用的ord()内置函数重名，因此，ord()调用实际上变成了对ord实例的调用，并导致TypeError异常。但如果我们引入包含Ord类

3、的模块，则不会出现这个问题。因为交互式创建的ord对象与Ord类使用的ord()函数分别存在于两个模块中，彼此不会互相替代。如果我们确实要交互式地创建一个类并需要重用某个内置对象的名称，就必须确保该类调用的是内置对象，这里可以通过导入builtins模块来提供对所有内置函数无歧义的访问。在代码中调用builtins.ord()来替代ord()。2022-6-98.1 面向对象程序设计进阶8.1.2 函子在计算机科学中，函子（Functor）是指一个对象，该对象可以像普通的函数一样被调用。由于Python的函数本身就是对象，所以在Python中，函子可以被理解为另外一种函数对象。任何含有_cal

4、l()_特殊方法的类都是函子。使用函子的主要好处是，可以维护一些状态信息。我们也可以用普通函数完成同样的任务，但如果我们同时需要存储一些状态信息，或者进行更复杂的处理，函子通常是正确的选择2022-6-98.1 面向对象程序设计进阶8.1.2 函子下面创建了一个函子，功能是除去字符串末尾的基本标点符号。其创建和使用格式如下。strip_punctuation = Strip(,;:.!?)strip_punctuation(whoops!) #返回: whoops 这里我们创建了一个Strip函子的实例，并用值“,;:.!?”将其初始化。当这个实例被调用时，都会返回作为参数的字符串，并除去其末

5、尾的标点符号。下面给出Strip类的完整实现。class Strip:def _init_(self, characters):self.characters = charactersdef _call_(self, string):return string.strip(self.characters)。2022-6-98.1 面向对象程序设计进阶8.1.3 上下文管理器使用上下文管理器（Context Manager）可以简化代码，这是通过确保某些操作在特定代码块执行前与执行后再进行来实现的。之所以能实现这种操作，是因为上下文管理器定义了两个特殊的方法_enter_()和_exit_()，

6、在with语句的范围类，Python会对其进行特别处理。当一个上下文管理器在with语句中创建时，它的_enter_()方法会自动被调用。当上下文管理器超出其作用范围时，到了with语句之外时，其_exit_()方法将自动被调用。2022-6-98.1 面向对象程序设计进阶8.1.3 上下文管理器我们可以自定义上下文管理器，或者使用预定义的上下文管理器。调用内置的open()函数所返回的文件对象就是上下文管理器。使用上下文管理器的语法如下： with expression as variable:suite2022-6-98.1 面向对象程序设计进阶8.1.4 描述符描述符（Descripto

7、r）也是类，用于为其他类的属性提供访问控制。实现了一个或多个描述符特殊方法（例如_get_()，_set_()和_delete_()）的任何类都可以被称为（也可以用作）描述符。内置的property()与classmethod()函数都是使用描述符实现的。理解描述符的关键是：尽管在类中创建描述符的实例时将其作为一个类属性，但是Python在访问描述符时是通过类的实例进行的。2022-6-98.1 面向对象程序设计进阶8.1.4 描述符假定有一个类，其实例存放一些字符串。并且需要的时候可以获取字符串的XML转义处理后的版本。此处创建一个描述符，以便根据需要提供XML转义处理后的字符串，而又不需要

8、对其进行存储。描述符的类如下： class Product:_slots_ = (_name, _description, _price)name_as_xml = XmlShadow(name)description_as_xml = XmlShadow(description) def _init_(self, name, description, price):self._name = nameself.description = descriptionself.price = price2022-6-98.1 面向对象程序设计进阶8.1.4 描述符现在考察另外一种描述符，该描述符可用于

9、存储某个对象的所有属性数据，对象本身则不再需要存储任何内容。在该实例中，我们仅使用一个字典来进行存储。下面给出使用了描述符修改后的Point类的开头。class Point:_slots_ = ()x = ExternalStorage(x)y = ExternalStorage(y) def _init_(self, x=0, y=0):self.x = xself.y = y 通过将slots设置为一个空元组，可以保证类不会存储任何数据属性。2022-6-98.1 面向对象程序设计进阶8.1.5 抽象基类抽象基类（Abstract Base Class）也是一个类，但这个类不能用于创建对象

10、。使用抽象基类的目的是为了定义接口（Interface）。抽象基类会列出一些方法与特性，而继承自抽象基类的类必须对其进行实现。这是种很有用的机制，因为我们可以将抽象基类当作一种保证，确保任何自抽象基类衍生而来的类均会实现抽象基类指定的方法与特性。抽象基类中包含至少一种抽象方法或特性，抽象方法在定义时可以不实现（其suite为pass，或者产生一个NotImplementedError异常，以强制子类对其重新实现），也可以包含具体的实现。抽象基类也可以包含其他具体的（非抽象）方法与特性。2022-6-98.1 面向对象程序设计进阶8.1.5 抽象基类只有在实现了所有继承而来的抽象方法与抽象特性之

11、后，从抽象基类衍生而来的类才可以创建实例。对与那些已经包含具体实现的抽象方法，衍生类可以简单地使用super()来调用基类的实现版本。与通常一样，任何具体方法与特性都可以通过继承获取。所有抽象基类必须包含元类（Metaclass）abc.ABCMeta（来自abc模块），或来自其某个子类。2022-6-98.1 面向对象程序设计进阶8.1.6 多继承多继承是指某个类继承自两个或多个类。Python完全支持多继承。多继承存在的问题是，可能导致同一个类被继承多次（比如一个类中某两个基类继承自同一个类）。这意味着，某个被调用的方法如果不在子类中，而是在两个或多个基类中（或基类的基类中），那么被调用方

12、法的具体版本取决于方法的解析顺序，从而使得使用多继承得到的类存在模糊的可能。2022-6-98.1 面向对象程序设计进阶8.1.6 多继承声明多继承的方式与单继承类似。 class Base1:pass class Base2:pass class MultiDerived(Base1, Base2):pass MultiDerived类继承自类Base1和Base2，并同时拥有这两个类的特性。为了保证多继承中调用方法的正确性，我们有必要考察Python中方法的解析顺序。2022-6-98.1 面向对象程序设计进阶8.1.6 多继承有一套规则用于找到类中方法的解析顺序，被称为方法解析顺序（MR

13、O），MRO保证一个类总是在它的基类之前出现。一个类的MRO可以通过_mro_属性或mro()方法查看，前者返回一个元组，后者返回一个列表： MultiDerived._mro_(,) MultiDerived.mro(),2022-6-98.1 面向对象程序设计进阶8.1.7 元类元类之于类，就像类之于实例。也就是说，元类用于创建类，正如类用于创建实例一样。元类最简单的用途就是自定义抽象基类，正如我们在前面所看到的那样。不同于很多编程语言，Python的类也是对象，当使用关键字class后，Python会执行它，并创建一个对象。下面的代码在内存中创建了一个名为“ObjectCreator”的

14、类。 class ObjectCreator(object): pass 这个类对象自身可以创建对象，即类的实例，但它本身是一个对象，所以我们可以对其进行赋值、添加属性或将其作为函数的参数。2022-6-98.1 面向对象程序设计进阶8.1.7 元类更进一步，我们能够动态创建类，就如同创建其他对象一样，我们可以用class关键字来创建类。 def choose_class(name): if name = foo: class Foo(object): pass return Foo else: class Bar(object): pass return Bar 2022-6-98.1 面向

15、对象程序设计进阶8.1.7 元类因为类也是对象，所以必定存在一个工具，用来创建类。当我们使用class关键字时，Python自动创建了对象，但正如许多Python的其他特性，有一种方法也可以让我们手动创建这个对象。type()函数有一种完全不同的功能，即可以动态地创建类。我们可以将类的描述作为参数传递给type()函数，然后得到一个类的返回值。 所以，类： class MyClass(object): bar = True 可以用以下的方式创建。 MyClass = type(MyClass , (), bar:True) 目录目录2022-6-928.1. 面向对象程序开发进阶8.2. 函数

16、式编程8.3. 多线程编程2022-6-98.2 函数式编程函数是Python内建支持的一种封装，我们通过把大段代码拆成函数，通过一层一层的函数调用，就可以把复杂任务分解成多个简单的任务，这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。函数式编程（Functional Programming），其思想更接近数学计算，抽象度较高。函数式编程就是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，对任意一个函数，只要输入是确定的，输出就是确定的。而允许使用变量的程序设计语言，由于函数内部的变量状态不确定，同样的输入，可能得到不同的输出，因此，这种函

17、数是有副作用的。函数式编程的一个特点就是，允许把函数本身作为参数传入另一个函数，甚至还允许返回一个函数。2022-6-98.2 函数式编程8.2.1 高阶函数要理解高阶函数（Higher-order function），首先要对Python中的函数概念有正确的理解。由于Python中一切都是对象，所以可以让一个变量指向函数。在Python中，我们不仅可以把函数调用的结果赋值给变量，也可以把函数本身赋值给变量。 f = abs f 然后通过这个变量来调用函数： f(-10)102022-6-98.2 函数式编程8.2.1 高阶函数变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一

18、个函数作为参数，这种函数就称之为高阶函数。一个简单的高阶函数代码如下。 def add(x, y, f):return f(x) + f(y) 当我们调用add(-2, 6, abs)时，参数x，y和f分别接收-2，6和abs，根据函数定义，我们知道实际的计算为：abs(-2)+abs(6) =2+6=8。可以输入以下代码进行验证。 add(-2, 6, abs)82022-6-98.2 函数式编程8.2.2 闭包通常我们把定义在一个函数里的函数称为嵌套函数，下面是一个简单嵌套函数的定义。 def print_msg(msg):This is the outer enclosing funct

19、ion def printer():This is the nested functionprint(msg) returnprinter 2022-6-98.2 函数式编程8.2.2 闭包我们将嵌套的printer函数作为返回值返回，然后我们尝试调用这个函数。 f = print_msg(Hello) f()Hello print_msg()函数被调用，并接收参数“Hello”，返回的函数被赋值给f。当我们调用f()时，传入的参数“Hello”仍然被保存着，即使print_msg()函数的执行已经结束。在外部函数（ Enclosing Function）作用域里的数据“Hello”，即便在超

20、出作用域后仍然被保存着。这种把某些数据与函数关联在一起的技术在Python中被称为闭包（Closure）。 2022-6-98.2 函数式编程8.2.2 闭包创建一个闭包所需要具备的条件：必须有一个嵌套函数。嵌套函数必须应用一个在外部函数中定义的值。外部函数必须将嵌套函数作为返回值返回。闭包可以提供一些数据隐藏的方式，也可用来减少全局数据的使用。另外，闭包为一些问题提供了更符合面向对象思想的解决方案。2022-6-98.2 函数式编程8.2.3 匿名函数当我们传入函数作为参数时，有些时候并不需要显式地定义函数，直接传入匿名函数更方便。匿名函数在Python中被称为lambda函数。在Pytho

21、n中，对匿名函数提供了有限的支持。还是以map()函数为例，为了计算f(x)=x2，除了定义一个f(x)的函数外，还可以在参数中直接传入匿名函数： list(map(lambda x: x * x, 1, 2, 3, 4, 5, 6, 7, 8, 9)1, 4, 9, 16, 25, 36, 49, 64, 81 2022-6-98.2 函数式编程8.2.3 匿名函数关键字lambda表示匿名函数，冒号前面的x表示函数参数。使用匿名函数会受到一些限制，只能有一个表达式，但也不用写return，返回值就是该表达式的结果。因为函数没有名字，匿名函数也带来一个好处：不必担心函数名冲突。此外，匿名函数

22、也是一个函数对象，也就是说可以把匿名函数赋值给一个变量，再利用变量来调用该函数： f = lambda x: x * x ffunction at 0 x101c6ef28 f(5)25 同样，也可以把匿名函数作为返回值返回。 2022-6-98.2 函数式编程8.2.4 修饰器Python中，我们可以使用修饰器（Decorator）为现有的代码添加功能。这种使用一部分程序在编译时改变剩余部分程序的技术，被称为元编程（Metaprogramming）。为了理解修饰器，我们必须再次强调一个概念，即Python中一切都是对象，包括函数。所以函数也可以作为另一个函数的返回值或参数。函数和方法通常被称

23、为可调用对象（Callable），事实上，任何实现了_call_()方法的对象都是可调用对象。修饰器就是一个返回值是可调用对象的可调用对象。一个基本的修饰器接收一个函数，然后向其添加功能，最后返回这个函数。2022-6-98.2 函数式编程8.2.4 修饰器下面的代码中定义了一个简单的修饰器make_pretty：def make_pretty(func):def inner():print(I got decorated)func()return inner def ordinary():print(I am ordinary) 2022-6-98.2 函数式编程8.2.4 修饰器 运行代码

24、的结果如下： ordinary()I am ordinary pretty = make_pretty(ordinary) pretty()I got decoratedI am ordinary2022-6-98.2 函数式编程8.2.4 修饰器通常我们会把原函数重新赋值为修饰器返回的函数： ordinary = make_pretty(ordinary) 在Python中，有一个语法能简化这个操作，可以通过把符号加修饰器的名称放在需要修饰的函数上方来实现，例如：make_prettydef ordinary():print(I am ordinary) 与下面的代码是等效的：def ord

25、inary():print(I am ordinary)ordinary = make_pretty(ordinary) 2022-6-98.2 函数式编程8.2.5 偏函数偏函数（Partial Function）是指使用现存函数以及某些参数来创建函数，新建函数与原函数执行的功能相同，但是某些参数是固定的，因此调用者不需要传递这些参数。要注意的是，这里的偏函数和数学意义上的偏函数不一样。Python的functools模块提供了偏函数功能。在编写函数时，可以通过设定参数的默认值，降低函数调用的复杂度。使用偏函数也可以做到这一点。2022-6-98.2 函数式编程8.2.5 偏函数例：int(

26、)函数可以把字符串转换为整数，默认按参数为十进制进行转换，并输出十进制的整数。 int(1234)1234 int()函数还提供额外的base参数，默认值为10。如果传入base参数“base=N”就可以将参数字符串视为N进制数进行转换，并仍然输入十进制结果。 假设我们要转换大量的二进制字符串，但每次都传入int(x, base=2)非常麻烦，此时我们就可以定义一个int2()的函数，默认把base=2作为参数。 def int2(x, base=2):return int(x, base)目录目录2022-6-928.1. 面向对象程序开发进阶8.2. 函数式编程8.3. 多线程编程2022

27、-6-98.3 多线程编程在本节中，我们将讨论在一些在代码中进行并行处理的方法。首先我们会讨论进程和线程的概念以及两者的区别。接下来我们会介绍在Python中使用多线程编程的方法，并给出一些代码。在本章的最后，将介绍一个使用threading模块实现的Python多线程编程的例子。2022-6-98.3 多线程编程8.3.1 多线程的编程动机在多线程编程出现前，计算机程序被分成多个步骤，由CPU一步一步地按序执行。在需要保证一个任务中每步都按顺序执行时，这种方法是自然而合理的。然而当一个任务可以被分成多个子任务，并且这些子任务相互独立时，我们更希望这些任务能够并行执行，这样的并行处理可以大幅度

28、地提升整个任务的效率。这就是多线程编程的目的。2022-6-98.3 多线程编程8.3.2 进程和线程对于操作系统来说，一个正在执行的任务就是一个进程（Process），比如打开一个浏览器就是启动一个浏览器进程。每个进程都有自己的地址空间、内存、数据栈以及其他记录其运行轨迹的辅助数据。操作系统管理在其上运行的所有进程，并为这些进程公平地分配时间。不过各个进程有自己的内存空间、数据栈等，所以只能使用进程间通信（IPC），而不能直接共享信息。有些时候一个进程还不止同时干一件事，比如记事本，它除了要处理用户的文字输入，还要负责文字的排版和用户搜索等工作。在一个进程内部，要同时干多件事，就需要同时运行

29、多个“子任务”，我们把进程内的这些“子任务”称为线程（Thread）。一个进程中的各个线程之间共享同一片数据空间，所以线程之间可以比进程之间更方便地共享数据以及相互通信。在进程的整个运行过程中，每个线程都只做自己的事，在需要的时候跟其他的线程共享运行的结果。2022-6-98.3 多线程编程8.3.2 进程和线程由于每个进程至少要干一件事，所以一个进程至少有一个线程。当然，一些复杂的进程可以有多个线程，多个线程可以同时执行，多线程的执行方式和多进程是一样的，也是由操作系统在多个线程之间快速切换，让每个线程都短暂地交替运行，看起来就像同时执行一样。然而，真正地同时执行多线程需要多核CPU才可能实

30、现。2022-6-98.3 多线程编程8.3.3 线程与PythonPython代码的执行由Python虚拟机来控制（又称为解释器主循环）。Python被设计为在主循环中，同时只有一个线程在执行，就像在单CPU的系统中运行多个进程那样，内存中可以存放多个程序，但任意时刻，只有一个程序在CPU中运行。同样地，虽然Python解释器中可以“运行”多个线程，但在任意时刻，只有一个线程在解释器中运行。2022-6-98.3 多线程编程8.3.3 线程与Python在多线程环境中，Python虚拟机按以下方式执行：设置GIL。切换到一个线程去运行。运行以下程序。 指定数量的字节码指令； 线程主动让出控制

31、（可以调用time.sleep(0)）。把线程设置为睡眠状态。解锁GIL。再次重复以上所有步骤。调用外部代码时（如内置的C/C+扩展函数），GIL会被锁定，直到这个函数执行结束。不过，编写扩展函数的程序员可以主动解锁GIL，所以作为Python开发人员，不用担心我们的Python代码会被锁住。2022-6-98.3 多线程编程8.3.4 thread模块要创建一个新的线程，最简单且有效的方法是引入Thread模块，调用其thread.start_new_thread(function, args，kwargs=None)方法。这个方法会立即返回一个新线程，并调用作为参数的function函数，

32、args是包含位置参数的元组，使用空的元组说明调用function函数时不传递参数，kwargs是可选的包含关键字参数的字典。当函数运行完成（即返回）时，这个新线程也将结束运行。2022-6-98.3 多线程编程例：import threadimport time#定义每个线程中执行的函数：每隔delay时间便打印当前的时间def print_time( threadName, delay): count = 0 while count 5: time.sleep(delay) count += 1 print(:.format(threadName, time.ctime(time.tine

33、()#创建两个新线程try: thread.start_new_thread( print_time, (Thread-1, 2, ) ) thread.start_new_thread( print_time, (Thread-2, 4, ) )except: print Error: unable to start thread while 1:pass2022-6-98.3 多线程编程8.3.4 thread模块当执行上述代码时，会得到类似下面的结果：Thread-1: Thu Sep1 15:42:17 2016Thread-1: Thu Sep1 15:42:19 2016Threa

34、d-2: Thu Sep1 15:42:19 2016Thread-1: Thu Sep1 15:42:21 2016Thread-2: Thu Sep1 15:42:23 2016Thread-1: Thu Sep1 15:42:23 2016Thread-1: Thu Sep1 15:42:25 2016Thread-2: Thu Sep1 15:42:27 2016Thread-2: Thu Sep1 15:42:31 2016Thread-2: Thu Sep1 15:42:35 2016虽然thread模块能让我们快速有效地使用多线程，但其相对于更新的threading模块来说有较多

35、的限制。在实际应用中，应该总是使用threading模块。2022-6-98.3 多线程编程8.3.5 threading模块threading模块在Python 2.4时被引入。相对于thread模块，threading模块提供更强大也更高级的多线程支持。除了含有全部thread模块的方法外，threading模块还添加了一些实用的新方法。下面是一些比较有代表性的新方法。threading.activeCount()：返回当前活动的线程对象数量。threading.currentThread()：返回当前线程对象。threading.enumerate()：返回当前活动线程的列表。2022-

36、6-98.3 多线程编程8.3.5 threading模块下表给出Thread模块中一些常用的方法。方法方法名名作作 用用run()定义线程的功能函数（一般会被重写）start()开始线程的执行join(timeout=None)程序挂起，直到该线程结束isAlive()判断一个线程是否还在运行getName()返回线程的名字setName(name)设置线程的名字2022-6-98.3 多线程编程8.3.5 threading模块为了创建一个新线程，首先需要定义一个继承自Thread类的子类，重写其_init_()方法和run()方法。当创建了一个新的Thread子类后，我们就可以将其实例化

37、，并通过调用start()方法来开始一个新线程。下面的看一个例子：2022-6-98.3 多线程编程import threadingimport time exitFlag = 0 class myThread (threading.Thread): def _init_(self, threadID, name, counter): threading.Thread._init_(self) self.threadID = threadID self.name = name self.counter = counter def run(self): print(Starting + self

38、.name) print_time(self.name, self.counter, 5) print(Exiting + self.name)2022-6-98.3 多线程编程def print_time(threadName, delay, counter): while counter: if exitFlag: threadName.exit() time.sleep(delay) print(:.format(threadName, time.ctime(time.tine() counter -= 1 thread1 = myThread(1, Thread-1, 1) threa

39、d2 = myThread(2, Thread-2, 2) thread1.start() thread2.start() print(Exiting Main Thread)2022-6-98.3 多线程编程8.3.5 threading模块在很多时候，我们希望主线程能等待所有子线程执行完后再退出，因为主线程通常会需要使用子线程的运行结果来做一些工作；或者希望线程在访问某个文件时按照一定的顺序，以防止不同的访问顺序造成结果的不一致。threading模块包含了一个易于实现的锁机制，可用于同步线程。可以通过调用Lock()方法来创建一个新的锁，这个方法将返回一个锁对象。锁对象拥有一个acqui

40、re(blocking)方法，可以强制线程进行同步的工作。其中可选的blocking参数能够控制线程在尝试获得锁时是否等待。blocking参数设置为0时，线程若无法获得锁，则立即返回0；blocking设置为1时，线程若无法获得锁，则会被阻塞等待锁的释放。线程对象可以通过release()方法来释放一个不再需要的锁。2022-6-98.3 多线程编程例（print_time函数与之前定义的相同）：import threadingimport time class myThread (threading.Thread): def _init_(self, threadID, name, cou

41、nter): threading.Thread._init_(self) elf.threadID = threadID self.name = name self.counter = counter def run(self): print(Starting + self.name) #获得一个锁 threadLock.acquire() print_time(self.name, self.counter, 3) #运行完成后释放锁 threadLock.release()2022-6-98.3 多线程编程threadLock = threading.Lock()threads = thr

42、ead1 = myThread(1, Thread-1, 1)thread2 = myThread(2, Thread-2, 2) thread1.start()thread2.start() threads.append(thread1)threads.append(thread2) #等待所有的线程运行完成for t in threads: t.join()print(Exiting Main Thread)2022-6-98.3 多线程编程8.3.5 threading模块线程1和线程2按照其start()方法的调用顺序依次运行，对线程调用join()方法后，当前线程（主线程）会接在被调用join方法的线程之后运行，也就是主线程会等待线程1和线程2运行结束后再结束。运行结果如下。 Starting Thread-1Starting Thread-2Thread-1: Thu Sep 119:11:28 2016Thread-1: Thu Sep 119:11:29 2016Thread-1: Thu Sep 119:11:30 2016Thread-2: Thu Sep 119:11:32 2016Thread-2: Thu Sep 119:11:34 2016Thread-2: Thu Sep 119:11:36 2016Exiting Main Thread