1 Python 列表切片

一、切片完整语法

列表切片的基本格式：
列表[start:end:step]

start：起始索引（包含该位置元素，可省略）

end：结束索引（不包含该位置元素，可省略）

step：步长（每隔多少个元素取一次，默认 1，可省略）

注意：

• 索引可为正数（从左往右，从 0 开始）或负数（从右往左，从 - 1 开始）
• 省略参数时，冒号的位置需保留以区分参数位置

二、常用切片场景及示例

以列表 a = [2, 4, 6, 8, 20, 30, 40] 为例：

1. 省略 step（默认步长 1）

• a[start:end]：从start取到end（不包含end）

  • a[2:5] → 从索引 2 到 4（5-1）→ [6, 8, 20]
  • a[-4:-1] → 从倒数第 4 到倒数第 2 → [8, 20, 30]

• a[start:]：省略end，表示取到列表末尾

  • a[3:] → 从索引 3 到末尾 → [8, 20, 30, 40]
  • a[-2:] → 从倒数第 2 到末尾 → [30, 40]（你提到的情况）

• a[:end]：省略start，表示从开头取到end

  • a[:3] → 从开头到索引 2 → [2, 4, 6]
  • a[:-2] → 从开头到倒数第 3 → [2, 4, 6, 8, 20]

• a[:]：省略start和end，表示取整个列表

  • a[:] → [2, 4, 6, 8, 20, 30, 40]（相当于复制列表）

2. 指定 step（步长）

• a[::step]：省略start和end，表示从开头到末尾按步长取

  • a[::2] → 步长 2（每隔 1 个取 1 个）→ [2, 6, 20, 40]（你提到的情况）
  • a[::3] → 步长 3 → [2, 8, 40]

• a[start:end:step]：指定起始、结束和步长

  • a[1:6:2] → 从索引 1 到 5，步长 2 → [4, 8, 30]
  • a[-5::-1] → 从倒数第 5 开始，步长 - 1（反向取）→ [6, 4, 2]

3. 负数步长（反向切片）

• 步长为负数时，start 需大于 end（从右往左取）
  • a[::-1] → 反转列表 → [40, 30, 20, 8, 6, 4, 2]
  • a[5:1:-1] → 从索引 5 到 2，反向取 → [30, 20, 8, 6]

三、总结

• 一个冒号 : 用于分隔 start 和 end（省略step）
• 两个冒号 :: 用于指定 step（可省略start和end）
• 负数索引从末尾开始计数（-1 是最后一个元素）
• 省略参数时，默认值为：start=0，end=列表长度，step=1

通过这些规则，可以灵活地截取列表中的任意部分。

2 enumerate 下标从0开始

在Python3中，下列程序运行结果为：
lists = [1, 2, 3, 4]
tmp = 0
for i,j in enumerate(lists):tmp += i * j
print(tmp)A 20
B 30
C 100
D None正确答案：A

解析过程

1. enumerate () 函数作用：
   用于将可遍历对象（如列表）组合为索引 - 元素对，格式为enumerate(sequence, [start=0])，默认从 0 开始计数，在 for 循环中可同时获取索引和元素值。

2. 循环过程拆解：
   遍历列表[1, 2, 3, 4]时，索引i和元素j的对应关系及计算如下：

   • i=0, j=1 → 0×1 = 0 → tmp=0
   • i=1, j=2 → 1×2 = 2 → tmp=0+2=2
   • i=2, j=3 → 2×3 = 6 → tmp=2+6=8
   • i=3, j=4 → 3×4 = 12 → tmp=8+12=20

3. 最终结果：
   变量tmp的最终值为 20，因此程序输出 20。

3 Python字典的get()方法的使用

在 Python 中，字典的 get() 方法用于获取指定键对应的值，它是一种安全获取字典元素的方式，相比直接使用 键名 访问（如 dict[key]），能更好地处理键不存在的情况。

基本语法

python

运行

dict.get(key, default_value)

• 参数说明：
  • key：必需，要查找的键。
  • default_value：可选，当键不存在时返回的默认值（如果不指定，默认返回 None）。

使用场景与示例

1. 基本使用：获取存在的键的值

当键存在于字典中时，get() 会返回该键对应的 value：

python

运行

person = {"name": "Alice", "age": 25, "city": "New York"}# 获取存在的键
name = person.get("name")
print(name)  # 输出：Aliceage = person.get("age")
print(age)   # 输出：25

2. 处理键不存在的情况！！！！！！！！！！！！！！！！！！！！

当键不存在时，get() 会返回指定的默认值（或 None），而不会像直接访问 dict[key] 那样抛出 KeyError 错误：

python

运行

person = {"name": "Alice", "age": 25}# 键不存在，不指定默认值，返回 None
gender = person.get("gender")
print(gender)  # 输出：None# 键不存在，指定默认值
country = person.get("country", "Unknown")
print(country)  # 输出：Unknown

3. 与直接访问的对比

直接使用 dict[key] 访问不存在的键会报错，而 get() 更安全：

python

运行

person = {"name": "Alice"}# 直接访问不存在的键，会抛出 KeyError
# print(person["height"])  # 报错：KeyError: 'height'# 使用 get() 方法，返回默认值
height = person.get("height", 160)
print(height)  # 输出：160（不会报错）

总结

• get() 方法的核心优势是避免因键不存在而导致的 KeyError，适合在不确定键是否存在的场景中使用。
• 当需要为不存在的键返回特定默认值（如空字符串、0、提示信息等）时，get() 比条件判断（如 if key in dict）更简洁。

