列表（list）是Python中的一种内置数据结构，它是一个有序的元素集合，可以包含重复的元素。列表是可变的，这意味着你可以在创建后添加、删除或更改元素。列表的灵活性和易用性使其成为Python编程中最常用的数据结构之一。

1.1 创建列表

列表使用方括号 [] 创建，或者使用 list() 函数。列表中的元素之间用逗号 , 分隔。

# 使用方括号创建列表
my_list = [1, 2, 3, "Python"]

# 使用列表推导式创建列表
squares = [x**2 for x in range(10)]  # 生成一个包含0到9平方的列表

# 使用 list() 函数创建列表
another_list = list((1, 2, 3, "Python"))

# 直接创建空列表
empty_list = []

1.2 访问列表元素

你可以通过索引来访问列表中的元素，索引从0开始。

# 访问第一个元素
first_element = my_list[0]

# 访问最后一个元素
last_element = my_list[-1]

# 使用负索引访问元素
second_last_element = my_list[-2]

1.3 修改列表元素

列表是可变的，所以你可以直接通过索引来修改元素。

# 修改第一个元素
my_list[0] = "Hello"

# 修改最后一个元素
my_list[-1] = "World"

1.4 添加元素

你可以使用 append() 方法在列表末尾添加一个元素，或者使用 extend() 方法将另一个列表的元素添加到当前列表末尾。

# 在列表末尾添加一个元素
my_list.append("New Element")

# 将另一个列表的元素添加到当前列表末尾
my_list.extend([4, 5, 6])

1.5 删除元素

使用 remove() 方法删除列表中的特定元素，或者使用 pop() 方法删除并返回指定索引的元素。

# 删除列表中第一个匹配的元素
my_list.remove("Python")

# 删除并返回指定索引的元素
removed_element = my_list.pop(1)  # 删除索引为1的元素

1.6 切片

列表切片允许你访问列表的一部分。切片操作不会修改原始列表，而是返回一个新的列表。

# 获取子列表
sub_list = my_list[1:4]  # 从索引1到索引3（不包括索引4）

1.7 遍历列表

使用 for 循环遍历列表中的所有元素。

for element in my_list:
    print(element)

# 使用 while 循环遍历
index = 0
while index < len(my_list):
    print(my_list[index])
    index += 1

注意事项 列表索引是0-based，这意味着第一个元素的索引是0，第二个元素的索引是1，依此类推。 尝试访问超出列表长度的索引将导致 IndexError。 修改列表时要小心，尤其是在遍历列表的同时进行添加或删除操作，因为这可能会导致意外的行为。 列表推导式和内置方法（如 map(), filter(), reduce()）可以使代码更简洁，但在处理大型数据集时要注意性能。 在使用 del 语句删除元素时，要确保不会意外删除错误的元素。 列表可以包含不同类型的元素，这使得它们在存储和操作数据时非常灵活。

1.8 列表的操作方法

1. `append(obj)` - 添加元素到列表末尾

my_list = [1, 2, 3]
my_list.append('a')  # my_list 现在是 [1, 2, 3, 'a']

2. `extend(iterable)` - 将另一个可迭代对象的元素添加到列表末尾

my_list = [1, 2, 3]
my_list.extend(['a', 'b', 'c'])  # my_list 现在是 [1, 2, 3, 'a', 'b', 'c']

3. `insert(index, obj)` - 在指定位置插入元素

my_list = [1, 2, 4]
my_list.insert(2, 'b')  # my_list 现在是 [1, 2, 'b', 4]

• insert和extend的区别：

1. insert可以指定插入元素的位置，extend不能指定，只能合并到末尾
2. insert是在原列表的基础上增加元素，什么都可以加（列表、字符串……），extend只能合并2个列表，对列表进行扩展，不能添加字符串

4. `remove(obj)` - 删除列表中第一个匹配的元素

my_list = [1, 2, 3, 4]
my_list.remove(3)  # my_list 现在是 [1, 2, 4]

5. `pop([index])` - 删除并返回指定位置的元素，如果不指定索引，则删除最后一个元素

my_list = [1, 2, 3, 4]
popped_element = my_list.pop(1)  # my_list 现在是 [1, 3, 4]，popped_element 是 2
last_element = my_list.pop()  # my_list 现在是 [1, 3]，last_element 是 4

6. `clear()` - 移除列表中的所有元素

my_list = [1, 2, 3]
my_list.clear()  # my_list 现在是 []

7. `reverse()` - 反转列表中的元素顺序

my_list = [1, 2, 3]
my_list.reverse()  # my_list 现在是 [3, 2, 1]

8. `sort([key], [reverse])` - 对列表进行排序。`key` 是一个函数，用于从列表中的每个元素中提取比较键值；`reverse` 是一个布尔值，指定排序是升序还是降序。

my_list = [4, 1, 3, 2]
my_list.sort()  # my_list 现在是 [1, 2, 3, 4]
my_list.sort(reverse=True)  # my_list 现在是 [4, 3, 2, 1]

9. `copy()` - 返回列表的浅拷贝

