《Python编程基础》课件-项目6：高级特性

Python内存管理与垃圾回收基础教学目标1.了解Python内存管理

2.掌握

引用计数机制

3.了解对象的生命周期

4.了解sys.getrefcount的使用

5.了解垃圾回收机制

6.了解分代垃圾回收Python内存管理是自动的，由解释器处理对象分配和释放，避免手动管理如C语言。核心概念：Python对象（如列表、字典）在堆上分配，每个对象有引用计数器跟踪引用数。当计数为0，对象被释放。这防止内存泄漏，提高开发效率。例如，在脚本中创建变量时，Python自动分配内存。1、Python内存管理概述

#简单对象创建示例x=[1,2,3]#创建列表对象，分配内存，引用计数=1y=x#y引用x，计数增至2dely#删除y，计数减至1#当所有引用删除，对象释放内存引用计数是Python内存管理的核心，每次引用对象时计数增1，删除时减1。为0时释放。核心概念:在CPython中，sys.getrefcount()查看计数。优势：实时回收，简单。缺点：不处理循环引用（后续）。用于理解变量赋值如a=b增加计数。2.引用计数机制importsys#导入sys查看引用计数a="hello"#创建字符串，计数=1b=a#b引用a，计数=2print(sys.getrefcount(a))#输出:3（额外函数参数引用）delb#删除b，计数减1对象生命周期从创建（new/init）到销毁（del）。核心概念:创建时分配内存，引用计数管理生存期。销毁时调用__del__释放资源如文件句柄。理解这帮助调试终结器问题。注意__del__不保证调用顺序，用于资源清理而非逻辑。3.对象生命周期classMyClass:#定义类def__init__(self):#初始化，对象创建print("Objectcreated")def__del__(self):#终结器，对象销毁时调用print("Objectdestroyed")obj=MyClass()#创建，输出:Objectcreateddelobj#删除引用，计数=0，输出:Objectdestroyedsys.getrefcount()返回对象当前引用计数，用于调试内存。核心概念:函数本身临时增1计数，故实际计数-1。结合gc模块监控。可用它追踪泄漏，如循环中未释放对象。4.sys.getrefcount的使用importsys#导入syslst=[1,2]#创建列表，计数=1print(sys.getrefcount(lst))#输出:2（函数临时引用）lst.append(lst)#自引用，计数增，但创建循环print(sys.getrefcount(lst))#输出:3垃圾回收（GC）补充引用计数，处理无法回收的对象如循环引用。在Python中，使用分代GC，提高效率。核心概念:对象分三代，新对象在0代，存活多次晋升。阈值触发收集。GC自动运行，但可手动触发。5.垃圾回收介绍importgc#导入gc模块gc.collect()#手动触发垃圾回收，返回回收对象数print(gc.get_threshold())#输出阈值，如(700,10,10)#阈值控制收集频率分代GC假设大多数对象短暂存活，将对象分代：0代频繁收集，高代较少。核心概念:收集时使用标记-清除算法。优化长运行程序。可调整阈值测试性能。注意：GC暂停执行，影响实时应用。6.分代垃圾回收importgc#导入gcprint(gc.get_count())#输出当前代对象数，如(300,5,1)gc.set_threshold(700,10,10)#设置阈值，调整收集频率gc.collect(0)#只收集0代GC模块提供Python中控制垃圾回收的接口，通过gc.enable/disable管理自动回收，支持调试而không依赖默认。在Python环境中，这种使用入门允许查询对象，并在实际中用于测试而không依赖sys。其入门的核心在于get_objects列表对象，避免泄漏，并在实际脚本中诊断而không依赖工具。核心概念:GC模块控制回收；入门强调启用查询；使用包括对象列表7.GC模块使用入门importgc#导入gc.disable()#禁用自动GCobj={}#创建对象print(gc.get_objects()[-1])#输出最近对象，如{}gc.enable()#启用小结1.Python内存管理自动化，通过引用计数器管理对象生命周期

2.引用计数内存管理的核心，每次对象引用变动都会更新计数，计数为0时对象被释放3.对象生命周期由创建到销毁，涉及内存分配和资源释放

4.分代垃圾回收优化内存回收效率，通过设置阈值和手动触发gc.collect()管理内存Python内存管理与垃圾回收进阶教学目标1.掌握gc模块高级使用

2.了解CPythonGC算法

3.了解内存泄漏检测

循环引用是对象互相引用，导致计数永不为0，无法回收。核心概念：如列表自引用，造成泄漏。GC通过标记-清除检测孤岛。应避免不必要循环，如使用弱引用解决。影响大对象程序。1、循环引用问题

