Python 列表概念

在Python中，列表（List）是一种有序、可变、允许重复元素的数据结构。列表使用方括号 ​[]​来表示，可以包含任意类型的元素，如整数、字符串、列表等。

Python 访问列表中的值

在Python中，要访问列表中的值，你可以使用索引和切片。以下是一些例子：

1. 使用索引访问单个值：
   你可以使用列表的索引来访问单个元素。索引从0开始，负数索引表示从列表末尾开始逆向索引。

my_list = ['apple', 'banana', 'cherry', 'date']

print(my_list[0])   # 输出：'apple'
print(my_list[2])   # 输出：'cherry'
print(my_list[-1])  # 输出：'date'

2. 使用切片访问多个值：
   你可以使用切片操作访问列表中的多个元素，语法为list[start:stop:step]，如果不指定start或stop，将从开头或结尾开始切片。

print(my_list[1:3])  # 输出：['banana', 'cherry']
print(my_list[:2])   # 输出：['apple', 'banana']
print(my_list[2:])   # 输出：['cherry', 'date']
print(my_list[::2])  # 输出：['apple', 'cherry']

3. 遍历列表中的值：
   可以使用for循环遍历列表中的所有值。

for item in my_list:
    print(item)

Python 更新列表

在Python中，你可以使用多种方式来更新列表，包括添加元素、修改元素、删除元素等操作。以下是对每种操作的详细解释：

1. 添加元素：

   • 使用append()方法在列表末尾添加一个元素。这个方法会将指定的元素追加到列表的末尾。

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

   • 使用extend()方法添加一个可迭代对象的元素到列表末尾。可迭代对象可以是一个列表、元组、集合等。

     my_list = [1, 2, 3]
     my_list.extend([4, 5])  # 在列表末尾添加可迭代对象[4, 5]
     print(my_list)  # 输出：[1, 2, 3, 4, 5]
     

   • 使用加号运算符（+）合并两个列表。

     my_list1 = [1, 2, 3]
     my_list2 = [4, 5]
     new_list = my_list1 + my_list2  # 合并两个列表
     print(new_list)  # 输出：[1, 2, 3, 4, 5]
     

2. 修改元素：

   要修改列表中的元素，你可以通过索引直接赋值为新的元素。

   my_list = [1, 2, 3]
   my_list[1] = 4  # 修改索引为1的元素为4
   print(my_list)  # 输出：[1, 4, 3]
   

3. 删除元素：

   • 使用remove()方法删除列表中指定值的元素。如果有多个相同值的元素，它只会删除第一个出现的。

     my_list = [1, 2, 3]
     my_list.remove(2)  # 删除值为2的元素
     print(my_list)  # 输出：[1, 3]
     

   • 使用pop()方法删除索引指定的元素，并返回被删除的元素。如果不传递索引，默认删除最后一个元素。

     my_list = [1, 2, 3]
     popped_elem = my_list.pop(1)  # 删除索引为1的元素
     print(popped_elem)  # 输出：2
     print(my_list)  # 输出：[1, 3]
     

   • 使用del关键字删除指定索引的元素或删除整个列表。

     my_list = [1, 2, 3]
     del my_list[1]  # 删除索引为1的元素
     print(my_list)  # 输出：[1, 3]
     
     del my_list  # 删除整个列表
     # print(my_list)  # 报错：NameError: name 'my_list' is not defined
     

Python 列表脚本操作符

在Python中，列表支持多种脚本操作符，可以用于对列表进行复制、连接、重复等操作。以下是一些常用的列表脚本操作符：

1. 加法运算符（+）：

   • 用于连接（合并）两个列表，生成一个新的包含两个列表元素的列表。

   list1 = [1, 2, 3]
   list2 = [4, 5, 6]
   new_list = list1 + list2
   print(new_list)  # 输出：[1, 2, 3, 4, 5, 6]
   

2. 乘法运算符（*）：

   • 用于重复列表的元素，生成一个包含重复元素的新列表。

   list3 = [1, 2, 3]
   repeated_list = list3 * 3
   print(repeated_list)  # 输出：[1, 2, 3, 1, 2, 3, 1, 2, 3]
   

3. 成员运算符（in和not in）：

   • 用于检查某个元素是否存在于列表中。

   list4 = [1, 2, 3, 4, 5]
   print(2 in list4)       # 输出：True
   print(6 not in list4)   # 输出：True
   

Python 列表截取与拼接

在Python中，列表截取和拼接是常用的操作，可以用于获取列表的子集或合并多个列表。以下是对列表截取和拼接的详细解释：

列表截取：

你可以使用索引和切片来截取列表的子集。列表的索引从0开始，可以是负数（表示倒数第几个元素），切片通过start:end:step的方式指定范围。

my_list = [1, 2, 3, 4, 5]

# 获取单个元素
print(my_list[0])  # 输出：1

# 切片获取子列表
print(my_list[1:4])  # 输出：[2, 3, 4]
print(my_list[:3])   # 输出：[1, 2, 3]
print(my_list[2:])   # 输出：[3, 4, 5]
print(my_list[-3:])  # 输出：[3, 4, 5]

