Python入门（第三章）

开篇

本章节主要介绍两大内容：一、什么是函数以及他是使用等。二、什么是数据容器、数据容器中的列表类型及使用方法等

一、什么是函数：

• 什么是函数：是提前组织好的，可重复使用的，用来实现特定功能代码块
• 在之前我们所使用到的，print(),input(),int()…这些都是函数
• 这次我们要再认识一个函数len(),用于统计字符串的长度
• 以下代码块为len函数的基础语法

# 定义两个变量，用于一会计算他们的长度
name_1 = "hhhhhhhhhhhh"
name_2 = "hhhhhhh"
# 再定义了两个变量，用于接收len函数统计了name_1、2长度后的返回值
lenth_1 = len(name_1)
lenth_2 = len(name_2)
# 输出lenth_1、2变量中的值
print(f"name_1中有{lenth_1}个字符")
print(f"name_2中有{lenth_2}个字符")

输出结果：name_1有12个字符，name_2有7个字符，len统计后得出的结果存在于lenth_1、2变量中
从以上示例我们来对比之前说的函数特性，是否满足

• 1、len这个函数是Python官方内置已经写好的代码块
• 2、len这个是否可以重复使用，是的，他可以重复的对同一变量和不同的变量来进行字符串长度统计
• 3、用来实现特定功能的代码块，是的，len是专门用来实现字符串长度计算的功能代码块
  

1-1、为什么要使用函数？

• 例如我们要实现字符串长度计算的功能，那么按照之前学的，不适用函数，那么我们就会使用for循环挨个遍历变量里的字符串来进行统计
• 我们要统计一个变量那么我们就要写一个for循环，要统计两个我就要写两个for循环…
• 这样就会发现，重复的事情，我要写很多遍，导致代码量巨大，写了一堆代码干着重复的事情
• 例如下方计算name_1、2、3变量，我就需要写三个for循环，很麻烦

name_1 = "hhhhhhhhhhhh"
cont = 0
for i in name_1:
    cont += 1
print(f"name_1中有：{cont}个字符")


cont = 0
name_2 = "hhhh"
for i in name_2:
    cont += 1
print(f"name_3中有：{cont}个字符")


cont = 0
name_3 = "hhhhhh"
for i in name_3:
    cont += 1
print(f"name_3中有：{cont}个字符")

输出结果：从这里看，我要实现一次这样的功能我就要写一次，这样看麻烦程度就很显而易见了吧。

• 当我们有了函数后，我们就可以随意的调用,无需再写那么多重复复杂的for循环，直接使用函数传入参数，他就会帮我们实现特定的功能

name_1 = "hhhhhhhhhhhh"
name_2 = "hhhh"
name_3 = "hhhhhh"
print("name_1中有%d" % len(name_1))
print("name_1中有%d" % len(name_2))
print("name_1中有%d" % len(name_3))

输出结果：

1-2、如何自定义自己的函数？

使用def 函数名(入参):表明这是一个函数
同样的注意层级四个缩进，写上你要实现的功能
例如下列代码块：实现自己的字符串长度计算

# def（函数关键字），my_len（函数名），data(入参变量)
def my_len(data):
	# 具体实现字符串长度统计的代码块
    cont = 0
    for i in data:
        cont += 1
    print(f"字符串中{data}的长度是{cont}")
# 使用my_len自定义函数，统计name_1、2、3字符串长度
my_len(name_1)
my_len(name_2)
my_len(name_3)

输出结果：我们可以看出，我们使用my_len(name_1)
他是将name_1的内容传入的函数的data入参中
然后在通过具体的功能代码块将data里的字符挨个遍历出来，cont统计个数，print将data里的内容输出和cont统计数输出
具体的功能实现是在函数里进行的，我们只是将我们要实现功能的这段代码封装到了函数中

根据我们自定义的my_len函数总结：

• 1、该函数是否是提前组织好的：我们预先将我们要实现的功能在函数里组织写好了的（满足）
• 2、是否可重复调用：我们通过了my_len函数重复使用得出了name_1、2、3的字符长度
• 3、针对特定的功能：我们自定义的my_len是专门用来做字符串长度计算的特定函数

同时我们为什么要使用函数：是为了针对特定功能，可供重复利用的代码段。
好处：将功能封装到函数中，供我们重复使用，提高代码的复用性、降低代码重复性、提高开发效率

1-3、函数的基础语法

• 上节简单介绍了一下什么是函数，以及模拟如何定义函数，接下来我们就要开始正式学习函数了
• 基础语法
  def 函数名(入参变量):
  函数体（也就是这个函数要具有做些什么事情）
  return 返回值
• 语法解析：def就是声明这是个函数的关键字，函数名就是你要给这个函数取的一个名字,括号内的入参变量就是要传入函数的数据内容
  函数体也就是这个函数具体要实现功能代码
  return返回值，就是这个函数最后返回的数据是什么
• 接下里我们将逐步的介绍函数，所以入参变量和返回值先不用管，没有这两个东西，函数也能保证最基本的定义
• 下方代码块定义了一个自己的函数

# 定义一个my_hi的函数，输出一段打招呼的话
# 虽然我们创建的是无入参的函数，但是括号是一定要要的
def my_hi():
    print("hi 你好，我叫胡图图，今年5年，我家住在翻斗花园二号楼一零零一室")
# 此处为调用了这个函数，不调用函数，函数只是定义了，但是他不会去主动执行里面的函数体
my_hi()

输出结果：此时就写了一个最基本的函数了，这个函数体内的功能就是输出一句话，但是我们如果不调用函数程序不会主动去执行函数体的内容，所有我们得调用他，他才会执行函数体内的代码，就像是我们有一个工具，我们要拿到他或者给他通电等等理解方式，让他去干活，他才会运行.

