1. 函数概论

函数就是对实现特定功能的代码的封装

2）.函数的分类

系统函数(内置函数) - 系统已经声明好的函数(类似已经造好的机器)，程序员会用就行,
例如: print\input\sum\max\hex\len\id\type等...
自定义函数 - 程序员自己声明的函数(自己造机器)

3）.声明函数(造机器)

1)语法:
def 函数名(形参列表):
函数说明文档
函数体

2)说明:
def - python中声明函数的关键字(固定写法)
函数名 - 和变量名的要求一样
(): - 固定写法
形参列表 - 以'变量名1,变量名2,变量名3,...'的形式存在；每个变量就要形参。
形参的个数根据情况可以没有也可以有多个。
形参的作用是将函数外面的数据传递到函数里面
函数说明文档 - 用三个双引号引来的字符串；作用是对函数的功能进行说明
函数体 - 和def保持一个缩颈的一行或者多行语句。（实现函数功能的多条语句）

3)初学者声明函数的步骤
a.确定函数的功能
b.根据函数功能确定函数名
c.确定函数的参数: 看实现函数的功能需不需要从外面传值，需要几个？
d.实现函数的功能

注意(重要!!!!): 声明函数的时候不会执行函数体

写一个函数，求两个数的和并且打印

def sum1(num1, num2):
    """
    函数功能说明部分 - 求和
    :param num1: 参数说明， 数字1
    :param num2: 参数说明， 数字2
    :return: 返回值说明
    """
    print('=======')
    print(num1 + num2)
print('~~~~~~')

4).函数的调用（调用函数相当于使用机器）

1)语法
函数名(实参列表)

2)说明
函数名 - 已经声明过的函数的函数名
() - 固定写法
实参列表 - 以'值1, 值2, 值3,...'形式存在; 这儿的每个值就叫实参；
实参是用来给形参赋值的

sum1(10, 20)
# sum1(10)   # TypeError: sum1() missing 1 required positional argument: 'num2'
# sum1(10, 20, 30)  # TypeError: sum1() takes 2 positional arguments but 3 were given

# 同一个函数可以调用多次
sum1(100, 300)

2 函数的使用过程

1)函数调用过程

1）语法
函数名(实参列表)
2)调用函数的作用: 执行函数体；获取返回值
3)函数调用过程(非常重要!!!!):
第一步: 回到函数声明的位置
第二步: 传参(用实参给形参赋值)
第三步: 执行函数体
(第四步: 执行完函数体就确定返回值)
第五步: 回到函数调用的位置接着往后执行

# 声明一个函数，实现求1+2+3+...+N的和
def sum1(n):
    # n = 10; n=100
    t = 0
    for num in range(1, n+1):
        t += num
    print(t)

sum1(10)
sum1(100)

# 声明一个函数，实现求m+m+1+m+2+...+N的和
def sum2(m, n):
    # m=10, n=100
    # m=1, n=9
    print('m: %d, n:%d' % (m, n))
    t = 0
    for num in range(m, n+1):
        t += num
    print(t)

sum2(10, 100)
sum2(1, 9)

# 声明一个函数，打印字符串中所有的字母字符
def print_alpha(str1):
    # str1 = 'how are 123 y 90!'
    new_str = ''
    for char in str1:
        if 'a' <= char <= 'z' or 'A' <= char <= 'Z':
            new_str += char
    print(new_str)

print_alpha('how are 123 y 90!')

# 声明一个函数，在指定的字符串中数字字符后都添加一个指定的字符
# 'abc123', '*'  ->  'abc1*2*3*'
# 'h2wo4end', '='  -> h2=wo4=end
def append_char(str1, char):
    # str1 = 'abc123', char = '*'
    new_str = ''
    for x in str1:
        if '0' <= x <= '9':
            new_str += x + char
        else:
            new_str += x
    print(new_str)

append_char('abc123', '*')

3.函数的参数

1).位置参数和关键字参数(针对实参)

根据调用函数的时候传参的方式将参数分别位置参数和关键字参数
1)位置参数: 让实参和形参在位置上一一对应(第一个实参给第一个形参赋值，第二个实参给第二个形参赋值...)
2)关键字参数: 以'形参名=值'的形式传参
注意: 位置参数和关键字参数可以一起使用，但是一起用的时候要求位置参数必须在关键字参数的前面
3)什么时候使用关键字参数：需要跳过前面某个或者某几个参数，直接给后面某个参数赋值的时候必须使用关键字参数

ef func1(a, b, c):
    # a=10,b=20,c=30
    print('a:{}, b:{}, c:{}'.format(a, b, c))

# 位置参数传参
func1(10, 20, 30)
# 关键字参数传参
func1(a=100, b=200, c=300)
func1(b=200, c=300, a=100)

# 位置参数和关键字参数同时使用
func1(10, b=20, c=30)
func1(10, c=30, b=20)

2).参数默认值（形参）

