Python程序设计-从基础到应用 课件 第5、6章 函数与模块、类和对象

函数与模块函数概述大问题问题1问题2……问题n函数函数的定义与调用函数的参数传递递归函数变量的作用域知识要点模块函数的定义与调用“七乐彩”彩票中奖概率“七乐彩”，采用组合玩法，从01~30共30个号码中选择7个号码，组合为一注投注号码。根据中奖规则，各等奖的中奖概率如下：中奖级别中奖规则中奖概率一等奖7个基本号码全中二等奖中6个基本号码及特别号码三等奖中6个基本号码四等奖中5个基本号码及特别号码五等奖中5个基本号码六等奖中4个基本号码及特别号码七等奖中4个基本号码s1=1s2=1s3=1foriinrange(1,8):s1=s1*iforiinrange(1,24):s2=s2*iforiinrange(1,31):s3=s3*ip1=s1/(s1*1)*s2/(1*s2)/(s3/(s1*s2))print(p1)s1=1s2=1s3=1s4=1s5=1foriinrange(1,8):s1=s1*iforiinrange(1,7):s2=s2*iforiinrange(1,23):s3=s3*iforiinrange(1,31):s4=s4*iforiinrange(1,24):s5=s5*ip2=s1/(s2*1)*s3/(1*s3)*1/(s4/(s1*s5))print(p2)s1=1s2=1s3=1s4=1s5=1s6=1foriinrange(1,8):s1=s1*iforiinrange(1,7):s2=s2*iforiinrange(1,23):s3=s3*iforiinrange(1,22):s4=s4*iforiinrange(1,31):s5=s5*iforiinrange(1,24):s6=s6*ip3=s1/(s2*1)*s3/(1*s4)*1/(s5/(s1*s6))print(p3)s1=1s2=1s3=1s4=1s5=1s6=1s7=1foriinrange(1,8):s1=s1*iforiinrange(1,6):s2=s2*iforiinrange(1,3):s3=s3*iforiinrange(1,23):s4=s4*iforiinrange(1,22):s5=s5*iforiinrange(1,31):s6=s6*iforiinrange(1,24):s7=s7*ip4=s1/(s2*s3)*s4/(1*s5)*1/(s6/(s1*s7))print(p4)s1=1s2=1s3=1s4=1s5=1s6=1s7=1foriinrange(1,8):s1=s1*iforiinrange(1,6):s2=s2*iforiinrange(1,3):s3=s3*iforiinrange(1,23):s4=s4*iforiinrange(1,21):s5=s5*iforiinrange(1,31):s6=s6*iforiinrange(1,24):s7=s7*ip5=s1/(s2*s3)*s4/(s3*s5)*1/(s6/(s1*s7))print(p5)s1=1s2=1s3=1s4=1s5=1s6=1s7=1s8=1foriinrange(1,8):s1=s1*iforiinrange(1,5):s2=s2*iforiinrange(1,4):s3=s3*iforiinrange(1,23):s4=s4*iforiinrange(1,21):s5=s5*iforiinrange(1,3):s6=s6*iforiinrange(1,31):s7=s7*iforiinrange(1,24):s8=s8*ip6=s1/(s2*s3)*s4/(s5*s6)*1/(s7/(s1*s8))print(p6)s1=1s2=1s3=1s4=1s5=1s6=1s7=1foriinrange(1,8):s1=s1*iforiinrange(1,5):s2=s2*iforiinrange(1,4):s3=s3*iforiinrange(1,23):s4=s4*iforiinrange(1,20):s5=s5*iforiinrange(1,31):s6=s6*iforiinrange(1,24):s7=s7*ip7=s1/(s2*s3)*s4/(s5*s3)*1/(s6/(s1*s7))print(p7)“七乐彩”彩票中奖概率计算编程，计算并输出“七乐彩”各等奖的中奖概率。

…………143行代码代码冗余程序结构不清晰“七乐彩”彩票中奖概率计算中奖级别中奖概率一等奖二等奖三等奖四等奖五等奖六等奖七等奖

程序构件：组合

程序构件：阶乘“七乐彩”彩票中奖概率计算计算各等奖中奖概率

阶乘运算𝑛!n,mn函数是程序中实现一定功能的程序代码，供其他代码调用完成特定工作。