#循环引用示例a=[]#空列表，计数=1b=[]#另一个，计数=1a.append(b)#a引用b，b计数=2b.append(a)#b引用a，a计数=2dela,b#删除变量，但计数仍=1，需GC回收gc模块控制垃圾回收，如手动收集、禁用。核心概念:gc.enable()/disable()切换，gc.get_objects()列对象。用于调试泄漏。可用它监控内存使用。注意：禁用GC风险泄漏。2.gc模块高级使用importgc#导入gcgc.disable()#禁用自动GC#执行代码，可能积累垃圾gc.enable()#重新启用print(gc.garbage)#输出不可回收垃圾列表弱引用不增计数，允许GC回收引用对象。核心概念:weakref模块创建，如weakref.ref()。用于缓存，避免循环。注意：弱引用对象可能None。3.弱引用importweakref#导入weakrefobj={}#对象，计数=1weak=weakref.ref(obj)#弱引用，不增计数print(weak())#输出对象delobj#删除，对象回收print(weak())#输出NoneCPythonGC使用引用计数+标记-清除+分代。核心概念:标记阶段标识可达对象，清除释放不可达。处理循环引用。4.CPythonGC算法importgc#导入gcgc.set_debug(gc.DEBUG_LEAK)#启用调试，追踪泄漏gc.collect()#收集，输出调试信息#检查gc.garbage泄漏对象内存泄漏是未释放内存积累，导致崩溃。核心概念:使用objgraph或heapy工具检测。监控sys.getsizeof()。注意：循环引用常见原因。5.内存泄漏检测importsys#导入sysobj=[iforiinrange(1000)]#大列表print(sys.getsizeof(obj))#输出大小，如96#重复创建未删除，导致泄漏优化包括使用slots减少对象大小、避免全局变量、及时del大对象。核心概念:调整GC阈值高负载程序。使用内存分析器如memory_profiler。6.内存优化classOptimized:#使用slots优化__slots__=['x']#限制属性，减少内存def__init__(self):self.x=1obj=Optimized()#小内存对象CPython内存模型是Python解释器中堆管理的方式，通过obmalloc分配小对象，确保高效而不直接依赖系统malloc。在Python环境中，这种模型使用竞技场和池，并在实际中减少碎片且其行为不依赖于垃圾回收（GC）。模型的核心在于对不同大小的内存块进行分级管理，不依赖Python语言层的逻辑。核心概念:CPython模型obmalloc；模型包括竞技场；内存强调小对象池。7.CPython内存模型importgc#导入gc.set_debug(gc.DEBUG_STATS)#启用调试统计gc.collect()#回收，输出模型统计如arenasprint(gc.get_debug())#输出调试标志小结1.循环引用导致对象计数永不为零，需要通过GC进行特殊处理2.gc模块提供了手动控制垃圾回收的功能，如启用、禁用和手动触发3.弱引用通过不增加引用计数来允许对象被垃圾回收器回收4.CPython的垃圾回收机制包括引用计数、标记-清除和分代收集深浅拷贝的区别与实现教学目标1.掌握浅拷贝的实现方式

2.了解浅拷贝的局限性

3.了解什么是深拷贝

4.了解深浅拷贝的区别

浅拷贝（ShallowCopy）是Python中复制对象的一种方式，它创建新对象，但内部嵌套的可变对象（如列表内列表）仍共享引用。核心概念：浅拷贝只复制顶层对象，子对象保持原引用。这意味着修改拷贝的嵌套对象会影响原对象。优势：高效，内存开销小。1、什么是浅拷贝？

