1. 字符串反轉(zhuǎn)

字符串是 Python 中最常用的序列類型，反轉(zhuǎn)操作非常高頻，以下是三種核心方法。

1.1 方法1：切片[::-1]（最推薦?。?/h3>

這是 Python 中最簡潔高效的字符串反轉(zhuǎn)方式，利用切片的**步長（step）**參數(shù)實現(xiàn)。

切片語法回顧： s[start:end:step]

• start：起始索引（省略則從開頭）
• end：結(jié)束索引（省略則到末尾）
• step：步長，-1 表示從后往前取

代碼示例：

s = "Hello Python"

# 切片反轉(zhuǎn)：start和end省略，step=-1
reversed_s = s[::-1]

print(f"原字符串: {s}")
print(f"反轉(zhuǎn)后: {reversed_s}")
# 輸出:
# 原字符串: Hello Python
# 反轉(zhuǎn)后: nohtyP olleH

解析：

• 切片 [::-1] 會從字符串最后一個字符開始，向前遍歷所有字符，生成新的反轉(zhuǎn)字符串。
• 優(yōu)點：代碼一行搞定，時間復雜度 O(n)，效率極高。

1.2 方法2：reversed()+join()

reversed() 是 Python 內(nèi)置函數(shù)，返回一個反向迭代器，需要用 join() 將迭代器拼接成字符串。

代碼示例：

s = "Hello Python"

# 1. reversed(s) 返回反向迭代器
# 2. ''.join() 將迭代器中的字符拼接成字符串
reversed_s = ''.join(reversed(s))

print(f"原字符串: {s}")
print(f"反轉(zhuǎn)后: {reversed_s}")
# 輸出: nohtyP olleH

解析：

• reversed(s) 不會直接生成列表，而是返回迭代器（節(jié)省內(nèi)存），適合處理超長字符串。
• join() 用于將可迭代對象（如迭代器、列表）的元素拼接成字符串。

1.3 方法3：手動循環(huán)拼接（理解原理用）

通過索引從后往前遍歷字符，逐個拼接成新字符串，適合理解反轉(zhuǎn)邏輯。

代碼示例：

s = "Hello Python"
reversed_s = ""

# 從最后一個索引（len(s)-1）開始，遍歷到 0
for i in range(len(s)-1, -1, -1):
    reversed_s += s[i]

print(f"原字符串: {s}")
print(f"反轉(zhuǎn)后: {reversed_s}")
# 輸出: nohtyP olleH

解析：

• range(len(s)-1, -1, -1)：起始是最后一個索引，結(jié)束是 -1（不包含，所以到 0），步長 -1。
• 優(yōu)點：直觀理解反轉(zhuǎn)過程；缺點：代碼冗長，效率略低（字符串拼接會生成新對象）。

字符串反轉(zhuǎn)總結(jié)： 日常開發(fā)優(yōu)先用切片 [::-1]，簡潔高效。

2. 四大數(shù)據(jù)結(jié)構(gòu)反轉(zhuǎn)

2.1 列表反轉(zhuǎn)

列表是可變序列，反轉(zhuǎn)方法分為原地反轉(zhuǎn)（修改原列表）和非原地反轉(zhuǎn)（返回新列表）。

方法1：切片[::-1]（非原地，返回新列表）

和字符串切片類似，返回一個新的反轉(zhuǎn)列表，不修改原列表。

代碼示例：

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

# 切片反轉(zhuǎn)，返回新列表
reversed_lst = lst[::-1]

print(f"原列表: {lst}")          # 原列表不變: [1, 2, 3, 4, 5]
print(f"反轉(zhuǎn)后新列表: {reversed_lst}") # [5, 4, 3, 2, 1]

解析：

優(yōu)點：不修改原列表，代碼簡潔；缺點：生成新列表，占用額外內(nèi)存。

方法2：list.reverse()（原地反轉(zhuǎn)，修改原列表）

列表的內(nèi)置方法，直接修改原列表，返回 None（新手易錯?。?。

代碼示例：

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

# 原地反轉(zhuǎn)，修改原列表，返回 None
result = lst.reverse()

print(f"原列表（已修改）: {lst}") # [5, 4, 3, 2, 1]
print(f"返回值: {result}")        # None（注意！不是反轉(zhuǎn)后的列表）