函数f，接受参数n，返回𝑛!函数的定义——定义阶乘函数python中，函数定义的一般形式如下：def

<函数名>(<形式参数表>):<函数体>[return<返回值列表>]

12345deff(n):s=1foriinrange(1,n+1):s*=ireturns函数的定义——定义阶乘函数使用def

保留字进行函数的定义。def

<函数名>(<形式参数表>):<函数体>[return<返回值列表>]

12345deff(n):s=1foriinrange(1,n+1):s*=ireturns函数的定义——定义阶乘函数函数名必须符合python标识符的命名规则。def

<函数名>(<形式参数表>):<函数体>[return<返回值列表>]

12345deff(n):s=1foriinrange(1,n+1):s*=ireturns函数的定义——定义阶乘函数形式参数用于传递值。def

<函数名>(<形式参数表>):<函数体>[return<返回值列表>]

12345deff(n):s=1foriinrange(1,n+1):s*=ireturns函数的定义——定义阶乘函数形式参数用圆括号括起来，注意括号后有冒号。def

<函数名>(<形式参数表>):<函数体>[return<返回值列表>]

12345deff(n):s=1foriinrange(1,n+1):s*=ireturns函数的定义——定义阶乘函数函数体由一行或多行语句组成，要注意缩进。def

<函数名>(<形式参数表>):

<函数体>[return<返回值列表>]

12345deff(n):s=1

foriinrange(1,n+1):s*=ireturns函数的定义——定义阶乘函数return语句，表示函数结束，并带回返回值。def

<函数名>(<形式参数表>):<函数体>[return<返回值列表>]

12345deff(n):s=1foriinrange(1,n+1):s*=i

returns函数的调用——调用阶乘函数定义后的函数，需要经过“调用”才能运行。函数调用的一般形式如下：<函数名>(<实际参数表>)12345deff(n):s=1foriinrange(1,n+1):s*=ireturnsprint(f(5))#函数调用6程序构件：阶乘

运行结果120函数的定义——定义组合函数功能计算公式

参数n,m返回

程序构件：组合

定义组合函数,需要调用“阶乘”函数。678defC(n,m):s=f(n)/(f(m)*f(n-m))returns主程序——调用组合函数910111213p1=C(7,7)*C(22,0)*C(1,0)/C(30,7)p2=C(7,6)*C(22,0)*C(1,1)/C(30,7)p3=C(7,6)*C(22,1)*C(1,0)/C(30,7)p4=C(7,5)*C(22,1)*C(1,1)/C(30,7)p5=C(7,5)*C(22,2)*C(1,0)/C(30,7)p6=C(7,4)*C(22,2)*C(1,1)/C(30,7)p7=C(7,4)*C(22,3)*C(1,0)/C(30,7)#输出各等奖中奖概率…141516…程序构件：组合

deff(n):s=1foriinrange(1,n+1):s=s*ireturnsdefC(n,m):s=f(n)/(f(m)*f(n-m))returnsp1=C(7,7)*C(23,0)/C(30,7)p2=C(7,6)*C(22,0)*C(1,1)/C(30,7)p3=C(7,6)*C(22,1)*C(1,0)/C(30,7)p4=C(7,5)*C(22,1)*C(1,1)/C(30,7)p5=C(7,5)*C(22,2)*C(1,0)/C(30,7)p6=C(7,4)*C(22,2)*C(1,1)/C(30,7)p7=C(7,4)*C(22,3)*C(1,0)/C(30,7)print("一等奖中奖概率:{:.10f}".format(p1))print("二等奖中奖概率:{:.10f}".format(p2))print("三等奖中奖概率:{:.10f}".format(p3))print("四等奖中奖概率:{:.10f}".format(p4))print("五等奖中奖概率:{:.10f}".format(p5))print("六等奖中奖概率:{:.10f}".format(p6))print("七等奖中奖概率:{:.10f}".format(p7))“七乐彩”彩票中奖概率计算910111213p1=C(7,7)*C(22,0)*C(1,0)/C(30,7)p2=C(7,6)*C(22,0)*C(1,1)/C(30,7)p3=C(7,6)*C(22,1)*C(1,0)/C(30,7)p4=C(7,5)*C(22,1)*C(1,1)/C(30,7)p5=C(7,5)*C(22,2)*C(1,0)/C(30,7)p6=C(7,4)*C(22,2)*C(1,1)/C(30,7)p7=C(7,4)*C(22,3)*C(1,0)/C(30,7)#输出各等奖中奖概率…141516…22行代码避免代码重复程序结构清晰“七乐彩”彩票中奖概率计算：运行结果一等奖中奖概率:0.0000004912二等奖中奖概率:0.0000034385三等奖中奖概率:0.0000756459四等奖中奖概率:0.0002269378五等奖中奖概率:0.0023828470六等奖中奖概率:0.0039714117七等奖中奖概率:0.0264760782>>>函数的调用处理函数的定义与调用定义一函数，计算n!。

