====== 函数 ======

# 导入random模块★ —— randint(M, N) —— 产生一个M到N的随机数
import random

1.什么是函数

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

2.函数的分类

系统函数 —— 系统已经定义完成的函数，直接调用函数使用函数功能即可

如：print(), input(), id(), type(), che(), bin()...

自定义函数 —— 自己定义的函数

3.函数的定义/声明

a.语法：

def 函数名（参数列表/形参列表）:

函数体

b.说明

def —— python中声明函数的关键字

函数名 —— 标识符，不能是关键字；（pep8命名规范，见名知义，看到函数名大概知道函数名的功能）

（） —— 固定格式

参数列表 —— 参数1，参数2，参数3...；这儿的参数叫形参，定义的时候形参就是变了，可以看成是声明在函数中的变量（功能：将函数外面的数据传递到函数里面）

： —— 固定格式

函数体 —— 一个完整的函数体包含：函数说明文档、实现函数功能的代码段，return 语句★函数返回值★

c.初学者声明函数的步骤

第一步：确定函数的功能

第二步：根据功能确定函数名

第三步：确定形参（确定需不需要参数，确定需要几个参数），看实现函数的功能是否需要从函数外面传值进来？需要传几个？

第四步：实现函数的功能

第五步：确定函数返回值

★注意！★声明函数的时候不会执行函数体，只有在调用的时候才会执行

4.函数的调用 —— 使用

a.语法：

函数名（实参列表）

b.说明：

函数名 —— 这个函数名对应的函数必须是已经声明过的函数

（） —— 固定写法

实参列表 —— 实参是用来给形参赋值（用实参给形参赋值的过程叫 传参），实参和形参要一一对应

c.调用过程★★★

第一步：回到函数声明的位置

第二步：用实参给形参赋值（传参）

第三步：执行函数体

第四步：执行完函数体就确定并返回 返回值 —— 自然死亡/遇到return

第五步：再回到函数调用的位置，接着往后继续执行（这个时候函数调用表达式的值才是之前确定返回值）

---

写一个函数，求两个数的和

a.声明函数，不执行

def yt_sum(num1, num2) :  # 函数名
    print(num1 + num2)   # 函数体

b.调用函数

def yt_sum(num1, num2) :
    """注释
    求两个数的和(函数功能说明):param num1: 求和的第一个数(参数说明):param num2: 求和的第二个数
:return: 无(返回值说明)
    """
    # num1, num2 = 10, 20
    print('==========')
    print(num1, num2)
    print(num1 + num2)
# yt_sum()  # 按住ctrl可查看注释，两行回车可以去掉波浪线


yt_sum(10,20)
# 10 20
# 30

声明一个函数，打印指定数字的阶乘， n ！

def factorial(n) :# factorial的意思是阶乘
    """求指定数的阶乘"""
    sum1 = 1
    for x in range(1, n+1) :
        sum1 *= x
    print('%d的阶乘是：%d' % (n, sum1))


factorial(4)  # 4的阶乘是：24
factorial(10)  # 10的阶乘是：3628800

注意：一个函数可以调用多次

声明一个函数，打印指定列表中指定元素的对应的下标

def list_index(list1, item) :
    """打印指定列表（list1）中指定元素（item）对应的下标"""
    count = 0  # 保存指定列表中指定元素的个数
    for index in range(len(list1)) :
        if list1[index] == item :
            print(index)
            count += 1

    if count == 0 :
        print('列表中没有指定元素！')


list_index([1, 2, 3, 1, 8, 19], 1)  # 看1 的下标，0  3
list_index([1, 2, 3, 1, 8, 19], 10)  # 看 10的下标，列表中没有指定元素！

---

练习：声明一个函数，函数功能是猜数字游戏。

如：随机产生一个0~100的数字，用户不断输入数字，知道输入的数字和产生数字一样游戏就结束，当猜错了，可以给出'大了'/'小了'这样的提示

# 随机数：27
# 请输入数字（0~100）：50
# 大了，再小点儿
# 请输入数字（0~100）：20
# 小了，再大点儿
# ...
# 请输入数字（0~100）：27
# 猜对了！

# # 导入random模块★一般在创建文件的开始就导入模块
# import random
# randint(M, N) —— 产生一个M到N的随机数
# num = random.randint(0, 100)
# print(num)

def number_game():
    """猜数字游戏"""
    print('===========游戏开始===============')
    # 随机数
    num = random.randint(0, 100)
    # 猜的次数
    count = 0
    while True:
        # 输入数字
        input_num = int(input('请输入数字(0-100):'))
        count += 1
        # 判断是否猜对了
        if input_num == num:
            print('猜对了!')

            if count > 7:
                print('很好!')
            elif count > 4:
                print('真棒!')
            else:
                print('非常棒！！')

            # 游戏结束
            print('===========游戏结束===============')
            break
        else:
            if input_num > num:
                print('大了，再小点儿!')
            else:
                print('小了，再大点儿')

number_game()

====== 函数的参数 ======

1.位置参数和关键字参数（根据实参的传递方式对参数进行的分类）

a.位置参数：实参位置和形参保持一致，按形参声明的先后顺序一一赋值

b.关键字参数：调用函数的时候以 形参=实参 的方式来 传参，这个时候实参的顺序无所谓，不可多也不可少

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

# 通过位置参数传参
func1(10, 20, 30)  # 10 20 30

# 通过关键字参数传参
func1(c=30, a=10, b=20)  # 10 20 30

# 通过位置参数和关键字参数结合传参（注意关键字参数必须在位置参数的后面）
func1(10, 20, c=30)  # 10 20 30

2.参数默认值

声明函数的时候，可以给参数赋默认值；

