python基础语法（三-中）

基础语法3：

2.列表与元组：

<1>.列表、元组是什么？

都用来存储数据，但是两者有区别，列表可变，元组不可变。

<2>.创建列表：

创建列表有两种方式：

[1].a = 【】；

[2].b = list()；

<3>.下标访问：

a[1]......

a[-1] = a[len(a) - 1] = 最后一个数；

<4>.切片操作：

通过切片，可以一次取出一组连续元素，得到一个子列表

使用[:]进行切片

alist = [1,2,3,4]
print(alist[1:3])

除了这种切片方式，还可以有：
[1].alist[1: ],省略后边界，获取到末尾。

[2].alist[ :-1],省略前边界，从头开始获取。

[3].alist[ : ],两个边界均省略，获取整个列表。

<5>.遍历列表元素：

用for循环：

alist = [1,2,3,4]
for elem in alist:
    print(elem)

用for生成下标：

alist = [1,2,3,4]
for i in range (0,len(alist)):
    print(alist[i])

用while循环：

alist = [1,2,3,4]
i = 0
while i < len(alist):
    print(alist[i])
    i+=1

<6>.插入元素：

使用append：

a = [1, 2, 3, 4]
a.append(5)
a.append('hello')
i = 0  # 初始化变量 i
while i < len(a):
    print(a[i])
    i += 1

使用insert：

a = [1, 2, 3, 4]
a.insert(4, 5)      # 在索引 4 的位置插入元素 5（即列表末尾）
a.insert(0, 'start') # 在列表开头插入字符串 'start'
a.insert(len(a), 'end') # 在列表末尾插入字符串 'end'

i = 0
while i < len(a):
    print(a[i])
    i += 1

<7>.查找元素：

`in` 操作符：检查元素是否存在

作用： 判断元素是否存在于列表中，返回布尔值 True 或 False。
语法： element in list
示例：

a = [1, 2, 3, 'hello']

print(2 in a)       # 输出: True
print('world' in a) # 输出: False

`index()` 方法：查找元素的索引

作用： 返回元素在列表中第一次出现的索引位置。
语法： list.index(element, start, end)
- element：要查找的元素
- start（可选）：开始查找的索引位置
- end（可选）：结束查找的索引位置
示例：

a = [1, 2, 3, 'hello', 3]

print(a.index(3))       # 输出: 2（第一个 3 的索引）
print(a.index('hello')) # 输出: 3

结合使用示例

下面是一个结合 in 和 index() 的示例，用于安全地查找元素并处理可能的错误：

a = [1, 2, 3, 'hello']

# 先检查元素是否存在，避免 IndexError
element = 'hello'
if element in a:
    index = a.index(element)
    print(f"元素 '{element}' 的索引是: {index}")
else:
    print(f"元素 '{element}' 不存在于列表中")

# 查找不存在的元素
element = 'world'
if element in a:
    print(a.index(element))
else:
    print(f"'{element}' 不存在")

<8>.删除元素：

在 Python 中，列表提供了多种删除元素的方法，最常用的是 pop() 和 remove()，下面详细介绍它们的用法和区别。

`pop()` 方法：根据索引删除元素

作用： 删除列表中指定索引的元素，并返回该元素的值。
语法： list.pop(index)
- index（可选）：要删除元素的索引，默认为 -1（删除最后一个元素）。
示例：

a = [10, 20, 30, 40]

# 删除并返回索引为 1 的元素（第二个元素）
removed = a.pop(1)
print(removed)  # 输出: 20
print(a)        # 输出: [10, 30, 40]

# 删除并返回最后一个元素
last = a.pop()
print(last)     # 输出: 40
print(a)        # 输出: [10, 30]

注意： 如果索引超出范围，会抛出 IndexError。

`remove()` 方法：根据值删除元素

作用： 删除列表中第一个匹配的元素（按值查找），无返回值。
语法： list.remove(value)
- value：要删除的元素值。
示例：

a = [10, 20, 30, 20]

# 删除第一个值为 20 的元素
a.remove(20)
print(a)  # 输出: [10, 30, 20]

# 尝试删除不存在的值
a.remove(50)  # 会抛出 ValueError: list.remove(x): x not in list

注意： 如果元素不存在，会抛出 ValueError。

区别总结

方法	删除依据	返回值	异常处理	适用场景
`pop()`	索引	被删除的元素	索引越界时抛出 `IndexError`	删除指定位置的元素，需获取删除值
`remove()`	值	无（返回 `None`）	值不存在时抛出 `ValueError`	删除指定值的元素，不关心位置

其他删除方式

（1）`del` 语句：按索引或切片删除

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

# 删除单个元素
del a[2]        # 删除索引为 2 的元素（第三个元素）
print(a)        # 输出: [1, 2, 4, 5]

# 删除切片
del a[1:3]      # 删除索引 1 到 2 的元素
print(a)        # 输出: [1, 5]