12345deff(n):#函数定义

s=1foriinrange(1,n+1):s*=ireturnsprint(f(5))#函数调用6函数的调用定义一函数，计算n!。

12345deff(n):#n是形参

s=1foriinrange(1,n+1):s*=ireturnsprint(f(5))#5是实参61.参数传递通过函数名调用函数功能，将实参传递给对应形参。函数的调用定义一函数，计算n!。

12345deff(n):s=1foriinrange(1,n+1):s*=ireturnsprint(f(5))62.执行函数体转去执行被调用的函数，执行函数体语句。函数的调用定义一函数，计算n!。

12345deff(n):s=1foriinrange(1,n+1):s*=i

returnsprint(f(5))63.函数返回函数返回，释放形参及被调用函数中变量所占用的内存单元，返回主程序继续执行。120函数的返回值函数的返回值return语句用来结束函数，同时可以将函数运算的结果返回给函数被调用处。12345deff(n):s=1foriinrange(1,n+1):s*=i

returnsprint(f(5))6120函数的返回值函数可以没有return，此时函数并不返回值。>>>defprinthello(): print("HelloPython")

>>>printhello()HelloPython函数的返回值return语句可以返回多个值，多个返回值以元组的形式组织。 >>>deff2(a,b): return2*a,3*b>>>f2(3,4)(6,12)>>>x,y=f2(3,4)>>>print(x,y)612函数的定义与调用——实例解析实例解析输出100~200之间所有的素数，并统计个数实例解析素数是一个大于1的正整数，除了1和它本身以外，不能被其他正整数整除。100101102…200…nj:234……n-1i:实例解析编写函数prime(n)，判别n是否是素数。12345defprime(n):ifn==1:returnFalseelifn==2:returnTrue678910else:foriinrange(2,n):ifn%i==0:returnFalsereturnTrue实例解析主程序，遍历100~200之间的每个数，调用prime()函数，判别并统计素数个数。678910count=0forjinrange(100,201):ifprime(j)==True:print(j,end="")count=count+1print("\ncount=",count)11101103107109113127131137139149151157163167173179181191193197199count=21>>>函数的参数传递形式参数和实际参数函数定义时的参数，称为形式参数(形参)。1234deff(n):#n是形参

s=1foriinrange(1,n+1):s*=i函数调用时的参数，称为实际参数(实参)。567returnsa=5print(f(a))#a是实参引用和对象a1引用对象Python中引用和对象是分离的。a=1b2引用对象b=1b=“hello”引用和对象a1引用对象Python中引用和对象是分离的。a=1b2引用对象b=2b=“hello”‘hello’参数传递:函数调用，实参传递给形参。12345defchange(listB):listB=[4,5,6]listA=[1,2,3]change(listA)print(listA)组合数据类型listA[1,2,3]listB实参形参参数传递:形参重新赋值，引用新对象。12345defchange(listB):