#浅拷贝基本示例importcopy#导入copy模块，用于拷贝操作original=[1,2,[3,4]]#原列表，包含嵌套列表shallow=copy.copy(original)#浅拷贝，创建新列表，但嵌套共享shallow[2][0]=5#修改拷贝的嵌套元素print(original)#输出:[1,2,[5,4]]，原对象受影响浅拷贝可以通过copy模块的copy()函数、列表的copy()方法或切片[:]实现。核心概念:切片创建新容器，但元素引用相同。copy.copy()通用所有支持拷贝的对象。2.浅拷贝的实现方式#多种浅拷贝方式lst=[10,20,30]#原列表shallow1=lst[:]#切片浅拷贝shallow2=lst.copy()#列表方法浅拷贝importcopy#导入copyshallow3=copy.copy(lst)#copy函数浅拷贝shallow1[0]=100#修改拷贝，不影响原lstprint(lst)#输出:[10,20,30]浅拷贝的局限在于嵌套可变对象共享，导致意外修改。核心概念:id()函数检查对象身份，嵌套id相同证明共享。适合扁平结构，避免深层修改。3.浅拷贝的局限性#浅拷贝局限示例importcopy#导入copyorig={'a':[1,2],'b':3}#原字典，嵌套列表shallow=copy.copy(orig)#浅拷贝print(id(orig['a'])==id(shallow['a']))#输出:True，嵌套共享shallow['a'][0]=100#修改嵌套，影响origprint(orig['a'])#输出:[100,2]深拷贝（DeepCopy）是Python中完全复制对象及其所有嵌套对象的方式，创建独立副本。核心概念:递归复制所有层级，适用于复杂结构如嵌套字典。优势：安全独立，但内存和时间开销大。4.什么是深拷贝？#深拷贝基本示例importcopy#导入copyoriginal=[1,2,[3,4]]#原列表，嵌套deep=copy.deepcopy(original)#深拷贝，递归复制deep[2][0]=5#修改嵌套，不影响原print(original)#输出:[1,2,[3,4]]，原不变深浅拷贝区别在于复制深度：浅拷贝只复制顶层，深拷贝复制所有层。核心概念:在Python中，浅拷贝高效但风险共享修改；深拷贝安全但资源消耗。使用id()比较嵌套对象身份。5.深浅拷贝的区别#区别比较importcopy#导入copyorig=[[1,2],3]#原列表shallow=copy.copy(orig)#浅拷贝deep=copy.deepcopy(orig)#深拷贝print(id(orig[0])==id(shallow[0]))#输出:Trueprint(id(orig[0])==id(deep[0]))#输出:False自定义类可通过__copy__()和__deepcopy__()实现浅深拷贝。核心概念:deepcopy()需递归调用deepcopy()处理成员。用于复杂对象如带有文件柄的类。6.自定义类的拷贝实现importcopy#导入copyclassMyClass:#自定义类def__init__(self,data):self.data=data#初始化def__copy__(self):#浅拷贝方法returnMyClass(self.data)#新实例，共享datadef__deepcopy__(self,memo):#深拷贝方法returnMyClass(copy.deepcopy(self.data,memo))#递归深拷贝obj=MyClass([1,[2]])#实例deep=copy.deepcopy(obj)#调用__deepcopy__拷贝包含弱引用的对象时，默认的深拷贝可能无法正确处理弱引用指向的目标。直接拷贝后，新对象中的弱引用仍指向原对象，若原对象被回收，弱引用失效；或我们希望它指向新副本，而非原对象。核心概念在类的__deepcopy__方法中，根据memo字典获取目标对象的新副本，并重新创建指向新副本的弱引用类。7.weakref在拷贝中的应用importweakrefimportcopyclassData:passclassContainer:def__init__(self,data):self.ref=weakref.ref(data)#弱引用指向datadef__deepcopy__(self,memo):#获取data的新副本（若已拷贝过则从memo取）new_data=copy.deepcopy(self.ref(),memo)new_obj=Container(new_data)#新容器指向新数据returnnew_objd=Data()c=Container(d)c2=copy.deepcopy(c)print(c2.ref()isd)#False，指向新副本print(c2.ref()isnotNone)#True小结1.浅拷贝创建新对象，但内部嵌套的可变对象仍共享引用

2.深拷贝通过递归复制所有层级的对象3.深浅拷贝的主要区别在于复制的深度，浅拷贝只复制顶层，而深拷贝复制所有层4.自定义类可以通过实现__copy__()和__deepcopy__()方法来支持浅拷贝和深拷贝字典的排序教学目标1.了解字典在Python中的有序性

2.了解sorted()函数的基本使用

3.掌握按键排序的实现

4.了解按值排序的实现

5.掌握自定义排序键在Python中，字典（dict）是内置数据结构，用于存储键值对，字典默认保持插入顺序。这意味着遍历字典时，项按插入序出现，但排序通常指按键或值重新排列。优势：有序性简化数据处理，如JSON序列化。核心概念：字典无内置sort()方法，因为它是无序集合的演变；使用sorted()函数实现有序。1、字典在Python中的有序性

#字典有序性示例d={'b':2,'a':1,'c':3}#创建字典，按插入顺序存储print(list(d.keys()))#输出:['b','a','c']，保持插入序d['d']=4#添加新键，追加到末尾print(list(d.keys()))#输出:['b','a','c','d']sorted()函数对可迭代对象排序，返回新列表，可用于字典键、值或项。在Python中，sorted(d)默认按键排序。核心概念:sorted()不修改原字典，适合临时排序；参数key指定排序依据，如len。2.sorted()函数基本使用#sorted()基本排序d={'apple':5,'banana':2,'cherry':8}#原字典sorted_keys=sorted(d)#按键排序，返回列表print(sorted_keys)#输出:['apple','banana','cherry']sorted_values=sorted(d.values())#按值排序print(sorted_values)#输出:[2,5,8]lambda表达式可以实现自定义函数。语法简洁。在sorted函数中，常指定key为lambda表达式，可以实现按照自定义规则排序。核心概念:lambda匿名函数；具体应用可以实现sorted排序的自定义，实例强调简洁。3.lambda表达式按键排序使用sorted(d.items())返回排序后的元组列表，可转换为字典保持顺序。在Python中，结合dict()创建排序字典。reverse=True降序。核心概念:items()返回(键,值)视图，sorted()按键排序。4.按键排序的实现#按键排序实现d={'c':3,'a':1,'b':2}#无序插入sorted_d=dict(sorted(d.items()))#按键排序，转为字典print(sorted_d)#输出:{'a':1,'b':2,'c':3}sorted_desc=dict(sorted(d.items(),reverse=True))#降序print(sorted_desc)#输出:{'c':3,'b':2,'a':1}按值排序使用sorted(d.items(),key=lambdax:x[1])，指定key函数取值。在Python中，这返回按值排序的项列表，可转字典。lambda匿名函数提取值，支持复杂如绝对值。核心概念:lambda匿名函数提取值，支持复杂如绝对值。5.