• 调用函数:函数名(入参)等同于my_hi(),但由于我们目前定义的是无参函数，所以我们括号内无需传入变量或字面量等数据
• 如果无参函数你硬传入参数会导致程序错误，同理有参你不传参也会报错
• 我们都知道代码文件的执行循序是从上至下，当代码执行到定义函数时就只是创建了函数，知道有这么个东西
• 然后执行到调用函数，他则有返回到定义函数的代码块中去让这个函数工作,所以调用函数是先执行，才后返回执行了前面定义的函数
  

总结：1、入参如果不需要则可以不用写 2、 返回值如果不需要则可以不用写 3、 函数必须先定义后使用

1-4、函数的传入参数

上节我们将了无参无返回值的函数的定义，其中传入参数将再此给大家介绍
传入参数的功能：在函数进行功能实现时，接收外部（调用时）提供的数据
可通过下放方示例看出，本次要1+2等于几，下次我要计算2+2等于几，无参函数的话我就需要不停的修改代码，很局限，

# 例如如下无参函数代码很局限，只能计算固定的1+2
# 那么用户想计算的是2+3就得改一次函数
def add_1():
    result = 1 + 2
    print(f"1+2的结果是：{result}")
# 调用函数
add_1()

输出结果

当出现有参函数后，我们就可以通过用户输入的方式，将数据传入函数中，这样就可以一个函数实现同功能不同场景的数据计算

# 定义了一个函数并写了两个入参num_1、2
def add_2(num_1, num_2):
    # 函数体内的工作是将传入的num_1、2进行相加并存入result变量中
    result = num_1 + num_2
    # 计算完成后使用print将其结果输出
    print(f"{num_1} + {num_2}的结果是：{result}")

# 由于input输入得到的是一个str类型的，str配合加号是拼接，无法用于计算，所以我们需要将其转为int
add_2(int(input("请出入您第一个想计算的数字")), int(input("请输入您第二个想相加的数字")))

输出结果：由此我们就可以动态的对不同的数据进行相加

总结：函数内写入的两个变量称为形参（形式参数），表明函数声明时需要两个变量
调用时的两个参数称为实参（实际参数），表明函数执行中真正使用的参数

1-4、函数的返回值

什么是返回值他有什么作用？

• 例如我叫小明帮我买3瓶可乐，这3瓶就相当于我们传入的参数，当小明收到我说的话后，他就会去帮我买可乐，最后给我3瓶可乐
• 同理，生活中我们做什么事情都是要有结果的，在程序中也相同，当我把我要的东西给函数后，函数也要返回相应我想要的东西出来给我，这就是返回值
• 返回值语法：return 要返回的内容
• 注意，返回值同时也代表函数的工作结束，所以请不要将代码写到返回值后面，否则后面的代码无效

# 以下函数有一个形参，用于接收用户传入的数据
def add(x):
	# 定义返回值，返回一段字符串
    return f"已帮您定了{x}间房"

# 调用函数，并再写入input在实参内，用于用户输入的数据传入函数的形参，最终函数执行完后将返回值存入r变量中
r = add(int(input("您要定几间房？")))
# 输入r，输出结果：已帮您定了3间房
print(f"变量r接收的返回值为：{r}")

# 当然你也可以不存入变量中，直接输出出来
print(f"不用变量存储，直接输出add函数返回值为：{add(int(input("您要定几间房？")))}")

输出结果：但是现在是否是有个疑问，我为什么要写返回值，这个效果直接在函数体print出来不就可以了吗？
是这样的，这个效果在函数体直接print是可以实现，但是print出来的输出只是存在于函数体呢，无法将结果拿到函数体外去存储等之后的一系列操作
而返回值，是可以将返回值的数据拿出来继续进行如判断、存储等一系列操作的

总结：函数内写入的两个变量称为形参（形式参数），表明函数声明需要两个变量
调用时的两个参数称为实参（实际参数），表明函数执行中真正使用的参数
函数体内print等操作不是真正意义上的结果返回，返回值才是用于结果返回，拿到返回值可存储等用于之后的业务逻辑

1-4、函数的返回值之None类型

在函数中如果我们没有用return语句返回数据，那么函数会有返回值吗？

• 有的，Pyhton中有一个特殊的字面量：None，他的类型是NoneType，无返回值的函数实际上就返回了None字面量
• None表示：空的、无意义的，所以当函数返回的None就代表当前函数是没有返回值的，返回了个空数据

# 当我们不写返回值，查看他是否存在返回值和类型
def sai_hi():
    i = 1+1

print(f"sai_hi的返回值为：{sai_hi()}")
print(f"sai_hi的返回值类型为：{type(sai_hi())}")


# 同时我们也可以直接定义None空的返回值
def sai_hi_2():
    i = 1+1
    return None


print(f"sai_hi_2的返回值为：{sai_hi_2()}")
print(f"sai_hi_2的返回值类型为：{type(sai_hi_2())}")

# 同时None类型也可以用作定义变量上，定义一个空类型的数据变量
result = None

输出结果：可以从结果看出，当我们没写返回值，那么返回值同样是有数据的，但他是一个None类型的数据，代表空数据的意思
同时在定义变量时，我们现在还暂用用不到这个变量，他的内容也暂时无法确定，我们就可以使用None来定义这个变量，暂时为空数据的变量

函数的使用案例
要求：使用函数实现一个判断是否成年的功能，根据函数的返回结果在业务上判断他是否可以进入网吧

# 定义一个函数，根据用户传入的年龄来判断我要返回的内容
def check_age(age):
    # 当age大于等于18，则返回字面量成功的意思
    if age >= 18:
        return "SUCCESS"
    else:
        # 否则返回None，空
        return None


