Python函数

1.函数的概念：函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创建函数，这被叫做用户自定义函数。

2.定义函数：前面使用的print()函数和input()都是Python的内置函数，这些函数由Python定义。

无参函数：def add():     result = 11 + 22     print(result)

有参函数： def add_modify(a, b):     result = a + b     print(result)

def printme( str ):
   "打印传入的字符串到标准显示设备上"
   print str
   return

2.调用函数：函数在定义完成后不会立刻执行，直到被程序调用时才会执行。注：1. 程序在调用函数的位置暂停执行。2. 将数据传递给函数参数。3. 执行函数体中的语句。4. 程序回到暂停处继续执行。

# 定义函数
def printme( str ):
   "打印任何传入的字符串"
   print str
   return
 
# 调用函数
printme("我要调用用户自定义函数!")
printme("再次调用同一函数")

函数内部也可以调用其他函数，这被称为函数的嵌套调用。

def add_modify(a, b):     result = a + b     add()            print(result) add_modify(10, 20)

函数在定义时可以在其内部嵌套定义另外一个函数，此时嵌套的函数称为外层函数，被嵌套的函数称为内层函数。

def add_modify(a, b):
    result = a + b
    print(result)
    def test(): 
        print("我是内层函数")                  
add_modify(10, 20)

注意：函数外部无法直接调用内层函数，只能通过外层函数间接调用内层函数

3.函数参数的传递:将定义函数时设置的参数称为形式参数（简称为形参)，将调用函数时传入的参数称为实际参数（简称为实参）。函数的参数传递是指将实际参数传递给形式参数的过程。

函数参数的传递可以分为位置参数传递、关键字参数传递、默认参数传递、参数的打包与解包以及混合传递。

def get_max(a, b):
    if a > b:
        print(a,"是较大的值！")
    else:
        print(b,"是较大的值！")
get_max(8, 5)

关键字参数的传递是通过“形参=实参”的格式将实参与形参相关联，将实参按照相应的关键字传递给形参。

def connect(ip, port):
    print(f"设备{ip}:{port}连接！")
connect(ip="127.0.0.1", port=8080)

4.参数的打包与解包：打包——“*”：

定义：def test(*args):     print(args)

调用：test(11, 22, 33, 44, 55)

结果：(11, 22, 33, 44, 55)

打包——“**”：

定义：def test(**kwargs):     print(kwargs)

调用：test(a=11, b=22, c=33, d=44, e=55)

结果：{'a': 11, 'b': 22, 'c': 33, 'd': 44, 'e': 55}

解包：*

定义：def test(a, b, c, d, e):     print(a, b, c, d, e)

调用：nums = (11, 22, 33, 44, 55) test(*nums)

结果：{'a': 11, 'b': 22, 'c': 311 22 33 44 553, 'd': 44, 'e': 55}

**：

定义：def test(a, b, c, d, e):     print(a, b, c, d, e)

调用：nums = {"a":11, "b":22, "c":33, "d":44, "e":55} test(**nums)

结果：11 22 33 44 55

5.混合传递：前面介绍的参数传递的方式在定义函数或调用函数时可以混合使用，但是需要遵循一定的规则，具体规则如下。

优先按位置参数传递的方式。 然后按关键字参数传递的方式。 之后按默认参数传递的方式。 最后按打包传递的方式。

在定义函数时：
带有默认值的参数必须位于普通参数之后。
带有“*”标识的参数必须位于带有默认值的参数之后。
带有“**”标识的参数必须位于带有“*”标识的参数之后

定义：def test(a, b, c=33, *args, **kwargs): print(a, b, c, args, kwargs)

调用：test(1, 2) test(1, 2, 3) test(1, 2, 3, 4) test(1, 2, 3, 4, e=5)

结果： 2 33 () {} 1 2 3 () {} 1 2 3 (4,) {} 1 2 3 (4,) {'e': 5}

6. 函数的返回值：函数中的return语句会在函数结束时将数据返回给程序，同时让程序回到函数被调用的位置继续执行。

定义：def filter_sensitive_words(words):     if "山寨" in words:         new_words = words.replace("山寨", "**")         return new_wordsdef filter_sensitive_words(words):     if "山寨" in words:         new_words = words.replace("山寨", "**")         return new_words

调用：result = filter_sensitive_words("这个手机是山寨版吧！") print(result)

结果：这个手机是**版吧！

如果函数使用return语句返回了多个值，那么这些值将被保存到元组中。

定义：def move(x, y, step):     nx = x + step     ny = y - step     return nx, ny     # 使用return语句返回多个值

调用：result = move(100, 100, 60)       print(result)

结果：(160, 40)

7.局部变量和全局变量：根据作用域的不同，变量可以划分为局部变量和全局变量。

局部变量：函数内部定义的变量，只能在函数内部被使用。函数执行结束之后局部变量会被释放，此时无法再进行访问。

def test_one():
    number = 10    	              # 局部变量
    print(number) 	              # 函数内部访问局部变量
test_one()
print(number)

def test_one():
    number = 10      
    print(number)             # 访问test_one()函数的局部变量number
def test_two():
    number = 20
    print(number)             # 访问test_two()函数的局部变量number
test_one()
test_two()

全局变量：全局变量可以在整个程序的范围内起作用，它不会受到函数范围的影响。

number = 10         							# 全局变量
def test_one():
    print(number)   							# 函数内部访问全局变量
test_one()
print(number)

全局变量在函数内部只能被访问，而无法直接修改。

# 定义全局变量
number = 10
def test_one():
    print(number) 
    number += 1
test_one()
print(number)

8.global和nonlocal关键字

global关键字：使用global关键字可以将局部变量声明为全局变量，其使用方法如下：

number = 10                    # 定义全局变量
def test_one():
    global number              # 使用global声明变量number为全局变量
    number += 1
    print(number)
test_one()
print(number)

nonlocal关键字：使用nonlocal关键字可以在局部作用域中修改嵌套作用域中定义的变量，其使用方法如下：

def test():
    number = 10
    def test_in():
        nonlocal number
        number = 20
    test_in()
    print(number)
test()

9.递归函数：函数在定义时可以直接或间接地调用其他函数。若函数内部调用了自身，则这个函数被称为递归函数。注：递归函数在定义时需要满足两个基本条件：一个是递归公式，另一个是边界条件

递归函数的执行可以分为以下两个阶段：
1.递推：递归本次的执行都基于上一次的运算结果。
2.回溯：遇到终止条件时，则沿着递推往回一级一级地把值返回来 

def函数名([参数列表])：
	if 边界条件：
		rerun 结果
	else:
		return 递归公式

 阶乘n!：

n! = 1 * 2 * 3 * … * n，可以分为以下两种情况： 1. 当n=1时，所得的结果为1。 2. 当n>1时，所得的结果为n*(n-1)!。

def func(num):
     if num == 1: 
         return 1
     else:
         return num * func(num - 1)
num = int(input("请输入一个整数："))
result = func(num)
print("5!=%d"%result)