【Python基础】Python数据容器（列表）

Python数据容器

1、数据容器入门

学习数据容器，就是为了批量存储或者批量使用多份数据

• 数据容器：一种可以存储多个元素的Python数据类型

Python中的数据容器：

一种可以容纳多份数据的数据类型，容纳的每一份数据称之为一个元素，每一个元素，可以是任意类型的数据，如字符串、数字、布尔等。

• 数据容器根据特点的不同，如：

  • 是否支持重复元素
  • 是否可以修改
  • 是否有序，等

• 分为5类，分别是：

  • 列表（list）、元组（tuple）、字符串（str）、集合（set）、字典（dict）

2、数据容器：list（列表）

列表的定义

# 定义一个列表list
my_list = ["hi", "hello", "python"]
print(my_list)
print(type(my_list))

my_list = ["hi", 66, True]
print(my_list)
print(type(my_list))

# 定义一个嵌套的列表
my_list = [[1, 2, 3], ["a", "b"]]
print(my_list)
print(type(my_list))

TIP：列表可以一次存储多个数据，且 这些数据可以为不同的数据类型，支持嵌套

• 什么是元素？

  数据容器内的每一份数据，都称之为元素

• 元素的类型有限制吗？

  元素的数据类型没有任何限制，甚至元素也可以是列表，这样就定义了嵌套列表

列表的下标索引

• 如何从列表中取出特定位置的数据？

  可以使用：下标索引

• 反向索引（从后向前）：从-1开始，依次递减（-1，-2，-3…）

# 通过下标索引取出对应位置的数据
my_list = ["Tom", "Lily", "Rose"]

# 列表[下标索引]，从前往后：从0开始，每次+1  从后向前：从-1开始，每次-1
print(my_list[0])
print(my_list[1])
print(my_list[2])
# 通过下标索引取数据，一定不要超出范围
# print(my_list[3])
print()

# 通过下标索引取出数据（倒序取出）
print(my_list[-1])
print(my_list[-2])
print(my_list[-3])

# 取出嵌套列表的数据
my_list = [[1, 2, 3], ["a", "b", "c"]]
print(my_list[0][0])
print(my_list[-1][0])

运行效果：
Tom
Lily
Rose

Rose
Lily
Tom
1
a

小结：

1. 列表的下标索引是什么？

   • 列表的每一个元素，都有编号称之为下标索引
   • 从前向后的方向，编号从0开始递增
   • 从后向前的方向，编号从-1开始递减

2. 如何通过下标索引取出对应位置的元素呢？

   列表[下标]，即可取出

3. 下标索引的注意事项：

   • 下标索引的取值范围，超出列表范围则无法取出元素，并且会报错

列表的常用操作

列表除了可以：

• 定义
• 使用下标索引获取值

以外，列表也提供了一系列功能：

• 插入元素
• 删除元素
• 清空列表
• 修改元素
• 统计元素个数

等等功能，这些功能我们都称之为：列表的方法

列表的查询功能（方法）

(1)查找某元素的下标

功能：查找指定元素在列表的下标，如果找不到，报错ValueError

语法：列表.index（元素）

index就是列表对象（变量）内置的方法（函数）

mylist = ["hi", "hello", "python"]
# 1.1 查找某元素在列表内的下标索引
index = mylist.index("hi")
print(f"hi在列表中的下标索引值是：{index}")

# 1.2 如果被查找的元素不存在，会报错
# index = mylist.index("h")
# print(f"h在列表中的下标索引值是：{index}")

(2）修改特定位置（索引）的元素值

语法：列表[下标] = 值

可以使用如上语法，直接对指定下标（正向、反向下标均可）的值进行：重新赋值（修改）

# 2.修改特定下标索引的值
mylist[0] = "嗨"
print(f"列表被修改元素值后，结果是：{mylist}")

(3)插入元素：

语法：列表.insert（下标，元素），在指定的下标位置，插入指定的元素

# 3.在指定下标位置插入新元素
mylist.insert(1, "nihao")
print(f"列表被修改元素值后，结果是：{mylist}")

(4)追加元素：

语法：列表.append（元素），将指定元素，追加到列表的尾部

# 4.在列表的尾部追加```单个```新元素
mylist.append("world")
print(f"列表被修改元素值后，结果是：{mylist}")

(5)追加元素-方式2：

语法：列表.extend（其它数据容器），将其他数据容器的内容取出，一次追加到列表尾部

# 5.在列表的尾部追加```一批```新元素
mylist2 = [1, 2, 3]
mylist.extend(mylist2)
print(f"列表被追加一批元素（一个新的列表）后，结果是：{mylist}")

(6)删除元素：

语法1：del列表[下标]

语法2：列表.pop（下标）

• 方法2 还可以使用变量去接收它删除的变量
• pop方法，本质上是将指定下标的元素取出来，然后返回出去，即 我们可以得到返回值，同时这个元素也从列表中移除掉了

# 6、删除指定下标索引的元素（2种方式）
mylist = ["hi", "hello", "python"]

# 6.1 方式1： del列表[下标]
del mylist[1]
print(f"利用方法1进行删除后：{mylist}")

# 6.2 方式2： 列表.pop(下标)
mylist = ["hi", "hello", "python"]
element = mylist.pop(1)
print(f"利用方法2取出元素后列表内容：{mylist}，取出的元素是：{element}")

(7)删除某元素在列表中的第一个匹配项

语法：列表.remove（元素）

# 7、删除某元素在列表中的第一个匹配项
mylist = ["hi", "hello", "hi", "hello", "python"]
mylist.remove("hello")
print(f"通过remove方法一处元素后，列表的结果是：{mylist}")

(8)清空列表内容

语法：列表.clear（）

# 8、清空列表
mylist = ["hi", "hello", "python"]
mylist.clear()
print(f"列表被清空了，结果是：{mylist}")

(9)统计某元素在列表内的数量

语法：列表.count（元素）

# 9、统计某元素在列表中的数量
mylist = ["hi", "hello", "hi", "hello", "python"]
count = mylist.count("hi")
print(f"列表中hi的数量是：{count}")

(10)统计列表内，有多少元素

语法：len（列表）

可以得到一个int数字，表示列表内的元素数量

# 10、统计列表中全部的元素数量
mylist = ["hi", "hello", "hi", "hello", "python"]
count = len(mylist)
print(f"列表的元素数量总共有：{count}个")

列表的特点

• 可以容纳多个元素（上限为2**63-1、9223372036854775807个)