按值排序的实现#按值排序d={'apple':5,'banana':2,'cherry':8}#字典sorted_by_value=dict(sorted(d.items(),key=lambdax:x[1]))#按值升序print(sorted_by_value)#输出:{'banana':2,'apple':5,'cherry':8}sorted_desc_value=dict(sorted(d.items(),key=lambdax:x[1],reverse=True))#降序print(sorted_desc_value)#输出:{'cherry':8,'apple':5,'banana':2}自定义排序使用key函数，如按键长度或值属性。在Python中，key可为函数或lambda，支持多条件。operator.itemgetter()高效提取。核心概念:operator.itemgetter()高效提取。6.自定义排序键#自定义排序fromoperatorimportitemgetter#导入itemgetterd={'short':1,'longer':2,'a':3}#字典sorted_by_key_len=dict(sorted(d.items(),key=lambdax:len(x[0])))#按键长度print(sorted_by_key_len)#输出:{'a':3,'short':1,'longer':2}sorted_by_value=dict(sorted(d.items(),key=itemgetter(1)))#使用itemgetter按值字典排序应用于数据分析、报告生成，如按频率排序词频。在Python中，结合collections.Counter高效。排序后可迭代输出或存储。核心概念:结合collections.Counter高效。7.字典排序的应用与注意事项#应用示例：词频排序fromcollectionsimportCounter#导入Counterwords=['apple','banana','apple','cherry']#列表freq=Counter(words)#创建词频字典sorted_freq=dict(sorted(freq.items(),key=lambdax:x[1],reverse=True))#按频降序print(sorted_freq)#输出:{'apple':2,'banana':1,'cherry':1}小结1.字典默认保持插入顺序，无内置sort()方法，使用sorted()函数实现排序。2.sorted()函数可以对字典进行按键、按值或自定义方式排序。3.使用lambda表达式或operator.itemgetter()可以实现复杂的排序逻辑。4.字典排序应用于数据分析和报告生成，如使用collections.Counter进行词频排序函数的柯里化教学目标1.掌握实现柯里化的基本方法

2.使用functools.partial实现柯里化

函数的柯里化（Currying）是一种函数式编程技术，将一个接受多个参数的函数转换为一系列只接受单个参数的函数链。这种转换允许逐步应用参数，直到所有参数被提供后才执行原始函数。核心概念：柯里化：多参数函数到单参数函数序列的转换。参数绑定：逐步固定参数，直到函数完全应用。函数式编程：强调不可变性和高阶函数的使用。优势：提升代码复用性和可读性。1、什么是函数的柯里化及其重要性

#非柯里化函数示例defadd(x,y,z):#接受三个参数returnx+y+z#直接计算sums#柯里化版本概念（手动模拟）defcurried_add(x):#第一层：接受xdefinner1(y):#第二层：接受ydefinner2(z):#第三层：接受zreturnx+y+z#最终计算returninner2#返回内层函数returninner1#返回中间函数#使用：逐步应用参数result=curried_add(1)(2)(3)#输出6手动实现柯里化通过嵌套函数或lambda表达式完成。这涉及定义外层函数接受第一个参数，并返回一个内层函数接受下一个参数，依此类推，直到所有参数被捕获后执行计算。核心概念:嵌套函数：外函数返回内函数，形成链。闭包：内函数捕获外层变量，如先前参数。lambda表达式：简洁方式实现匿名嵌套函数。2.手动实现柯里化的基本方法#原始多参数函数defmultiply(a,b,c):#接受三个参数returna*b*c#计算乘积#手动柯里化实现defcurry_multiply(a):#第一层：绑定adefinner_b(b):#第二层：绑定b，使用闭包访问adefinner_c(c):#第三层：绑定c，使用闭包访问a和breturnmultiply(a,b,c)#调用原始函数returninner_c#返回最内层函数returninner_b#返回中间函数通过一个加法函数展示柯里化的实际运行，可视化参数逐步应用的过程。选择简单函数如加法，便于追踪每个步骤的返回值。核心概念:部分应用：绑定部分参数，返回新函数。函数返回函数：柯里化的核心机制。可重用性：部分柯里化函数可多次调用。3.柯里化的简单代码示例#手动柯里化加法函数defcurry_add(x):#接受第一个参数xdefinner_y(y):#接受第二个参数yreturnx+y#计算并返回结果（假设二元函数）returninner_y#返回内层函数#简单使用add_five=curry_add(5)#绑定x=5，创建加5函数result1=add_five(3)#计算5+3=8result2=add_five(10)#复用，计算5+10=15print(result1,result2)#输出815Python的标准库functools提供partial函数，实现高效柯里化，而无需手动嵌套。partial绑定前几个参数，返回一个新函数，可继续接受剩余参数。核心概念:functools.partial：内置工具，创建部分应用函数。位置参数绑定：按顺序绑定前参数。关键字参数：支持kwarg绑定，如partial(func,a=1)。4.