listB=[4,5,6]listA=[1,2,3]change(listA)print(listA)形参引用新对象listA[1,2,3]listB实参形参形参引用了新对象！[4,5,6]参数传递:调用结束后，实参仍然不变。12345defchange(listB):listB=[4,5,6]listA=[1,2,3]change(listA)print(listA)listA[1,2,3]实参[1,2,3]参数传递:函数调用，实参传递给形参。12345defchange(listB):listB[0]=4listA=[1,2,3]change(listA)print(listA)listA[1,2,3]listB实参形参参数传递:修改形参引用对象的值，形参不引用新对象。12345defchange(listB):listB[0]=4listA=[1,2,3]change(listA)print(listA)listA[4,2,3]listB实参形参形参不引用新对象形参直接修改对象值！参数传递:调用结束后，实参会发生改变。12345defchange(listB):listB[0]=4listA=[1,2,3]change(listA)print(listA)listA[4,2,3]实参形参不引用新对象[4,2,3]结论:如果函数体内，对形参的引用赋值，则形参引用了新的对象，实参不会发生改变。如果在函数体内，修改形参指向的对象的值，则形参没有引用新的对象，实参会发生改变。不同类型的参数不同类型的参数：位置参数函数按照参数位置传递参数，即位置参数。函数调用时语法形式如下：>>>defbmi(weight,height):print(“{:.2f}”.format(weight/height**2))>>>bmi(60,1.58)24.03<函数名>(<参数名>)不同类型的参数：关键字参数按照参数名称方式传递参数，即关键字参数。函数调用时语法形式如下：>>>defbmi(weight,height):print(“{:.2f}”.format(weight/height**2))>>>bmi(height=1.58,weight=60)>>>24.03<函数名>(<参数名>=<实际值>)不同类型的参数：可选参数函数的参数在定义时可以指定默认值。函数定义时语法形式如下：>>>defmultiply(x,y=10):print(x*y)>>>multiply(99)990>>>multiply(99,2)198def<函数名>(<必选参数列表>,<可选参数>=<默认值>):形式参数和实际参数参数名前有一个*，是可变长位置参数，允许接受多个参数。函数调用时，将多个参数构成一个元组，作为参数传递到函数中。1234deff1(*b):s=1foriinb:

s=s*ireturns567print(f1(1,2,3))print(f1(1,2,3,4,5))6120>>>不同类型的参数：可变长关键字参数参数名前有**，是可变长关键字参数，允许接受多个含参数名的参数。函数调用时，将参数名和参数构成一个字典，传递到函数中。1234deff2(**c):print(c)f2(NO=”001”,name=“Tom”)f2(NO=”002”,name=“Jerry”,sex=”male”){'NO':'001','name':'Tom'}{'NO':'002','name':'Jerry','sex':'male'}可变长关键字参数——实例解析实例解析学生信息注册登记实例解析12345defregister(number,name,**other):print("学号:",number,"姓名:",name)print(other)register('101','Tom')other={'性别':'M','系部':'computer','年龄':21}register('102','Jack',**other)6编写函数，实现学生信息注册登记，要求必须登记学号、姓名，其他如性别、系部、年龄等信息不强制登记。实例解析学号:101姓名:Tom{}学号:102姓名:Jack{'系部':'computer','性别':'M','年龄':21}编写函数，实现学生信息注册登记，要求必须登记学号、姓名，其他如性别、系部、年龄等信息不强制登记。递归函数递归的定义老和尚讲故事德罗斯特效应递归函数函数之间可以相互调用，若一个函数直接或间接地调用了自己，这种调用称为递归调用。f函数调用f函数直接调用f1函数调用f2f2函数调用f1函数间接调用递归函数递归算法的两个基本特征：12递推归纳：把问题转化为比原问题规模小的同类问题递归终止：当问题小到一定规模，结束递归，逐层返回递归函数计算n!递推归纳n!

(n-1)!

(n-2)!……递归终止

递归函数用递归的方法求阶乘n!2412345deffac(n):ifn==1:return1else:returnfac(n-1)*nprint(fac(4))6递归函数递归调用过程：递推、回归fac(4)fac(4)4*fac(3)fac(3)fac(2)3*fac(2)2*fac(1)fac(1)16242实例解析字符串逆置实例解析字符串逆置，比如s='hello',逆置后s='olleh'处理过程：将首字符移动到末尾，剩余的字符串同样处理。直至剩余字符串为空。递推归纳reverse(s)=reverse(s[1:])+s[0]递归终止

实例解析用递归的方法进行字符串逆置olleh>>>12345defreverse(s):ifs[1:]=="":returns[0]else:returnreverse(s[1:])+s[0]print(reverse("hello"))6递归函数小结递推归纳问题转化为比原问题规模小的同类问题。递归终止

