1.函数

2.参数

3.函数的返回值

4.函数的四种类型

5.函数的嵌套调用

1.函数

1.1概念

1、所谓函数，就是把具有独立功能的代码块组织为一个整体，方便在需要的时候调用
2、函数的使用包含两个步骤：
定义函数 —— 在函数中编写代码，实现功能
调用函数 —— 执行编写的代码
3、函数的作用，在开发程序时，使用函数可以提高编写的效率以及代码的重用性

1.2命名规则

函数名称应该能够简单明确的表达函数功能，以方便后续的调用
函数名称的命名应该符合标识符的命名规则
1.可以由字母、下划线和数字组成
2.不能以数字开头
3.不能与关键字重名

1.3定义与调用

定义函数的格式如下：

def 函数名():

    函数封装的代码
   

函数的调用：

函数名()

1.4文档注释

在开发中，如果希望给函数添加注释，应该在定义函数的下方，
使用连续的三对引号，这种注释是给函数用的，方便给调用的人知道函数是怎么用的
在连续的三对引号之间编写对函数的说明文字
在函数调用位置，使用鼠标点击函数名后，然后使用快捷键 CTRL + Q 可以查看函数的说明信息

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)

func_sum()

注意：因为函数体相对比较独立，函数定义的上方，应该和其他代码（包括注释保留） 两个空行

2.参数

2.1参数的使用

在函数名的后面的小括号内部填写参数
多个参数之间使用半角逗号分隔，如

def sum_2_num(num1, num2):
    result = num1 + num2
    print("%d + %d = %d" % (num1, num2, result))
sum_2_num(50, 20)

2.2参数的作用

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

2.3形参与实参

形参：定义函数时，小括号中的参数，是给真实数据占位用的，在函数内部作为变量使用
实参：调用函数时，小括号中的参数，是传递到函数内部的真实数据
形参的作用域
想想以下程序两次打印 a 的结果是?

a = 5  

def test1(a): 
    # 这里 a 是形参，是在函数内部定义的，作用域只在函数内部
    a += 1
    print("%d" % a)

test1(2)  
# 这里因为形参的作用域不到这里，所以这个 a 是外面的 a
print("%d" % a)

形参的作用域(起作用的范围) 只在定义函数的代码块 中，一旦超出该范围就不存在了，如果强行使用该形参名，则使用的是同名的自定义变量，如果此时外面没有a就报错了
编程中应该尽量避免函数的形参和同文件的变量名同名
因为形参的作用域只在本函数的内部，所以不同函数的形参可以是同名

2.4默认参数

形参设定默认值称为默认参数
调用函数时，如果没有传入默认参数对应的实参，则实参使用默认值。

def printinfo(name, age = 35):
   # 打印任何传入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

# 调用printinfo函数
printinfo("miki")
printinfo("miki", 20)

注意：默认参数一定要位于参数列表的最后面。

>>> def printinfo(name, age=35, sex):
...     print name
...
  File "<stdin>", line 1
SyntaxError: non-default argument follows default argument

2.5关键字参数

调用函数时，实参可以指定对应的形参，称为关键字参数

def printinfo(name, age):
   # 打印任何传入的字符串
   print("Name: %s", % name)
   print("Age: %s", % age)

printinfo(age=9,name="miki" )

# 关键字参数一旦使用，所有实参都要使用，除非该实参对应的是可变参数
# sum_num(1, 2, 3, 4, a=5)
# sum_num(a=5, b=4)

2.6可变参数

args

```函数可以定义可变参数，用于接收任意数量的参数
  可变参数的前边需要添加一个*，用于提示python解释器该参数为可变参数
  使用可变参数直接用args即可（不需要加*）
  可变参数的本质是将传递的参数包装成了元组```


def sum_num(a, b, *args):  
    result = a + b
    for temp in args:
        result += temp

    return result

sum_num(1, 2, 3, .., n)

kwargs

```可变参数还有一种形式 可以接收不存在的关键字参数
定义参数时需要在变量名前添加两个*
这种可变参数会将不存在的关键字参数包装成字典```


def sum_num(a, b, *args, **kwargs):  
    print(a)
    print(b)
    print(args)
    print(kwargs)

sum_num(1, 2, 3,4, mm=5, nn=6)

传递可变参数

解包

```可变参数和参数解包的区别
可变参数在形参中，利用“*“，”**“来实现
参数解包在实参中，利用“*“，”**“来实现```


def demo(a,b,c):
    print(a,b,c)

args=(1,2,3)
demo(*args)

kwargs={"a":1,"b":2,"c":3}
demo(**kwargs)

3.函数的返回值

3.1返回值

在程序开发中，有时候会希望 一个函数执行结束后，告诉调用者一个结果，以便调用者针对具体的结果做后续的处理
返回值是函数完成工作后，最后给调用者的返回的一个结果
在函数中使用 return 关键字可以返回结果
调用函数一方，可以使用变量来接收函数的返回结果，也可以不接收只调用。
注意：
1、没有返回值，也有返回值，这个值是 None
2、return 表示返回，后续的代码都不会被执行

