一、定义

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,n+1):
        s*=i
    return s//m,n,m

#结果
fact(10,5)
为：(725760,10,5)

a,b,c=fact(10,5)
print(a,c)
为：725760 10 5

三、局部变量和全局变量

规则1：基本数据类型，无论是否重名，局部变量与全局变量不同
规则2：组合数据类型，如果局部变量为真实创建，则是全局变量

#规则1
n,s=10,100
def fact(n,n+1):
        s*=i
    return s #此处局部变量 s是3628800
print(fact(n),s) #此处全局变量 s是100

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,dst))
        count+=1
    else:
        hanoi(n-1,mid,dst)
        print("{}:{}->{}".format(n,dst))
        count+=1
        hanoi(n-1,src)