使用functools.partial实现柯里化importfunctools#导入functools模块#原始函数defpower(base,exponent,mod):#三参数函数return(base**exponent)%mod#计算幂模#使用partial柯里化mod_power=functools.partial(power,exponent=2)#绑定exponent=2，创建平方函数result=mod_power(3,mod=5)#提供base=3,mod=5，计算(3**2)%5=4print(result)#输出4柯里化用于函数组合、配置管理和数据处理管道。例如，在列表处理中，预绑定过滤条件；在事件处理中，创建专用回调。核心概念:函数组合：柯里化函数易于管道连接。配置函数：预绑定常量创建变体。高阶函数：柯里化支持map、reduce等。5.柯里化在实际场景中的应用importfunctools#导入模块#原始转换函数defconvert(value,factor,offset):#三参数：值、因子、偏移returnvalue*factor+offset#计算#柯里化应用：温度转换c_to_f=functools.partial(convert,factor=1.8,offset=32)#绑定摄氏到华氏参数temps_c=[0,100]#输入列表temps_f=list(map(c_to_f,temps_c))#使用map应用柯里化函数print(temps_f)#输出[32.0,212.0]partialmethod类方法应用是Pythonfunctools中绑定类方法参的过程，确保实例方法柯里化而không依赖partial。其应用的核心在于partialmethod(f,arg)，避免self问题，并在实际中用于类依赖lambda。核心概念:partialmethod类柯里化；应用包括绑定；方法强调self6.partialmethod类方法应用fromfunctoolsimportpartialmethod#导入classCalc:#类defadd(self,x,y):returnx+y#方法curried_add=partialmethod(add,5)#柯里化绑定x=5c=Calc()#实例print(c.curried_add(10))#输出15注意事项包括避免过度柯里化导致的可读性下降，以及处理默认参数冲突。常见问题：参数顺序错误（partial按位置绑定）；闭包内存泄漏（长期持有柯里化函数）；类型检查挑战。核心概念:参数顺序：确保绑定匹配函数签名。内存管理：避免不必要闭包。测试：单独验证部分函数。7.常见问题与最佳实践importfunctools#导入模块#问题示例：参数顺序错误deffunc(a,b=0):#有默认参数returna+bpartial_func=functools.partial(func,b=5)#正确：关键字绑定try:wrong_partial=functools.partial(func,5)#位置绑定到a，默认b=0print(wrong_partial())#输出5(a=5,b=0)exceptTypeErrorase:#如果误绑，可能报错print(e)#处理异常小结1.函数的柯里化是将多参数函数转换为接受单个参数的函数链的技术2.手动实现柯里化可以通过嵌套函数或lambda表达式，利用闭包捕获外层变量3.functools.partial可以高效实现柯里化，通过绑定部分参函数缓存机制教学目标1.了解函数缓存机制

2.掌握实现函数缓存的基本方法

函数缓存机制（FunctionCaching），也称为记忆化（Memoization），是一种优化技术，用于存储函数调用的结果，以便在相同输入下直接返回缓存值，而非重新计算。核心概念：函数缓存：存储函数输入-输出对的机制。记忆化：特定于纯函数的缓存形式，避免副作用。1、什么是函数缓存机制及其重要性

#非缓存函数示例defcompute(x,y):#接受两个参数print("Computing...")#模拟昂贵计算returnx+y#返回结果#调用多次相同参数result1=compute(1,2)#输出"Computing..."并返回3result2=compute(1,2)#再次输出"Computing..."并返回3（无缓存，重复计算）手动实现函数缓存通过装饰器或闭包，使用字典存储结果。这涉及定义一个包装函数，检查输入是否已缓存，若是则返回缓存值，否则计算并存储。核心概念:装饰器：函数包裹原函数，实现缓存逻辑。闭包：内部函数访问外部缓存字典。哈希键：将参数转换为可哈希类型，如tuple(args,**kwargs)。2.手动实现函数缓存的基本方法#手动缓存装饰器defmanual_cache(func):#接受原函数作为参数cache={}#初始化空字典作为缓存defwrapper(*args):#包装函数，接受任意位置参数key=tuple(args)#将参数转换为元组作为键（假设无kwargs）ifkeyincache:#检查键是否已存在print("Cachehit!")#命中缓存returncache[key]#返回缓存值else:result=func(*args)#调用原函数计算cache[key]=result#存储结果到缓存print("Cachemiss!")#未命中，新增returnresult#返回新计算值returnwrapper#返回包装函数基础示例通过一个求和函数展示缓存的实际运行，可视化缓存命中与未命中的过程。核心概念:缓存命中：键存在，直接返回。缓存未命中：计算并添加新键值对。3.函数缓存的简单代码示例#简单手动缓存示例cache_dict={}#全局缓存字典（或闭包内）defcached_multiply(x,y):#缓存乘法函数key=(x,y)#创建键元组ifkeyincache_dict:#检查缓存returncache_dict[key]#命中返回result=x*y#计算结果cache_dict[key]=result#存储到缓存returnresult#返回#调用示例print(cached_multiply(3,4))#未命中，计算12并存储print(cached_multiply(3,4))#命中，直接返回12print(cache_dict)#输出缓存内容：{(3,4):12}Python的标准库functools提供lru_cache装饰器，实现高效缓存，支持最大大小和LRU（最近最少使用）淘汰策略。这比手动方法更简洁，支持类型提示和关键字参数。核心概念:functools.lru_cache：内置装饰器，自动管理缓存。maxsize：缓存最大条目，None为无限。LRU淘汰：移除最近最少使用的项。4.

