8、Python中的函数整理总结（程序结构、模块、包、命令行参数、多项式相加程序、全排列程序）

一、函数

函数的定义和调用：

函数是重用的程序段。他们允许你给一段语句命名一个名字，这是函数定义。你可以在你的程序的任何地方使用这个名称运行这个语句块，这是函数调用。内置函数不用定义，直接调用。自定义函数语法格式： def 函数名(参数表) 函数体函数要先定义，再使用 #如要定义函数：y=x^2+1 >>> def f(x): value=x**2+1 return value >>> n=int(input()) 2 >>> y=(f(n)) >>> print(y) 5

求斐波那契数列的和：

>>>def fibs(n): result=[1,1] for i in range(n-2): result.append(result[-2]+result[-1]) return result >>> print(fibs(5)) [1, 1, 2, 3, 5]

匿名函数–lambda表达式： 函数定义的另一种方法是用lambda表达式，它定义了一个匿名函数。lambda的一般形式是关键字lambda后面跟一个或多个参数，紧跟一个冒号，后面是一个表达式。作为表达式，lambda返回一个函数值。lambda用来编写简单的函数，而def用来处理更强大任务的函数。

>>>g=lambda x,y,z:x+y+z >>> g(1,4,5) 10

函数参数：

函数定义时的参数称为形参，这些参数就像变量一样。参数在函数定义的圆括号内指定，用逗号分割。当我们调用函数时，函数中的参数值称为实参函数形参取得的值是你调用函数时提供的实参

位置参数：

Python处理参数的方式要比其他语句更加灵活。其中，最熟悉的参数类型是位置参数，传入参数的值是按照顺序依次赋值给形参 >>>from math import sqrt >>> def dis(x1,y1,x2,y2): print("x1={},y1={},x2={},y2={}".format(x1,x2,y1,y2)) return sqrt((x1-x2)**2+(y1-y2)**2) >>> print(dis(1,3,4,5)) x1=1,y1=4,x2=3,y2=5 3.605551275463989

关键字参数：

为了避免位置参数严格的位置要求，调用参数时可以指定对应形式参数的名字，这是关键字参数，他甚至可以采用与函数定义时不同的顺序 >>>from math import sqrt >>> def dis(x1,y1,x2,y2): print("x1={},y1={},x2={},y2={}".format(x1,x2,y1,y2)) return sqrt((x1-x2)**2+(y1-y2)**2) >>> print(dis(x1=1,y1=3,x2=4,y2=5)) x1=1,y1=4,x2=3,y2=5 3.605551275463989

位置参数和关键字参数混合：

如果同时出现两种参数形式，首先应该写出的是位置参数，后是关键字参数 >>>from math import sqrt >>> def dis(x1,y1,x2,y2): print("x1={},y1={},x2={},y2={}".format(x1,x2,y1,y2)) return sqrt((x1-x2)**2+(y1-y2)**2) >>> print(dis(1,3,y2=5,x2=4)) x1=1,y1=4,x2=3,y2=5 3.605551275463989

下面程序出错

>>> from math import sqrt >>> def dis(x1,y1,x2,y2): print("x1={},y1={},x2={},y2={}".format(x1,x2,y1,y2)) return sqrt((x1-x2)**2+(y1-y2)**2) >>> print(dis(1,y1=3,4,5)) SyntaxError: invalid syntax

默认值参数：

当调用方没有提供对应形式参数的值时，你可以指认默认形式参数值。如果你提供实参，在调用时会代替默认值。 >>>from math import sqrt >>> def dis(x1,y1,x2,y2): print("x1={},y1={},x2={},y2={}".format(x1,x2,y1,y2)) return sqrt((x1-x2)**2+(y1-y2)**2) >>> print(dis(1,3,4)) 默认参数值在函数对象被创建时计算 >>> def init(arg,result=[]): result.append(arg) print(result) >>> init('a') ['a'] >>> init('b') ['a', 'b'] >>> init(1,[1]) [1, 1]