# 这里通过if判断条件，调用了check函数，传入用户输入的年龄实参，None在if里代表者False，也就是空数据就是False
# 所以，当我实参为：18，那么他会在函数里的if判断是否大于等于18，大于等于则返回字面量"SUCCESS"，小于18则返回None空返回值
# 再到调用者的if，我们没写判断条件，就只是用函数的返回值来进行判断，当返回值有数据时则为True，执行成立的代码块
# 当返回值为None时空数据时，则执行False不成立的代码块，所以None在if里同等于False
# 如果您想为None的时候执行True的代码块，则可加上not，将条件反过来例如：if not check_age(int(input("请输入您的年龄"))):
if check_age(int(input("请输入您的年龄"))):
    print("您已成年，可以进入网吧")
else:
    print("您未成年，不能进入网吧")

输出结果

1-5、函数的注释

• 在我们定义函数后，我们在回头看看我们有哪些函数，这些函数分别是做什么用的时候，通常我们要一段段去再理解分析代码，这样很麻烦影响效率
• 所以我们要养成写说明的习惯，代码是给计算机看的，而注释是给我们人类看的语言，他并不是一个程序代码
• 函数注释的格式 三引号括着，三引号内函数的整体注释 :param 形参:用于解释形参的内容, :return:用于解释返回值的内容
• 同时利用PYcharm工具调用函数时，鼠标悬停在函数上，可以直接看到函数的注释，便于我们理解

def add(x, y):
    """
    这是函数的整体注释，该函数用于两数相加
    :param x:这是形参x的注释，x是用于相加的其中一个数字
    :param y:这是形参y的注释，y是用于相加的另一个数字
    :return:这是返回值的注释，该返回值用于返回x+y的结果
    """
    result = x + y
    return f"{x}+{y} = {result}"


print(add(float(input("请输入相加的第一个数字")), float(input("请输入相加的第一个数字"))))

当我们书鼠标悬停在调用的函数上时，我们的工具就会将该函数的注释信息给显示出来

1-5、函数的嵌套调用

函数的嵌套调用指的是在一个函数体中调用了另外一个函数，这就是函数的嵌套
示例如下：

# 定义一个func_b的函数
def func_b():
    print("---2---")


# 在定义一个func_a的函数
def func_a():
    # 函数体内执行输出---1---
    print("---1---")
    # func_a函数体内调用func_b函数
    func_b()
    # 函数体呢执行输出---3---
    print("---3---")
#调用func_a函数
func_a()

• 输出结果：调用a函数，输出1、2、3
• 得出嵌套的执行顺序是：进入a函数体，执行输出1，然后调用到b函数，到b函数体内执行输出2，当调用的函数执行完后，再返回a函数将剩余的代码执行输出3

1-6、变量在函数的作用域

函数体的变量作用域在函数体内，同时该变量被称之为：局部变量
函数体外的变量作用域在全局，可在函数体内调用也可在函数体外调用，该变量被称之为：全局变量
总结：变量作用域分为两种：局部变量、全局变量，函数体内定义的变量只作用域函数体内，函数外定义的变量作用域在全局可调用
以下为：局部变量示例

def testA():
    num = 100  # 函数体内定义的变量叫：局部变量，只能在函数体内调用
    print(num)

# 输出函数体内的print(num)的值：100
testA()
# 以下错误示例演示，当我们定义了局部变量，在外部去调用他时，首先工具就提示了错误，如果不行非要执行，则该代码会报错
# print(num) # 报错：name 'num' is not defined. Did you mean: 'sum'（num这个变量定义了吗？）

局部变量输出结果

以下为：全局变量示例

# 那么我想在函数内部调用外部变量该如何操作
num_1 = 100  # 定义了一个全局变量，初始值为：100
num_2 = 300

def testB():
    # num_1赋值等于200
    num_1 = 200 # 实际是新定义了一个局部变量
    # 输出num
    print(f"num_1值为：{num_1}，num_2值为：{num_2}")

testB() # 所以输出结果： num_1值为：200，num_2值为：300
print(f"num_1值为：{num_1}") # 所以输出结果：num_1值为：100

从以上代码看出，我定了一个全局num_1值为：100和num_2值为：300，又在函数体内将num_1值修改为：200
但是实际输出发现，在外部调用函数输出了num_1=200、num_2=300，但是外部再输出num_1发现,值居然还是100
由此可见，这外部的num_1和内部的num_1不是一个东西，外头的是全局变量，内部再去写num_1其实是新定义了一个局部变量，当函数执行完后局部变量就被销毁了

1-7、global关键字

那么我想在函数体内将全局变量进行修改，那么该如何操作呢？以下为global关键字示例

num_3 = 100
def testC():
    # 在函数内部想使用和修改全局变量，需加global关键字，用于声明这是个全局变量
    global num_3
    num_3 = 200
    print(num_3)
# 调用函数
testC()
# 输出全局变量num_3
print(num_3)

总结：当你想在函数体内使用和修改全局变量，需加上global关键字声明这是全局变量

1-8、函数案例总结

案例一

• 定义函数，函数需有一个数字类型的形参，用于体温检测
• 判断到访者的体温，如体温在37.5及以下正常则允许进入，37.5以上异常则拒绝进入

# 代码块
def temperature(x):
    if x <= 37.5:
        print(f"您的体温为：{x}度,正常，允许进入")
    else:
        print(f"您的体温为：{x}度,异常,不允许进入")

temperature(float(input("请输入您的体温")))

输出结果

案例二