使用functools.partial实现柯里化importfunctools#导入functools模块@functools.lru_cache(maxsize=128)#应用LRU缓存，最大128项deffactorial(n):#阶乘函数ifn==0orn==1:#基线条件return1returnn*factorial(n-1)#递归调用（缓存优化）#使用示例print(factorial(5))#计算并缓存中间结果print(factorial(5))#直接从缓存返回print(factorial.cache_info())#输出CacheInfo(hits=1,misses=6,maxsize=128,currsize=6)函数缓存用于递归优化、API节流和数据处理管道。例如，在斐波那契计算中，缓存避免指数级重复；在Web服务中，缓存查询结果减少数据库负载。核心概念:递归优化：存储子问题结果。API缓存：减少外部调用。。5.函数缓存机制在实际场景中的应用importfunctools#导入模块@functools.lru_cache(maxsize=None)#无限缓存deffib(n):#斐波那契函数ifn<=1:#基线returnnreturnfib(n-1)+fib(n-2)#递归#应用示例print(fib(30))#快速计算大n值，缓存所有子结果print(fib.cache_clear())#清空缓存（可选重置）lru_cache装饰器基础使用是Pythonfunctools中缓存函数结果的工具，通过maxsize限大小，确保最近使用而非依赖手动。其使用的核心在于@缓存，并在实际中基础，用于递归非依赖字典。核心概念:lru_cacheLRU缓存；基础包括maxsize；装饰器强调最近使用。6.lru_cache装饰器基础使用fromfunctoolsimportlru_cache#导入@lru_cache(maxsize=32)#装饰，限32deffib(n):#斐波returnnifn<2elsefib(n-1)+fib(n-2)#递归print(fib(10))#55，缓存中间print(fib.cache_info())#输出命中未命中，如hits=8,misses=11缓存泄漏（无限增长）和不可哈希参数（需自定义键）。常见问题：副作用函数缓存错误；线程安全（lru_cache线程安全）；过期数据。核心概念:缓存泄漏：无限缓存耗尽内存。不可哈希：自定义键处理列表等。线程安全：lru_cache内置支持。7.常见问题与最佳实践importfunctools#导入模块@functools.lru_cache(maxsize=32)#小缓存以防泄漏defrisky_func(x):#示例函数returnx*2#简单计算#问题示例：不可哈希参数try:risky_func([1,2])#报TypeError:unhashabletype:'list'exceptTypeErrorase:print(e)#处理异常#最佳实践：自定义键defhashable_key(args):#转换函数returntuple(tuple(a)ifisinstance(a,list)elseaforainargs)#使列表可哈希小结1.函数缓存机制是一种优化技术，用于存储函数调用结果，避免重复计算。2.可通过装饰器或闭包手动实现函数缓存，使用字典存储结果。3.functools模块的lru_cache装饰器提供自动管理缓存的功能，支持最大大小和LRU淘汰策略。4.函数缓存应用于递归优化、API节流和数据处理管道，提高效率和性能。Python中的单例模式教学目标1.掌握实现单例模式的基本方法

2.学习使用元类实现单例模式

单例模式（SingletonPattern）是一种创建型设计模式，确保一个类只有一个实例，并提供一个全局访问点来获取该实例。核心概念：单例模式确保类只有一个实例；全局访问点通过类方法或属性提供；适用于共享资源管理；Python实现依赖__new__或元类。1、什么是单例模式及其重要性