数量可变参数：

当函数参数数目不确定时，星号将一组可变数量的位置参数合成参数值的元组 >>> def countnum(a,*b):#计算参数个数 print(b) print(len(b)+1) >>> countnum(3,7,9) (7, 9)#以元组的形式存放 3 >>> countnum(5,8,1,6,89) (8, 1, 6, 89) 5

收集参数到字典中—：

>>> def countnum(a,**d): print(d) print(len(d)+1) >>> countnum(3,x1=9,x2=1,x3=6,x4=89) {'x1': 9, 'x2': 1, 'x3': 6, 'x4': 89} 5

print函数完整表示：

print(*object,sep="",end="\n",file=sys.stdout)object:输出参数，可变数量缺省值参数:sep="": 输出分隔符 end="\n": 输出函数结束换行 file=sys.stdout: 输出到屏幕缺省

实参拆包:

>>> l=[2,7,5] >>> print(l)#参数个数是一个 [2, 7, 5] >>> print(*l)#实参拆包 2 7 5 *或 **都是加在形参的前面，表示不定长参数，分别用来接收不带变量名的多余参数和带有变量名的多余参数，分别将他们以元组和字典的形式接受进函数。当在实参的前面加上*，就意味着拆包，*表示将序列拆成一个个单独的实参。

可变对象和不可变对象当参数：

可变对象和不可变对象当参数，效果可能是不同的当实参是不可变对象时，形参值改变不会影响实参！当实参是可变对象时，形参值改变可能会影响实参！

函数返回值：

函数用return语句返回值。return后面的表达式的值就成为这次函数调用的返回值。如函数没有用return语句返回，这时函数返回的值为None；如果return后面没有表达式，调用的返回值也为None。None是Python中一个特殊的值，虽然它不表示任何数据，但仍然具有重要的作用。

EX1：求整数M和N区间内素数的个数并对他们求和(2<=M<N)

>>> def isprime(i): for k in range(2,i): if i%k==0: return False return True >>> m,n=input().split() 2 9 >>> m,n=int(m),int(n) >>> p=[i for i in range(m,n+1) if isprime(i)] >>> print(len(p),sum(p)) 4 17

EX2：返回值是函数

>>> def test(par): return par >>> def test1(): return 1000 >>> def test2(par): return 2000 >>> def f(x): return {'a':test,'b':test1,}.get(x,test2) >>> print(f('a')(1000)) 1000 >>> print(f(4)(100)) 2000 >>> print(f('a')(100)) 100

集合add函数返回值None：

按列表原来次序输出非重复元素 >>> l=[2,3,5,8,3,6,8,6,5] >>> seen=set() >>> l1=[i for i in l if i not in seen and not seen.add(i)] >>> print(l1) [2, 3, 5, 8, 6]

命名空间和作用域：

