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

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

#例如
add()
add_modify(10, 20)

def add_modify(a, b):
    result = a + b
    add()   	#嵌套调用函数add()
    print(result)
add_modify(10, 20)

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)

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

“*” —— 接收以元组形式打包的多个值

“**”—— 接收以字典形式打包的多个值

4.1打包：

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}

4.2解包：

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}

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

def 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)

四、变量作用域：变量并非在程序的任意位置都可以被访问，其访问权限取决于变量定义的位置，其所处的有效范围称为变量的作用域。

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

1、局部变量：

函数内部定义的变量，只能在函数内部被使用

函数执行结束之后局部变量会被释放，此时无法再进行访问。

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

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

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

五、global和nonlocal关键字：函数内部无法直接修改全局变量或在嵌套函数的外层函数声明的变量，但可以使用global或nonlocal关键字修饰变量以间接修改以上变量。

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

def test():
    number = 10
    def test_in():
        nonlocal number #在局部作用域中修改嵌套作用域中定义的变量
        number = 20
    test_in()
    print(number)
test()

六、递归函数：函数在定义时可以直接或间接地调用其他函数。若函数内部调用了自身，则这个函数被称为递归函数。

1、递归函数的执行可以分为以下两个阶段：

1.递推：递归本次的执行都基于上一次的运算结果。

2.回溯：遇到终止条件时，则沿着递推往回一级一级地把值返回来。

格式：

def函数名([参数列表])：

? if 边界条件：

? rerun 结果

? else:

? return 递归公式

七、匿名函数：匿名函数是一类无需定义标识符的函数，它与普通函数一样可以在程序的任何位置使用。Python中使用lambda关键字定义匿名函数，它的语法格式如下：

lambda <形式参数列表> :<表达式>

八、实例展示：

编写一个函数，可以接受任意多个数字 *xxx,返回元组() 要求：元组的第一个数字是所有数字的平均数sum()/len()，后面数字要比平均数大的所有数字[].append()

def receive(lst):
    li=[]
    avg=sum(lst)/len(lst)
    li.append(avg)
    for i in lst:
        if i>avg:
            li.append(i)
    return li
lst=list(map(int,input().split(" ")))
tp=tuple(receive(lst))
print(tp)