一、定义
def <函数名>(<参数>):
<函数体>
return <返回值>
#计算 n!
def fact(n):
s=1
for i in range(1,n+1):
s*=i
return s
二、可变参数传递
1、函数定义时可为某些参数指定默认值,构成可选参数
def <函数名>(<非可选参数>,<可选参数>):
<函数体>
return <返回值>
#可选参数必须放在非可选参数后面
#计算 n!//m
def fact(n,m=1):
s=1
for i in range(1,n+1):
s*=i
return s//m
2、函数定义时可设计可变数量参数,即不确定参数的数目
def <函数名>(<参数>,*b):
<函数体>
return <返回值>
def fact(n,*b):
s=1
for i in range(1,n+1):
s*=i
for item in b:
s*=item
return s
#函数的返回值中,如果 return了多个数据,则用“()”括住,用“,”分隔,即元组类型
def fact(n,m=1):
s=1
for i in range(1,n+1):
s*=i
return s//m,n,m
#结果
fact(10,5)
为:(725760,10,5)
a,b,c=fact(10,5)
print(a,b,c)
为:725760 10 5
三、局部变量和全局变量
规则1:基本数据类型,无论是否重名,局部变量与全局变量不同
规则2:组合数据类型,如果局部变量为真实创建,则是全局变量
#规则1
n,s=10,100
def fact(n,m=1):
s=1
for i in range(1,n+1):
s*=i
return s #此处局部变量 s是3628800
print(fact(n),s) #此处全局变量 s是100
n,s=10,100
def fact(n,m=1):
global s #可通过 global保留字在函数内部声明全局变量
for i in range(1,n+1):
s*=i
return s #此处 s是全局变量362880000
print(fact(n),s) #此处全局变量 s被函数修改,是362880000
#规则2
ls=["F","f"]
def func(a):
ls.append(a) #此处 ls是列表类型,未真实创建,等同于全局变量
return
func("C") #全局变量 ls被修改
print(ls) #结果为:['F','f','C']
ls=["F","f"] #通过使用 []真是创建了一个全局变量列表 ls
def func(a):
ls=[] #此处 ls是列表类型,真实创建,局部变量
ls.append(a)
return
func("C") #局部变量 ls被修改
print(ls) #结果为:['F','f']
四、代码复用与模块化设计
函数 和 对象 是代码复用的两种主要形式
- 函数:将代码命名.在代码层面建立了初步抽象
- 对象:属性和方法。
<a>.<b>
和<a>.<b>()
。在函数之上再次组织进行抽象
紧耦合、松耦合
- 紧耦合:两个部分交流很多,无法独立存在
- 松耦合:两个部分交流很少,可以独立存在
- 模块内部紧耦合,模块之间松耦合
五、函数递归
函数定义中调用自身的方式
两个关键特征
- 链条:计算过程存在递归链条
- 基例:存在一个或多个不需要再次递归的基例
实现:函数+分支语句,分别对应链条和基例
#求 n!
def fact(n):
if( n==0):
return 1
else:
return n*fact(n-1)
#字符串反转
def rva(s):
if s=="":
return s
else:
return rvs(s[1:])+s[0] #每次将首个字符放在字符串的最后
#斐波那契数列
def f(n):
if n==1 or n==2:
return 1
else:
return f(n-1)+f(n-2)
#汉诺塔
count=0
def hanoi(n,src,dst,mid):
global count
if n==1:
print("{}:{}->{}".format(1,src,dst))
count+=1
else:
hanoi(n-1,src,mid,dst)
print("{}:{}->{}".format(n,src,dst))
count+=1
hanoi(n-1,mid,dst,src)