声明函数时候,形参可以设置默认值， 设置完默认值后调用函数的时候有默认值的参数可以不用传参。
一个函数可以给所有的参数都设置默认值，也可以给部分参数设置默认值；必须保证没有默认值参数必须放在有默认值参数的前面

def func2(x=11, y=22, z=33):
    print('x:{}, y:{}, z:{}'.format(x, y, z))

func2(100, 200, 300)  # x:100, y:200, z:300
func2(100)  # x:100, y:22, z:33
func2(100, 200)  # x:100, y:200, z:33
func2()  # x:11, y:22, z:33

func2(100, z=300)  # x:100, y:22, z:300

3).参数类型说明

1)给参数赋默认值, 默认值的类型就是参数的类型
2)以'参数名:类型名'的形式声明函数

def func3(a: int, b: str, c=10):
    print('a:{}, b:{}, c:{}'.format(a, b, c))
    print(a % 10, c % 20)
# func3(90, 'qwe', [12, 45])
def func4(x: list):
    # x.append(100)
    x.append(100)

4).不定长参数

1)在形参前加，那么这个参数就可以同时接受多个实参(位置参数); 带的参数会作为一个元祖，对应的多个实参是元祖中的元素
2)在形参前加, 那么这个参数也可以同时接受多个实参(关键字参数,关键字自己随便命名);
将带的参数作为一个字典，将关键字参数的关键字作为key实参作为value存储在字典中。
def func(args,*kwargs), 这个函数中 *args 和 **kwargs的作用

# 写一个函数，计算多个数的和
# sum1(1), sum1(2, 45), sum1(2, 4, 5, 6), ....
def func5(*nums):
    # nums = (89, 9, 34.8)
    print(nums)
    print(sum(nums))

func5(89, 9, 34.8)
# func5(a=10, b=20)   # 带*的不定长参数，不能使用关键字参数传参

def func6(x, y, *nums):
    print(x, y, nums)

func6(1, 2, 3, 4, 5, 6, 7, 100)

def func7(**nums):
    print(nums)

func7(a=1, b=2, x=4)
func7(a=1)

# *args 和 **kwargs一起用是为了保证不定长参数传参的时候既可以使用位置参数也可以使用关键字参数
def func8(*args, **kwargs):
    print(args, kwargs)

func8(1, 23)
func8(a=2, c=90, k=34)
func8(2, 4, x=2, y=89)

# (了解)补充: *的用法: *列表/*元祖  -> 直接取出列表/元祖中所有的元素
#               **字典  -> 直接取出字典中的所有元素
list1 = [89, 90, 89]
# *list1  -> 89, 90, 89
print(*list1)  # 89 90 89 ->print(89, 90, 89)

def func9(x, y):
    print(x, y)

func9(1, 2)

list2 = [10, 20]
func9(*list2)

dict1 = {'a': 1, 'b': 2}  # a= 1, b=2
def func10(b, a):
    print(a, b)

func10(**dict1)

# 练习: 声明一个函数，求多个数的差
# differ(1, 2)  -> -1     differ(10, 2, 3) -> 5  differ(10, 20, 30) -> -40
def differ(*nums):
    if not nums:
        print(0)
    else:
        sum1 = nums[0]
        for num in nums[1:]:
            sum1 -= num
        print(sum1)

differ(1, 2)
differ(10, 2, 3)
differ(10, 20, 30)

4.函数的返回值

1). 什么是返回值

返回值就是return关键字后表达式的值 (怎么确定函数的返回值)
返回值就是函数调用表达式的值 (怎么获取函数的返回值)
(python中所有函数都有返回值，默认是None)

1)什么是return
return是函数体中的关键字(只能在函数中使用), 作用有两个: 结束函数\确定函数返回值
a.结束函数: 执行函数体的时候只要遇到return函数直接结束
b.确定函数返回值: return 返回值(可以是具体的数据，声明过的变量，运算表达式)

2)什么是函数调用表达式
函数调用语句就是函数调用表达式, 例如: func1(10), max([1, 2]),
每个调用函数的语句都有结果，这个结果就是调用这个函数得到的返回值

def func1():
    for x in range(10):
        if x == 2:
            return
        print(x)
    print('里面: 函数结束')

print('func1:', func1())

def func2():
    print('=====')
    return
    print('++++++')
    print('------')

print('func2:', func2())

def func3():
    if False:
        return 10

print('func3:', func3())

def func4():
    return 100

print('func4:', func4())

2).怎么使用返回值

想要用函数的返回值，就使用函数调用表达式的值。
普通数据能做的事情，函数调用表达式都可以做

func4()

num = 100
num1 = func4()
print(num, num1)

list1 = [100, 200]
list2 = [func4(), 200]
print(list1, list2)

print(100 > 200, 100 * 2)
print(func4() > 200, func4()*2)

3).什么时候需要返回值

初学者：看实现函数的功能会不会产生新的数据
return 返回值1,返回值2,...

def sum1(num1, num2):
    return num1 + num2

re = sum1(10, 20)
print(re)
list1 = [re, 20]