初识函数

函数

函数的意义：

生活中
一种东西：行为，是一个/一系列动作的集合。
行为~生活中一个事物本身具备，只有在执行的时候才会发生。
代码中
常规的代码就是生活中的一个/一系列动作。
函数，就是将一个/一系列代码封装起来，在需要的时候才会执行。

规则：
先声明、后调用

声明：
Python中提供了一个关键字：def 专门来定义函数

def 函数名称（函数执行需要的数据）：
	"""函数的注释，说明函数的作用"""
	函数的执行过程
	return  函数执行的结果

函数类型

1、不需要提供资源，不需要返回结果
#需求：开窗通风

def open_window():
    """开窗通风的函数"""
    print("中午下课时")
    print("打开窗户，打开门")

调用执行：

open_window()

运行结果：
中午下课时
打开窗户，打开门

2、不需要提供资源，需要返回结果
#需求：收快递

def receive_thing():
    """收取快递的行为"""
    #函数中的执行过程
    print("帮我收一个快递")
    print("门口快递架")
    print("防辐射丝袜")
    #返回结果
    return "防辐射丝袜"

调用执行：

thing = receive_thing()
print("收到的快递: ", thing)

运行结果：
帮我收一个快递
门口快递架
防辐射丝袜
收到的快递: 防辐射丝袜

3、需要提供资源，不需要返回结果
#需求：购买年会表演服

def buy_clothes(style, money):
    """购买年会表演服的函数"""
    print("购买衣服的样式: ", style)
    print("购买衣服的资金: ", style)
    print("购买完成，等待年会开始...")

调用执行函数，提供执行函数需要的数据：

buy_clothes("燕尾服", 18888)
buy_clothes("丝袜", 500)

运行结果：
购买衣服的样式: 燕尾服
购买衣服的资金: 18888
购买完成，等待年会开始…
购买衣服的样式: 丝袜
购买衣服的资金: 500
购买完成，等待年会开始…

4、需要提供资源，需要返回结果
#需求（需要的功能，要求的限制）：买烟的行为

def buy_cigratte(name, money):
    if 10 < money < 15:
        return "可以购买万宝路"
    elif money > 15:
        return "可以购买中华"
    else:
        return "买个棒棒糖戒烟吧..."

调用执行：需要提供数据，需要接受返回数据

cigratte = buy_cigratte("中华", 15)
print("购买结果:", cigratte)

运行结果：
购买结果: 买个棒棒糖戒烟吧…

函数的参数

• 形式参数：函数声明时，定义在函数名称后面括号中的变量，说明函数要执行的数据，简称形参。
• 实际参数：函数调用执行时，需要在函数名称后面的括号中填写具体数据，让函数可以使用这些具体数据进行运算，简称实参。

函数的执行过程，就是将实际参数传递(赋值)给形式参数，函数中的代码执行过程中针对接收到的具体数据进行运算的过程。

1） 参数的传递：位置参数

实际参数按照前后顺序依次赋值给形式参数。

def party(people, wine):
    print("参与人员: ", people)
    print("酒: ", wine)

party("花花", "茅台")

运行结果：
参与人员: 花花
酒: 茅台

2）参数的操作：默认值

函数声明定义时，可以给某个参数设置默认数据，在调用执行时，有默认数据的参数可以不传递实际数据。

注意：默认值参数必须放在参数列表的最后面的位置。

def party(people, wine = "茅台"):
    print("参与人员: ", people)
    print("酒:", wine)

party("老刘")
party("花花", "拉菲")

运行结果：
参与人员: 老刘
酒: 茅台
参与人员: 花花
酒: 拉菲

3）可变参数

定义在函数声明后括号中的特殊参数，可以接受0~n个实际参数。
注意：可变参数一定要放在普通参数的后面的位置。

def party(name, *things):
    print("参与人员:", name)
    print("使用资源:", things)

party("老刘")
party("老刘", "蜡烛", "披萨", "牛排")

运行结果：
参与人员: 老刘
使用资源: ()
参与人员: 老刘
使用资源: (‘蜡烛’, ‘披萨’, ‘牛排’)

4）关键字参数

定义在函数声明后括号中的特殊参数，可以接受0~n个键值对数据
注意：关键字参数一定要放在普通参数的后面的位置。

def party(name, **things):
    print("参与人员: ", name)
    print("使用资源: ", things)

party("老刘")
party("老刘", wine = "二锅头", girl = "花花")

运行结果：
参与人员: 老刘
使用资源: {}
参与人员: 老刘
使用资源: {‘wine’: ‘二锅头’, ‘girl’: ‘花花’}

5）(号称)万能参数
定义在函数后面的括号中的特殊参数序列，可以让这个函数接受任何形式的参数数据。

def party(*args, **kwargs):
    print(args) #arguments  参数
    print(kwargs) #key word arguments 关键字参数

party()  
party("老刘")
party("老刘",girl = "花花", food= "牛排")

运行结果：
{}
(‘老刘’,)
{‘girl’: ‘花花’, ‘food’: ‘牛排’}

6）强制关键字参数（位置参数）
定义在函数后面括号中的特殊参数，强制要求按照指定的键值对方式传递数据。
#它不是可变参数

def party(name, *, wine, food):
    print(name)
    print(wine)
    print(food)

party("老刘", wine = "二锅头", food = "牛排")

运行结果：
老刘
二锅头
牛排

位置参数——
优点：声明简单，语法简单 。
缺点：调用执行时~每个传递的实际参数，都必须非常清楚他们的作用。
关键字参数——
优点：调用执行时每个实际参数的意义，都有对应的变量说明。
缺点：声明较为难以理解。

函数的返回值

函数中通过return 关键字返回结果
函数中的代码执行过程中，一旦执行了return~函数结束。

1、正常情况：一个函数返回一个结果。

我们来声明定义一个运算的函数，计算两个数据的四则运算：

def calculations(num1, num2, opera):
		# 执行两个数据的四则运算
		# 函数执行完成，要返回运算结果
		return res
		
r = calculations(12, 10, ‘*’)
print(r)

运行结果：120

2、扩展情况：从变量的连续赋值演变的一种返回值情况，Python中的函数，可以返回多个数据

def calculations(num1, num2, opera):
		# 执行两个数据的四则运算
		# 函数执行完成，要返回运算结果
		return num1, num2, opera, res
		
n1, n2, o, r = calculations(12, 10, ‘*’)
print(n1, n2, o, r)

运行结果：12, 10, * , 120

函数的调用

1、函数之间的相互调用

def func_a():
	print("func_a函数执行了")
	
    # 调用执行其他函数
	func_b()

def func_b():
	 print("func_b函数执行了")

# 程序启动，调用执行了func_a()函数
func_a()

运行结果：
func_a函数执行了
func_b函数执行了

2、函数自己调用自己：函数递归调用

def func_c():
    r = input("按任意键继续，按R键结束")
    if r == "R":
        return
        
    # 调用当前函数自己
    return func_c()

func_c()

运行结果：
按任意键继续，按R键结束 （输入R程序结束）