复习昨天的内容
"""
0.列表(list)
[元素1, 元素2, ...]
可变，有序
元素可以是任意类型的数据，可以重复
元素的增删改查
相关运算和方法
相同数据的时候用列表计算

1.元祖(tuple)
(元素1, 元素2, ...) 元素1, 元素2, ... (元素,) - 只有一个元素时，后面必须加逗号
不可变，有序
元素可以是任意类型的数据，可以重复
获取元素的值 - 查（因为不可变不能增删改）
相关运算

2.字典(dict)
{key1:value1, key2:value2, ...} {}
可变，无序
元素是键值对；键不可变并且唯一；值可以任意类型的数据，可以重复
元素的增删改查 - 通过key来
相关运算和方法 in / not 在这里是判断key的存在
多个数据不是相同信息用字典计算

3.集合(set)
{元素1, 元素2, ...} set()
可变，无序
元素不可变并且唯一
元素的增删查； 数学集合运算
相关运算
"""

一，认识函数

"""
1.什么是函数
函数就是对实现某一特定功能的代码段的封装

2.函数的分类
系统函数: 系统已经给我们定义好的函数，程序员直接调用函数使用功能
print(), input, id(), type(), chr(), bin()...

自定义函数: 需要程序员自己去定义的函数

3.函数的定义/声明 - 造机器的意思
a.语法

def 函数名(参数列表):
    函数体

b.说明
def - python中声明函数的关键字
函数名 - 标识符，不能是关键字；
PEP8命名规范: 所有字母小写。 见名知义(看到函数名大概知道函数的功能)
() - 固定格式
参数列表 - 参数1, 参数2, 参数3...； 这儿的参数叫形参
定义的时候形参就是变量
功能是将函数外面的数据传递到函数里面
: - 固定格式
函数体 - 一个完整的函数体包含: 函数说明文档,实现函数功能的代码段,函数返回值(产物)

c.初学者声明函数的步骤
第一步: 确定函数的功能
第二步: 根据功能确定函数的命名
第三步: 确定形参(确定需不需要参数， 确定需要几个参数)
看实现函数的功能需不需要从函数外面传值进来？需要传几个？
第四步: 实现函数的功能
第五步: 确定函数返回值

(重点!!!)注意: 声明函数的时候不会执行函数体！，只有在调用的时候才会执行

4.函数的调用 - 使用机器的意思
a.语法:
函数名(实参列表)
b.说明:
函数名 - 这个函数名对应的函数必须是已经声明过的函数
() - 固定写法
实参列表 - 实参是用来给形参赋值(用实参给形参赋值的过程叫传参)
实参和形参要一一对应

c.函数的调用过程(重点!!!!)
第一步: 回到函数声明的位置
第二步: 用实参给形参赋值(传参)
第三步: 执行函数体
第四步: 执行完函数体就确定并返回返回值
第五步: 再回到函数调用的位置，接着执行后面的其他代码
"""
写一个函数， 求两个数的和
声明函数

def th_sum(num1, num2):
    """
    求两个数的和(函数功能说明)
    :param num1:  # 参数1说明 求和的第一个数
    :param num2: # 参数2说明  1求和的第二个数
    :return:  # 返回值说明    无
    """
    # 实参回到这里 就是让 num1 = 10, num2 = 20
    print('=========')
    print(num1, num2)
    print(num1 + num2)  # 不会被执行 声明函数的时候不会执行函数体！

# 调用函数
th_sum(10, 20)  # 可以按Ctr1查看注释  10是实参，赋给形参的num1. 20是实参，赋给形参的num2
print('~~~~~~~')  # ~~~~~~~先执行上面完了才执行这步

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

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


factorial(4)  # 24
# 注意一个函数可以调用多次
factorial(5)  # 120

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

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) 

导入random模块
import random
"""
randint(M, N) - 产生一个M带N的随机整数
print()
num = random.randint(M, N)
print(num)
"""
导入random模块
import random
"""
randint(M, N) - 产生一个M带N的随机整数
print()
num = random.randint(M, N)
print(num)
"""

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

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

27
请输入数字(0-100): 50
大了，再小点儿
请输入数字(0-100): 20
小了，再大点儿
请输入数字(0-100): 27
猜对了
"""


def caishuzi():
    import random
    suijishu = random.randint(0, 100)
    count = 0
    while True:
        # 输入数字
        print('========游戏开始=========')
        num = int(input('请输入数字:'))
        count += 1
        # 判断是否猜对
        if num < suijishu:
            print('小了，再大点')
        if num > suijishu:
            print('大了，再小点')
        if num == suijishu:
            print('猜对了')
            # 游戏结束
            print('========游戏结束=========')
            if count > 7:
                print('可以换个脑袋')
            elif count > 4:
                print('正常人')
            else:
                print('天才')
            break


caishuzi()   # 数字游戏

二，paramter(关于函数的参数)

"""
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)  # 关键字参数必须在位置参数后面，不然会报错