（2）清空列表：`clear()`

a = [1, 2, 3]
a.clear()       # 等同于 a = []
print(a)        # 输出: []

<9>.列表的拼接：

在 Python 中，列表的拼接有两种主要方式：使用 + 运算符和 extend() 方法。它们的功能相似，但在实现方式和性能上有一些区别。

`+` 运算符：创建新列表

作用： 将两个列表合并为一个新列表，原列表不变。
语法： new_list = list1 + list2
示例：

a = [1, 2, 3]
b = [4, 5, 6]

# 使用 + 拼接列表
c = a + b
print(c)  # 输出: [1, 2, 3, 4, 5, 6]

# 原列表不变
print(a)  # 输出: [1, 2, 3]
print(b)  # 输出: [4, 5, 6]

注意： 只能用于列表类型，否则会抛出 TypeError。

`extend()` 方法：原地扩展列表

作用： 将另一个可迭代对象（如列表、元组、字符串）的元素添加到原列表末尾，原列表被修改。
语法： list1.extend(iterable)
示例：

a = [1, 2, 3]
b = [4, 5, 6]

# 使用 extend() 扩展列表
a.extend(b)
print(a)  # 输出: [1, 2, 3, 4, 5, 6]

# 原列表 a 被修改，b 不变
print(b)  # 输出: [4, 5, 6]

# 扩展其他可迭代对象
a.extend((7, 8))    # 扩展元组
a.extend("hello")   # 扩展字符串
print(a)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8, 'h', 'e', 'l', 'l', 'o']

区别总结

方法	操作类型	原列表是否修改	性能（大量元素）	适用场景
`+`	创建新列表	否	较慢（复制内存）	需要保留原列表，创建临时结果
`extend()`	原地修改列表	是	较快（直接追加）	不需要保留原列表，性能敏感

其他拼接方式

（1）`+=` 运算符：等价于 `extend()`

a = [1, 2]
b = [3, 4]

a += b  # 等同于 a.extend(b)
print(a)  # 输出: [1, 2, 3, 4]

（2）列表乘法：复制列表元素

a = [1, 2]
b = a * 3  # 复制 3 次
print(b)  # 输出: [1, 2, 1, 2, 1, 2]

<10>.关于元组：

在 Python 中，元组（tuple） 是一种不可变的序列类型，用于存储多个元素。它与列表（list）类似，但元组一旦创建就不能修改，这使得元组在需要保证数据不被意外更改的场景中非常有用。

元组的基本特点

不可变（Immutable）：创建后不能添加、删除或修改元素。
有序：元素按插入顺序排列，可以通过索引访问。
允许重复元素：元组中可以包含重复的值。
异构：可以包含不同类型的元素（如整数、字符串、列表等）。

元组的创建

（1）使用小括号 `()`

empty_tuple = ()  # 空元组
single_tuple = (1,)  # 单元素元组（注意逗号！）
multiple_tuple = (1, "apple", [2, 3])  # 多元素元组

（2）省略括号（逗号分隔）

implicit_tuple = 1, 2, 3  # 等价于 (1, 2, 3)

（3）使用内置函数 `tuple()`

from_list = tuple([1, 2, 3])  # 从列表转换
from_str = tuple("hello")     # 从字符串转换

元组的基本操作

（1）访问元素

t = (10, 20, 30, 40)
print(t[0])    # 输出: 10（索引从 0 开始）
print(t[-1])   # 输出: 40（负索引表示从后往前）
print(t[1:3])  # 输出: (20, 30)（切片操作）

（2）遍历元组

for element in (1, "a", True):
    print(element)

（3）拼接和重复

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)  # 输出: (1, 2, 3, 4)（拼接）
print(t1 * 3)   # 输出: (1, 2, 1, 2, 1, 2)（重复）

（4）检查元素是否存在

t = (1, 2, 3)
print(2 in t)  # 输出: True

元组的不可变性

t = (1, 2, 3)
t[0] = 10  # 报错: TypeError: 'tuple' object does not support item assignment

但如果元组中的元素是可变对象（如列表），则可以修改该元素的内部状态：

t = (1, [2, 3])
t[1].append(4)  # 允许修改列表内部
print(t)  # 输出: (1, [2, 3, 4])

元组的常用方法

（1）`count()`：统计元素出现次数

t = (1, 2, 2, 3)
print(t.count(2))  # 输出: 2

（2）`index()`：查找元素的索引

t = (10, 20, 30)
print(t.index(20))  # 输出: 1

元组与列表的对比

特性	元组（tuple）	列表（list）
可变性	不可变（Immutable）	可变（Mutable）
语法	用 `()` 创建，逗号分隔	用 `[]` 创建，逗号分隔
性能	略高（创建和访问更快）	略低（动态调整大小）
应用场景	存储固定数据、函数返回值	动态数据、需要修改元素