• 利用我们之前所学，使用函数写一个ATM机的一个程序，实现存取款等功能
• 要求一：该程序要有个主菜单，主菜单输出：【姓名您好，欢迎来到翻斗银行ATM机，请选择您的操作：】
• 要求二：用户姓名需用户输入
• 要求三：提示并要求用户输入1：查询余额，2：存款，3：取款，4：退出
• 要求四：根据用户输入的数字，办理相应的业务，每进入一个业务都需要输出正在办理的业务标头提示
• 要求五：对用户的输入进行校验，例如输入要进入的业务不可输入字符和提示外的数字，如输入了则一直重试，除非用户选择退出
• 要求六：同时输入的金额也要进行校验

# 定义全局变量
name = input("请输入您的姓名")
money = 500000


# 判断是否为数字的函数
def is_decimal_number(amt):
    """
    该函数主要用于对用户金额的输入合法性判断
    :param amt: 该入参用于传入用户输入的金额数据
    :return: 通过try作用是捕获异常，float()对amt金额的数据转换，转换成功则返回True，失败则将捕获异常到返回False，表示输入的非数字
    """
    try:
        float(amt)
        return True
    except ValueError:
        return False


# 主菜单界面
def index():
    """
    该函数具体用于ATM机的欢迎主界面，主要提示用户输入正确的编号进行相应的业务办理
    :return: 将用户输入的编号进行返回，便于判断程序流程走向
    """
    print("=============主菜单=============")
    print(f"{name}您好，欢迎来到翻斗银行，请选择您的操作：")
    print("""查询余额\t【输入1】
存款\t\t【输入2】
取款\t\t【输入3】
退出\t\t【输入4】""")
    return input("请输出您的选择：")


# 查询余额的函数
def select_amt(is_show):
    """
    该函数具体用于用户余额查询
    :param is_show: 由于存取款都需要调用到余额查询，但是不输入标头，该形参用于存储布尔类型的数据，控制标头的输出
    :return: 该函数仅需打印余额，无需返回值
    """
    if is_show:
        print("=============查询余额=============")
    print(f"{name}您好，您当前余额为：{money}")


# 存款函数
def add_amt():
    """
    该函数用于存款业务的功能实现
    :return: 通过用户对金额的输入，并判断输入的合法性，将最后的执行状态作为一个返回值，供后续是否重试或退出等场景的判断
    """
    print("=============存款=============")
    # 让用户输入金额存入num变量中
    num = input("请输入您的存款金额：")
    # 判断num变量内的数据，是否为数字
    if is_decimal_number(num):
        # 为数字，则将其转为float类型
        num = float(num)
        # 声明两个全局变量，用于金额计算和用户名反馈
        global name
        global money
        # 将用户输入要存入的金额，于余额相加
        money += num
        # 输出存款成功
        print(f"{name}您好，已成功存入：{num}元")
        # 存款成功后，调用查询余额的函数，查询存款后的余额
        select_amt(None)
        return True
    elif num == "exit":
        return True
    else:
        # 当输入存款金额非数字，则提示金额非法，返回主菜单
        print("金额非法，请重试")
        return False


# 取款函数,存款我们是将所以要做的操作都放到函数内部执行的
# 如果你想通过入参的方式将金额传给函数也可以的，例如下列代码块
def cut_amt(amt):
    """
    该函数用于取款业务功能的实现
    :param amt: 该入参为用户输入的取款金额额
    :return: 通过用户对金额的输入，并判断输入的合法性，将最后的执行状态作为一个返回值，供后续是否重试或退出等场景的判断
    """

    # 首先调用判断是否为数字的函数，判断传入的amt内容是否为数字
    if is_decimal_number(amt):
        # 将数据转为金额该有的float类型
        amt = float(amt)
        # 声明两个全局变量，用于金额计算和用户名反馈
        global name
        global money
        # 再次判断，取款的金额不得大于余额
        if money >= amt:
            # 将用户输入要存入的金额，于余额相加
            money -= amt
            print(f"{name}您好，已成功取出：{amt}元")
            # 存款成功后，调用查询余额的函数，查询存款后的余额
            select_amt(None)
            return True
        else:
            # 取款金额大于余额则取款失败，返回False
            print(f"{name}您好，您的余额为：{money}，取款金额不得大于余额，取款失败")
            return False
    elif amt == 'exit':
        # 相同，当用户输入exit时，同样返回True，让其内无限循环停止，返回主菜单
        return True
    else:
        print("输入的金额非法")
        return False


# 定义一个无限循环
while True:
    # 使用变量i接收index函数的用户输入返回值
    i = index()
    # 由于防止用户胡乱输入，导致系统异常终止
    # 所以我们先判断下用户输入的是否为整数，为整数在对用户输入的内容进行数据转换
    if i.isdigit():
        # 当用户用户输入为数字，则将用户输入数据转为int，便于if条件的判断
        i = int(i)

        # 当用户输入1，则进入余额查询
        if i == 1:
            # 调用余额查询的函数，由于我们存取完成后都需要调用该函数，但是该函数的标头只有真正进入查询界面才需显示
            # 为了区分哪些要显示标头，哪些不显示，所以该函数添加了入参，当为True的时候就打印标头，False不打印标头，只打印余额
            select_amt(True)
            # 查询完成后跳出本次循环，开始下次循环
            continue

        # 用户输入为：2时，进入存款业务
        elif i == 2:
            """
            - 函数体内，我们判断用户的输入合法性，，当他输入的是数字则正常存款
            - 如用户输入是非数字，则一直让其重试
            - 所以此处需要定义一个无限循环
            """
            while True:
                # 调用函数，并将返回值存入变量中，记录函数运行结果
                # 其实该代码也可以不要，只是我想记录查看打印一个当前函数返回值
                add_num_resource = add_amt()
                """
                - 通过if判断，返回值如果为True，则证明用户输入了exit或者输入了合法的金额
                - 既然用户选择了退出或输入正确就没必要一直让其卡在输入界面了
                - 所以判断返回值为True时，就利用break退出这个无限循环
                - 反观如果用户既没有选择退出，也没有输入正确金额，就让其一直重试
                - 如果不想查看返回值内容，条件可以直接if 函数
                - 因为我们的函数返回的都是布尔类型的
                """
                if add_num_resource:
                    print(add_num_resource)
                    break
                print(add_num_resource)
                # 内无限循环遇到break结束后，再跳出第一层的无限循环，开始新的第一层无限循环
                continue

        elif i == 3:
            while True:
                """
                - 由于取款我们采用了入参的方式，所以我们需要在无限内循环先将标头输入
                - 再调用inpt输入入参到函数中，这样看起来是不是要不存款的
                """
                print("=============取款=============")
                if cut_amt(input("请输入您取款的金额")):
                    break
                # 内无限循环遇到break结束后，再跳出第一层的无限循环，开始新的第一层无限循环
                continue
        elif i == 4:
            break
        else:
            print("异常：请输入有效的选项")
    else:
        print("异常：您输入了非法选项，请重新输入")

