目录

正向索引：

反向索引：

嵌套列表：

 修改列表中的值

列表常用的方法

实例

练习：

---

正向索引：

从0开始，依次递增。第一个元素的索引为0，第二个元素的索引为1，依此类推。

列表的下标索引（正向）

例如：

fruits = ['apple', 'banana', 'cherry']
print(fruits[0])  # 输出 'apple'
print(fruits[1])  # 输出 'banana'

反向索引：

从-1开始，依次递减。最后一个元素的索引为-1，倒数第二个元素的索引为-2，以此类推。

列表的下标索引（反向）

例如：

print(fruits[-1])  # 输出 'cherry'
print(fruits[-2])  # 输出 'banana'

嵌套列表：

最底层的列表被标记为"元素0"、"元素1"、"元素0"和"元素1"，这些元素分别属于两个不同的列表，即"列表(list)"0和"列表(list)"1。这两个列表又作为元素存在于最上层的"列表(list)"中。

# 创建一个嵌套列表
nested_list = [[1, 2], [3, 4]]

# 访问嵌套列表中的元素
print(nested_list[0][0])  # 输出: 1
print(nested_list[0][1])  # 输出: 2
print(nested_list[1][0])  # 输出: 3
print(nested_list[1][1])  # 输出: 4

最底层的列表被标记为"元素0"、"元素1"、"元素0"和"元素1"，这些元素分别属于两个不同的列表，即"列表(list)"0和"列表(list)"1。这两个列表又作为元素存在于最上层的"列表(list)"中。

线性表（常见的线性表-----数组 栈 队列 链表） ---- 基于链表的数据结构实现的

注意：python里面是没有数组的 数组的存储空间是连续的，它删除比较麻烦，因为内存是连续的，查询速度特别快（因为是连续的）-----------增删改的效率比较低

栈：先进后出，后进先出

队列：先进先出，后进后出

链表（比较特殊的数据结构）：（只有一个6byte的空间，但是要存8byte的数组，肯定是不够的，所以是有很多零碎的内存块，科学家就使用线将各种零碎的内存块连接起来）

单向链表：节约内存

没有头节点，只有尾节点

双向链表

一般有三个节点，第一个节点存上一个节点的地址（头指针），中间的存储数据，最后一个存下一个节点的内存（尾指针）

Python中的列表就是基于双向链表实现的（查询慢，增删快）

• 定义

  由弱数据类型语言决定，直接赋值给变量

  如： ls = [ 2,3,4,5 ]

  使用全局函数list对列表进行定义

   ls = list()
  ​
    ls = list([1,2,3,4,5,""])
  ​
    #容器中的每一个值，我们叫做元素

• 如何访问元素

  使用下标来访问，注意下标是从0开始的(外国人喜欢从0开始计数) ls[0] 如果下标超过范围会报异常， 可以用下标来访问值，也可以修改值，另外下标也可以是负数

  求列表的长度？

  全局函数len(容器) -----------返回容器的长度

• 如何遍历容器

   For循环
       For i in ls：
          Print(i)
  ​
   While循环
       Index = 0
       While index < len(ls)：
            Print(ls[index])
            Index += 1

   修改列表中的值

  示例 1：修改列表中特定位置的值

  假设有一个列表，你想修改其中某个位置的元素。

  fruits = ['apple', 'banana', 'cherry']
  # 修改索引为1的元素，即把'banana'改为'orange'
  fruits[1] = 'orange'
  print(fruits)  # 输出: ['apple', 'orange', 'cherry']

  示例 2：遍历列表并修改所有值

  如果想要基于某种条件或运算修改列表中的每一个元素，可以遍历列表。

  numbers = [1, 2, 3, 4, 5]
  # 将列表中的每个元素都平方
  for i in range(len(numbers)):
      numbers[i] = numbers[i] ** 2
  print(numbers)  # 输出: [1, 4, 9, 16, 25]

  或者使用列表推导式更简洁地实现同样的功能：

  numbers = [1, 2, 3, 4, 5]
  squared_numbers = [x ** 2 for x in numbers]
  print(squared_numbers)  # 输出: [1, 4, 9, 16, 25]

  示例 3：修改嵌套列表中的值

  对于嵌套列表（列表中的列表），你需要通过两层索引来访问和修改内部列表的元素。

  nested_list = [[1, 2], [3, 4]]
  # 修改嵌套列表中第二个列表的第一个元素
  nested_list[1][0] = 'changed'
  print(nested_list)  # 输出: [[1, 2], ['changed', 4]]

列表常用的方法

