Python的函数

阅读 1

2024-09-24

什么是函数

在开发程序时，需要某块代码多次，但是为了提高编写的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数

函数的文档说明

def funcTest(a,b):
    "用来完成2个数求和"
    print("%d"%(a b))
funcTest(11,22)

如果执行，以下代码

help(funcTest)
#能够看到test函数的相关说明
Help on function funcTest in module __main__:

funcTest(a, b)
    用来完成2个数求和
(END)

函数定义和调用

定义函数的格式如下:

 def 函数名():
     代码

demo:

 # 定义一个函数，能够完成打印信息的功能 
def printInfo():
    print('------------------------------------' )
    print('人生苦短，我用Python')
    print ('------------------------------------')

调用函数

定义了函数之后，就相当于有了一个具有某些功能的代码，想要让这些代码能够执行，需要调用它调用函数很简单的，通过函数名() 即可完成调用

 # 定义完函数后，函数是不会自动执行的，需要调用它才可以 
printInfo()

函数参数(一)

为了让一个函数更通用，即想让它计算哪两个数的和，就让它计算哪两个数的和，在定义函数的时候可以让函数接收数据，就解决了这个问题，这就是函数的参数

定义带有参数的函数

示例如下:

def add2num(a, b): 
    c = a b
    print(c)

调用带有参数的函数

以调用上面的add2num(a, b)函数为例:

def add2num(a, b): 
    c = a b
    print(c)
add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据

调用函数时参数的顺序

 >>> def test(a,b): ... print(a,b) ...
>>> test(1,2)
12
>>> test(b=1,a=2) 21
>>>
>>> test(b=1,2)
File "<stdin>", line 1
SyntaxError: positional argument follows keyword argument >>>

定义时小括号中的参数，用来接收参数用的，称为 “形参”
调用时小括号中的参数，用来传递给函数用的，称为 “实参”

函数返回值(一)

所谓“返回值”，就是程序中函数完成一件事情后，最后给调用者的结果

带有返回值的函数

想要在函数中把结果返回给调用者，需要在函数中使用return

如下示例:

def add2num(a, b): 
    c = a b
    return c
sum=add2num(11, 22) #调用带有参数的函数时，需要在小括号中，传递数据
print(sum)

保存函数的返回值

在本小节刚开始的时候，说过的“买烟”的例子中，最后儿子给你烟时，你一定是从儿子手中接过来对么，程序也是如此，如果一个函数返回了一个数据，那么想要用这个数据，那么就需要保存

保存函数的返回值示例如下:

 #定义函数
def add2num(a, b):
     return a b
#调用函数，顺便保存函数的返回值 
result = add2num(100,98)
#因为result已经保存了add2num的返回值，
所以接下来就可以使用了 print(result)

4种函数的类型

函数根据有没有参数，有没有返回值，可以相互组合，一共有4种
无参数，无返回值
无参数，又反悔
有参数，无返回值
有参数，有返回值

无参数，无返回值的函数

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

def printMenu(): 
    print('--------------------------') 
    print(' File')
    print(' Edit')
    print(' Selection')
    print(' View')
    print('--------------------------')

无参数，有返回值的函数

此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

 # 获取温度
def getTemperature():
#这里是获取温度的一些处理过程 #为了简单起见，先模拟返回一个数据
     return 24
temperature = getTemperature()

有参数，无返回值的函数

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

有参数，有返回值的函数

此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数

 # 计算1~num的累积和
def calculateNum(num):
    result = 0 
    i=1
    while i<=num:
        result = result   i
        i =1 
    return result
result = calculateNum(100) 
print('1~100的累积和为:%d'%result)

函数根据有没有参数，有没有返回值可以相互组合
定义函数时，是根据实际的功能需求来设计的，所以不同开发人员编写的函数类型各不相同

函数的嵌套调用

def testB():
    print('---- testB start----') 
    print('这里是testB函数执行的代码...(省略)...') 
    print('---- testB end----')