#普通类：允许多个实例classNormalClass:#定义普通类def__init__(self):#初始化方法pass#无特殊控制obj1=NormalClass()#创建第一个实例obj2=NormalClass()#创建第二个实例，不同对象print(obj1isobj2)#输出False，表示不同实例#单例概念：限制为一个实例（完整实现见后续页）classSingleton:#单例类预览_instance=None#类属性存储唯一实例def__new__(cls):#重写__new__控制创建ifcls._instanceisNone:#检查是否已存在cls._instance=super().__new__(cls)#创建唯一实例returncls._instance#返回同一实例手动实现单例模式通过重写__new__方法和使用类属性存储实例。这涉及在__new__中检查是否已存在实例，若无则创建，否则返回现有实例。核心概念:__new__方法负责对象创建，可用于控制实例数；类属性存储共享实例；手动实现提供灵活性，但需处理初始化重复。2.手动实现单例模式的基本方法#手动单例类实现classManualSingleton:#定义单例类_instance=None#类属性，初始为None，用于存储唯一实例def__new__(cls,*args,**kwargs):#重写__new__方法，控制实例创建ifcls._instanceisNone:#检查是否已存在实例cls._instance=super(ManualSingleton,cls).__new__(cls)#创建新实例returncls._instance#返回唯一实例def__init__(self,value=None):#初始化方法，可接受参数ifnothasattr(self,'initialized'):#检查是否已初始化（防止重复）self.value=value#设置属性self.initialized=True#标记已初始化核心概念:实例唯一性通过is运算符验证；单例模式突出全局共享；适用于配置或连接池。3.单例模式的简单代码示例#简单单例配置类classConfigSingleton:#单例配置管理器_instance=None#存储唯一实例def__new__(cls):#重写创建方法ifcls._instanceisNone:#未存在则创建cls._instance=super().__new__(cls)#调用超类创建cls._instance.config={}#初始化配置字典returncls._instance#返回实例#调用示例config1=ConfigSingleton()#获取实例config1.config['theme']='dark'#设置配置config2=ConfigSingleton()#再次获取，应同一print(config2.config['theme'])#输出'dark'，共享配置print(id(config1)==id(config2))#输出True，确认同一对象使用元类（metaclass）实现单例，通过自定义类的创建过程控制实例化。核心概念:元类控制类行为；__call__拦截实例化；实例字典支持多类单例。4.使用元类实现单例模式#元类单例实现classSingletonMeta(type):#定义元类，继承type_instances={}#字典存储各类的唯一实例def__call__(cls,*args,**kwargs):#重写__call__，当类被调用时触发ifclsnotincls._instances:#检查类是否已有实例cls._instances[cls]=super().__call__(*args,**kwargs)#创建并存储returncls._instances[cls]#返回实例#使用元类classLogger(metaclass=SingletonMeta):#指定metaclassdef__init__(self):#初始化self.log=[]#日志列表单例模式用于数据库连接池、缓存管理器或全局配置。核心概念:实际应用聚焦资源共享；数据库/配置常见场景；结合线程锁处理并发。5.单例模式在实际场景中的应用importsqlite3#导入数据库模块classDBConnection(metaclass=SingletonMeta):#单例数据库连接def__init__(self):#初始化self.conn=sqlite3.connect('app.db')#创建连接#应用示例db1=DBConnection()#获取连接cursor1=db1.conn.cursor()#使用游标db2=DBConnection()#同一连接cursor2=db2.conn.cursor()#共享常见问题：多线程竞争创建；继承冲突。最佳实践：使用threading.Lock；限制使用单例；模块级变量替代；文档化全局影响。核心概念:线程安全需锁保护；过度使用导致耦合；最佳实践强调最小化全局状态。6.分代垃圾回收importthreading#导入线程模块classThreadSafeSingleton:#线程安全单例_instance=None#实例_lock=threading.Lock()#锁def__new__(cls):#重写创建withcls._lock:#获取锁ifcls._instanceisNone:#检查cls._instance=super().__new__(cls)#创建returncls._instance#返回Borg模式变体是Python中共享状态，而非实例的单例变体，通过__dict__共享确保一致核心概念:Borg共享状态；变体包括__dict__；模式强调多实例一致。6.Borg模式变体介绍classBorg:#类_shared={}#共享字典def__init__(self):#初始化self.__dict__=self._shared#共享b1=Borg()#实例1b1.val=5#设置b2=Borg()#实例2print(b2.val)#输出5，共享print(b1isb2)#输出False，多实例小结1.单例模式确保一个类只有一个实例，并提供全局访问点2.单例模式可以通过重写__new__方法或使用元类来实现3.单例模式适用于管理共享资源，如数据库连接或全局配置4.实现单例模式时需考虑线程安全和避免过度使用导致的问题Python的多进程编程教学目标1.了解Python的多进程编程

2.了解创建进程的基本方法

3.掌握multiprocessing.Pool实现多进程

