5.0 Python 定义并使用函数

函数是python程序中的基本模块化单位，它是一段可重用的代码，可以被多次调用执行。函数接受一些输入参数，并且在执行时可能会产生一些输出结果。函数定义了一个功能的封装，使得代码能够模块化和组织结构化，更容易理解和维护。在python中，函数可以返回一个值或者不返回任何值，而且函数的参数可以是任何python对象，包括数字、字符串、列表、元组等。python内置了许多函数，同时也支持用户自定义函数。

Python 中可以创建这样四种类型的函数:

• 全局函数：定义在模块
• 局部函数：嵌套于其它函数中
• lambda函数：表达式，如需多次调用
• 方法：与特定数据类型关联的函数，并且只能与数据类型关联一起使用

函数创建的相关定义规则:

• 函数代码块以def关键词开头,后接函数标识符名称和圆括号()
• 任何传入参数和自变量必须放在圆括号中间,圆括号之间可以用于定义参数
• 函数的第一行语句可以选择性地使用文档字符串,-用于存放函数说明
• 函数内容以冒号起始,并且必须保持缩进,否则会当作普通语句来执行
• return [表达式] 结束函数,选择性地返回一个值给调用方,也就是返回值

5.1 有参与无参函数

Python是一种支持函数编程的编程语言。在Python中，函数可以分为有参函数和无参函数。有参函数接受零个或多个参数，并执行操作或返回一个值。无参函数则根本不需要任何参数。通常，有参函数通过其参数来接受外部数据，以便在函数执行时进行操作或返回结果。而无参函数则只提供在函数代码中预定义的代码块。因此，无论是有参函数还是无参函数，它们都是Python编程中非常重要的组成部分，具有广泛的用途。

定义无参函数: 如下我们编写一个无参数的函数,并在后面直接调用其执行.

>>> import sys
>>> 
>>> def lyshark():                 #定义lyshark()函数,函数执行打印
...     print("hello lyshark!")
>>> 
>>> lyshark()                      #调用了lyshark()函数,打印一段话
hello lyshark!
>>> 

定义有参函数: 如下我们编写两个函数,分别给予相应的参数,其返回值则不相同.

>>> import sys
>>> 
>>> def area(width,height):       #一个计算面积的函数,其中width,height是形式参数
...     return width * height
>>> 
>>> def print_me(name):           #一个打印函数,其中name是形式参数
...     print("welcome:",name)
>>> 
>>>   
>>> print_me("lyshark")           #调用打印函数,并掺入相应的数值
welcome: lyshark
>>> 
>>> w=10
>>> h=25
>>> print(area(w,h))              #计算平方并打印,传入数值变量计算
250

5.2 函数参数传递

默认情况下,参数通过其位置进行传递,从左至右,这意味着,必须精确地传递和函数头部参数一样多的参数,但也可以通过关键字参数、默认参数或参数容器等改变这种机制.

通常python中所支持的参数传递形式:

• 普通参数：普通参数传递,在定义函数时就指定了规律是从左至右传递
• 默认参数：定义函数时是使用"name=value"的语法直接给变量一个值,从而传入的值可以少于参数个数
• 指定参数：调用函数时指定"name形式参数=value实际参数"的语法通过参数名进行匹配
• 动态参数：在我们定义函数时,形式参数中收集任意多基于普通参数
  【定义函数时使用* ：收集普通参数,返回元组,*args】【定义函数时使用**：收集指定参数,返回列表,**kwargs】
• 动态参数解包：在调用函数时,使用**开头的参数,从而传递任意多基于普通或指定参数

关于函数中形式参数与实际参数的区别:

• 形式参数：形参变量只有在被调用时才分配内存单元,在调用结束时,即刻释放所分配的内存单元.因此,形参只在函数内部有效.函数调用结束返回主调用函数后则不能再使用该形参变量
• 实际参数：实参可以是常量、变量、表达式、函数等,无论实参是何种类型的量,在进行函数调用时,它们都必须有确定的值,以便把这些值传送给形参.因此应预先用赋值,输入等办法使参数获得确定值

普通参数传递: 定义一个函数体,并且为其传递三个参数,执行函数并打印结果.

>>> def stu(name,age,country):
...     print("姓名：",name)
...     print("年龄：",age)
...     print("国籍：",country)

>>> stu("lyshark",22,"CN")
姓名： lyshark
年龄： 22
国籍： CN
>>>
>>> stu("zhangsan",33,"CN")
姓名： zhangsan
年龄： 33
国籍： CN