输出结果

二、什么是数据容器

• 什么是数据容器？他是一个可以存储多个Python数据类型例如：字符串、数字、布尔等
• 一个数据容器他可以容纳多个数据，每个数据我们也将他称之为元素1、2…N
• 数据容器他根据特点的不同，例如：是否支持重复数据、是否可修改、是否有序等特点进行区分
• 所以接下来将分为以下5种数据类型分别进行讲解：list(列表)、tuple(元组)、str(字符串)、set(集合)、dict(字典)

例如下图，一个数据容器中可以存储着多种元素（数据）

• 例如我们要记录5名学生信息，那么传统我们就定义五个变量分别用于记录，50个100个那这样就会大大的降低开发维护效率，也显得我们的代码很低端。
• 这时我们就可以使用数据容器种的某种数据类型完成我们想要实现的效果了，一个数据容器存储多种元素或多种数据类型。
  如下图：左图传统写法定义了很多变量分别记录，右图我们就可以使用例如list（列表）将所有数据都存在一个数据容器list种
  

2-1、list列表

2-1-1、list列表基础语法

• list列表基础语法及定义:列表是由中括号来表示，里面的每个元素(数据)分别都用逗号分割，然后正常存储于变量中，这样就获得了一个list数据变量了
• list特点：一个list列表可以存储多种不同的数据类型，他存储的数据类型是不受限制的，同时列表里还可以再存列表，这种我们称之为嵌套

name_list = ["小美", "小花", "小樱"]
print("=======list基础语法===========")
# 然后通过print和type将该变量的类型和数据打印出来看看，是不是list列表类型，元素是否都能打印出来呢?
print(name_list) # 输出结果：['小美', '小花', '小樱']
print(type(name_list)) # 输出结果：<class 'list'>

# 同时我们介绍过list可以存储多种不同的数据类型，那么来实验一下
name_list = ["小美", 60.5, 20, True]
print("=======list支持存储多种数据类型===========")
print(name_list)
print(type(name_list))

# list也支持里面再存放一个list，称之为嵌套
name_list = [["小美", 56.5, 20, False], ["小花", 88.5, 5, True]]
print("=======list嵌套存储===========")
print(name_list)
print(type(name_list))

输出结果：可以从结果看出，list可以存储多种数据类型例如字符串、数字、布尔，同时也可以在列表中再嵌套多个数据列表类型

2-1-2、list列表下标索引

• 上节我们学习了list列表的定义并将他的数据及类型输出出来
• 那么我不想输出所有，我只想输出某个特定的数据，那么我们可以通过下标索引来实现
• 每个元素他都依次从左到右的顺序都固定着一个下标，从0开始到N结束。
  如下图：我们右一个list列表，里面有三个元素，分别他的下标就是从0开始N结束，分别按序对应着元素一、二、三
  

# 代码块示例，开头介绍了下标是从0开始N结束，按序从左到右
# 那么也就是分别对应着下方的列表元素，小美下标为：0，小花下标为：1.....依次增加
name_list = ["小美", "小花", "王刚", "小七"]
print("=======从左到右提取列表元素================")
# 那么我们就可以通过：列表名称[下标]来进行特定元素的提取，以下代码就是提取下标0的元素
print(name_list[0])
# 提取下标1的元素
print(name_list[1])
# 提取下标2的元素
print(name_list[2])
# 提取下标3的元素
print(name_list[3])

输出结果：

上面我们介绍了从左到右提起，那么我们也可以从右到左提取
从右到左他的下标就是从-1、-2、-3…-N，以下代码提取了下标-1，也就是最右边的元素
如下图：从右到左倒序提取的话，我们就可以按-1、-2…的下标进行提取

name_list = ["小美", "小花", "王刚", "小七"]
print("=======从右到左提取列表元素================")
print(name_list[-1])
print(name_list[-2])
print(name_list[-3])
print(name_list[-4])

输出结果：

那么列表中的元素他是个嵌套列表，同样也可以使用下标的方式获取，列表中某个列表元素
如下图：当我的list列表中又存了嵌套列表，那么他的下标也是相同的，第一个列表元素下标1，第二个列表元素下标2…依次类推

# 嵌套列表下标提取示例
print("=======提取类型为嵌套列表的元素================")
add_list = [["小美", 20, 165.2], ["小花", 25, 170.5]]
# 相同的，我要提取嵌套列表中的第一位列表元素，那么下标0，就可以提取出下标为0的列表元素了
print(add_list[0])
# 提取下标为1的列表元素，也就是第二个嵌套列表元素
print(add_list[1])