如果一个形参有默认值了，那么调用函数的时候这个参数就可以不用传参

如果有的形参有默认值，有的形参没有默认值，那么有默认值的形参要放在没有默认值的形参的后面

调用函数要保证每个参数都有值！★

# 参数c有默认值，调用函数的时候c可以不用传参
def func2(a, b, c=0) :
    # a=100,b=200
    print(a, b, c)

func2(100, 200, 300)  # 100 200 300
func2(100, 200)  # 100 200 0
func2(a=100, c=200, b=150)  # 100 150 200
func2(b=110, a=220)  # 220 110 0

---

def func3(width=1, color='black', long=10):
    print('画一条长度是%d宽度是%s的%s线' % (long, width, color))

func3()  # 画一条长度是10宽度是1的black线
func3(color='red')  # 画一条长度是10宽度是1的red线
func3(1)  # 画一条长度是10宽度是1的black线
func3(1,'red')  # 画一条长度是10宽度是1的red线
func3(2, long=20)  # 画一条长度是20宽度是2的black线

3.参数的类型说明 —— 类型说明只有提示功能，没有约束功能

a.给参数设置默认值，默认值的类型就是参数的类型

b.在形参后面加 —— :类型名，来说明参数类型，这种方式调用的时候必须传参

c.函数声明的时候在（）后面加 —— ->类型名，来说明函数返回值的类型

类型说明的好处：a.对实参的类型进行说明指导。 b.实现函数功能的时候有类型相关的语法提示

def list_item(list1: list, index=0)->int :
    print(list1[index])

list_item([2, 34])  # 2


def func4(a: list, b: str) :
    a.append(b)

4.不定长参数 —— 函数的参数个数不确定

a.声明函数的时候，在参数名前加 * ，可以用来同时获取多个实参的值 —— 实质是将带 * 的参数变成元祖，将多个实参的值作为元祖的元素

注意：

a.如果函数中既有不定长参数又有普通参数，那么不定长参数必须放在普通参数的后面

b.两个**的参数要放在一个的后面

# 写一个函数，计算多个数的和
def yt_sum(*nums) :
    print(nums)

yt_sum()  # ()
yt_sum(1)  # (1,)
yt_sum(1, 2)  # (1, 2)
yt_sum(1, 2, 3)  # (1, 2, 3)
yt_sum(1, 2, 3, 4)  # (1, 2, 3, 4)
yt_sum(1, 2, 3, 4, 5)  # (1, 2, 3, 4, 5)

---

def func5(name, age, *scorse) :
    print(name, scorse)

func5('小明', 18, 209)  # 小明 (209,)
func5('小白', 10, 20, 30)  # 小白 (20, 30)

b.在参数名前加两个 ** —— 会将这个参数变成一个字典，来获取关键字参数的值，其它关键字作为key，实参作为value

def func6(**nums) :
    print(nums)

func6()  # {}
func6(a=10)  # {'a': 10}
func6(a=10, b=20)  # {'a': 10, 'b': 20}

---

def func7(*args, **kwargs) :  # 一般同时出现
    print(args, kwargs)

func7(10, 5, 89)  # (10, 5, 89) {}
func7(a=90, b=9, c=99)  # () {'a': 90, 'b': 9, 'c': 99}
func7(90, 99, z=0, a=87)  # (90, 99) {'z': 0, 'a': 87}

---

# 写一个函数，计算多个数的和（要求可以使用位置参数也可以使用关键字参数）
def yt_sum(*args, **kwargs) :
    sum1 = 0
    # 遍历元祖
    for num in args :
        sum1 += num

    # 遍历字典
    for key in kwargs :
        sum1 += kwargs[key]

    print(sum1)

yt_sum(1, 2)  # 3
yt_sum(1, 2, 3, a=4, b=5)  # 15

====== 函数的返回值 ======

1.什么是返回值 —— 返回值就是将函数里面的数据传递到函数外面

a.返回值就是函数调用表达式的值，就是return关键字后面的表达式的值

b.python中每个函数都有返回值，默认是 None

函数调用表达式 —— 调用函数的语句

return —— 关键字，只能写在函数体中。功能：1.确定函数的返回值。 2.结束函数。

执行函数的时候如果遇到retuen，函数直接结束，并且将return后面的值作为函数的返回值

函数调用过程：★★★

回到函数声明的位置

传参 —— （保证每个参数都有值）

执行函数体

执行完函数确定返回值 —— 如果执行过程中没有遇到return，函数的返回值是 None；如果执行过程中遇到了return，return后面是什么，返回值就是什么

回到函数调用的位置 —— 这个时候函数调用表达式的值就是函数的返回值

def func1() :
    print('====')
    # return 100  # return的值为100，result即是100，不执行下面的print('*****')
    print('*****')

result = func1()  # func1()就是函数调用表达式
print(result)  # None  默认值   或  100


def func2() :
    print(200)

print(func2())  # 200  返回值为 None

练习：读程序

def func2(num) :
    if num & 1 :
        print(100)
        # return 100
    else :
        return 200

    return 300

print(func2(10))  # num=10  print(200)
print(func2(111))  #num=111  print(100)  print(300)

2.多个返回值

return 值1，值2，值3... <==> return（值1，值2，值3...）

def func3() :
    return 1, 2, 3

print(func3())  # (1, 2, 3)

x, y, z = func3()
print(x, y, z)  # 1 2 3

3.怎么确定函数是否需要返回值

实现函数的功能如果会产生新的数据，就将这个数据用return返回

def yt_sum(num1, num2) :
    # print(num1 + num2)
    return num1+num2

result = yt_sum(10, 2823)
print(result)  # 2833
print(result+100)  # 2933
list1 = [result]
print(list1)  # [2833]