带默认参数传递: 同样的,我们可以给指定的字段添加默认参数,如果用户不输入则默认使用指定参数,此处需要注意：如果您要使用带默认参数的函数,则需要把带参数的字段,放在函数最后一项.

>>> def stu(age,country,name="none",sex="man"):
...     print("姓名: ",name)
...     print("性别: ",sex)
...     print("年龄: ",age)
...     print("国籍: ",country)
...
>>>
>>> stu(23,"CN","lyshark","man")    #此时我们给予全部的参数则无默认值
姓名:  lyshark
性别:  man
年龄:  23
国籍:  CN
>>> stu("zhangsan","mal",23,"CN")   #形参如何排列,实参就得如何排列
姓名:  23
性别:  CN
年龄:  zhangsan
国籍:  mal
>>> stu(23,"CN")                    #传递输入是忽略带有默认值的字段
姓名:  none
性别:  man
年龄:  23
国籍:  CN

动态参数传递(传递列表): 若你的函数在定义时不确定用户想传入多少个参数,就可以使用非固定参数,传递一个列表.

>>> def stu(name,age,*args):                  #*args会把多传入的参数变成一个元组.
...     print(name,age,args)
>>>
>>> stu("lyshark",22)
lyshark 22 ()                                 #这个()就是args,只是因为没传值,所以为空.
>>> 
>>> stu("lyshark",22,"a","b","c","d")         #传值后会把它当作一个列表
lyshark 22 ('a', 'b', 'c', 'd')
>>> 
>>> ls=[1,2,3,4,5]                             #先声明列表
>>> stu("lyshark",22,ls)                       #传递这个列表
lyshark 22 ([1, 2, 3, 4, 5],)                  #第三个值,打印出列表

执行函数时有·*,则把所有迭代对象拆分为单个元素作为元组的元素,如传入列表,会把列表中每一个元素遍历添加到元组中当作一个元素,如下可看到差别.

>>> def fun(*args):                          #动态参数返回元组
...     print(args,type(args))
>>>
>>> lists=[1,2,3,4]                          #定义要传递的列表
>>> fun(lists)                               #传递一个列表
([1, 2, 3, 4],) <class 'tuple'>
>>> 
>>> fun(*lists)
(1, 2, 3, 4) <class 'tuple'>

动态参数传递(传递字典): 我们可以使用**kwargs默认参数,来接收一个字典,并通过函数体打印出来.

>>> def stu(name,age,*args,**kwargs):
...     print(name,age,args,kwargs)
>>> 
>>> stu("lyshark",22)                                     #传递默认参数
lyshark 22 () {}
>>> 
>>> stu("lyshark",22,"a","b",sex="Male",province="山东")  #传递元组和字典
lyshark 22 ('a', 'b') {'sex': 'Male', 'province': '山东'}

如上方法是在调用函数的时候传递的字典,当然我们也可以直接将一个现有的字典传递进去.

>>> def fun(name,**kwargs):
...     print(name,kwargs)
>>>
>>> dic={"k1":"v1","k2":"v2"}
>>> 
>>> fun("lyshark",**dic)
lyshark {'k1': 'v1', 'k2': 'v2'}

动态参数传递(万能参数): 我们使用*与**通常情况下可以传递任何值,所以称作万能参数.

>>> def fun(*args,**kwargs):
...     print(args,type(args))
...     print(kwargs,type(kwargs))
>>>
>>> lists=[1,2,3,4,5,6,7,8,9]
>>> dic={"a":1001,"b":1002,"c":1003}
>>> 
>>> fun(*lists,**dic)
(1, 2, 3, 4, 5, 6, 7, 8, 9) <class 'tuple'>
{'a': 1001, 'b': 1002, 'c': 1003} <class 'dict'>

拓展补充: 其实在python中我们经常看到万能参数,比如str.format()方法,就是一个典型的万能参数的例子,如下演示,了解即可.

>>> string="hello {0},age {1}"
>>> print(string.format("lyshark",22))
hello lyshark,age 22
>>> 
>>> string="hello {name},age {age}"
>>> print(string.format(name="lyshark",age=22))
hello lyshark,age 22
>>> 
>>> string="hello {0},age {1}"
>>> print(string.format(*["lyshark",22]))
hello lyshark,age 22
>>> 
>>> dic ={"name":"lyshark","age":22}
>>> string="hello {name},age {age}"
>>> 
>>> print(string.format(**dic))
hello lyshark,age 22

