python函数（细讲）

 计算n!（n的阶乘）

函数的定义 

def fact(n): #fact是函数名，n是参数
    s=1
    for i in range(1,n+1):
        s*=i
    return s #最后将阶乘的结果s返回来
#这就是一个函数的定义，程序看到这段定义，并不会去执行这段代码，执行是要使用函数的调用方式

函数的调用

调用时要给出实际参数

要用实际参数替换定义中的占位参数

函数调用后会得到实际参数运行之后的运行结果（即返回值）

例如：我们用fact(10)计算10！

之后的结果赋给变量a

并且将a打印出来

def fact(n): 
    s=1
    for i in range(1,n+1):
        s*=i
    return s
a=fact(10) #所谓函数的调用就是用函数的名称给定一个具体的值作为参数，fact(10)这是函数的调用
print(a)

 函数的参数传递

def<函数名>(): #函数可以有参数，也可以没有，但是必须保留括号
    <函数体>
    return<返回值>

可选参数传递 

def<函数名>(<非可选参数>,<可选参数>):
    <函数体>
    return<返回值>

def fact(n,m=1): #n为非可选参数（即必选参数），且必须放在可选参数前,m为可选参数
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m  #n的阶乘整除m
a=fact(10) #调用的时候可以使用第二个参数，也可以不使用，这里给出fact(10)，10替换了n,m默认为1
print(a)

---

def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m #n的阶乘整除m
a=fact(10,5) #我们也可以给出第二个参数，m就替换为5，而不是默认开始给的值
print(a)

可变参数传递 

def<函数名>(<参数>,*b): #那些确定要给的参数放在前面，然后最后增加一个*b来表达不确定的参数，用*c、*a表示也可以，这个b是一个自己可以定义的变量名字
    <函数体>
    return<返回值>

这里我们计算n! 乘数的问题

def fact(n,*b):#*b是可变参数
    s=1
    for i in range(1,n+1):
        s*=i #这里计算n的阶乘的值
    for item in b:
        s*=item
    return s
a=fact(10,3)#指的是我们算了10！并且与3相乘
print(a)

---

def fact(n,*b):#*b是可变参数
    s=1
    for i in range(1,n+1):
        s*=i #这里计算n的阶乘的值
    for item in b:
        s*=item
    return s
a=fact(10,3,5,8)#这里体现出了*b的作用，可以给出很多值，这些值会跟10！运算的结果逐一相乘并返回结果
print(a)

参数传递的两种方式

def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m
a=fact(10,5) #位置传递（一般都默认位置传参）
a=fact(m=5,n=10)#名称传递（也可以名称传参）
print(a)

函数的返回值

函数可以返回零个或多个结果

return保留字用来传递返回值

函数可以有返回值也可以没有

可以有return也可以没有

return可以传递零个返回值

也可以传递任意多个返回值

def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m,n,m  #传递多个返回值
a=fact(m=5,n=10)#名称传参
print(a)

 用小括号中间逗号分隔的这种形式

是一种组合数据类型叫元组类型

列表类型是指用方括号

中间用逗号分隔的几个元素

还可以使用几个变量

它们之间有逗号来分隔

并且获得返回值

def fact(n,m=1):
    s=1
    for i in range(1,n+1):
        s*=i
    return s//m,n,m
a,b,c=fact(m=5,n=10)  #它指的是将函数运算的返回值分别赋给a b c
print(a,b,c)

 局部变量和全局变量

一段程序中间有一个函数定义

其中使用的变量叫做全局变量 

局部变量是函数内部使用的变量

全局变量是函数外部整个程序使用的变量 

 

n,s=10,100 #这里的n和s就是全局变量
def fact(n): #fact()函数中的n是局部变量
    s=1 #函数中的s是局部变量与全局变量s不同
    for i in range(1,n+1):
        s*=i
    return s #此处局部变量的值s是3628800
print(fact(n),s) #这里的n和s是全局变量，此处的全局变量s是100

#!!!局部变量和全局变量是不同变量，局部变量是函数内部的占位符，与全局变量可能重名但不同

#!!!函数运算结束后，局部变量被释放（即这个变量将不再存在，它只是用于函数内部运算的）

#!!!可以使用global保留字在函数内部使用全局变量

 global保留字用来在函数内部中声明这个变量

这个变量是全局变量而不是局部变量

n,s=10,100
def fact(n):
    global s #fact()函数中使用global保留字声明此处s是全局变量s
    for i in range(1,n+1):
        s*=i
    return s #此处s指全局变量s
print(fact(n),s) #此处全局变量s被函数修改，运行结果与之前使用局部变量的s是不同的

组合数据类型

 局部变量如果它是组合数据类型

而且未在函数内部创建

它等同于全局变量

ls=["F","f"] #通过使用[]真是创建了一个全局变量列表ls
def func(a):
    ls.append(a) #此处ls是列表类型，未真实创建，则等同于全局变量
    return
func("C") #指的是调用这段函数，全局变量ls被修改，向ls列表中增加一个变量C
print(ls)

 

 如果一个组合数据类型

在函数中它被真实创建了

那么它就是这个函数的局部变量了

所以是局部变量

那么在函数运行之后

这个变量就会被释放或消亡

它就不存在了

ls=["F","f"] #通过使用[]真实创建了一个全局变量列表ls
def func(a):
    ls=[] #此处ls是列表类型，真实创建，ls是局部变量
    ls.append(a)
    return
func("C") #局部变量ls被修改
print(ls) #这里打印的是全局变量

#如果一个组合数据类型，在函数中它被真实创建了，那么它就是这个函数的局部变量了，所以是局部变量，那么在函数运行之后，这个变量就会被释放，它就不存在了。

 lambda函数

lambda函数返回函数名作为结果

lambda函数是一种匿名函数

（没有名字的函数）

使用lambda保留字定义，函数名是返回结果

lambda函数用于定义简单的

能在一行内表示的函数

<函数名>=lambda<参数>:<表达式> #这是一种非常简单的函数的紧凑表达形式，它等价于用def和return，但它的后面只能跟表达式而不能跟函数体

f=lambda x,y:x+y #lambda保留字表示定义lambda函数，x和y表示这个函数有两个参数，我们定义了一个函数f，它有两个参数，运算的内容是x+y
f(10,15)
25

 lambda函数也可以接受那种没有参数的函数

f=lambda:"lambda函数"
print(f())
lambda函数

谨慎使用lambda函数

lambda函数主要用作

一些特定函数或方法的参数

lambda函数有一些固定使用方法

建议逐步掌握

一般情况，建议使用def定义的普通函数