# 使用步长获取间隔元素
print(my_list[::2])  # 输出：[1, 3, 5]

# 获取列表的副本（深拷贝）
new_list = my_list[:]  # 等同于 new_list = list(my_list)

列表拼接：

你可以使用加号运算符（+）来拼接两个或多个列表。拼接后将生成一个新的列表，包含所有被拼接的元素。

list1 = [1, 2, 3]
list2 = [4, 5, 6]
concatenated_list = list1 + list2
print(concatenated_list)  # 输出：[1, 2, 3, 4, 5, 6]

需要注意的是，列表拼接会生成一个新的列表，而不会修改原始列表。

Python 嵌套列表

在Python中，嵌套列表指的是将一个列表作为另一个列表的元素，形成多层次的嵌套结构。这种嵌套结构允许你在一个列表中存储更复杂的数据结构，例如列表的列表。以下是关于嵌套列表的一些示例和解释：

创建嵌套列表：

nested_list = [[1, 2, 3], ['a', 'b', 'c'], [True, False]]

上面的nested_list就是一个包含3个子列表的嵌套列表。每个子列表可以有不同长度，包含不同类型的元素。

访问嵌套列表的元素：

你可以使用多重索引来访问嵌套列表中的元素，每个索引对应一个层级。

nested_list = [[1, 2, 3], ['a', 'b', 'c'], [True, False]]
print(nested_list[0][1])  # 输出：2
print(nested_list[1][2])  # 输出：'c'
print(nested_list[2][0])  # 输出：True

遍历嵌套列表：

你可以使用嵌套循环来遍历嵌套列表中的元素。

nested_list = [[1, 2, 3], ['a', 'b', 'c'], [True, False]]
for inner_list in nested_list:
    for element in inner_list:
        print(element)

操作嵌套列表：

你可以向嵌套列表中添加新的子列表，或者修改已有的子列表的元素。

nested_list = [[1, 2, 3], ['a', 'b', 'c']]
nested_list.append([True, False])  # 添加新的子列表
nested_list[0][1] = 5  # 修改某个子列表中的元素

Python 列表比较

在Python中，你可以使用比较运算符对列表进行比较。下面是一些常用的列表比较方式：

1. 相等性比较（==和!=）：

   • 用于检查两个列表是否相等或不相等。

   list1 = [1, 2, 3]
   list2 = [1, 2, 3]
   print(list1 == list2)  # 输出：True
   print(list1 != list2)  # 输出：False
   

2. 大小比较（<, <=, >, >=）：

   • 可以按照字典顺序逐个元素比较两个列表的元素。从第一个开始比较，如果找到一个位置两个列表的元素不相等，则根据不等元素的比较结果确定整体列表的比较结果。

   list3 = [1, 2]
   list4 = [1, 3]
   print(list3 < list4)  # 输出：True，因为 2 < 3
   

3. 成员身份测试（in和not in）：

   • 可以测试一个列表是否包含某个特定元素。

   list5 = [1, 2, 3]
   print(2 in list5)      # 输出：True
   print(4 not in list5)  # 输出：True
   

注意，在Python中，列表比较是逐个元素进行比较的，如果两个列表的所有元素一一对应相等，则认为这两个列表相等，否则根据比较结果确定大小关系。

Python列表函数&方法

在Python中，列表（List）是一个非常常用且功能丰富的数据类型，具有许多内置的函数和方法可以对列表进行操作。以下是一些常用的列表函数和方法：

列表函数：

1. len(): 返回列表中元素的个数。

   my_list = [1, 2, 3, 4, 5]
   print(len(my_list))  # 输出：5
   

2. max(): 返回列表中的最大值。

   my_list = [10, 5, 8, 20]
   print(max(my_list))  # 输出：20
   

3. min(): 返回列表中的最小值。

   my_list = [10, 5, 8, 20]
   print(min(my_list))  # 输出：5
   

4. sum(): 返回列表所有元素的和（仅当列表内元素为数值型）。

   my_list = [1, 2, 3, 4, 5]
   print(sum(my_list))  # 输出：15
   

列表方法：

1. append(): 在列表末尾添加一个新元素。

   my_list = [1, 2, 3]
   my_list.append(4)
   print(my_list)  # 输出：[1, 2, 3, 4]
   

2. extend(): 将另一个列表中的元素逐个添加到当前列表的末尾。

   list1 = [1, 2]
   list2 = [3, 4]
   list1.extend(list2)
   print(list1)  # 输出：[1, 2, 3, 4]
   

3. insert(): 在指定位置插入一个元素。

   my_list = [1, 2, 3]
   my_list.insert(1, 5)
   print(my_list)  # 输出：[1, 5, 2, 3]
   

4. pop(): 移除并返回指定位置的元素（默认为最后一个元素）。

   my_list = [1, 2, 3]
   element = my_list.pop()
   print(element)  # 输出：3
   print(my_list)  # 输出：[1, 2]
   

还有很多其他列表函数和方法可供使用。

关注我，不迷路，共学习，同进步

关注我，不迷路，共学习，同进步