Python基础语法学习-Day4

1、函数定义

• 在程序开发时，需要某块代码多次使用，为了提升编码的效率以及代码的重用，所以把具有独立功能的代码块组织为一个小模块，这就是函数。
• python中利用关键字def来定义一个函数，并向python指出来函数名。
• 还可能在括号内指出函数为其完成任务需要什么样的信息。
• 最后定义以冒号结尾。
• 在定义函数后，代码块部分第一行用三引号括起来的，是这个函数的文档说明，可以通过help(函数名)来查看函数的相关说明。

2、函数调用

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

def printInfo():
    print('*'*50)
    print('hello world')
    print('*'*50)
    
printInfo()

结果:
**************************************************
hello world
**************************************************

3、函数参数

• 定义函数时，可以在小括弧内写入参数，用来接收参数用的，称为“形参”，在调用时，小括号中的参数，用来传递参数的，称为“实参”。
• 当一个函数中有多个参数时，调用函数参数顺序按照定义给定的顺传入，如果想传递单个参数，可以用参数名=值的方式，精确传入。
• 按顺序传入参数时要注意参数不要写乱了，如果用精确传参的，参数顺序可以调换，注意当用精确传参时，就要所有参数都给定参数名，防止位置错乱报错。
• 当在定义函数时，用参数名=值的方式，则该参数属于缺省参数，即在调用时不传入该参数，该参数会默认使用定义时给定的值。注意，带有默认值的参数一定要位于参数列表的最后面。
• 有时可能需要一个函数能处理比当初声明时更多的参数，这些参数称为不定长参数，声明时不会命名。加了星号*的变量args会存放所以未命名的变量参数，args为元组，而加**的变量kwargs会存放命名参数，即形如key=value的参数，kewargs为字典。
• python中函数参数是引用传递（注意不是值传递）。对于不可变类型，因变量不能修改，所以运算不会影响到变量自身，而对于可变类型来说，函数体中的运算可能会更改传入的参数变量。

顺序传参
def test(a,b):
    print('*'*50)
    print(a,b)
    print('*'*50)

   
test(10,15)

结果：
**************************************************
10 15
**************************************************

精确传参

def test(a,b):
    print('*'*50)
    print(a,b)
    print('*'*50)

   
test(b=15,a=10)

结果：
**************************************************
10 15
**************************************************

如果给定一个精确参数，另外一个未指明，且不是按照函数定义时的顺序传入的，则会报错


def test(a,b):
    print('*'*50)
    print(a,b)
    print('*'*50)

   
test(b=15,10)

结果：

  line 15 test(b=15,10)
                              ^
SyntaxError: positional argument follows keyword argument

引用传参（不可变类型）
def selfAdd(a):
    a += a
    
a_int = 1
print(a_int)

b = selfAdd(a_int)
print(a_int)

结果：
1
1

引用传参（可变类型）
def selfAdd(a):
    a += a
    
a_list = [1,2]
print(a_list)

b = selfAdd(a_list)
print(a_list)

结果：
[1, 2]
[1, 2, 1, 2]

def selfAdd(a):
    a = a + a
    
a_list = [1,2]
print(a_list)

b = selfAdd(a_list)
print(a_list)

结果：
[1, 2]
[1, 2]


从上述可以看出，实际上a += a 与 a = a + a 是不同的。

4、函数返回值

想要把结果返回给调用者，需要在函数中用return来返回结果。同时，在函数返回一个值时，调用函数的需要用一个变量来接收返回的值。

def add2num(a,b):
    
    return a+b
    
result = add2num(2,3)
print(result)

结果：
5

还可以利用元组的特性，返回多个值。

def divid(a,b):
    shang = a//b
    yushu = a%b
    return shang,yushu

sh, yu = divid(10,3)
print(sh)
print(yu)

结果：
3
1

5、函数作用域

• 函数里边的变量一般只作用在函数内部，称为局部变量。
• 不同的函数，可以定义相同名字的局部变量，不允许相同名字的函数出现。
• 局部变量的作用就是临时保存数据。
• 在函数外边定义的变量叫全局变量。
• 全局变量可以在所以函数中访问。
• 如果在函数中修改全局变量，那么就需要使用关键字global进行声明。
• 如果要修改嵌套作用域（enclosing 作用域，外层非全局作用域）中的变量则需要 nonlocal 关键字来声明。
• 如果全局变量与函数中的局部变量同名，在函数使用时使用的是函数中的局部变量。
• 在函数中不使用global声明全局变量时不能修改全局变量，其本质上是不能修改全局变量的指向，即不能将全局变量指向新的数据。
• 对于不可变类型的全局变量来说，因其指向的数据不能修改，所以不使用global时无法修改全局变量。
• 对于可变类型的全局变量来说，因其指向的数据可以修改，所以不使用global时也可修改全局变量。

6、函数的嵌套调用

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

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

testA()

结果:
-----testA start-----
-----testB start-----
这里是testB函数执行的代码
-----testB end-----
-----testA end-----

7、递归函数

• 如果一个函数在内部不调用其他的函数，而是调用自身，则称该函数为递归函数。

#递归函数-阶乘

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

ret = calNum(10)
print(ret)

结果：
3628800

8、匿名函数

• 用lambda关键词能创建小型的匿名函数，这种函数得名于省略了用def声明函数的标准步骤。
• lambda函数的语法只包含一个语句：lambda [arg1 [,arg2, …argn]] : expression。
• lambda函数能接收任何数量的参数，但只能返回一个表达式的值。
• 匿名函数不能直接调用print，因为lambda需要一个表达式。
• 应用场合，函数作为参数传递。

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

结果：
a = 1
b = 2
result = 3
None

可以看到print返回值是None