解析：

優(yōu)點：不需要額外內(nèi)存，直接修改原列表；缺點：會改變原列表，且返回值是 None，不能寫 a = lst.reverse()。

方法3：reversed()+list()（非原地，返回迭代器轉(zhuǎn)列表）

reversed() 返回反向迭代器，用 list() 轉(zhuǎn)成新列表，不修改原列表。

代碼示例：

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

# reversed() 返回迭代器，list() 轉(zhuǎn)成新列表
reversed_lst = list(reversed(lst))

print(f"原列表: {lst}")          # [1, 2, 3, 4, 5]
print(f"反轉(zhuǎn)后新列表: {reversed_lst}") # [5, 4, 3, 2, 1]

解析：

適合需要迭代器的場景（如遍歷大列表時節(jié)省內(nèi)存），轉(zhuǎn)列表后和切片效果一致。

列表反轉(zhuǎn)總結(jié)：

• 不想修改原列表：用 lst[::-1] 或 list(reversed(lst))。
• 想直接修改原列表：用 lst.reverse()（注意返回值是 None）。

2.2 元組反轉(zhuǎn)

元組是不可變序列，沒有 reverse() 方法（不能原地修改），只能通過非原地方式返回新元組。

方法1：切片[::-1]（推薦）

和字符串、列表切片一致，返回新的反轉(zhuǎn)元組。

代碼示例：

t = (1, 2, 3, 4, 5)

# 切片反轉(zhuǎn)，返回新元組
reversed_t = t[::-1]

print(f"原元組: {t}")          # (1, 2, 3, 4, 5)
print(f"反轉(zhuǎn)后新元組: {reversed_t}") # (5, 4, 3, 2, 1)

方法2：reversed()+tuple()

reversed() 返回迭代器，用 tuple() 轉(zhuǎn)成新元組。

代碼示例：

t = (1, 2, 3, 4, 5)
reversed_t = tuple(reversed(t))
print(f"反轉(zhuǎn)后: {reversed_t}") # (5, 4, 3, 2, 1)

元組反轉(zhuǎn)總結(jié)： 優(yōu)先用切片 [::-1]，簡潔高效。

2.3 集合反轉(zhuǎn)（說明）

重要：集合（Set）是無序的！ 集合中的元素沒有固定順序，因此“集合反轉(zhuǎn)”本身沒有意義。

如果強行將集合轉(zhuǎn)成列表反轉(zhuǎn)，再轉(zhuǎn)回集合，最終集合的順序仍然是不確定的（Python 內(nèi)部優(yōu)化決定）。

代碼示例（僅演示，無實際意義）：

s = {1, 2, 3, 4, 5}

# 1. 集合轉(zhuǎn)列表
lst = list(s)
# 2. 列表反轉(zhuǎn)
reversed_lst = lst[::-1]
# 3. 轉(zhuǎn)回集合（順序又變了?。?
s_new = set(reversed_lst)

print(f"原集合: {s}")          # 例如 {1,2,3,4,5}（順序不確定）
print(f"反轉(zhuǎn)列表后轉(zhuǎn)回集合: {s_new}") # 順序仍然不確定

結(jié)論：集合不需要反轉(zhuǎn)操作，如果需要有序的“集合”，可以用 list 或 collections.OrderedDict（Python 3.7+ 字典已有序）。

2.4 字典反轉(zhuǎn)

Python 3.7+ 中，字典（Dictionary）是有序的（按插入順序存儲鍵值對）。字典反轉(zhuǎn)分為兩種場景：

1. 鍵值對反轉(zhuǎn)：將 {k: v} 變成 {v: k}。
2. 按插入順序反轉(zhuǎn)項：將鍵值對的順序倒過來。

鍵值對反轉(zhuǎn)（k:v→v:k）

通過字典推導式實現(xiàn)，注意：值必須唯一，否則后面的會覆蓋前面的！

代碼示例：

# 原字典：鍵唯一，值也唯一
original_dict = {"a": 1, "b": 2, "c": 3}

# 字典推導式：鍵值互換
reversed_dict = {v: k for k, v in original_dict.items()}