匿名函数匿名函数Lambda函数，是一个匿名函数。语法如下：>>>lambdax,y:x+y<function<lambda>at0x035E00C0>>>>Lambda参数列表:表达式匿名函数绑定一个名字，语法如下：>>>f=lambdax,y:x+y>>>f(2,3)5>>><函数名>=Lambda参数列表:表达式等价于：def<函数名>(参数列表):return表达式实例解析匿名函数作为其他函数的参数实例解析列表ls=[(‘a’,3),(‘b’,9),(‘c’,6),(’d’,2)]，根据每个元组的第二项数据，即每个字符的频次，降序排列输出。>>>ls=[('a',3),('b',9),('c',6),('d',2)]>>>ls.sort(key=lambdax:x[1],reverse=True)>>>>>>print(ls)[('b',9),('c',6),('a',3),('d',2)]>>>变量的作用域变量的作用域根据程序中变量所在的位置和作用范围，变量分为局部变量和全局变量。在一个函数内定义的变量，称为局部变量。在所有函数之外定义的变量，称为全局变量。全局变量和局部变量n=30#全局变量deffun(x,y):n=x*y#局部变量

print("n=",n)fun(3,4)print("n=",n)123456n=12n=30>>>全局变量的声明全局变量在函数内部使用时，需要提前使用保留字global声明，语法形式如下：global<全局变量>n=30#全局变量deffun(x,y):globaln#全局变量n=x*yprint("n=",n)fun(3,4)print("n=",n)1234567n=12n=12>>>全局变量若全局变量是组合数据类型ls=[1,2,3]#全局变量deffun():ls=[4,5,6]#给变量ls赋值，局部变量print(ls)fun()print(ls)123456[4,5,6][1,2,3]>>>全局变量若全局变量是组合数据类型ls=[1,2,3]#全局变量deffun():ls[0]=9#修改变量ls的元素值，全局变量print(ls)fun()print(ls)123456[9,2,3][9,2,3]>>>变量的作用域归纳对于简单类型全局变量，函数体内部若要使用该全局变量，必须用global声明；否则函数体内部使用的是局部变量。对于组合类型全局变量，若函数体内部，真实创建了同名变量，则函数内部的是局部变量；若函数体内部没有创建同名变量，则函数体内部使用的是全局变量。模块模块在python中，可以把程序分割成许多单个文件，这些单个的文件称为模块。模块将一些常用的功能单独放置到一个文件中，方便其他文件来调用。导入模块导入模块的一般形式如下：import模块#evensum.pydeffun(alist):s=0foriinalist:ifi%2==0:s=s+ireturns1234567#t.pyimportevensumls=[1,2,3,4,5,6,7,8,9]s=evensum.fun(ls)print("s=",s)12345s=20>>>导入模块导入模块中的函数,一般形式为:from模块import函数名#evensum.pydeffun(alist):s=0foriinalist:ifi%2==0:s=s+ireturns1234567#t.pyfromevensumimportfunls=[1,2,3,4,5,6,7,8,9]s=fun(ls)print("s=",s)12345s=20>>>导入模块导入模块中的所有函数，不需要一一列举函数名，一般形式为：from模块import*#evensum.pydeffun(alist):s=0foriinalist:ifi%2==0:s=s+ireturns1234567#t.pyfromevensumimport*ls=[1,2,3,4,5,6,7,8,9]s=fun(ls)print("s=",s)12345s=20>>>单元小结 本单元我们学习了函数的定义和调用，进一步学习并理解了函数的参数传递，以及不同类型的形式参数；学习了匿名函数，理解递归算法的思想和递归调用处理过程，学习了全局变量、局部变量的使用，介绍了模块导入方法，并通过多个实例解析，帮助大家掌握函数的使用。第6章类和对象面向对象的概念类和对象的概念面向过程程序设计把数据定义为不同的数据结构，用函数来实现功能，函数与数据是分离的。与之不同的，面向对象程序设计将数据和对数据的操作方法封装在一起，构成一个相互依存、不可分割的整体，称之为对象，将相同类型的对象进行抽象形成类。面向对象的三个基本特征封装继承多态封装封装是将对象的属性和行为打包放在一起形成一个整体，其中，对象的属性由若干数据组成，对象的行为由若干对数据的操作组成，这些操作采用函数形式实现，称为方法。继承继承是指将现有的类作为基类派生出新的类，基类是父类，派生类是子类。通过继承，子类可以重用父类的部分属性和行为，提高了软件开发的效率和可靠性。多态多态是一个跟继承相关的特性，在继承时，多个派生类可以定义与基类方法名称相同、但行为方式各不相同的方法。调用该名称的方法时，同样的消息会根据对象所属的派生类的不同做出不同的响应，这一特性称为多态。类的定义和对象的创建内置的类创建对象内置类创建对象的语法：<对象名>=<类名>(<形参列表>)调用对象的属性和方法，格式：