输出结果：

• 再然后我就想提取列表中某一嵌套列表中的某一个元素,其实也是大同小异的
• 我们知道了列表他是0开始的下标，那么嵌套列表中的下标也是0开始的，我们在提取数据的代码中再多加一层下标即可提取.
  如下图：可以看出，我外层list里面还有层list，内层list分别存放着一些元素，
  例如我要提取内层list列表一的元素一，就可以理解为下标为0的list里面下标为1的元素
  

print("=======提取嵌套列表中的某一元素================")
# 第一个[0]表示外层列表第0个下标的元素，第二个[0]表示嵌套列表中的第0个下标的数据
print(f"提取第一个list中的第一个元素为：{add_list[0][0]}")
# 提取下标为0的嵌套列表中的下标为1的元素
print(f"提取第一个list中的第二个元素为：{add_list[0][1]}")

# 提取下标为1的嵌套列表中的下标为0的元素
print(f"提取第二个list中的第一个元素为：{add_list[1][0]}")
# 提取下标为1的嵌套列表中的下标为1的元素
print(f"提取第二个list中的第二个元素为：{add_list[1][1]}")

输出结果：

总结：

什么是列表下标索引：

• 列表中每个元素都有对应的编号，也称之为下标
• 每个元素从左到右，他的下标是从0开始递增
• 每个元素从右到左，他的下标是从-1开始递减

下标的作用：

• 通过下标索引可以帮助我们取出列表中某个特定的元素
• 写法是：列表[下标]，即可取出输出，取嵌套列表中的某的特定元素就让他多加一层下标即可：列表[第一层元素下标][第二层元素下标]

注意事项：

• 利用下标取元素时，需注意下标不能超出列表中实际有的下标，否则会导致系统错误提示：下标越界的问题

2-1-3、列表的常用操作

前面我们学习到了列表的定义和使用下标获取特定的列表元素，除了这两个功能，列表还提供了一系列的功能：

• 插入元素
• 删除元素
• 清空元素
• 修改元素
• 统计元素
  等等功能，这些功能我们统称为：列表的方法

好了现在有多出了一个名次，什么是方法？可以看下图
回忆下函数是将某个特定的功能实现的代码封装在一起的叫做函数
在Python中，如果函数定义在class(类)成员中，则函数会被称之为：方法
如下图：可以看到方法的内部其实还是一个函数，只是他定义在class(类)中的。
由此看出方法和函数其实除了写法和定义的地方不同，但功能都是一样的，都有def定义函数，都有入参，都有返回值，都是讲某些特定的功能封装在一起

我们调用函数是直接：函数名(入参)的方式去调用，但是方法你需要先实现他的class类对象，然后再：类名.(靠点号把方法点出来)方法名
如下图：从下图中可以看出，我们有一个Student的类，里面有个add的方法同时有两个形参，然后我们下方调用这个方法时，需要先实现Student这个类对象名称为：st，然后我们再st(类对象).(点)add(1,2)(方法名及入参)

• 这个方法先不必过于纠结，这里简单介绍方法是因为接下来我们要使用到list给我们提供的一些方法，这里结束告诉各位之后我们点出来的东西是list的方法，后续会慢慢正式介绍到方法的
  

index()查询元素下标

现在各位对方法的概念和使用有一个大概的了解了，之后开始进入正题列表方法的使用及实现功能，之前说那么多主要是让各位知道方法要怎么用

• 列表的查询方法，可通过：列表对象.index(查找的元素内容)来获得该元素在列表中的下标是多少

# 列表的查询方法
my_list = ["小美", "小花", "小英", "王刚"]
# 这里我们通过my_list(这个列表对象)点出了列表index()的方法，该方法可供我们查找对应的元素下标是多少
# 这里我们用index这个变量去存储.index()方法返回的元素下标
index = my_list.index("小英")
print(f"小英在列表中的下标是：{index}")

输出结果：可以看出.index()这个方法可以帮我们快速找到元素的下标所在

• 注意：如果查找的元素没有则会：ValueError: ‘哈哈’ is not in list提示ValueError的一个错误
  

修改列表元素

当我要修改列表中某个元素的值，那么该如何写呢？
我们知道my_list[1]这个可以查询到这个列表中的下标1的值，那么我们再加上一个 =(赋值符号)那么是不是就可以完成修改了

# 修改列表中的某个元素的值
my_list[1] = "哈哈"
print(f"下标一的值修改后变为了：{my_list[1]}")

输出结果：我们利用my_list这个列表对象及[1]指定下标，加上等于赋值符号，就可以完成修改的动作了

插入列表元素inset()

插入元素可以使用inset(下标,元素)的方法去实现
例如我想在小美和小花之间插入一个哈哈，那么小美现在是下标是0，小花的小标是1，那么我插入以后，小花下标就变成2了，哈哈的下标才是1
那这也就是为什么inset(插入的下标位置要写1的原因了, “哈哈”)

print(f"插入前的列表：{my_list}")
my_list.insert(1, "哈哈")
print(f"插入后的列表：{my_list}")

输出结果：可以看到，通过inset方法讲哈哈插入到下标1的位置去了

追加列表元素append()与extend（）

当我们想在最后一个元素后面追加一个新元素，那么我们可以使用append()方法
语法：列表对象.append(元素)

print("==========append列表单元素追加==========")
my_list.append("小新")
print(f"追加后的列表：{my_list}")

输出结果

当我们想一次批量追加多个元素就需要将方法换成extend()
语法：extend([元素一、元素二])

# 批量追加列表元素
print("==========extend批量追加列表元素==========")
my_list.extend(["图图", "小七"])
print(f"批量追加后的列表：{my_list}")