Python的多进程编程通过multiprocessing模块实现，允许创建多个独立进程，每个进程拥有自己的内存空间和Python解释器，从而实现真正的并行执行，尤其适合多核CPU环境。核心概念：multiprocessing模块提供进程创建和管理；进程独立于线程，避免GIL；适用于CPU-bound任务；重要性在于性能优化和资源利用。1、什么是Python的多进程编程及其重要性#单进程示例：顺序执行deftask(n):#定义任务函数returnsum(range(n))#计算sums，模拟计算密集result1=task(1000000)#顺序调用，耗时长result2=task(1000000)#再次调用，仍耗时#多进程概念：并行执行（完整实现见后续页）importmultiprocessing#导入模块p1=multiprocessing.Process(target=task,args=(1000000,))#创建进程1p2=multiprocessing.Process(target=task,args=(1000000,))#创建进程2p1.start();p2.start()#启动并行p1.join();p2.join()#等待完成创建进程的基本方法使用multiprocessing.Process类，指定target函数和args参数，然后调用start()启动进程，并用join()等待完成。核心概念:：Process类实例化进程；target指定执行函数；args/kwargs传递参数；start()和join()管理生命周期。2.创建进程的基本方法importmultiprocessing#导入multiprocessing模块defworker(num):#定义工作函数print(f"Worker{num}started")#输出启动信息#模拟工作print(f"Worker{num}finished")#输出完成if__name__=='__main__':#主进程守护，确保Windows兼容processes=[]#进程列表foriinrange(3):#创建3个进程p=multiprocessing.Process(target=worker,args=(i,))#创建Process对象processes.append(p)#添加到列表p.start()#启动进程forpinprocesses:#等待所有进程p.join()#阻塞直到完成核心概念:进程独立执行函数；结果通过共享对象或队列返回。3.多进程的简单代码示例importmultiprocessing#导入模块defsquare(n):#定义平方函数returnn*n#返回平方值if__name__=='__main__':#主进程保护numbers=[1,2,3,4]#输入列表processes=[]#进程列表results=[]#结果列表（实际中用队列更好）fornuminnumbers:#为每个数创建进程p=multiprocessing.Process(target=square,args=(num,))#创建进程processes.append(p)#添加p.start()#启动forpinprocesses:#等待p.join()#完成（结果收集需改进）#模拟结果（实际用Queue）print([square(n)forninnumbers])#输出[1,4,9,16]multiprocessing.Pool提供进程池管理，自动分配任务到固定进程数，通过map()或apply()执行函数。核心概念:Pool管理固定进程；map()并行映射；自动结果有序返回。4.使用multiprocessing.Pool实现多进程importmultiprocessing#导入模块defcube(x):#定义立方函数returnx**3#返回立方值if__name__=='__main__':#主进程保护withmultiprocessing.Pool(processes=4)aspool:#创建4进程池，使用with自动管理results=pool.map(cube,range(10))#并行计算0-9的立方print(results)#输出[0,1,8,27,64,125,216,343,512,729]多进程编程用于并行数据处理、科学模拟或Web爬虫。核心概念:实际应用聚焦并行任务；数据分块处理；与多线程比较用于I/O。5.多进程编程在实际场景中的应用importmultiprocessing#导入模块importtime#模拟耗时defprocess_data(data):#处理函数time.sleep(1)#模拟耗时returnsum(data)#返回sumsif__name__=='__main__':#保护data_chunks=[[1,2,3],[4,5,6],[7,8,9]]#数据分块withmultiprocessing.Pool()aspool:#默认进程池results=pool.map(process_data,data_chunks)#并行处理print(results)#输出[6,15,24]GIL对多进程影响是Python中全局锁不限进程但影响线程的过程，确保多进程并行。其影响的核心在于CPU任务受益，并在实际中用于计算。核心概念:GIL锁线程不锁进程；对多进程影响小；影响强调CPU受益。6.GIL对多进程影响importmultiprocessingasmp#导入importtime#时间defcpu_bound():#CPU任务sum(range(1000000))#求和start=time.time()#开始processes=[mp.Process(target=cpu_bound)for_inrange(4)]#4进程forpinprocesses:p.start()#启动forpinprocesses:p.join()#等待print(time.time()-start)#输出时间，如0.5s，并行受益GIL不限常见问题：数据共享需Queue/Pipe；启动慢；内存复制。核心概念:通信工具Queue/Pipe；最佳实践强调效率和安全性。7.常见问题与最佳实践importmultiprocessing#导入模块defproducer(q):#生产者q.put('data')#放入数据if__name__=='__main__':#保护q=multiprocessing.Queue()#创建队列p=multiprocessing.Process(target=producer,args=(q,))#创建进程p.start()#启动print(q.get())#获取'data'p.join()#等待小结1.Python的多进程编程通过multiprocessing模块实现。2.multiprocessing.Process类，使用start()和join()管理生命周期。3.multiprocessing.Pool允许通过进程池管理自动分配任务。4.多进程编程适用于并行数据处理等，提高性能和资源利用属性描述符与属性管理教学目标1.掌握实现描述符的基本方法

2.了解使用property装饰器管理属性

1、什么是属性描述符及其重要性属性描述符（PropertyDescriptors）是Python中一种高级机制，用于自定义类属性的访问、设置和删除行为，通过实现__get__、__set__和__delete__方法的对象来管理属性。核心概念：描述符协议通过__get__等方法拦截属性操作；数据描述符优先于实例属性；非数据描述符仅__get__；重要性在于属性控制和代码复用。#普通属性示例classNormalClass:#定义普通类def__init__(self):#初始化self.value=10#直接设置属性obj=NormalClass()#创建实例print(obj.value)#直接访问，输出10obj.value=20#直接修改，无控制#描述符概念：自定义访问（完整实现见后续页）classDescriptor:#描述符类def__get__(self,instance,owner):#获取时调用returnself._value#返回值def__set__(self,instance,value):#设置时调用self._value=value#存储值，可添加验证2.手动实现描述符的基本方法手动实现描述符的基本方法涉及定义一个类，实现__get__、__set__和可选__delete__方法，然后在目标类中作为类属性使用。这允许自定义属性行为，如添加类型检查或计算值。核心概念:get(self,instance,owner)处理读取；set(self,instance,value)处理写入；描述符存储在类中，影响所有实例。#手动描述符类classIntDescriptor:#定义描述符def__init__(self):#初始化self._value=0#默认值def__get__(self,instance,owner):#获取属性时调用returnself._value#返回存储值def__set__(se