一、复习

0.列表（list）

[元素1, 元素2, 元素3···] [元素]
可变、有序
元素可以是任何数据类型，可以重复
元素的增删改查
相关运算和方法

1.元组（tuple）

(元素1, 元素2, 元素3···) 元素1, 元素2··· [元素]
不可变、有序
元素可以是任何数据类型，可以重复
获取元素的值
相关运算

2.字典（dict）

{key1: value, key2: value2```} {}
可变、无序
元素是键值对，键不可变且唯一，值可以是任何数据类型，可以重复
元素的增删改查
相关运算和方法

3.集合（set）

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

二、了解函数

打飞机游戏：
飞机的功能：左移、右移 上移、下移、发射子弹、爆炸···

print('左移')
print('右移')
print('上移')
print('下移')
print('发射子弹')
print('爆炸')

飞行过程：左移、右移、左移、左移

没有使用函数时，遇到的问题：
1.同样的代码要写很多事。
2.一旦功能发生改变，需要修改多处代码

解决方法：使用函数：

def zuo_yi():
    print('左移')
    print('看后视镜')
    print('向左打方向盘')
    print('踩油门')
    print('回正方向盘')


def you_yi():
    print('左移')
    print('看后视镜')
    print('向右打方向盘')
    print('踩油门')
    print('回正方向盘')

三、函数

1.什么是函数：

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

2.函数的分类：

系统函数：系统已经给我们定义好的函数，我们可以直接调用函数，使用函数的功能。
input(), print(), id(), id(), type(), chr(), bin(), max()...
自定义函数：需要我们自己去定义的函数。

3.自定义函数的规范：

a.语法：

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

b.说明：

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

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

第一步：确定函数的功能；
第二步：根据功能给函数命名；
第三步：确定参数（形参，确定需不需要参数，要几个）；
看实现的功能需不需要从外表传值进来，要传几个。
第四步：实现函数的功能。
第五步：确定函数返回值

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

4.函数的调用 -----使用机器

a.语法:

函数名(实参列表)

b.说明：

函数名 -----这个函数名必须是已经声明过的函数。
() -----固定写法。
实参列表 -----用实参用来给形参赋值（用实参给形参赋值的过程加传参）
实参和形参要一一对应（数量、位置）。

c.函数的调用过程（重点。。。。。）：

第一步：调用时，回到函数声明的位置。
第二步：用实参给形参赋值（传参）。
第三步：执行函数体。
第四步：执行完函数体后，确定并返回值，然后返回返回值。
第五步：回到函数调用的位置，接着执行后面的代码。

例如：写一个函数，功能为求两个数的和。

def new_sum(num1, num2):
    """
    求两数之和。                       -----函数功能说明
    :param num1:求和的第一个数        -----对参数 num1 进行说明
    :param num2:求和的第二个数        -----对参数 num2 进行说明
    :return: 无                       -----对返回值进行说明
                        -----说明不换行时 Ctrl + 鼠标指针 就都能看到所有提示
    """
    print('===========================')
    print(num1, '与', num2, '的两数之和为：', num1 + num2)


x = 1
y = 2
new_sum(x, y)               # 调用函数
new_sum(10, 20)

运行结果：

===========================
1 与 2 的两数之和为： 3
===========================
10 与 20 的两数之和为： 30

练习：

1.声明一个函数，打印指定的 n1

def jc(num1):
    """求 指定数 的阶乘。"""
    i = 1
    num2 = 1
    while i <= num1:
        num2 *= i
        i += 1
    print('%d 这个数的阶乘为：' % num1, num2)


n = int(input('请输入一个数：'))
jc(n)
jc(5)

运行结果：

请输入一个数：2
2 这个数的阶乘为： 2
5 这个数的阶乘为： 120

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

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

def xb(list1, item):
    """打印指定列表中指定元素对应的下标"""
    i = 0
    while i < len(list1):
        if list1[i] == item:
            print(item, '这个元素对应的下标为：', i)
        elif i == len(list1):
            print('指定列表内没有该元素')
        i += 1


list1 = ['a', 'b', 'c', 100]
xb(list1, 100)
xb([1, 2, 3, 'adc'], 3)

运行结果：

100 这个元素对应的下标为： 3
3 这个元素对应的下标为： 2

3.声明一个函数，功能为猜数字游戏：

随机产生一个 0 ~ 100 的数字，用户不断的输入数字，直到输入的数字和产生的数字一样，游戏就结束。
当猜错了，会给出大了或小了的提示。
产生随机数：

import random               # 导入 random 模块。
random.randint(0, 100)      # 产生一个 0 ~ 100 的随机整数。

解：

def csyx():
    """猜数游戏"""
    print('已经进入猜数游戏。')
    print('产生随机数中...')
    import random  # 导入 random 模块。
    num2 = random.randint(0, 100)  # 产生一个 0 ~ 100 的随机整数。
    print('产生完成。')
    num1 = int(input('请输入一个整数（ 0 ~ 100 ）：'))
    cs = 1
    while num1 != num2:
        cs += 1
        if num1 < num2:
            print('猜错了，稍微小了点。')
            num1 = int(input('请再次输入：'))
        elif num1 > num2:
            print('猜错了，稍微大了点。')
            num1 = int(input('请再次输入：'))
    print('恭喜你，猜对了。\n一共猜了 %d 次。\n奖励一个么么哒~~~\n游戏结束。' % cs)


csyx()

运行结果：

已经进入猜数游戏。
产生随机数中...
产生完成。
请输入一个整数（ 0 ~ 100 ）：50
猜错了，稍微小了点。
请再次输入：70
猜错了，稍微大了点。
请再次输入：60
猜错了，稍微小了点。
请再次输入：65
猜错了，稍微小了点。
请再次输入：68
猜错了，稍微小了点。
请再次输入：69
恭喜你，猜对了。
一共猜了 6 次。
奖励一个么么哒~~~
游戏结束。

四、参数

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

a.位置参数：

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

b.关键字参数：

调用函数的时候，以 形参 = 实参 的方式来传参，这个时候实参的顺序无所谓
例如

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


# 通过位置参数给形参赋值
func1(10, 100, 1000)
# 通过关键字参数给形参赋值
func1(b=1000, c=100, a=10)
# 通过位置参数和关键字参数结合传参（注意：关键字参数必须在位置参数的后面）
func1(10, 100, c=1000)

运行结果：

10 100 1000
10 1000 100
10 100 1000

2.参数默认值

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

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


func2(10)

运行结果：

10 None 0

3.参数的类型说明（这里面的类型说明没有提示功能，没有约束功能）

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

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

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

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

def func3(a, list1: list, b=None)->int:
    list1.append()              # 说明类型后，就会有提示。
    print(a, b, list1)

4.不定长参数（参数个数不确定）

a.在参数名前面加 * ，可以用来同时获取多个实参的值。

实质是将带 * 的参数编程元组，将多个实参的值作为元组的元素。

b.在参数名前面加 ** ，

会将这个参数变成一个字典，来获取关键字参数的值，其它关键字作为 key ，实参作为 value 。

注意：
a.如果函数中既有不定长参数又有普通参数，不定长参数要放在普通参数之前。
b.使用不定长参数时， ** 定义的长参数要放在 * 定义的长参数之后。

例如：

def func4(*nums):
    print(nums)


func4(1)
func4(1, 2)
func4(1, 2, 3)


# 加 * 的用法，不定长参数要放在不带 * 的参数之前。
def func5(name, *nums):
    print(name, nums)


func4(1)
func4(1, 2)
func4(1, 2, 3)


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


func6(a=10)
func6(a=10, b=20)


# 既有 * 定义的长参数，又有 ** 定义的长参数，在使用的时候更灵活。
def func7(*name, **nums):
    print(name, nums)


func7(1, 2, 3)
func7(a=10, b=20)
func7(1, 2, 3, a=10, b=20, c=30)

运行结果：

(1,)
(1, 2)
(1, 2, 3)
(1,)
(1, 2)
(1, 2, 3)
{'a': 10}
{'a': 10, 'b': 20}
(1, 2, 3) {}
() {'a': 10, 'b': 20}
(1, 2, 3) {'a': 10, 'b': 20, 'c': 30}

练习：写一个函数，计算多个数的和（要求可以使用位置参数也可以使用关键字参数）

def dgsdh(*tuple1, **dict1):
    """算多个数的和。"""
    i = 0
    k = 0
    sum1 = 0
    while i < len(tuple1):
        sum1 += int(tuple1[i])
        i += 1
    for j in dict1:
        x = dict1[j]
        sum1 += x
        k += 1
    num1 = i + k
    print('一共有 %d 个数字，' % num1, '和为：', sum1)


dgsdh(1, 2, 3, a=4, b=5)

运行结果：

一共有 5 个数字， 和为： 15

五、返回值

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

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

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

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

函数的调用过程：
1).回到函数声明的位置
2).传参 -----保证每个参数都有返回值
3).执行函数体
4).执行完函数确定返回值 -----如果执行过程中，没有遇到 return ，函数的返回值就为 None；
若遇到 return ，函数的返回值就为 return 后面的东西。
5).回到函数调用的位置（这个时候，函数调用表达式的值，就是函数的返回值）
例如

def func1():
    print('*****')
    return True
    print('=====')


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

运行结果：

*****

2.多个返回值

return 值1, 值2, 值3··· -----相当于返回一个元组。
例如：

def func2():
    return 1, 2, 3


x, y, z = func2()
print(x, y, z)

运行结果：

1 2 3

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

如果函数的功能要拿到新的数据，就将这个数据用 return 返回。