以下是“Python内置数据结构列表与元组示例详解”的完整攻略。

1. 列表（List）

列表是Python中最常用的数据结构之一，它是一个有序的集合，可以存储任意类型的数据，包括数字、字符串、列表、元组等。列表使用方括号[]来表示，其中的元素用逗号分隔。

1.1 创建列表

可以使用以下方式来创建一个列表：

# 创建一个空列表
my_list = []

# 创建一个包含元素的列表
my_list = [1, 2, 3, 'a', 'b', 'c']

1.2问列表元素

可以使用下标来访问列表中的元素，下标从0开始，负数表示从后往前数。

_list = [1, 2, 3, 'a', 'b', 'c']

# 访问第一个元素
print(my_list[0])

# 访问最后一个元素
print(my_list[-1])

1.3 修改列表元素

可以使用下标来修改列表中的元素。

my_list = [, 2, 3, 'a', 'b', 'c']

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

# 修改最后一个元素
my_list[-1] = 'd'

print(my_list)

1.4 列表切片

可以使用切片来获取列表的子集，切片的语法为[start:end:step]，其中start表示起始下标，end表示结束下标（不包含），step表示步长。

my_list = [1, 2, 3, 'a', 'b', 'c']

# 获取前三个元素
print(my_list[:3])

# 获取后三个元素
print(my_list[-3:])

# 获取第二个到第五个元素
print(my_list[1:5])

# 获取所有偶数下标的元素
print(my_list[::2])

1.5 列表方法

列表提供了许多方法来操作列表，以下是一些常用的方法：

1.5.1 append()

在列表末尾添加一个元素。

my_list = [1, 2, 3]

my_list.append(4)

print(my_list)

1.5.2 extend()

在列表末尾添加另一个列表中的所有元素。

my_list = [1 2, 3]

my_list.extend([4, 5, 6])

print(my_list)

1.5.3 insert()

在指定位置插入一个元素。

my_list = [1, 2, 3]

my_list.insert(1, 'a')

print(my_list)

1.5.4 remove()

删除列表第一个匹配的元素。

my_list = [1, 2, 3, 'a', 'b', 'c']

my_list.remove('a')

print(my_list)

1.5.5 pop()

删除并返回指定位置的元素，默认为最后一个元素。

my_list = [1, 2, 3, 'a', 'b', 'c']

my_list.pop(3)

print(my_list)

1.5.6 index()

返回列表中第一个匹配元素的下标。

my_list = [1, 2, 3, 'a', 'b', 'c']

print(my_list.index('a'))

1.5.7 count()

返回列表中指定元素的个数。

my_list = [1, 2, 3, 'a', 'b', 'c', 'a']

print(my_list.count(''))

1.5.8 sort()

对列表进行排序。

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

my_list.sort()

print(my_list)

1.5.9 reverse()

将列表中的元素反转。

my_list = [1, 2, 3, 'a', 'b', 'c']

my_list.reverse()

print(my_list)

2. 元组（Tuple）

元组是Python中另一个常用的数据结构，它与列表类似，也是一个有序的集合，可以存储任意类型的数据，但是元组是不可变的，一旦创建就不能修改。元组使用圆括号()来表示，其中的元素用逗号分隔。

2.1 创建元组

可以使用以下方式来创建一个元组：

# 创建一个空元组
my_tuple = ()

# 创建一个包含元素的元组
my_tuple = (1, 2, 3, 'a', 'b', 'c')

2.2 访问元组元素

可以使用下标来访问元组中的元素，下标从0开始，负数表示从后往前数。

my_tuple = (1, 2, 3, 'a', 'b', 'c')

# 访问第一个元素
print(my_tuple[0])

# 访问最后一个元素
print(my_tuple[-1])

2.3 元组切片

可以使用切片来获取元组的子集，切片的语法为[start:end:step]，其中start表示起始下标，end表示结束下标（不包含），step表示步长。

```pythonmy_tuple = (1, 2, 3, 'a', 'b', 'c')

获取前三个元素

print(my_tuple[:3])

获取后三个元素

print(my_tuple[-3:])

获取第二个到第五个元素

print(my_tuple[1:5])

获取所有偶数下标的元素
print(my_tuple[::2])


### 2.4 元组方法

元组是不可变的，因此只提供了少量的方法来操作元组，以下是一些常用的方法：

#### 2.4.1 index()

返回元组中第一个匹配元素的下标。

```python
my_tuple = (1, 2, 3, 'a', 'b', 'c')

print(my_tuple.index('a'))

2.4.2 count()

返回元组中指定元素的个数。

my_tuple = (1, 2, 3, 'a', 'b', 'c', 'a')

print(my_tuple.count('a'))

3. 总结

列表和元组是Python中最常用的数据结构之一，它们都是有序的集合，可以存储任意类型的数据。列表是可变的，可以随意添加、删除和修改元素，而元组是不可变的，一旦创建就不能修改。在本攻略中，我们分别介绍了列表和元组的创建、访问、切片和常用方法，并给出了相应的示例说明。

以下是两个示例说明。

示例1：使用列表实现堆栈

stack = []

# 入栈
stack.append(1)
stack.append(2)
stack.append(3)

# 出栈
print(stack.pop())
print(stack.pop())
print(stack.pop())

期望的输出结果是：

3
2
1

示例2：使用元组实现多返回值

def get_name_and_age():
    return 'Alice', 18

name, age = get_name_and_age()

print(name, age)