"""
2.参数默认值
声明函数的时候，可以给参数赋默认值。
如果一个形参有默认值了，那么调用函数的时候就可以不用穿参
如果有的形参有默认值，有的形参没有默认值，那么有默认值的形参要放在没有默认值的形参的后面

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

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


func2(100, 200, 300)  # 100 200 300
func2(100, 200)  # 100 200 0  c有默认值, 没有c = 0 (默认值)就会报错，因为参数必须对应


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


func3()  # 画一条长度是10宽度是1的black
func3(color = 'red')  # 也可以是func3(1,'red'# ) 画一条长度是10宽度是1的red
func3(3)  # 画一条长度是10宽度是3的black

"""
3.参数的类型说明 - 类型说明只有提示功能，没有约束功能
a.给参数设置默认值， 默认值的类型就是参数的类型
b.在形参后面加 : 类型名，来说明参数类型。这种方式调用的时候必须传参
c.函数声明的时候在()后面加 ->类型名，来说明函数返回值的类型

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

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


list_item([2, 34])  # 2 按住Ctrl(看类型)


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


func4([1, 2, 3], 'ass')  # [1, 2, 3, 'ass']

"""
4.不定长参数 --函数的参数个数不确定
a. 声明函数的时候在参数名前加, 可以用来同时获取多个实参的值
-- 实质是将带的参数编程元祖，将多个实参的值作为元祖的元素

注意:a.如果函数中既有不定长参数又有普通参数，那么不定长参数必须放在普通参数的后面（不然会报错）
b.两个的参数要放在一个的后边，不然会报错
"""

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


th_sum1(1)
th_sum1(1, 2)  # 1, 2) 出来的是元祖
th_sum1(1, 2, 3)
th_sum1(1, 2, 3, 4, 5)


def func5(name, *scores):
    print(name, scores)


func5('小明') # 小明 ()-指的是空元祖
func5('小花', 10, 20, 30)  # 小花 (10, 20, 30)

"""
b.在参数名前加两个*，会将这个参数编程一个字典来获取关键字参数的值，其他关键字作为key，实参作为value
"""

def fun6(**nums):
    print(nums)


# fun6(10)  # TypeError: fun6() takes 0 positional arguments but 1 was given 会报错，**必须是关键字参数
fun6(a=10)  # {'a': 10} 必须是关键字参数 变成字典
fun6()  # {}


def func7(*args, **kwargs):  # 两颗*的必须放在一颗*的后面，不然会报错
    print(args, kwargs)

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

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


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

三returnValue 返回值

"""
1.什么是返回值 - 返回值就是将函数里面的数据传递到函数外面(和参数相反)
a.返回值就是函数调用表达式的值，就是return关键字后面的表达式的值
b.python中每个函数都有返回值，默认是None

函数调用表达式 - 调用函数的语句
return - 关键字，只能写在函数体中。功能:1.确定函数的返回值 2.结束函数
执行函数的时候如果遇到return, 函数直接结束,并且将return后面的值作为函数的返回值

函数调用过程:
回到函数声明的位置
传参 - (保证每个参数都有值)
执行函数体
执行完函数确定返回值 - 如果执行过程中没有遇到return,函数的返回值是None
如果执行过程中遇到return,return后面是什么返回值就是什么
回到函数调用的位置(这个时候函数调用表达式的值就是函数的返回值)
"""

def func1():
    print('****')
    return
    print('=====')  # 遇到return 不会出现


result = func1()  # func1()就是函数调用表达式
print(result)  # None


def func1():
    print('****')
    return 123  # 遇到return, 输出return后面的值
    print('=====')  # 遇到return 不会出现


result = func1()  # 此时 func1()=123, 然后再把123赋给result
print(result)  # *** 123 return后面的值作为函数的返回值

练习:读程序

def func2(num):
    if num & 1:  # 取奇数
        return 100
    else:
        return 200
    return 300


print(func2(10))  # 200  num = 10 if num&1 10为偶数，不成立，所以else 答案200
print(func2(111))  # 100  num = 111 111为奇数 成立  所以执行if 答案 100

"""
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 th_sum(num1, num2):
    # print(num1 + num2) 取出来数字之后就不能用了
    return num1 + num2   # 用return就会保存这个数据，可以使用


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