方法名	含义
append()	向列表尾部追加元素
insert（index, object）	向指定的位置追加元素
sort()	列表排序（只能排Int）字母按照ASCII值进行排序，类型不能混淆
index()	查找元素第一次在列表中出现的位置，如果没有这个元素则会
reverse()	将列表元素顺序翻转
remove()	通过元素来移除元素，如果元素不存在则抛出异常
count()	统计元素在列表中的个数
clear()	清除元素
copy()	浅拷贝对象（拷贝） 不等价于 = （引用传递），在堆内存中进行对象拷贝
extend()	合并列表
pop()	与append()相反，删除列表最后一个元素，并返回值这个元素，要删除指定位置的元素，用pop(i)方法，其中i是索引位置

实例

下面是一些关于如何使用 Python 列表方法的例子：

append() 方法：向列表尾部追加元素。

my_list = [1, 2, 3]
my_list.append(4)  # 添加元素 4 到列表末尾
print(my_list)  # 输出: [1, 2, 3, 4]

insert(index, object) 方法：向指定的位置追加元素。

my_list = [1, 2, 3, 4, 5]
my_list.insert(2, "new_element")  # 在索引 2 的位置插入元素
print(my_list)  # 输出: [1, 2, 'new_element', 3, 4, 5]

sort() 方法：列表排序（只能排Int）字母按照ASCII值进行排序，类型不能混淆。

my_list = [5, 1, 9, 3, 7]
my_list.sort()  # 对列表进行升序排列
print(my_list)  # 输出: [1, 3, 5, 7, 9]

# 注意：对于非数字类型的元素，需要自定义比较函数或使用 sorted() 函数

index(element) 方法：查找元素第一次在列表中出现的位置，如果没有这个元素则抛出异常。

my_list = [1, 2, 3, 4, 5]
print(my_list.index(3))  # 输出: 2

reverse() 方法：将列表元素顺序翻转。

my_list = [1, 2, 3, 4, 5]
my_list.reverse()
print(my_list)  # 输出: [5, 4, 3, 2, 1]

remove(element) 方法：通过元素来移除元素，如果元素不存在则抛出异常。

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)  # 移除元素 3
print(my_list)  # 输出: [1, 2, 4, 5]

count(element) 方法：统计元素在列表中的个数。

my_list = [1, 2, 3, 2, 1]
print(my_list.count(2))  # 输出: 2

clear() 方法：清除元素。

my_list = [1, 2, 3, 4, 5]
my_list.clear()
print(my_list)  # 输出: []

copy() 方法：浅拷贝对象（拷贝）不等于 = （引用传递），在堆内存中进行对象拷贝。

my_list = [1, 2, 3]
copied_list = my_list.copy()
print(copied_list)  # 输出: [1, 2, 3]

extend(iterable) 方法：合并列表。

my_list1 = [1, 2, 3]
my_list2 = [4, 5, 6]
my_list1.extend(my_list2)
print(my_list1)  # 输出: [1, 2, 3, 4, 5, 6]

pop([index]) 方法：与append()相反，删除列表最后一个元素，并返回值这个元素，要删除指定位置的元素，用pop(i)方法，其中i是索引位置。

my_list = [1, 2, 3, 4, 5]
print(my_list.pop())  # 输出: 5
print(my_list)  # 输出: [1, 2, 3, 4]

my_list.pop(2)  # 删除索引为 2 的元素
print(my_list)  # 输出: [1, 2, 4]

练习：

使用Python列表实现学生年龄管理

在本篇博客中，我们将探讨如何使用Python的列表功能来处理与学生年龄相关的一系列任务。以下是我们的目标：

• 定义一个学生年龄列表。
• 在列表末尾追加元素。
• 向列表末尾追加另一个列表。
• 获取列表的第一个和最后一个元素。
• 查找指定元素在列表中的索引位置。
• 对列表进行排序。

初始化一个包含若干学生年龄的列表：

student = [21, 25, 21, 23, 22, 20]

模拟新学生加入班级的情景，我们使用append()方法向列表尾部添加一名31岁的学生年龄：

student.append(31)
print(student)  # 输出当前列表状态
# 输出: [21, 25, 21, 23, 22, 20, 31]

如果有多个学生同时加入，可以利用extend()方法将一个包含多个人年龄的列表合并进来。这里，新增了三位学生，年龄分别为29、33、30岁：

student_new = [29, 33, 30]
student.extend(student_new)
print(student)  # 输出: [21, 25, 21, 23, 22, 20, 31, 29, 33, 30]

在管理过程中，可能需要移除列表中的元素。这里，分别移除了最年轻（索引为0）和最新加入（索引为-1）的学生年龄，并打印移除的值：

num = student.pop(0) # 输出: 21 （移除并打印元素）
print(num)
num = student.pop(-1)  # 输出: 30 （移除并打印元素）
print(num)

为了查找特定学生年龄的位置，比如刚加入的31岁学生，我们使用index()方法获取其索引：

print(student.index(31))  # 输出: 6 （显示31在列表中的索引位置）

最后，为了便于分析或进一步处理，对整个年龄列表进行排序，保持数据有序：

student.sort()
print(student)  # 输出: [20, 21, 21, 22, 23, 25, 29, 31, 33] （列表按升序排列）