Python实用案例教程 第7章 函数和模块

3. 返回结果
带参数return返回一个表达式值，不带参数值return返回None。 注意：返回的表达式可以是列表、元组、集合、多个值。
>>> def divide( a,b) : n1=a//b;n2=a-n1*b return n1,n2 >>> x,y=divide( 123,5) >>> x,y (24, 3)
目 录
02
可变长度参数
可变长度参数 可变长度参数在定义函数时主要有两种形式：*参数 或者 aaaaaa “*参数”用来接收任意多个实参并将其放在一个元组中，“**参数”接收类似于参数名参 数一样显式将多个实参并将其放入字典中。 例如： def poutx (∗x) : print (x) >>> poutx(1,2,3) (1, 2, 3) >>> poutx(1,2,3,4,5,6) (1, 2, 3, 4, 5, 6) 例如： >>> def poutkx(**x): for item in x.items() : print(item) >>> poutkx(a=1,b=2,c=3) ('a', 1) ('b', 2) ('c', 3)
目 录
02
函数嵌套定义
函数嵌套定义
Python允许函数的嵌套定义，也就是在自定义函数内部可以再定义另外一个函数。 例如： 代码如下（ch7, funNest.py）： def myOP(optab, opc, opval): #自定义函数 if opc not in '+-*/': return 'OP Err!' def OP(opitem): #自定义函数定义函数 return eval(repr(opitem)+opc+repr(opval)) return map(OP, optab) #使用在函数内部定义的函数 print(list(myOP(range(6), '+', 2))) #调用myOP实现[0,1,2,3,4,5]+2 print(list(myOP(range(6), '/', 2))) #调用myOP实现[0,1,2,3,4,5]/2
目 录
03
序 列 解 包
1. 一个星号*形式 2. 两个星号**形式 3. 多种形式接收参数
1. 一个星号*形式
调用含有多个参数的函数时，可以使用Python列表、元组、集合、字典以及其他可迭代对象作 为实参，并在实参名前加一个星号*，Python解释器将自动进行解包，然后把序列中的值分别传递 给形参。 例如：
#列表解包
#位置参数和元组解包
#元组解包相当于位置参数 #元组解包、字典对应名字
第7章
代码重用和共享：函数和模块
——函数嵌套与递归
函数嵌套与递归
假设一个函数A，在它的函数体中又调用A，这样自己调用自己，自己再调用自己……，当某个 条件得到满足时就不再调用了，然后再一层一层地返回，直到该函数的第一次调用。如图7.4所示。
函数嵌套与递归
（2）递归方法：
代码如下：
def fact2(n) : if n == 0: s = 1 else: s=n * fact2(n-1) print('s=', s) return s num=int(input("n=")) print(num, '!=',fact2(num))
运行结果：
#位置参数 #参数名参数，b在a之前不影响对应关 #默认值参数，c采用默认值
定长参数 【例7.1】定义函数，实现可变个数数值相加。 代码如下（ch7，argsSum.py）： def mysum(*args): sum=0 for x in args: sum+=x return sum print(mysum(1,2,3,4,5,6)) print(mysum(1,2)) print(mysum(2)) 运行结果：
参数传递 其中，因为x是数字类型，所以是传值方式，函数外的x的值不变。 例如： >>> def add2(x): x[0]=x[0]+x[1] return x[0] >>> lst=[10,20] >>> add2(lst) 30 >>> lst[0] 30
目 录
01
定 长 参 数
定长参数 调用函数时参数包括位置参数、参数名、默认值参数、不定长参数。 位置参数实参须以形参相同顺序传入函数，参数名参数（或关键字）用参数名确定传入的 参数对应关系。用户可以跳过不传的参数或者乱序传参。如果没有传入参数的值，则认为是默 认值。 例如： >>> def pout(a,b,c=3): print(a,b,c) >>> pout(10,20,30) 10 20 30 >>> pout(b=123,a="abc",c=[4,5,6]) 系 >>> pout(1,2) 123
第7章
代码重用和共享：函数和模块
——变量作用域
目 录
01
局 部 变 量
局部变量
但是，在函数内部使用global定义或者声明变量就是全局变量，当函数结束以后仍然存在并 且可以访问。注意下列几种情况。 （1）一个变量已在函数外定义，如果在函数内需要修改这个变量的值，并将修改的结果反 映到函数之外，可以在函数内用关键字global明确声明要使用已定义的同名全局变量。 （2）在函数内部直接使用global关键字将一个变量定义为全局变量，如果在函数外没有定 义该全局变量，在调用这个函数之后，会创建新的全局变量。 （3）在函数内如果只引用某个变量的值而没有为其赋新值，该变量为全局变量。如果在函 数内为变量赋值，该变量就被认为是局部变量，在函数内赋值操作之前用关键字global进行了声
一个Python程序就是模块的系统。它有一个顶层文件以及多个模块文件组成。 说明：标准库模块是Python中自带的模块，也称为标准链接库。Python大约有200多个标 准模块，包含与平台不相关的常见程序设计任务，如操作系统接口、对象永久保存、文字匹 配模式、网络和Internet脚本、GUI建构等。Python除了关键字、内置的类型和函数．更多的功 能是通过模块来提供的。
#
运行结果：
第7章
代码重用和共享：函数和模块
——参数传递
参数传递 Python是不允许程序员选择采用传值还是传址的，采用的是“传对象引用”的方式，传值和 传址是根据传入参数的类型来选择的。 如果函数收到的是一个可变对象（比如字典或者列表）的引用，就能修改对象的原始值。如 果函数收到的是一个不可变对象（比如数字、字符串或者元组）的引用，就不能直接修改原始对 象。 例如： >>> def add1(x,y): x=x+y return x >>> x=-12.6; y=5 >>> add(x,y) -7.6 >>> x -12.6
对于采用元组合集合，与列表方式相同。 如果执行： >>> print( drt(*dic.values()) ) 就会出现错误。
2. 两个星号**形式
如果实参是字典，可以使用两个星号∗∗对其进行解包，并要求实参字典中的所有键都必须是 函数的形参名称，或者与函数中两个星号的可变长度参数相对应。 例如： >>> def dout(**d): for item in d.items(): print(item) >>> d={'one':1, 'two':2, 'three':3} >>> dout(**d) ('one', 1) ('two', 2) ('three',3)
函数嵌套与递归
【例7.2】 利用递归求阶乘n!。 （1）普通方法：n!=1*2*3*…*(n-2)*(n-1)*n 代码如下（ch7, funNest.py）： def fact1( n): s=1 for i in range(1,n): s=s*i print('s=', s) return s num = int(input("n=")) print(num, '!=', fact1(nn中，程序是作为一个主体的、顶层的文件来构造的，配合有零个或多个支持的文件， 而后者这些文件都可以称作模块。顶层文件包含了程序主要的控制流程，也就是启动应用的文 件。如图7.3所示描述了模块之间交互。
第7章
代码重用和共享：函数和模块
——用户编写函数
目 录
01
函数定义与调用
1. 定义一个函数 3. 返回结果 2. 函数调用
2．函数调用
定义一个函数，就是给函数取一个名称，用户可以通过函数名来调用执行，也可以直接从 Python提示符执行。 例如： >>> def addxy(x,y): return x+y >>> addxy(-12.6,5) -7.6 >>> sum=addxy(-12.6,5) >>> sum -7.6 #定义双参数(x,y)函数addxy #调用addxy函数，没有赋值 #函数返回结果 #调用addxy函数，赋值给sum变量
>>> def drt(a,b,c): d=b*b-4*a*c return d >>> lst= [1, 2 , 3] >>> print( drt(*lst) ) -8 >>> dic={1: 'a',2: 'b',3: 'c'} >>> print( drt(*dic) ) -8
#对列表进行解包 #用字典键值传递
运行结果：
目 录
04
列表推导式使用函数
列表推导式使用函数
列表推导式中可以使用函数，这样列表推导式就可以根据用户任何要求进行推导。 例如（ch7, funInfer.py）：
lst=[1,-2,3,-4] def func(val): if val% 2== 0: val= val*2 else: val= val*3 return val print( [func(val)+1 for val in lst if val>0] )
3. 多种形式接收参数
调用函数时如果对实参使用一个星号∗进行序列解包，那么解包后的实参将会被当作普通位置 参数对待，并且会在关键参数和使用两个星号∗∗进行序列解包的参数之前进行处理。 例如： >>> def pout(a,b,c=3): print (a,b,c) >>> pout(*[1,2,3]) 123 >>> pout(1,*(2,),3) 123 >>> pout(1,*(2,3)) 123 >>> pout(*(3,),**{ 'c':1, 'b':2}) 321
运行结果：
目 录
03
修 饰 器
修饰器
修饰器是函数嵌套定义的另一个重要应用。修饰器本质上也是一个函数，只不过这个函数 接收其他函数作为参数并对其进行一定的改造之后返回新函数。 代码如下（ch7, funEmb.py）：
def funbefore (func): def test(*args1,**args2): print ( 'Before') result=func(*args1, **args2) return result return test def funafter (func): def test(*args1,**args2): result= func(*args1,**args2) print ( 'After' ) return result return test @funbefore @funafter def myp(x): print(x) myp(123) myp('abc') #定义修饰器before #（1） #（2) #定义修饰器after #（1） #（2） #修饰 #修饰
1．定义一个函数
定义一个函数语句如下： def函数名([参数1,参数2,…,参数n])： "注释" 函数体（语句块） [ return[表达式]] 其中： 函数代码块以def关键词开头，后接函数标识符名称和圆括号()，圆括号之间可以用于定义参 数。 注释用于函数说明。 函数内容以冒号起始，并且统一缩进。 return[表达式]结束函数，选择性地返回一个值给调用方，可以将函数作为一个值赋值给指定 变量。不带表达式的return相当于返回None。
第7章
代码重用和共享：函数和模块
——Python程序结构
1. 包、模块、函数和类
Python的程序由包（对应文件夹）、模块（一个Python文件）、函数和类（在Python文件中） 等组成。包是由一系列模块组成的集合，模块是处理某一类问题的函数和类等的集合。如图7.1所 示。
2．程序的构架
Python一个程序分割为源代码文件的集合以及将这些部分连接在一起的方法。Python的程 序构架如图7.2所示。