输出结果

通过指定下标删除元素del与.poo()

删除有两种方法

• 1、del 列表对象[下标]：他可将列表中指定的下标元素进行删除
• 2、元素对象.pop(下标)：他是将列表中的指定下标元素移除并返回，这就是他将元素移除后，将移除后的元素返回出来，同时我们可以用变量来进行接收

# del删除下标元素
print("==========del删除下标元素==========")
del my_list[-1]
print(f"del列表元素删除后：{my_list}")

# .pop方法删除下标元素
print("==========.pop删除下标元素==========")
rem = my_list.pop(-1)
print(f"pod列表元素移除后的列表元素：{my_list},被移除的元素是：{rem}")

输出结果：可以看到del首先是把下标-1的给删除了，这个是没返回值的，接着.pop又将下标-1的图图移除了，并具有返回值，我们用变量rem接收了这个返回值，返回值是被移除的元素：【图图】

通过指定元素删除元素remove

刚才我们都是通过下标去删除元素，那么我们想通过元素匹配去进行删除，可以使用remover方法
语法：列表对象.remove(元素)
注意：该方法是从左到右去进行查到的，如遇到列表中相同的元素，只会删除第一个

# remove通过指定元素删除
print("==========remove通过指定元素删除==========")
my_list = ["小美", "小花", "小美", "小花"]
my_list.remove("小花")
print(f"remove后的列表结果：{my_list}")

输出结果：以上代码中重新定义了列表元素，小美、小花、小美、小花，然后使用remove删除元素小花,但是输出结果发现，他只从左到右查找匹配，删除了下标1的小花后，他就结束了，说明该方法只能删除一个，如需两个都删除那么你就要执行两次

clear清空列表元素

了解了del，.pop(元素)通过下标的两个删除方式，还有一个remove(元素)通过元素匹配的删除方式
那么我想直接把列表清空，可以通过clear()的方法实现
语法：列表对象.clear()，由于是清空所以无需给任何参数

# clear清空列表元素
print("==========clear清空列表元素==========")
my_list.clear()
print(f"clear清空后的列表结果：{my_list}")

输出结果：执行后，我们的列表就变成一个空列表了

count()统计某元素的数量

当我们想统计某个元素在列表中的数量时，就可以使用
语法：列表对象.count(元素)

# count统计某元素在列表中的个数
print("==========count统计某元素在列表中的个数==========")
my_list = ["小美", "小花", "小美", "小花"]
count = my_list.count("小美")
print(f"count统计小美在列表中的个数是：{count}")

输出结果：

len()统计列表中所有元素

当我们想统计列表中所有的元素数量时就可以使用之前学习到的len()
他不是list的方法，是Python内置的函数，我们可以通过他来实现这一功能
之前说过len()实际是利用for循环将一个变量里的字符串挨个遍历出来，然后通过count变量统计返回的
在之前的str类型里，一个字符算一个，列表里，一个元素代表一个字符

# len统计列表所有元素数量
print("==========len统计列表所有元素数量==========")
count = len(my_list)
print(f"通过len统计出my_list列表中的元素数量是：{count}")

输出结果：

lisr列表总结

list列表特性：
1、可以存错多个元素（数据）,可容纳的数量是：2**63-1（9223372036854775807）个，是特别多，理论上可以称为无限
2、列表可存储不同的数据类型，（str，int，float、list、bool）等等（混装）
3、列表是支持重复数据的存储。
4、列表元素存储是有序的（下标）
5、列表是可以修改，支持增删改查等等操作的

常用方法	常用方法	说明
查询类	列表[下标]	查询指定下标的元素
查询类	列表.index(元素)	查询某个元素所在下标
查询类	列表. count(元素)	统计指定的下标元素在列表中的数量
查询类	len(列表)	统计列表所有元素的数量
修改类	列表[下标] = 元素	修改指定下标元素
插入类	列表.inset(下标)	往指定下标插入元素
追加类	列表.append(元素)	在列表末尾追加元素
追加类	列表.extend(元素一, 元素二)	在列表末尾批量追加元素
下标删除无返回值	del 列表[下标]	通过指定下标删除指定元素
下标移除有返回值	列表.pop(下标)	通过下标移除指定元素，并将移除元素加入返回值返回
元素删除	列表.remove	通过元素匹配删除，如有重复元素，则会只删除从左到右查找的第一个元素
清空	列表. clear()	清空列表所有元素

2-1-4、lisr列表综合案例

我们说了这么多，那么接下来尝试用用list列表提供给我们的功能（方法）试试以下几个需求吧
有一个列表，内容是[21,25,21,23,22,20],记录了一批学生的年龄
需求一：定义一个列表，并用变量去接收它
需求二：追加一个元素31，到列表末尾
需求三：追加一个新列表元素[29,33,30]，到列表末尾（批量追加）
需求四：取出第一个元素（正确应是：21）
需求五：取出最后一个元素（正确应是：30）
需求六：查找元素31，在列表中的下标位置

# 定义列表，用全局变量接收
age_list = [21, 25, 21, 23, 22, 20]

# 使用append()对单个元素进行末尾追加
age_list.append(31)
print(f"追加一个元素31，到列表末尾后的age_list列表内容为：{age_list}")

#使用extend()对一组元素进行末尾追加
age_list.extend([29, 33, 30])
print(f"追加一组新列表元素[29,33,30]，到列表末尾后的age_list列表内容为：{age_list}")

# 使用age_list[0]取出第一个元素，并存入了变量list_1,(下标为0的元素)
list_1 = age_list[0]
print(f"取出age_list列表中的第一个元素为：：{list_1}")


