Python基础之函数

一、函数定义和调用函数

函数是可以实现某种操作的代码块，可以用它们构建更大的程序，我们可以把一个代码块与其他代码块组合使用，就像积木搭建房子一样。
在Python中，可以通过def关键字来定义函数，然后利用调用函数名来调用该函数。
定义函数：

	def <函数名>（<参数列表>）:
		<函数体>
		return<返回值列表>

调用函数是指运行函数定义中的代码，如果我们定义了一个函数，却从来不调用它，那么这段代码就永远不会运行。
调用函数：

	<函数名>(<参数列表>)

def sum_num():  #定义函数
    num1=10
    num2=12
    sum=num1+num2
    print("{}+{}={}".format(num1,num2,sum))

sum_num()  #调用函数，只有调用了函数，之前定义的函数才会运行
--------------------------------------------------------
输出结果：
10+12=22

二、函数的参数传递

参数的作用
函数的参数，增加函数通用性，针对相同的数据处理逻辑，能够适应更多的数据
1、 在函数内部，把参数当做变量使用，进行需要的数据处理
2、 函数调用时，按照函数定义的参数顺序，把希望在函数内部处理的数据，通过参数传递

1、形参和实参

形参：定义函数时，小括号中的参数，用来接收参数用，在函数内部作变量使用。
实参：调用函数时，小括号中的参数，使用来把数据传递到函数内部用的。

'''无参函数'''
def sum0_num():  #定义无参函数
    num1=10
    num2=12
    print("{}+{}={}".format(num1,num2,num1+num2))

sum0_num()  #调用函数，只有调用了函数，之前定义的函数才会运行
--------------------------------------------------------
输出结果：
10+12=22

'''有参函数'''
def sum1_num( num1,num2) :  #定义有参函数
    print("{}+{}={}".format(num1,num2,num1+num2))

sum1_num(10,12)  #调用函数，将实参传递给形参
--------------------------------------------------------
输出结果：
10+12=22

2、可选参数和可变数量参数传递

可选参数传递
函数的参数在定义时，可以指定默认值，当函数被调用时，如果没有传入对应的参数值，则使用函数定义时的默认值代替。

def test(str,fs=2): #可选参数也称缺省参数
    print(str*fs)
test("happy") # fs没有参数传入，直接取默认值
test("happy",3) #fs=3，直接替换原来定义的默认值
----------------------------------------------
输出结果：
happyhappy
happyhappyhappy

可变数量参数传递
函数在定义时，可通过星号实现可变数量参数，带有星号的可变参数只能出现在参数列表的后面，被当做是元组类型传递到函数中。

	def <函数名>（<参数1>,<*参数2>,<**参数3>）:
		<函数体>
		return<返回值列表>

def test1(a,*args): # *args表示元组
    print(type(args))
    for i in args:
        a +=i
    return a
result=test1(1,2,3,4)
print(result)
---------------------------------------
输出结果：
<class 'tuple'>
10

def test2(a,*b,**c): #**c代表字典
    print(type(c))
    print(a)
    print(b)
    print(c)
    
test2(1,2,3,4,name="小明",age=18,gender=True)
--------------------------------------------------
输出结果：
<class 'dict'>
1
(2, 3, 4)
{'name': '小明', 'age': 18, 'gender': True}

3、参数位置和名称传递

参数位置传递
函数调用时，实参默认采用按照位置顺序的方式传递给函数

参数名称传递
函数调用时，按照形参名称输入实参的方式传递给函数，参数之间的顺序可以任意调整。

<函数名>（<参数名>=<实际值>）

三、 函数返回值 return

return 语句用来退出函数并将程序返回到函数被调用的位置继续执行。
Python在调用函数时，为了使得函数返回我们想要的值，常用return来解决此问题。return语句可以同时将0个、1个或者多个函数运算后的结果返回函数被调用处的变量。

'''函数中没有return时'''
def test(a,b):
	s=a+b #可以使用变量来接收函数执行的结果
result=test(1,2)
print(result)
-----------------------------------------------------
输出结果：
None

执行调用函数，输出为None，没有结果输出，因为调用函数时并没有接收return这个结果。

'''函数中有return时'''
def test(a,b):
	s=a+b
	return s  #用return来接收结果
result=test(1,2)
print(result)
-----------------------------------------------------
输出结果：
3

def test(a,b):
    result=a+b
    return result #程序运行到所遇到的第一个return即返回，退出函数，调回调用处
    c=a-b #后面程序不再执行
    return c  
sum_result=test(10,12)
print(sum_result)
-----------------------------------------------------
输出结果：
22