print(f"原字典: {original_dict}")    # {'a': 1, 'b': 2, 'c': 3}
print(f"鍵值反轉(zhuǎn)后: {reversed_dict}") # {1: 'a', 2: 'b', 3: 'c'}

解析：

• original_dict.items() 獲取鍵值對 (k, v)。
• 推導式中寫成 {v: k}，實現(xiàn)鍵值互換。

易錯點：值不唯一時會覆蓋！

# 原字典：值有重復（'a' 和 'b' 對應的值都是 1）
original_dict = {"a": 1, "b": 1, "c": 3}

# 鍵值反轉(zhuǎn)后，后面的 'b':1 會覆蓋前面的 'a':1
reversed_dict = {v: k for k, v in original_dict.items()}

print(f"原字典: {original_dict}")    # {'a': 1, 'b': 1, 'c': 3}
print(f"鍵值反轉(zhuǎn)后: {reversed_dict}") # {1: 'b', 3: 'c'}（'a' 被覆蓋了！）

按插入順序反轉(zhuǎn)項（Python 3.7+）

將字典的鍵值對按插入順序倒過來，保持鍵值關(guān)系不變，只改變順序。

代碼示例：

# 原字典（按插入順序：a→b→c）
original_dict = {"a": 1, "b": 2, "c": 3}

# 1. items() 轉(zhuǎn)成列表，列表可以反轉(zhuǎn)
items_list = list(original_dict.items())  # [('a',1), ('b',2), ('c',3)]
# 2. 反轉(zhuǎn)列表
reversed_items = items_list[::-1]         # [('c',3), ('b',2), ('a',1)]
# 3. 轉(zhuǎn)回字典
reversed_dict = dict(reversed_items)

print(f"原字典: {original_dict}")    # {'a': 1, 'b': 2, 'c': 3}
print(f"順序反轉(zhuǎn)后: {reversed_dict}") # {'c': 3, 'b': 2, 'a': 1}

# 一行代碼搞定
reversed_dict_one_line = dict(list(original_dict.items())[::-1])
print(f"一行代碼: {reversed_dict_one_line}") # 同上

解析：

• 字典的 items() 本身是視圖對象，轉(zhuǎn)成列表后才能反轉(zhuǎn)。
• 反轉(zhuǎn)列表后用 dict() 轉(zhuǎn)回，保持鍵值關(guān)系，順序倒過來。

字典反轉(zhuǎn)總結(jié)：

• 鍵值互換：用字典推導式 {v: k for k, v in d.items()}（注意值唯一）。
• 順序反轉(zhuǎn)：轉(zhuǎn)列表反轉(zhuǎn)后再轉(zhuǎn)回字典 dict(list(d.items())[::-1])。

3. 文件內(nèi)容反轉(zhuǎn)并復制

將一個文件的內(nèi)容反轉(zhuǎn)后寫入另一個文件，分為三種常見場景：

• 整個文件內(nèi)容作為字符串反轉(zhuǎn)。
• 行順序反轉(zhuǎn)（第一行變最后一行，行內(nèi)容不變）。
• 每行內(nèi)容反轉(zhuǎn)（行順序不變，每行內(nèi)部字符反轉(zhuǎn)）。

前置準備： 先創(chuàng)建一個測試文件 original.txt，內(nèi)容如下：

第一行內(nèi)容
第二行內(nèi)容
第三行內(nèi)容

3.1 場景1：整個文件內(nèi)容反轉(zhuǎn)

將文件所有內(nèi)容作為一個大字符串，反轉(zhuǎn)后寫入新文件（適合小文件）。

代碼示例：

# 1. 讀取原文件全部內(nèi)容
with open("original.txt", mode='r', encoding='utf-8') as f:
    content = f.read()

# 2. 反轉(zhuǎn)整個字符串
reversed_content = content[::-1]

# 3. 寫入新文件
with open("reversed_whole.txt", mode='w', encoding='utf-8') as f:
    f.write(reversed_content)

print("整個內(nèi)容反轉(zhuǎn)完成！")

結(jié)果 reversed_whole.txt：

容內(nèi)行三第
容內(nèi)行二第
容內(nèi)行一第

3.2 場景2：行順序反轉(zhuǎn)（推薦?。?/h3>