<对象名>.<属性名><对象名>.<方法名>(<实参列表>)类创建对象例6-1：创建一个复数对象

#创建值为1+2i的复数对象c1，输出c1的复数表示形式及其实部、虚部和模c1=complex(1,2)print('c1:',c1)print('c1的实部：',c1.real)print('c1的虚部：',c1.imag)print('c1的模：',c1.__abs__())#计算c1的共轭复数c2，输出c2的复数表示形式及其实部、虚部和模c2=c1.conjugate()print('c2:',c2)print('c2的实部：',c2.real)print('c2的虚部：',c2.imag)print('c2的模：',c2.__abs__())类创建对象例6-1：创建一个复数对象自定义类类的定义：

class<类名>: <属性定义><方法定义>类的属性定义：

<类变量名>=<初始值>类的方法定义：def<方法名>(self,[形参列表]): <函数体> [return<返回值列表>]自定义类实例属性的定义和初始化在__init__方法中完成，语法形式如下：

def__init__(self,<形参列表>):self.<实例变量名>=初始值

__init__方法是一种类的特殊方法，称为构造函数，在创建对象时系统会自动调用该函数，用于初始化对象属性。自定义类例6-2：创建一个类似complex对象

classComplex2:#类属性定义

count=0

def__init__(self,real,imag=0):#类的构造函数，初始化对象属性

self.real=real

self.imag=imagComplex2.count+=1

defconjugate(self):#求共轭复数

returnComplex2(self.real,-self.imag)

def__abs__(self):#计算模

return(self.real**2+self.imag**2)**0.5

def__str__(self):#返回对象的描述信息，调用print()打印实例化对象时会调用该方法

ifstr(self.imag)[:1]=='-':return'('+str(self.real)+str(self.imag)+'i'+')'else:return'('+str(self.real)+'+'+str(self.imag)+'i'+')'自定义类创建对象例6-3：利用自定义的Complex2类创建一个对象

#创建Complex2类的实例对象c1，输出c1及其实部、虚部和模c1=Complex2(1,2)print('c1:',c1)print('c1的实部：',c1.real)print('c1的虚部：',c1.imag)print('c1的模：',c1.__abs__())#利用conjugate方法生成Complex2类的实例对象c2，输出c2及其实部、虚部和模c2=c1.conjugate()print('c2:',c2)print('c2的实部：',c2.real)print('c2的虚部：',c2.imag)print('c2的模：',c2.__abs__())自定义类创建对象例6-3：利用自定义类创建对象

#创建Complex2类的实例对象c1c1=Complex2(1,2)#调用Complex2类的count属性并输出print('当前已创建的Complex2类的对象总数：',Complex2.count)#调用c1对象的real属性和imag属性并输出print('c1的real属性：',c1.real)print('c1的imag属性：',c1.imag)#用conjugate方法生成Complex2类的实例对象c2c2=c1.conjugate()#调用Complex2类的count属性并输出print('当前已创建的Complex2类的对象总数：',c2.count)#调用c2对象的real属性和imag属性并输出print('c2的real属性：',c2.real)print('c2的imag属性：',c2.imag)类属性和类实例属性例6-4利用自定义的Complex2类创建一个对象c1，并利用conjugate方法生成对象c2，然后分别调用类属性和实例属性，比较其差别。

类的特殊方法类有很多的内置的特殊方法，它们通常使用双下划綫“__”开头和结尾。特殊方法说明系统调用形式__init__(self,…)构造函数，创建对象时调用类名(实参列表)__del__(self)析构函数，释放对象时调用del对象名__str__(self)返回对象描述信息，使用print语句时被调用print(对象名)__len__(self)返回对象的长度len(对象名)__abs__(self)计算模长abs(对象名)__add__(self,other)加运算对象名1+对象名2__sub__(self,other)减运算对象名1-对象名2__mul__(self,other)乘运算对象名1*对象名2__div__(self,other)除运算对象名1/对象名2