在多个同名函数的情况下,默认使用最后后一个函数,最后一个函数名会指向新的内存对象,函数名是函数体在内存中的引用.

>>> def fun(a,b):
...     return a+b
>>> def fun(a,b):
...     return a*b
>>> 
>>> print(fun(3,3))
9

函数传递的是指针,所以我们的数据会被保留下来如下例子.

>>> def fun(x):
...     x.append(8888)
>>> 
>>> lists=[1,2,3]
>>> fun(lists)
>>> 
>>> print(lists)
[1, 2, 3, 8888]

如下例子由于函数没有定义返回值,所以默认为none.

>>> def fun(x):
...     x.append(8888)
>>>
>>> lists=[1,2,3]
>>> lists=fun(lists)
>>> 
>>> print(lists)
None

5.3 通用函数返回值

return语句用来实现退出函数,选择性地向调用方返回一个表达式,不带参数值的return语句返回None,之前的例子都没有示范如何返回数值,如下先来看一下返回语句的规则:

• Return 语句用于退出函数,选择性地向调用方返回一个表达式
• 如果Return语句不带任何参数,则不带参数值的Return语句默认返回None
• 函数在执行过程中只要遇到Return,就会停止执行并返回结果,通俗的将遇到ret说明函数结束

默认函数返回: 如下使用默认函数返回,通常情况下返回一个确定数值.

>>> def add(num1,num2):
...     sum=num1+num2
...     print("函数内返回：",sum)
...     sum=sum+100
...     return sum
>>>
>>> temp=add(10,20)
函数内返回： 30
>>> print("函数外返回：",temp)
函数外返回： 130

选择性返回: 在函数体内部使用判断结构,如果输入的是偶数返回0,否则返回-1.

>>> def check(num):
...     if (num %2 ==0):
...         return 0
...     else:
...         return -1
>>>
>>> print(check(2))
0
>>> print(check(3))
-1

返回一个列表: 通过函数体的运算后,将一个列表返回给外部来接收使用.

import os

def temp_max(*args):
    all_max=[]
    temp=args
    for x in range(len(*args)):
        if temp[0][x] >= 50:
            all_max.append(temp[0][x])
    return all_max

a=[11,56,87,99,86,34,56,22,77,53]
my_max=[]

my_max=temp_max(a)
print(my_max)

5.4 通用函数闭包

函数是一段可执行代码,编译后就固化了,每个函数在内存中只有一份实例,得到函数的入口点便可以执行函数了,一个函数可作为另一个函数的参数或返回值,可以赋给一个变量.函数可以嵌套定义,即在一个函数内部可以定义另一个函数,有了嵌套函数这种结构,便会产生闭包问题.

闭包是由函数及其相关的引用环境组合而成的实体(闭包=函数+引用环境)这个从字面上很难理解,python中的闭包从表现形式上定义(解释)为：如果在一个内部函数里,对在外部作用域(但不是在全局作用域)的变量进行引用,那么内部函数就被认为是闭包(closure).这个定义是相对直白的,好理解的,下面举一个简单的例子来说明.

>>> def adds(x):
...     def adder(y):return x+y
...     return adder
...
>>> c=adds(10)
>>> type(c)
<class 'function'>
>>> c.__name__
'adder'
>>> c(10)
20

如上代码,在一个内部函数里：adder(y)就是这个内部函数,对在外部作用域(但不是在全局作用域)的变量进行引用：x就是被引用的变量,x在外部作用域adds里面,但不在全局作用域里,则这个内部函数adder就是一个闭包.闭包=函数块+定义函数时的环境,adder就是函数块,x就是环境,当然这个环境可以有很多,不止一个简单的x.

闭包返回函数: 通过使用闭包,返回一个函数,并使用函数做进一步的计算.

import os

def post_sum(*args):
    def sum():
        x=0
        for y in args:
            x=x+y
        return x
    return sum


post_sum(1,2,3,4,5)    #post_sum并没执行,而是返回一个指向求和的函数的函数名sum的内存指针

fp=post_sum(1,2,3,4,5) 
print(type(fp))        #调用f()函数,才真正调用了sum函数进行求和,这其实就是闭包

print(fp())

闭包选择返回: 通过返回值判断,来使用不同的闭包函数,从而返回不同的结果.

import os

def post(temp,*args):
    def sum():
        x=0
        for y in args:
            x=x+y
        return x
    def div():
        x=1
        for y in args:
            x=x*y
        return x

    if temp=="1":
        return sum
    else:
        return div