def testA():
    print('---- testA start----') 
    testB()
    print('---- testA end----')
testA()

一个函数里面又调用了另外一个函数，这就是所谓的函数嵌套调用
如果函数A中，调用了另外一个函数B，那么先把函数B中的任务都执行完毕之后才会回到上次函数A执行的位置

函数局部变量

什么是局部变量

局部变量，就是在函数内部定义的变量
不同的函数，可以定义相同的名字的局部变量，但是各用个的不会产生影响
局部变量的作用，为了临时保存数据需要在函数中定义变量来进行存储，这就是它的作用

全局变量

什么是全局变量

如果一个变量，既能在一个函数中使用，也能在其他的函数中使用，这样的变量就是全局变量

 # 定义全局变量
a =100
def test1():
    print(a)
def test2():
    print(a)

test1()
test2()

全局变量和局部变量名字相同问题

 # 定义全局变量
a =100
def test1():
    a=300
    print(a)
def test2():
    print(a)

test1()
test2()

输出结果：
300
100

修改全局变量

既然全局变量，就是能够在所以的函数中进行使用，那么可否进行修改呢?

 # 定义全局变量
a =100
def test1():
    global a
    print("-----test1----修改前---a=%d"%a)
    a=300
    print("-----test1----修改后---a=%d"%a)
    print(a)
def test2():
    print(a)

test1()
test2()

在函数外边定义的变量叫做全局变量
全局变量能够在所有的函数中进行访问
如果在函数中修改全局变量，那么就需要使用 global 进行声明，否则出错如果全局变量的名字和局部变量的名字相同，那么使用的是局部变量的，小技巧强龙不压地头蛇

可变类型的全局变量

在函数中不使用global声明全局变量时不能修改全局变量的本质是不能修改全局变量的指向，即不能将全局变量指向新的数据。
对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

匿名函数

用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda函数的语法只包含一个语句，如下:

  lambda [arg1 [,arg2,.....argn]]:expression

如下实例:

sum = lambda arg1, arg2:arg1   arg2
#调用sum函数
print ("Value of total : ", sum( 10, 20 ) )
print ("Value of total : ", sum( 20, 20 ))

Lambda函数能接收任何数量的参数但只能返回一个表达式的值
匿名函数不能直接调用print，因为lambda需要一个表达式

函数作为参数传递

def func(a,b,opt):
    print("a===",a)
    print("b===",b)
    print("result===",opt(a,b))
func(1,2,lambda x,y:x y)

输出结果：
a=== 1
b=== 2
result=== 3

作为内置函数的参数

下面的数据如何指定按age或name排序?
lnglist=[{"name":"Python","age":18},{"name":"Java","age":19},{"name":"C","age":20} ]

按name排序:

lnglist=[{"name":"Python","age":18},{"name":"Java","age":19},{"name":"C","age":20} ]
lnglist.sort(key=lambda x:x['name'])
print(lnglist)

结果：
[{'name': 'C', 'age': 20}, {'name': 'Java', 'age': 19}, {'name': 'Python', 'age': 18}]

按age排序:

lnglist=[{"name":"Python","age":21},{"name":"Java","age":19},{"name":"C","age":20} ]
lnglist.sort(key=lambda x:x['age'])
print(lnglist)
输出：
[{'name': 'Java', 'age': 19}, {'name': 'C', 'age': 20}, {'name': 'Python', 'age': 21}]

递归函数

什么是递归函数

通过前面的学习知道一个函数可以调用其他函数。如果一个函数在内部不调用其它的函数，而是自己本身的话，这个函数就是递归函数。

递归函数的作用

举个例子，我们来计算阶乘 n! = 1 * 2 * 3 * ... * n

def calNum(num):
    if num >=1:
        result=num * calNum(num-1)
    else:
        result=1
    return result
ret=calNum(5)
print(ret)

上一篇： Python的元组

下一篇：Python文件操作介绍

类别