return表示返回，在哪里调用就返回到哪里，程序运行到所遇到的第一个return即返回，退出函数，后续的代码都不会被执行，直接跳到函数调用处。
return返回值可以是一个数值，一个字符串，一个布尔值或一个列表、函数等。
return可以返回多个值，多个值时一元组类型保存。

四、 局部变量和全局变量

局部变量
定义在函数内部使用的变量，仅在函数内部有效，当函数退出时变量不存在。

def demo1():
    num=10
    print(num,id(num))
    num=20
    print("修改后num为{}，地址为{}".format(num,id(num)))
          
demo1()
          
def demo2():
    num=100
    print(num,id(num))
demo2()

-------------------------------------------------------------------------
输出结果：
10 2454820317776
修改后num为20，地址为2454820318096
100 2454820509136

不同函数内部同名局部变量，地址不同。

n=1
def func(a,b):
    c=a*b #c是局部变量，a和b作为函数参数也是局部变量
    return c
s=func("happy",2)
print(c)
----------------------------------------------------------
输出结果：
NameError                                 Traceback (most recent call last)
C:\Users\ADMINI~1\AppData\Local\Temp/ipykernel_12484/4292904185.py in <module>
----> 6 print(c)
NameError: name 'c' is not defined

从输出的结果来看，这说明当函数执行完退出后，内部的局部变量将被释放了，这也说明局部变量是有生命周期的。
局部变量的生命周期就是变量从被创建到被系统回收的过程。
（1）局部变量在函数执行时才会被创建
（2）函数执行结束后局部变量被系统回收
（3）局部变量在生命周期内，可以用来存储函数内部临时使用到的数据。

全局变量
定义在函数外面的变量，一般没有缩进，在程序执行全过程有效。

num=10 #定义全局变量
def demo1():
    print(num,id(num))
          
demo1()
          
def demo2():
    print(num,id(num))
demo2()
print("over") 
----------------------------------
输出结果：
10 2454820317776
10 2454820317776
over   

全局变量在不同的函数中的值和地址是一样的。
在函数内部如何使用全局变量，可以使用global关键字修改全局变量。

num=50
def demo1():
    print("demo1"+"-"*50)
    global num  #global关键字告诉Python要修改全局变量，在函数内部不能直接用赋值语句修改全局变量
    num=100
    print(num,id(num))
          
demo1()
          
def demo2():
    print("demo2"+"-"*50)
    print(num,id(num))
demo2()
------------------------------------------------------------
输出结果：
demo1--------------------------------------------------
100 2454820509136
demo2--------------------------------------------------
100 2454820509136

为了保证所有的函数都能够正确使用到全局变量，应该将全局变量定义在函数的上方。
函数执行时需要处理变量时：
（1）首先查找函数内部是否存在执行名称的局部变量，如果有，直接使用。
（2）如果没有，查找函数外部是否存在执行名称的局部变量，如果有，直接使用。
（3）如果还没有，程序将报错。
如果全局变量时个列表，如何在函数中修改全局变量？

ls=[] #ls是全局列表变量
def func(a,b):
    ls.append(b) #将局部变量b增加到全局列表变量ls中
    return a*b
s=func("happy",2) #测试ls值是否改变
print(s,ls)
-------------------------------------------------------------
输出结果：
happyhappy [2]

从结果来看，ls列表值改变了，函数内部如果没有被真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值。

ls=[] #ls是全局列表变量
def func(a,b):
    ls=[] #创建了名称为ls的局部列表变量
    ls.append(b) #将局部变量b增加到全局列表变量ls中
    return a*b
s=func("happy",2) #测试ls值是否改变
print(s,ls)
-------------------------------------------------------------
输出结果：
happyhappy [ ]

从结果来看，ls列表值没有改变，如果函数内部真实创建了列表同名的变量，无论是否有同名全局变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量值不变。

总结：
Python函数对变量的作用个遵守如下原则：
（1）简单数据类型（整型、浮点型、字符串）变量无论是否与全局变量重名，仅在函数内部创建和使用。函数退出后，变量被释放，如果有全局同名变量，其值不变。
（2）简单数据类型（整型、浮点型、字符串）变量在用global保留字声明后，作为全局变量使用，函数退出后该变量保留且值被函数改变。
（3）对于组合数据类型（列表，元组、集合、字典）的全局变量，如果在函数内部没有被真实创建的同名变量，则函数内部可以直接使用并修改全局变量的值。
（4）如果函数内部真实创建了组合数据类型的变量，无论是否有同名全局变量，函数仅对局部变量进行操作，函数退出后局部变量被释放，全局变量值不变。lambda

五、lambda函数–匿名函数

<函数名>=lambda<参数列表>:<表达式>

f=lambda x,y:x+y
result=f(10,12)
print(result)
---------------------------------
输出结果：
22