保持每行內(nèi)容不變，將行的順序倒過來（第一行變最后一行），這是最常用的文件反轉(zhuǎn)場景。

代碼示例：

# 1. 讀取所有行到列表（每個元素是一行，包含換行符）
with open("original.txt", mode='r', encoding='utf-8') as f:
    lines = f.readlines()

# 查看 lines 內(nèi)容：
# ['第一行內(nèi)容\n', '第二行內(nèi)容\n', '第三行內(nèi)容']

# 2. 反轉(zhuǎn)行列表
reversed_lines = lines[::-1]

# 3. 寫入新文件
with open("reversed_lines.txt", mode='w', encoding='utf-8') as f:
    f.writelines(reversed_lines)

print("行順序反轉(zhuǎn)完成！")

結(jié)果 reversed_lines.txt：

第三行內(nèi)容
第二行內(nèi)容
第一行內(nèi)容

解析：

readlines() 讀取的行包含換行符 \n，反轉(zhuǎn)后直接 writelines() 寫入即可，換行符會保留。

3.3 場景3：每行內(nèi)容反轉(zhuǎn)

保持行順序不變，將每行內(nèi)部的字符反轉(zhuǎn)。

代碼示例：

# 1. 讀取所有行
with open("original.txt", mode='r', encoding='utf-8') as f:
    lines = f.readlines()

# 2. 處理每一行：反轉(zhuǎn)內(nèi)容，保留換行符
processed_lines = []
for line in lines:
    # 先去除換行符，反轉(zhuǎn)，再加上換行符（如果原行有）
    if line.endswith('\n'):
        reversed_line = line.rstrip('\n')[::-1] + '\n'
    else:
        reversed_line = line[::-1]
    processed_lines.append(reversed_line)

# 3. 寫入新文件
with open("reversed_each_line.txt", mode='w', encoding='utf-8') as f:
    f.writelines(processed_lines)

print("每行內(nèi)容反轉(zhuǎn)完成！")

結(jié)果 reversed_each_line.txt：

容內(nèi)行一第
容內(nèi)行二第
容內(nèi)行三第

3.4 大文件處理注意事項

如果文件非常大（比如幾個 GB），read() 或 readlines() 會一次性加載到內(nèi)存，導致內(nèi)存溢出。此時可以：

• 行順序反轉(zhuǎn)：用 collections.deque 雙端隊列從后往前讀（較復雜），或先讀取所有行到列表（如果內(nèi)存夠）。
• 逐行處理：如果是每行內(nèi)容反轉(zhuǎn)，可以逐行讀取、反轉(zhuǎn)、寫入臨時文件，最后重命名（避免內(nèi)存溢出）。

大文件逐行處理示例（每行內(nèi)容反轉(zhuǎn)）：

# 大文件逐行處理，避免內(nèi)存溢出
with open("big_file.txt", mode='r', encoding='utf-8') as f_in, \
     open("big_file_reversed.txt", mode='w', encoding='utf-8') as f_out:
    
    for line in f_in:  # 逐行迭代，不一次性加載
        # 反轉(zhuǎn)每行
        if line.endswith('\n'):
            reversed_line = line.rstrip('\n')[::-1] + '\n'
        else:
            reversed_line = line[::-1]
        f_out.write(reversed_line)

print("大文件逐行反轉(zhuǎn)完成！")

總結(jié)

1. 字符串反轉(zhuǎn)：優(yōu)先用切片 s[::-1]。
2. 列表反轉(zhuǎn)：非原地用 lst[::-1]，原地用 lst.reverse()（注意返回 None）。
3. 元組反轉(zhuǎn)：用 t[::-1]。
4. 集合反轉(zhuǎn)：無意義（無序）。
5. 字典反轉(zhuǎn)：鍵值互換用推導式，順序反轉(zhuǎn)轉(zhuǎn)列表后反轉(zhuǎn)。
6. 文件反轉(zhuǎn)：小文件用 readlines() 反轉(zhuǎn)行，大文件逐行處理。

到此這篇關(guān)于Python中字符串和四大數(shù)據(jù)結(jié)構(gòu)的反轉(zhuǎn)操作指南的文章就介紹到這了,更多相關(guān)Python反轉(zhuǎn)操作內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論