变量可被访问范围称为变量的作用域，也称为变量命名空间或变量名字空间。 Python程序用命名空间区分不同空间的相同名字。Python解释器启动时建立一个全局命名空间，全局变量就放在这个空间，还建立内置命名空间( (built-in namespace)，记录所有标准常量名、标准函数名等。在全局命名空间中定义的变量是全局变量。每一个函数定义自己的命名空间，函数内部定义的变量是局部变量。如果在一个函数中定义一个变量x，在另外一个函数中也定义x变量，因为是在不同的命名空间，所以两者指代的是不同的变量。可以通过多种方式获取其他命名空间的变量。

局部变量和全局变量：

Python语言规定赋值及定义。“var=1”赋值语句定义了变量“var”并赋值为1全局变量：定义在函数外，作用域是整个程序。局部变量：定义在函数内，作用于是函数内部。形参也是局部变量

EX3：局部变量与全局变量同名

>>> def scope(): var1=1 print("函数内部打印结果") print(var1,var2) >>> var1=10 >>> var2=20 >>> scope() 函数内部打印结果 1 20 >>> print("函数外部打印结果") 函数外部打印结果 >>> print(var1,var2) 10 20

gobal关键字： 如希望在函数中使用全局变量，而不是创建局部变量，需要用global关键字声明

>>> def scope(): global var1 var1=1 print("函数内部打印结果") print(var1,var2) >>> var1=10 >>> var2=20 >>> scope() 函数内部打印结果 1 20 >>> print("函数外部打印结果") 函数外部打印结果 >>> print(var1,var2) 1 20

递归：

函数调用自身的编程技巧称为递归。递归作为一种算法在程序设计中广泛应用。它通常把大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。一般来说，递归需要终止条件和递归条件。当终止条件不满足时，递归前进；当终止条件满足时，递归返回。编写递归函数时，必须告诉它何时停止递归，从而避免形成无限循环。

EX4:

>>> def fib(n):#假定n是正整数，返回第n+1个斐波那契数列 if n==0 or n==1: return 1 else: return fib(n-1)+fib(n-2) >>> print(fib(4)) 5

EX5:改进斐波那契数列递归程序

>>> pre={0:1,1:1} >>> def fib(n): if n in pre:#可以用int检查字典中是否有n这个关键字 return pre[n] else: newvalue=fib(n-1)+fib(n-2) pre[n]=newvalue return newvalue >>> print(fib(4)) 5 >>> print(fib(100)) 573147844013817084101

EX6:求嵌套列表中数字元素和（返回多个值）

>>> def falatten(items): lst=[] for x in items: if isinstance(x,(list,tuple))and not isinstance(x,str): for element in faltten(x): lst.append(element) else: if type(x)!=str: lst.append(x) return lst >>> items=[11,2,[3,7],(68,-1),"123",9] >>> l=[i for i in flatten(items)] >>> print(l) >>> print(sum(l)) [11,2,3,7,68,-1,9] 99

内置函数： sorted函数：

sorted函数对字符串，列表，元组，字典等对象进行排序操作。sort是应用在list上的方法， sorted可以对更多的数据类型进行排序操作。即便都是对列表操作，list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted返回的是一个新的list，而不是在原来的基础上进行的操作。sorted(iterable[,key[,reserve]])iterable–序列，如字符串，列表，元组等。key-函数，缺省为空reserve–排序规则reserve = True降序，reserve=False升序（默认）。

map函数：

map会根据提供的函数对指定序列做映射。map函数语法：map(function, iterable,…)第一个参数function是对参数序列中的每一个元素调用function数，iterable是序列返回值的新列表或迭代器，每个元素是调用function函数的返回值 print(list(map(lambda x:x**2,[1,2,3,4,5])))#使用lambda匿名函数 [1, 4, 9, 16, 25] print(list(map(lambda x,y:x+y,[1,2,3,4,5],[2,4,6,8,10])))#提供了两个列表，对相同位置的列表数据进行相加 [3, 6, 9, 12, 15]

zip函数：

zip()函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表或迭代器。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。zip语法：zip([iterable,…]) 参数说明：iterable,…–两个或多个序列 返回值：返回元组列表 >>> a=[1,2,3] >>> b=[4,5,6] >>> c=[4,5,6,7,8] >>> print(list(zip(a,b))) [(1, 4), (2, 5), (3, 6)] >>> print(list(zip(a,c))) [(1, 4), (2, 5), (3, 6)]#元素个数与最短的列表一致

EX7:字典键值互换

>>> d={'blue':500,'red':100,'white':300} >>> d1=dict(zip(d.values(),d.keys())) >>> d1 {500: 'blue', 100: 'red', 300: 'white'}

eval和exec函数：

Python是一种动态语言，它包含很多含义。Python变量类型，操作的合法性检查都在动态运行中检查；运算的代码需要到运行时才能动态确定；程序结构也可以动态变化，容许动态加载新模块等。这两个函数就体现了这个特点。eval是计算表达式，返回表达式的值exec可运行Python的程序，返回程序运行结果。 >>> x,y=3,7 >>> eval('x+3*y-4') 20 >>> exec('print("helo world")') helo world

all和any函数：

all()和any()函数将可迭代的对象作为参数。all函数参数都是True时，才返回True，否则返回False。any函数参数只要有一个为True，就返回true,参数全部是False时，返回 False。 >>> n=47 >>> all([1 if n%k!=0 else 0 for k in range(2,n)]) True >>> n=15 >>> all([1 if n%k!=0 else 0 for k in range(2,n)]) False >>> any([[],False,0])#空列表和0都表示False False

程序结构：

书的内容按照这样的层次组织：单词、句子段落以及章。代码也有类似的自底向上的组织层次：数据类型类似于单词，语句类似于句子，函数类似于落，模块类似章。一个 Python程序可以在不同文件中，这些文件是一个个模块。用 importi语句引入import模块名模块名是另外一个Python文件的文件名，不包含扩展名，模块是可以运行的程序“import 模块名”就是执行文件名为模块名的程序

引入模块中函数另一种方法：

from 模块名 import *这种方法引入模块中的所有函数，调用的时候不需要再加模块名from 模块名 import 函数名这种方法引入模块中的单个函数，调用的时候也不需要再加模块名

创建模块： 下面是triangle模块（文件名为triangle.py）

>>> import math >>> def area(a,b,c): s=(a+b+c)/2 return (math.sqrt(s*(s-a)*(s-b)*(s-c))) #主程序是另一个文件<area.py> >>> import triangle >>> a=12 >>> b=34 >>> c=26 >>> print(triangle.area(a,b,c))

模块名字空间：

“主程序”指启动一个程序的代码。包含"主程序"的模块，他的模块空间就是全局名字空间模块空间中有: 模块名，它是模块的文件名，但包含"主程序"的模块名是"main" 全局变量 函数名dir(模块名)：显示模块内容

包：

我们已使用过单行代码、多行函数、独立程序以及同一目录下的多个模块。为了使 Python应用更具可扩展性，你可以把多个模块文件组织成目录，称之为包。包是一个目录，其中包含一组模块文件和一个init.py文件。如果模块存在于包中，使用"import包名.模块名”形式导入包中模块，用以下形式调用函数：“包名.模块名.函数"

sys模块：

上面的area.py和triangle.py两个文件在同一个目录下，通过Python运行主程序area.py，会引用triangle模块，执行函数area。模块的查找路径：sys.path如不在同一目录，可用sys模块加入搜索路径后调用。 命令行参数：如何不用input()函数向程序输入值？命令行参数可以解决这个问题sys.argv[0] 程序的文件名sys.argv[1] 第一个参数sys.argv[2] 第二个参数…sys.argv[n] 第n个参数 >>> import sys >>> print(sys.argv[0]) >>> print(sys.argv[1]) >>> print(sys.argv[2]) >>> print(int(sys.argv[1])*int(sys.argvs[2]))

多项式相加程序：

a={12:9,8:15,2:3} b={19:26, 8:-1,6:-13,2:-3,0:82} def polyadd(a,b): newpoly={} deg=set(a)|set(b) for d in deg: coe=a.get(d,0)+b.get(d,0) if coe!=0: newpoly[d]=coe return newpoly lst=list(polyadd(a,b).items()) print(sorted(lst,key=lambda x:x[0],reverse=True))

全排列程序： 输入整数n（3<=n<=7）,编写程序输出1,2,…,n整数的全排列，按字典序输出。 输入样例: 输入： 输出： 3 123 132 213 231 312 321

def perm(word): #满足输入要求的n个整数组成的字符串，如"123" result=[] if len(word)<=1: #递归结束 result.append(word) return result else: #递归过程 for i in range(len(word)): newword=word[:i]+word[i+1:] #生成去掉一个后的字符串 newresult=perm(newword) #递归调用 for s in newresult: s1=word[i]+s if s1 not in result: result.append(s1) return result n=int(input()) s="".join([str(i) for i in range(1,n+1)]) for s1 in perm(s): print(s1,end=" ")