my_list = [1, 2, [3, 4]]
shallow_copy = my_list.copy()  # shallow_copy 现在是 [1, 2, [3, 4]]

10. `count(obj)` - 返回列表中匹配指定元素的次数

my_list = [1, 2, 2, 3, 2]
count = my_list.count(2)  # count 是 3

11. `index(obj[, start[, end]])` - 返回列表中第一个匹配指定元素的索引。如果存在多个匹配项，还可以通过 `start` 和 `end` 参数来指定搜索范围。

my_list = [1, 2, 3, 4, 5]
index = my_list.index(3)  # index 是 2

12. `len(list)` - 返回列表中元素的数量

my_list = [1, 2, 3]
length = len(my_list)  # length 是 3

13. `cmp(list1,list2)` -用于比较两个列表的元素

如果比较的元素是同类型的,则比较其值,返回结果。
如果两个元素不是同一种类型,则检查它们是否是数字。
- 如果是数字,执行必要的数字强制类型转换,然后比较。
- 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")
- 否则,通过类型名字的字母顺序进行比较。
如果有一个列表首先到达末尾,则另一个长一点的列表"大"。
如果我们用尽了两个列表的元素而且所 有元素都是相等的,那么结果就是个平局,就是说返回一个 0

list1, list2 = [123, 'xyz'], [456, 'abc']

print cmp(list1, list2);  # 输出 -1
print cmp(list2, list1);  # 输出  1
list3 = list2 + [786];    #
print cmp(list2, list3)   # 输出 -1
list4 = list1.copy()
print cmp(list1,list4)    # 输出  0

14. `max(list)` - 返回列表元素中的最大值。

list1, list2 = ['123', 'xyz', 'zara', 'abc'], [456, 700, 200]

print "Max value element : ", max(list1);  # 输出 zara
print "Max value element : ", max(list2);  # 输出 700

15. `min(list)`：返回列表元素中的最小值。

list1, list2 = [123, 'xyz', 'zara', 'abc'], [456, 700, 200]

print "min value element : ", min(list1);   # 输出 123
print "min value element : ", min(list2);   # 输出 200

16. `+` 操作符：用于生成一个新的组合列表。

# 使用 + 拼接
my_list = (1,2,3) + (4,5,6)  # my_list= (1,2,3,4,5,6)

17. * 操作符：用于生成一个新的重复列表。

# 使用 * 
l1 = [1,2,3]
my_list = l1 *4   # my_list = [1,2,3,1,2,3,1,2,3,1,2,3]

注意事项 当使用 append() 和 extend() 方法时，原始列表会被修改。 remove() 方法只会删除找到的第一个匹配元素。如果列表中有多个相同的元素，其他匹配元素不会被删除。 pop() 方法在没有指定索引时，会删除列表的最后一个元素。如果你想删除特定位置的元素，应该提供索引参数。 sort() 方法会修改原始列表。如果你需要保留原始列表的顺序，可以使用 sorted() 函数，它会返回一个新的排序后的列表。 列表推导式可以包含复杂的表达式和条件，但应谨慎使用以保持代码的可读性。 列表推导式通常比使用循环创建列表更快，但也要注意不要创建过于复杂的推导式，以免降低代码的可维护性。

1.9 列表推导式

列表推导式提供了一种简洁的方式来创建列表，它是基于已有列表生成新列表的强大工具。

# 基本列表推导式
squares = [x**2 for x in range(10)]  # 生成一个包含 0 到 9 的平方的列表

# 带有条件的列表推导式
even_squares = [x**2 for x in range(10) if x % 2 == 0]  # 只包含偶数的平方

# 使用函数作为推导式的 key
transformed = [abs(x) for x in [-1, -2, -3]]  # 将负数转换为正数

1.10 列表的特点

列表（list）是Python中的一种内置数据结构，具有以下特点：

• 可变性：列表是可变的，这意味着你可以在创建后添加、删除或更改元素。
• 有序性：列表中的元素按照它们被添加的顺序进行存储和访问。
• 元素重复性：列表可以包含重复的元素。
• 支持多种数据类型：列表可以包含不同类型的数据，如整数、浮点数、字符串、甚至其他列表。
• 使用方括号：列表使用方括号 [] 来定义，元素之间用逗号 , 分隔。
• 索引和切片：列表支持索引和切片操作，允许你访问和操作列表中的特定部分。
• 丰富的内置方法：列表提供了多种内置方法，如 append(), extend(), insert(), remove(), pop(), del, clear(), copy(), len(), count(), index(), reverse(), sort() 等，这些方法使得操作列表变得非常方便。
• 动态大小：列表的大小是动态的，它可以根据需要自动增长或缩小。
• 性能：列表的某些操作（如在末尾添加元素）非常快速，但在列表中间插入或删除元素可能较慢，因为需要移动后续的所有元素。
• 迭代：列表可以被迭代，这使得它们在循环中非常有用。
• 嵌套：列表可以嵌套，即一个列表中的元素可以是另一个列表。
• 作为函数参数：列表常用于向函数传递多个参数，也可以作为函数的返回值。