def sum_2_num(num1, num2):
    """对两个数字的求和"""

    return num1 + num2

# 调用函数，并使用 result 变量接收计算结果
result = sum_2_num(10, 20)

print("计算结果是 %d" % result)

3.2关于return

return 后面可以不跟值

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)
    return

函数中凡是代码执行到 return 时，都会终止函数的执行，返回到函数调用的代码处。所以可以灵活利用return来结束程序

def func_sum():
    """求和 1+2"""
    sum_num = 1 + 2
    print(sum_num)

    return
    # 这行代码不会执行了
    print('不会执行这行代码')

res=func_sum()
print(res)

多个return

def is_even_num(num):
    """判断奇偶数"""
    if num % 2 == 0:
        return True
    else:
        return False

一个函数中可以有多个return语句，但是只要有一个return语句被执行，那么这个函数就会结束

多个返回值

def func2():
  return 1, 1.5

a = func2()
print(a)

a, b = func2()
print(a)
print(b)

a, b, c = 1, 1.5, "hello"
print(a)
print(b)
print(c)

当返回多个数据时，python会自动将数据组包成元组
如果使用多个变量接收返回值，python会自动将元组 拆包 成单个数据

4.四种函数的类型

函数根据有没有参数，有没有返回值，可以相互组合，一共有4种
1.无参数，无返回值
2.无参数，有返回值
3.有参数，无返回值
4.有参数，有返回值

4.1 无参数，无返回值的函数

此类函数，不能接收参数，也没有返回值，一般情况下，打印提示灯类似的功能，使用这类的函数

def print_menu():
    print('--------------------------')
    print('      xx涮涮锅 点菜系统')
    print('')
    print('  1.  羊肉涮涮锅')
    print('  2.  牛肉涮涮锅')
    print('  3.  猪肉涮涮锅')
    print('--------------------------')

4.2无参数，有返回值的函数

此类函数，不能接收参数，但是可以返回某个数据，一般情况下，像采集数据，用此类函数

# 获取温度
def get_temperature():
    # 这里是获取温度的一些处理过程
    # 为了简单起见，先模拟返回一个数据
    return 24

temperature = get_temperature()
print('当前的温度为:%d' % temperature)
结果:
当前的温度为: 24

4.3有参数，无返回值的函数

此类函数，能接收参数，但不可以返回数据，一般情况下，对某些变量设置数据而不需结果时，用此类函数

4.4有参数，有返回值的函数

此类函数，不仅能接收参数，还可以返回某个数据，一般情况下，像数据处理并需要结果的应用，用此类函数

# 计算1~num的累积和
def calculate_num(num):
    result = 0
    i = 1
    while i < =num:
        result = result + i
        i += 1
    return result

result = calculate_num(100)
print('1~100的累积和为:%d' % result)
结果:
1~100的累积和为: 5050

4.5小总结

1.函数根据有没有参数，有没有返回值可以相互组合
2.定义函数时，是根据实际的功能需求来设计的，所以不同开发人员编写的函数类型各不相同
3.实际上我们不会刻意区分函数的类型，这里是为了加深大家对参数和返回值的映像

5.函数的嵌套使用

5.1函数的嵌套调用

一个函数里面又调用了另外一个函数，这就是函数嵌套调用
如果函数 func2 中，调用了另外一个函数 func1
那么执行到调用 func1 函数时，会先把函数 func1 中的任务都执行完
才会回到 func2 中调用函数func1 的位置，继续执行后续的代码

def func1():
    print("func1开始")
    print("func1结束")


def func2():
    print("func2开始")

    func1()

    print("func2结束")

func2()

函数嵌套的演练 —— 打印分隔线

体会一下工作中需求是多变的
需求1：
定义一个 print_line 函数能够打印 * 组成的 一条分隔线

def print_line():

   print("*" * 50)

需求 2
定义一个函数能够打印由任意字符组成的分隔线

def print_line(char):

    print(char * 50)

需求 3
定义一个函数能够打印任意长度的分隔线

def print_line(char, length):

    print(char * length)

需求 4
定义一个函数能够打印 5 行 的分隔线，分隔线要求符合需求3
提示：工作中针对需求的变化，应该冷静思考，不要轻易修改之前已经完成的，能够正常执行的函数！

def print_line(char, length):

   print(char * length)


def print_lines(char, length):

   row = 0

   while row < 5:
       print_line(char, length)

       row += 1

嵌套练习

写一个函数求三个数的和
写一个函数求三个数的平均值

参考代码

# 求3个数的和
def sum_3_number(a, b, c):
    return a + b + c # return 的后面可以是数值，也可是一个表达式

# 完成对3个数求平均值
def average_3_number(a, b, c):

    # 因为sum_3_number函数已经完成了3个数的就和，所以只需调用即可
    # 即把接收到的3个数，当做实参传递即可
    sum_result = sum_3_number(a, b, c)
    ave_result = sum_result / 3.0
    return ave_result

# 调用函数，完成对3个数求平均值
result = average_3_number(11, 2, 55)
print("average is %d" % result)