classComplex2:……

def__add__(self,other):#加运算

returnComplex2(self.real+other.real,self.imag+other.imag)

def__mul__(self,other):#乘运算

newreal=self.real*other.real-self.imag*other.imag

newimag=self.real*other.imag+self.imag*other.realreturnComplex2(newreal,newimag)……类的特殊方法例6-5定义Complex2类的加运算和乘运算，并通过运算符形式调用进行相应的计算。

c1=Complex2(1,3)c2=Complex2(3,-1)c3=c1+c2c4=c1*c2print('c1:',c1)print('c2:',c2)print('c1+c2:',c3)print('c1*c2:',c4)例6-5定义Complex2类的加运算和乘运算，并通过运算符形式调用进行相应的计算。

类的特殊方法类的继承和多态类的继承类继承的语法形式如下：

class<派生类名>(<基类名>): <派生类属性定义> <派生类方法定义>在派生类中，定义实例属性并初始化的语法形式如下：

def__init__(self,<派生类属性列表>): <调用基类构造函数初始化基类属性> <新增属性初始化定义>类的继承调用基类构造函数的语法形式有如下两种：形式1：<基类名>.__init__(self,<基类属性列表>)形式2：super(<派生类名>,self).__init__(<基类属性列表>)在派生类方法定义时，调用基类方法的语法形式也有如下两种：形式1：<基类名>.<基类方法名>(self,<实际参数列表>)形式2：super(<派生类名>,self).<基类方法名>(<实际参数列表>)类的继承例6-6：创建基类Person类，并根据Person派生出Student类，

#定义基类Person类classPerson:

def__init__(self,name,sex,age,idcard):=name

self.age=age

self.sex=sex

self.idcard=idcard

defshow(self):print('姓名：',,'年龄：',self.age,'性别：',self.sex)print('身份证号码：',self.idcard)

#定义派生类classStudent(Person):#派生类构造函数

def__init__(self,stdnum,name,sex,major,age,idcard):#调用基类构造函数

super(Student,self).__init__(name,sex,age,idcard)#派生类新增属性初始化

self.stdnum=stdnum

self.major=major

def

showStudent(self):print('学号：',self.stdnum,'专业：',self.major)#调用基类方法

super(Student,self).show()类的继承例6-6：分别创建Person类和Student类的对象，调用类的方法输出所创建对象的属性。

#创建Person类对象per1=Person('张成','男',40,)print("调用Person类的show方法输出张成的个人信息如下：")per1.show()#创建Student类对象stu1=Student('202101101','李玉','女','计算机',20,)print("调用派生类Student类的showStudent方法输出李玉的个人信息如下：")stu1.showStudent()print("调用基类Person类的show方法输出李玉的个人信息如下：")stu1.show()类的继承例6-6：创建基类Person类，并根据Person派生出Student类。多态与方法重载多态是基类的一个方法在不同派生类中有不同的行为。Python通过方法重载来实现多态。方法重载是在派生类中使用与基类完全相同的方法名，而对方法的内容进行改写，从而实现对基类方法的重新定义。利用派生类创建的对象调用该方法，将调用派生类中的方法，而不再调用基类的方法。一个基类的多个派生类创建的不同对象调用同样的方法会产生不同的调用结果，这就是多态性。多态与方法重载例6-7加法运算符重载应用。

#定义一个新的数据类型对“+”运算符重载classNumber:

def__init__(self,x,y):

self.x=x

self.y=y

def__add__(self,other):returnNumber(self.x+other.x,self.y+other.y)#不同数据类型中“+”实现的功能举例a1=2a2=3a=a1+a2print("两个整数a1与a2相加的结果：",a)

b1=complex(2,3)b2=complex(3,-1)b=b1+b2print("两个复数b1与b2相加的结果：",b)c1='hello'c2='world!'c=c1+c2print("两个字符串c1与c2相连的结果：",c)d1=Number(1,10)d2=Number(2,20)d=d1+d2print("两个Number类型对象d1和d2进行加运算的结果：",d.x,d.y)多态与方法重载例6-7加法运算符重载应用。多态与方法重载

#定义基类AnimalclassAnimal:

def__init__(self,name