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()（元素不存在時）