fp=post("1",1,2,3,4)     #使用加法闭包函数
print(type(fp))
print(fp())

fp1=post("0",1,2,3,4)    #使用乘法闭包函数
print(type(fp1))
print(fp1())

闭包返回函数列表: 通过使用闭包函数,一次性返回多个函数列表,每个函数拥有独立空间.

>>> def count():
    fs=[]
    for i in range(1,4):
        def f():
            return i*i
        fs.append(f)
    return fs

>>> f1,f2,f3=count()
>>> print(f1())
9
>>> print(f2())
9
>>> print(f3())
9

5.5 函数嵌套与递归

除了函数的闭包以外,函数还支持两种调用方式,一种是嵌套函数,另一种是递归函数,这里需要注意的是,最好在开发中尽量少用这样的结构,这种结构一旦层数变多将很难后期进行维护,所以你懂的.

• 嵌套函数：即指在一个函数体中,嵌套另外一个函数体,内部函数执行后将结果返回给外部函数使用
• 递归函数：函数在其内部调用它自己,就叫做递归,但递归需设置退出条件,不然会一直递归下去,变成一个死循环

嵌套函数: 定义一个嵌套函数,并打印出其执行轨迹,并理解其原理.

import os

name="lyshark"

def chage_name():
    name="lyshark blog"

    def chage_name_new():
        name="mkdirs blog"
        print("第3层循环打印: ",name)

    chage_name_new()              #在函数内部调用内部的函数
    print("第2层循环打印: ",name)  #第二层函数执行结果

chage_name()                      #调用最外层函数
print("查看最外层变量: ",name)     #查看外层变量

>>>
第3层循环打印:  mkdirs blog
第2层循环打印:  lyshark blog
查看最外层变量:  lyshark

递归函数: 使用递归的方式实现指定数字的阶乘,如下所示.

import os

def fun(n):
    if 0==n:              # n=0 的话直接返回空,对用户输入的零进行判断
        return None
    elif 1==n:            # n=1 的话就不再递归
        return n
    else:
        return n*fun(n-1) # 递归在执行f(n-1),直到f(1)

print(fun(5))             # 120
'''
    f(5)的执行过程如下
        ===> f(5)
        ===> 5 * f(4)
        ===> 5 * (4 * f(3))
        ===> 5 * (4 * (3 * f(2)))
        ===> 5 * (4 * (3 * (2 * f(1))))
        ===> 5 * (4 * (3 * (2 * 1)))
        ===> 5 * (4 * (3 * 2))
        ===> 5 * (4 * 6)
        ===> 5 * 24
        ===> 120
'''

5.6 LAMBDA匿名函数

Lambda是Python中的一个关键字，用于创建匿名函数。匿名函数是没有名称的小函数，通常用于仅需要一次性使用的场景。它们可以被传递为参数，或者作为返回值返回给其他函数使用。

Lambda函数的语法很简单，使用lambda关键字定义，后跟参数，并且只能包含一个表达式。该表达式的结果则作为函数返回值。

关于匿名函数的一些注意事项:

• lambda只是一个表达式,函数体比 def 简单很多
• lambda表达式会自动return返回值,条件为真返回True,条件为假返回False
• lambda函数拥有自己的命名空间,且不能访问自己参数列表之外或全局命名空间里的参数
• lambda的主体是一个表达式,而不是一个代码块,仅仅能在lambda表达式中封装有限的逻辑进去
• lambda函数看起来只能写一行,却不等同于C或C++的内联函数,应该区别对待,毕竟是两们不同语言.

定义匿名函数: 使用功能最基本的语法定义一个匿名函数.

>>> sum=lambda x,y,z: x+y+z
>>> 
>>> print("三个数相加：",sum(10,20,30))
三个数相加： 60

定义匿名函数: 对于简单的函数,也存在一种简便的表示方式,即：lambda表达式.

# ######################### 普通函数 #########################
# 定义函数（普通方式）
def func(arg):
    return arg + 1
    
# 执行函数
result = func(123)
    
# ######################### lambda #########################
    
# 定义函数（lambda表达式）
my_lambda = lambda arg : arg + 1
    
# 执行函数
result = my_lambda(123)

向匿名函数传递列表: 想一个匿名函数传递一个列表,并分别计算后返回相应数据.

>>> res=map(lambda x:x**2,[1,5,4,8])
>>> 
>>> for i in res:
    print(i)

1
25
16
64

本文作者： 王瑞
本文链接： https://www.lyshark.com/post/be3b076e.html
版权声明： 本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！