4 Python 中文件对象的 seek() 方法

【file里面的seek方法是不是就是移动指针的意思？】

是的，Python 中文件对象的 seek() 方法的核心作用就是移动文件指针的位置。

文件指针可以理解为 “当前读写操作的位置”，就像我们阅读书本时的书签 —— 打开文件后，指针默认在文件开头（位置 0），随着读写操作会自动移动；而 seek() 允许我们主动调整这个 “书签” 的位置，从而实现从指定位置开始读写的功能。

基本语法

python

运行

file.seek(offset, whence)

• offset：必需，整数，表示要移动的字节数（正数向前移动，负数向后移动）。
• whence：可选，整数，指定偏移量的参考位置（默认值为 0）：
  • 0：从文件开头开始计算（默认模式）。
  • 1：从当前指针位置开始计算。
  • 2：从文件末尾开始计算。

示例说明

假设文件 test.txt 内容为："abcdefghij"（共 10 个字符，每个字符占 1 字节）。

python

运行

with open("test.txt", "r") as f:# 初始指针在 0（文件开头）print(f.read(2))  # 读取 2 字节，返回 "ab"，指针移到 2f.seek(4)  # 指针移到位置 4（从开头计算）print(f.read(3))  # 从位置 4 开始读 3 字节，返回 "efg"，指针移到 7f.seek(-2, 2)  # 从文件末尾（位置 10）向前移动 2 字节，指针到 8print(f.read())  # 从位置 8 开始读，返回 "ij"

注意事项

1. 文本模式与二进制模式：

   • 文本模式（"r"/"w" 等）下，whence=1 和 whence=2 可能会报错（不同 Python 版本行为有差异），建议仅在二进制模式（"rb"/"wb" 等）中使用这两种模式。
   • 文本模式中，offset 通常应为非负整数，且需与文件的编码方式兼容（避免在多字节字符中间定位）。

2. 与读写操作的配合：

   • 写入文件时，seek() 可以控制写入的位置（可能覆盖原有内容）。
   • 读取文件时，seek(0) 常用于将指针重置到开头，实现 “重新读取” 的效果。

总之，seek() 是通过移动文件指针来精确控制文件读写位置的关键方法，在需要随机访问文件内容时非常实用。

5 不同方法处理 "查找不到目标" 的情况

注意到：

find()方法用于在字符串中查找子字符串,当查找的子字符串不存在时,会返回-1。

--------------------------------------------------具体整理一下这些吧！

在 Python 中，不同方法处理 "查找不到目标" 的情况时，返回值或行为确实存在差异，主要分为以下几类，理解这些差异可以帮助你正确处理各种场景：

一、返回特定值（不报错）

这类方法在找不到目标时会返回一个约定好的 "空值" 或特定标记，不会抛出错误，最常见的有：

1. 字符串方法：

   • find(sub) / rfind(sub)：找不到返回 -1（如前面提到的）
   • index(sub) / rindex(sub)：注意：这两个方法与find功能类似，但找不到时会直接抛出 ValueError

   python

   运行

   s = "hello"
   print(s.find("x"))  # 返回 -1（安全）
   # print(s.index("x"))  # 报错：ValueError: substring not found
   

2. 字典方法：

   • get(key, default)：找不到键时返回 default（默认是None，如之前讲的）
   • dict[key] 直接访问：找不到键时会抛出 KeyError

   python

   运行

   d = {"name": "Alice"}
   print(d.get("age"))  # 返回 None（安全）
   # print(d["age"])  # 报错：KeyError: 'age'
   

二、返回None（不报错）

部分方法在找不到目标或操作无结果时，会默认返回None（通常是因为没有更合适的返回值）：

1. 列表的remove()方法：

   • 移除指定元素，成功无返回值（实际返回None），但找不到元素时会抛出ValueError

   python

   运行

   lst = [1, 2, 3]
   print(lst.remove(2))  # 返回 None（操作成功）
   # lst.remove(4)  # 报错：ValueError: list.remove(x): x not in list
   

2. 字符串的replace()方法：

   • 替换子字符串，找不到时返回原字符串（不会返回None，也不报错）

   python

   运行

   s = "hello"
   print(s.replace("x", "a"))  # 找不到"x"，返回原字符串 "hello"
   

三、总结：如何正确处理？

1. 优先使用 "安全方法"：
   当不确定目标是否存在时，尽量用返回特定值的方法（如find()、get()），避免直接访问（如index()、dict[key]），减少报错风险。

   python

   运行

   # 安全判断字符串是否包含子串
   s = "test"
   if s.find("x") != -1:  # 用 -1 判断print("存在")
   else:print("不存在")# 安全获取字典值
   d = {"a": 1}
   value = d.get("b", 0)  # 找不到时用默认值0，避免报错
   

2. 必须用可能报错的方法时，加异常处理：
   如果需要用index()、list.remove()等可能报错的方法，用try-except捕获异常：

   python

   运行

   lst = [1, 2, 3]
   try:lst.remove(4)
   except ValueError:print("元素不存在，无需移除")
   

3. 记住关键区别：

   • 返回-1：find()、rfind()（字符串）
   • 返回None：get()（不指定默认值时）、remove()（列表）等
   • 直接报错：index()、rindex()（字符串）、dict[key]（字典）、list.remove()（元素不存在时）