# 使用age_list[-1]取出第一个元素，并存入了变量list_2,(下标为-1的元素)
list_2 = age_list[-1]
print(f"取出age_list列表中的最后一个元素为：{list_2}")

# 使用index(31)查找指定元素所在下标
list_3 = age_list.index(31)
print(f"查询age_list列表中，元素31，所在标下位置为：{list_3}")

输出结果

2-1-5、lisr列表循环遍历

• 既然数据容器可以存储多个元素，那么就会有需求从容器中依次取出元素的操作
  将容器内的元素依次取出进行处理，我们称之为：遍历、迭代。
• 遍历列表的元素可以使用之前了解的while和for循环进行操作
  那由如何在循环中取出元素呢？我们可以使用下标索引的方式从0到N依次遍历
  循环条件又如何控制呢？while循环条件为True时结束，for循环条件是数据集没数据了就结束循环
• 所以while循环我们可以使用len()函数统计列表元素数量，循环条件就可以写成：循环控制变量 < len(列表)，然后每次循环结束控制变量+1，当变量大于列表数量就停止了，这里的变量就是每次循环遍历要取出元素的下标
• 那么for循环他是通过数据容器（数据集、待处理数据）有数据就会一直循环，那么我们的列表就是数据容器呀，每一个元素他都会按一个字符传给临时变量，那么我们在循环体内输出临时变量即可实现列表遍历了

# 以下为while遍历列表元素的函数定义
# 我们会经常用到遍历列表中的元素，所以我们就可以将他写成一个函数，我们每次要用的时候就直接调用函数就可以了
def my_while_list(llist_name):
    index = 0
    while index < len(age_list):
        emp_list = age_list[index]
        print(f"下标为{index}的元素为：{emp_list}")
        index += 1
    return None


# 定义列表并调用while列表遍历函数对列表进行依次遍历
print("===========while循环遍历列表==============")
age_list = [21, 25, 21, 23, 22, 20]
my_while_list(age_list)

输出结果：这样我们就实现了while循环依次遍历列表中的元素啦

# 以下为for遍历列表元素的函数定义
def my_for_list(list_name):
    # for循环其中可以不用定义index这个变量
    # 我只是为了要看看每个元素对应的下标是多少所以才用这个来作为计数器
    index = 0
    # for每次循环将数据容器内的元素依次放入i临时变量中
    for i in list_name:
    	# 所以我们每次循环都打印以下i临时变量就可以实现啦
        print(f"下标为{index}的元素为：{i}")
        # 用于记录当前第几次循环，也就是当前元素的下标啦
        index += 1

    return None

# 调用
print("===========for循环遍历列表==============")
age_list = [21, 25, 21, 23, 22, 20]
my_for_list(age_list)

输出结果

总结：1、什么是遍历：将数据容器中的元素依次取出，并处理，称之为遍历
2、如何遍历列表：使用while或for循环
3、for和while对比

• for循环更简单，while更灵活
• while可以控制循环，例如可以控制我只要遍历前三个元素等场景，同时可以做到无限循环，适用于较为复杂的遍历场景
  for循环不可以控制循环，他只能单一的将列表中所以的元素都依次遍历出来，虽然列表可以存很多数据接近无限，但是始终都会存满的，所以for循环不能无限遍历，适用于较为单一简单的遍历场景

2-1-6、lisr列表循环遍历案例

定义一个列表：[1,2,3,4,5,6,7,8,9,10]
遍历列表中的元素是奇还是偶数，并将他们分别存入新的列表中
使用while和for循环各实现一次

# 定义用于存储奇数的列表变量
odd_list = []
# 定义用于存储偶数的列表变量
even_list = []


# 定义一个使用while循环遍历判断奇偶数的函数
def my_while_list(list_name):
    # 用于控制循环并且当作从0开始的列表下标，循环控制条件
    index = 0
    # index当前循环列表下标 < len统计到的列表数量
    while index < len(list_name):
        # 声明全局变量，分别用于在函数体内对全局变量进行奇偶数存储
        global odd_list
        global even_list
        # 定义变量，用于存储当前遍历元素，用于奇偶数判断
        emp_list = my_list[index]
        if emp_list % 2 == 0:
            # 余数为0，说明该元素是偶数，使用append方法，将该元素追加到偶数列表
            even_list.append(emp_list)
        else:
            # 余数不为0，说明该元素是奇数，使用append方法，将该元素追加到奇数列表
            odd_list.append(emp_list)
        index += 1


# 定义列表，调用函数，输出函数执行完后分别存入奇偶数列表的内容
print(f"==========while循环遍历列表奇偶数=================")
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
my_while_list(my_list)
print(f"使用while遍历my_list列表中的奇数为：{odd_list}")
print(f"使用while遍历my_list列表中的奇数为：{even_list}")

输出结果：

# 定义一个使用for循环遍历判断奇偶数的函数
def my_for_list(list_name):
    # 使用for循环将列表元素挨个放入临时变量i中
    for i in list_name:
        if i % 2 == 0:
            global even_list
            even_list.append(i)
        else:
            global odd_list
            odd_list.append(i)

# 由于用于存储奇偶的列表在上段while遍历时已经插入一些元素了，所以我这里才需要先将这两个列表的数据清空
even_list.clear()
odd_list.clear()
print(f"==========for循环遍历列表奇偶数=================")
# 调用for循环遍历判断奇偶数的函数
my_for_list(my_list)
# 打印函数执行完后，存储奇偶数的列表元素
print(f"使用for遍历my_list列表中的奇数为：{odd_list}")
print(f"使用for遍历my_list列表中的奇数为：{even_list}")

输出结果：由于我是写在同一代码文件的，while循环时我已经定义了例如：odd_list、even_list列表，所以for循环这里缺少了，如果你是分开代码文件写的，就自行补上