• 可以容纳不同类型的元素（混装）

• 数据是有序存储的（有下标序号）

• 允许重复数据存在

• 可以修改（增加或删除元素等）

• 练习案例：常用功能练习

  """
  list常用操作的课后练习
  """
  
  # 1、定义这个列表，并用变量接收它，内容是：[21,25,21,23,22,20]
  mylist = [21, 25, 21, 23, 22, 20]
  # 2、追加一个数字31
  mylist.append(31)
  # 3、追加一个新列表[29， 33， 30]，到列表的尾部
  mylist.extend([29, 33, 30])
  # 4、取出第一个元素是
  num1 = mylist[0]
  print(f"从列表取出的第一个元素：{num1}")
  
  # 5、取出最后一个元素
  num2 = mylist[-1]
  print(f"取出最后一个元素：{num2}")
  
  # 6、查找元素31，在列表中的下标位置
  index = mylist.index(31)
  print(f"元素31在列表的下标位置是：{index}")
  
  print(f"最终，列表的内容是：{mylist}")
  
  运行效果：
  从列表取出的第一个元素：21
  取出最后一个元素：30
  元素31在列表的下标位置是：6
  最终，列表的内容是：[21, 25, 21, 23, 22, 20, 31, 29, 33, 30]
  

3、list（列表）的遍历

while循环遍历列表元素

将容器中元素依次取出处理的行为，称之为：遍历、迭代

• 如何遍历元素？

  可以使用while循环

• 如何在循环中取出列表元素？

  列表[下标]的方式取出

• 循环条件控制？

  • 定义一个变量表示下标，从0开始
  • 循环条件为 下标值 < 列表的元素数量

def list_while_func():
    """
    使用while循环遍历列表的演示函数
    :return:
    """
    my_list = ["hi", "hello", "Python"]
    # 循环控制变量通过下标索引来控制，默认0
    # 每一次循环将下标索引变量+1
    # 循环条件：下标索引变量 < 列表的元素数量

    # 定义一个变量用来标记列表的下标
    index = 0  # 初始值为0
    while index < len(my_list):
        # 通过index变量取出对应下标的元素
        element = my_list[index]
        print(f"列表的元素{index}：{element}")

        # 至关重要 循环变量（index）每次循环都+1
        index += 1
        
# 函数调用
list_while_func()

运行效果：
列表的元素0：hi
列表的元素1：hello
列表的元素2：Python

for循环遍历列表元素

• 表示，从容器内，依次取出元素并赋值到临时变量上。

• 在每一次的循环中，我们可以对临时变量（元素）进行处理。

def list_for_func():
    """
    使用for循环遍历列表的演示函数
    :return:
    """
    my_list = [1, 2, 3, 4, 5]
    # for 临时变量 in 数据容器：
    for element in my_list:
        print(f"列表的元素：{element}")
    # 由于没有循环的条件控制，只是将容器里的内容挨个取出，
    # 所以看上去比while循环简洁许多

# 函数调用
list_for_func()

while循环和for循环的对比

• 在循环控制上：

  • while循环可以自定循环条件，并自行控制
  • for循环不可以自定循环条件，只可以一个个从容器内取出数据

• 在无限循环上：

  • while循环可以通过条件控制做到无限循环
  • for循环理论上不可以，因为被遍历的容器容量不是无限的

• 在使用场景上：

  • while循环适用于任何想要循环的场景
  • for循环适用于，遍历数据容器的场景或简单的固定次数循环场景

• 练习案例：取出列表内的偶数

def even_num_while():
    """
    while循环取偶数
    :return:
    """
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    my_list_new = []
    index = 0
    while index < len(my_list):
        if my_list[index] % 2 == 0:
            my_list_new.append(my_list[index])
        index += 1
    print(f"通过while循环，从列表：{my_list}中取出偶数，组成新列表：{my_list_new}")


# 函数调用
even_num_while()


def even_num_for():
    """
    for循环取偶数
    :return:
    """
    my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    my_list_new = []
    for element in my_list:
        if element % 2 == 0:
            my_list_new.append(element)
    print(f"通过for循环，从列表：{my_list}中取出偶数，组成新列表：{my_list_new}")


# 函数调用
even_num_for()