當(dāng)我們經(jīng)常在代碼中使用 Python 字符串時，您可能需要以相反的順序使用它們。Python 包含一些方便的工具和技術(shù)，可以在這些情況下為您提供幫助。使用它們，您將能夠快速有效地構(gòu)建現(xiàn)有字符串的反向副本。

了解這些在 Python 中反轉(zhuǎn)字符串的工具和技術(shù)將幫助您提高作為 Python 開發(fā)人員的熟練程度。

在本教程中，萬平米將學(xué)到：

• 通過切片快速構(gòu)建反向字符串
• 使用和創(chuàng)建現(xiàn)有字符串的反向副本reversed().join()
• 使用迭代和遞歸手動反轉(zhuǎn)現(xiàn)有字符串
• 對字符串執(zhí)行反向迭代
• 使用相反的順序?qū)ψ址M(jìn)行排序sorted()

為了最大限度地利用本教程，你應(yīng)該知道的基本知識串，for以及while循環(huán)和遞歸。

一、使用核心 Python 工具反轉(zhuǎn)字符串

在某些特定情況下，可能需要以相反的順序使用 Python字符串。例如，假設(shè)您有一個字符串，并且想要一種快速的方法來反轉(zhuǎn)它以獲取. 您可以使用哪些 Python 工具來提供幫助？"ABCDEF""FEDCBA"

字符串在 Python 中是不可變的，因此不可能原地反轉(zhuǎn)給定的字符串。您需要創(chuàng)建目標(biāo)字符串的反向副本以滿足要求。

Python 提供了兩種直接的方法來反轉(zhuǎn)字符串。由于字符串是序列，因此它們是indexable、sliceable和iterable。這些功能允許您使用切片以相反的順序直接生成給定字符串的副本。第二個選項(xiàng)是使用內(nèi)置函數(shù)reversed()創(chuàng)建一個迭代器，該迭代器以相反的順序生成輸入字符串的字符。

二、通過切片反轉(zhuǎn)字符串

切片是一種有用的技術(shù)，它允許您使用稱為offsets的整數(shù)索引的不同組合從給定序列中提取項(xiàng)目。當(dāng)涉及到切片字符串時，這些偏移量定義了切片中第一個字符的索引、停止切片的字符的索引，以及一個定義每次迭代要跳過多少個字符的值。

要對字符串進(jìn)行切片，可以使用以下語法：

a_string[start:stop:step]

你的偏移量start，stop和step。此表達(dá)式從startto stop − 1by 中提取所有字符step。稍后您將更深入地了解這一切意味著什么。

所有偏移量都是可選的，它們具有以下默認(rèn)值：

這里，start表示切片中第一個字符stop的索引，同時保存停止切片操作的索引。第三個偏移量step允許您決定切片在每次迭代中將跳過多少個字符。

注意：切片操作在達(dá)到等于或大于 的索引時完成stop。這意味著它永遠(yuǎn)不會在最終切片中包含該索引處的項(xiàng)目（如果有）。

該step偏移允許您微調(diào)如何，而跳過其他從字符串中提取所需的字符：

>>>
>>> letters = "AaBbCcDd"

>>> # Get all characters relying on default offsets
>>> letters[::]
'AaBbCcDd'
>>> letters[:]
'AaBbCcDd'

>>> # Get every other character from 0 to the end
>>> letters[::2]
'ABCD'

>>> # Get every other character from 1 to the end
>>> letters[1::2]
'abcd'

在這里，您首先在letters不提供顯式偏移值的情況下進(jìn)行切片以獲取原始字符串的完整副本。為此，您還可以使用省略第二個冒號 ( :)的切片。隨著step等于2，切片會從目標(biāo)字符串中的每個其它字符。您可以使用不同的偏移量來更好地了解切片的工作原理。

為什么切片和第三個偏移量與 Python 中的字符串反轉(zhuǎn)有關(guān)？答案在于如何step處理負(fù)值。如果為 提供負(fù)值step，則切片向后運(yùn)行，即從右到左。

例如：如果您設(shè)置為stepequal -1，那么您可以構(gòu)建一個以相反順序檢索所有字符的切片：

>>>
>>> letters = "ABCDEF"

>>> letters[::-1]
'FEDCBA'

>>> letters
'ABCDEF'

此切片返回從字符串右端（索引等于 ）到len(letters) - 1字符串左端（索引為 ）的所有字符0。當(dāng)您使用此技巧時，您會以相反的順序獲得原始字符串的副本，而不會影響 的原始內(nèi)容letters。

創(chuàng)建現(xiàn)有字符串的反向副本的另一種技術(shù)是使用slice(). 這個內(nèi)置函數(shù)的簽名如下：

slice(start, stop, step)

此函數(shù)接受三個參數(shù)，與切片運(yùn)算符中的偏移量具有相同的含義，并返回一個切片對象，表示調(diào)用range(start, stop, step).

我們可以使用slice()來模擬切片[::-1]并快速反轉(zhuǎn)字符串。繼續(xù)并slice()在方括號內(nèi)運(yùn)行以下調(diào)用：

>>>
>>> letters = "ABCDEF"

>>> letters[slice(None, None, -1)]
'FEDCBA'

傳遞None給 的前兩個參數(shù)slice()告訴函數(shù)您要依賴其內(nèi)部默認(rèn)行為，這與沒有start和值的標(biāo)準(zhǔn)切片相同stop。換句話說，傳遞None給start和stop意味著您需要從底層序列的左端到右端的切片。

三、使用.join()和反轉(zhuǎn)字符串reversed()

第二種，可以說是最 Pythonic 的反轉(zhuǎn)字符串的方法是reversed()與str.join(). 如果您將字符串傳遞給reversed() ，您將獲得一個以相反順序生成字符的迭代器：

>>>
>>> greeting = reversed("Hello, World!")

>>> next(greeting)
'!'
>>> next(greeting)
'd'
>>> next(greeting)
'l'

當(dāng)您將next()withgreeting作為參數(shù)調(diào)用時，您會從原始字符串的右端獲取每個字符。

需要注意的重要一點(diǎn)reversed()是，生成的迭代器直接從原始字符串中生成字符。換句話說，它不會創(chuàng)建一個新的反向字符串，而是從現(xiàn)有字符串反向讀取字符。這種行為在內(nèi)存消耗方面相當(dāng)有效，并且在某些上下文和情況下（例如迭代）可能是一個根本性的勝利。

我們可以使用reversed()直接調(diào)用獲得的迭代器作為參數(shù).join()：

>>>
>>> "".join(reversed("Hello, World!"))
'!dlroW ,olleH'

在這個單行表達(dá)式中，您將調(diào)用的結(jié)果reversed()直接作為參數(shù)傳遞給.join() 。因此，您將獲得原始輸入字符串的反向副本。的組合reversed() ，并.join()為扭轉(zhuǎn)字符串一個很好的選擇。

四、手動生成反轉(zhuǎn)字符串

到目前為止，您已經(jīng)了解了快速反轉(zhuǎn)字符串的核心 Python 工具和技術(shù)。大多數(shù)時候，它們將是您的最佳選擇。但是，您可能需要在編碼冒險的某個時刻手動反轉(zhuǎn)字符串。

在本節(jié)中，您將學(xué)習(xí)如何使用顯式循環(huán)和遞歸來反轉(zhuǎn)字符串。最后一種技術(shù)在 Pythonreduce()函數(shù)的幫助下使用函數(shù)式編程方法。

五、反轉(zhuǎn)循環(huán)中的字符串

您將用于反轉(zhuǎn)字符串的第一種技術(shù)涉及for循環(huán)和連接運(yùn)算符 ( +)。使用兩個字符串作為操作數(shù)，此運(yùn)算符返回一個連接原始字符串的新字符串。整個操作稱為串聯(lián)。

注意：使用.join()是在 Python 中連接字符串的推薦方法。它干凈、高效且Pythonic。

這是一個函數(shù)，它接受一個字符串并使用串聯(lián)在循環(huán)中反轉(zhuǎn)它：

>>>
>>> def reversed_string(text):
...     result = ""
...     for char in text:
...         result = char + result
...     return result
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

在每次迭代中，循環(huán)采用后續(xù)字符char, fromtext并將其與 的當(dāng)前內(nèi)容連接起來result。請注意，result最初保存的是一個空字符串 ( "")。然后將新的中間字符串重新分配給result。在循環(huán)結(jié)束時，result保存一個新字符串作為原始字符串的反向副本。

注意：由于 Python 字符串是不可變的數(shù)據(jù)類型，您應(yīng)該記住本節(jié)中的示例使用了一種浪費(fèi)技術(shù)。它們依賴于創(chuàng)建連續(xù)的中間字符串，只是為了在下一次迭代中將它們丟棄。

如果您更喜歡使用whileloop，那么您可以執(zhí)行以下操作來構(gòu)建給定字符串的反向副本：

>>>
>>> def reversed_string(text):
...     result = ""
...     index = len(text) - 1
...     while index >= 0:
...         result += text[index]
...         index -= 1
...     return result
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

在這里，您首先使用 計算index輸入字符串中最后一個字符的len()。循環(huán)從index下到并包括0。在每次迭代中，您都使用擴(kuò)充賦值運(yùn)算符 ( +=) 創(chuàng)建一個中間字符串，該字符串將 的內(nèi)容result與來自 的相應(yīng)字符連接起來text。同樣，最終結(jié)果是通過反轉(zhuǎn)輸入字符串產(chǎn)生的新字符串。

六、用遞歸反轉(zhuǎn)字符串

我們還可以使用遞歸來反轉(zhuǎn)字符串。遞歸是指函數(shù)在自己的主體中調(diào)用自身。為了防止無限遞歸，您應(yīng)該提供一個無需再次調(diào)用函數(shù)即可生成結(jié)果的基本情況。第二個組件是遞歸 case，它啟動遞歸循環(huán)并執(zhí)行大部分計算。

下面是如何定義一個遞歸函數(shù)，該函數(shù)返回給定字符串的反向副本：

>>>
>>> def reversed_string(text):
...     if len(text) == 1:
...         return text
...     return reversed_string(text[1:]) + text[:1]
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

在本例中，您首先檢查基本情況。如果輸入字符串只有一個字符，則將該字符串返回給調(diào)用者。

最后一個語句，即遞歸情況，調(diào)用reversed_string()自身。該調(diào)用使用text[1:]輸入字符串的切片作為參數(shù)。此切片包含 中的所有字符text，第一個除外。下一步是將遞歸調(diào)用的結(jié)果與text[:1]包含 的第一個字符的單字符串 相加text。

在上面的例子中需要注意的一個重要問題是，如果你將一個長字符串作為參數(shù)傳遞給reversed_string()，那么你將得到一個RecursionError：

>>>
>>> very_long_greeting = "Hello, World!" * 1_000

>>> reversed_string(very_long_greeting)
Traceback (most recent call last):
    ...
RecursionError: maximum recursion depth exceeded while calling a Python object

達(dá)到 Python 的默認(rèn)遞歸限制是您應(yīng)該在代碼中考慮的一個重要問題。但是，如果您確實(shí)需要使用遞歸，那么您仍然可以選擇手動設(shè)置遞歸限制。

您可以通過調(diào)用getrecursionlimit()from來檢查當(dāng)前 Python 解釋器的遞歸限制sys。默認(rèn)情況下，此值通常為1000。您可以使用setrecursionlimit()來自同一模塊的sys. 使用這些函數(shù)，您可以配置 Python 環(huán)境，以便您的遞歸解決方案可以工作。來試試看吧！

使用reduce()扭轉(zhuǎn)字符串
如果您更喜歡使用函數(shù)式編程方法，則可以使用reduce()fromfunctools來反轉(zhuǎn)字符串。Pythonreduce()將折疊或歸約函數(shù)和可迭代對象作為參數(shù)。然后它將提供的函數(shù)應(yīng)用于輸入迭代中的項(xiàng)目并返回單個累積值。

以下是您可以如何利用reduce()反轉(zhuǎn)字符串的方法：

>>>
>>> from functools import reduce

>>> def reversed_string(text):
...     return reduce(lambda a, b: b + a, text)
...

>>> reversed_string("Hello, World!")
'!dlroW ,olleH'

在此示例中，該lambda函數(shù)采用兩個字符串并以相反的順序連接它們。調(diào)用在循環(huán)中reduce()應(yīng)用lambdatotext并構(gòu)建原始字符串的反向副本。

七、反向遍歷字符串

有時您可能希望以相反的順序遍歷現(xiàn)有字符串，這種技術(shù)通常稱為反向迭代。根據(jù)您的特定需求，您可以使用以下選項(xiàng)之一對字符串進(jìn)行反向迭代：

• 該reversed()內(nèi)置功能
• 切片運(yùn)算符， [::-1]

反向迭代可以說是這些工具最常見的用例，因此在以下幾節(jié)中，您將了解如何在迭代上下文中使用它們。

八、該reversed()內(nèi)置功能

以相反順序迭代字符串的最可讀和 Pythonic 的方法是使用reversed() . 不久前，當(dāng)您將它與.join()創(chuàng)建反向字符串一起使用時，您已經(jīng)了解了該函數(shù)。

但是，主要意圖和用例reversed()是支持 Python 可迭代對象的反向迭代。以字符串作為參數(shù)，reversed()返回一個迭代器，該迭代器以相反的順序從輸入字符串中產(chǎn)生字符。

以下是如何以相反的順序迭代字符串reversed()：

>>>
>>> greeting = "Hello, World!"

>>> for char in reversed(greeting):
...     print(char)
...
!
d
l
r
o
W

,
o
l
l
e
H

>>> reversed(greeting)
<reversed object at 0x7f17aa89e070>

for此示例中的循環(huán)非常具有可讀性。的名稱reversed()清楚地表達(dá)了其意圖并傳達(dá)了該函數(shù)不會對輸入數(shù)據(jù)產(chǎn)生任何副作用。由于reversed()返回一個迭代器，循環(huán)在內(nèi)存使用方面也很有效。

九、切片運(yùn)算符， [::-1]

對字符串執(zhí)行反向迭代的第二種方法是使用您之前在a_string[::-1]示例中看到的擴(kuò)展切片語法。即使這種方法不利于內(nèi)存效率和可讀性，它仍然提供了一種快速迭代現(xiàn)有字符串的反向副本的方法：

>>>
>>> greeting = "Hello, World!"

>>> for char in greeting[::-1]:
...     print(char)
...
!
d
l
r
o
W

,
o
l
l
e
H

>>> greeting[::-1]
'!dlroW ,olleH'

在本例中，我們應(yīng)用切片運(yùn)算符greeting來創(chuàng)建它的反向副本。然后你使用那??個新的反向字符串來饋送循環(huán)。在這種情況下，您正在迭代一個新的反向字符串，因此該解決方案的內(nèi)存效率低于使用reversed().

十、創(chuàng)建自定義可逆字符串

如果您曾經(jīng)嘗試過反轉(zhuǎn) Python 列表，那么您就會知道列表有一個方便的方法，稱為原位.reverse()反轉(zhuǎn)底層列表。由于字符串在 Python 中是不可變的，因此它們不提供類似的方法。

但是，您仍然可以使用.reverse()模仿list.reverse(). 您可以這樣做：

>>>
>>> from collections import UserString

>>> class ReversibleString(UserString):
...     def reverse(self):
...         self.data = self.data[::-1]
...

ReversibleString繼承自UserString，它是collections模塊的一個類。UserString是str內(nèi)置數(shù)據(jù)類型的包裝器。它是專門為創(chuàng)建str. UserString當(dāng)您需要創(chuàng)建具有附加功能的自定義字符串類時非常方便。

UserString提供與常規(guī)字符串相同的功能。它還添加了一個稱為.data持有的公共屬性，并允許您訪問包裝的字符串對象。

在里面ReversibleString，你創(chuàng)造.reverse()。此方法反轉(zhuǎn)包裝的字符串.data并將結(jié)果重新分配回.data. 從外部看，調(diào)用的.reverse()工作就像將字符串反轉(zhuǎn)到位。然而，它實(shí)際上做的是創(chuàng)建一個新的字符串，以相反的順序包含原始數(shù)據(jù)。

以下是ReversibleString實(shí)踐中的工作原理：

>>>
>>> text = ReversibleString("Hello, World!")
>>> text
'Hello, World!'

>>> # Reverse the string in place
>>> text.reverse()
>>> text
'!dlroW ,olleH'

當(dāng)您調(diào)用.reverse()on 時text，該方法就像您正在對底層字符串進(jìn)行就地更改一樣。但是，您實(shí)際上是在創(chuàng)建一個新字符串并將其分配回包裝的字符串。請注意，text現(xiàn)在以相反的順序保存原始字符串。

由于UserString提供與其超類相同的功能str，因此您可以reversed()開箱即用地執(zhí)行反向迭代：

>>>
>>> text = ReversibleString("Hello, World!")

>>> # Support reverse iteration out of the box
>>> for char in reversed(text):
...     print(char)
...
!
d
l
r
o
W

,
o
l
l
e
H

>>> text
"Hello, World!"

在這里，您調(diào)用reversed()withtext作為參數(shù)來提供for循環(huán)。此調(diào)用按預(yù)期工作并返回相應(yīng)的迭代器，因?yàn)?code>UserString從str. 請注意，調(diào)用reversed()不會影響原始字符串。

十一、以相反的順序?qū)?Python 字符串進(jìn)行排序

我們將學(xué)習(xí)的最后一個主題是如何以相反的順序?qū)ψ址淖址M(jìn)行排序。當(dāng)您不按特定順序處理字符串并且需要按逆字母順序?qū)λ鼈冞M(jìn)行排序時，這會很方便。

要解決此問題，您可以使用sorted(). 這個內(nèi)置函數(shù)返回一個列表，其中包含輸入可迭代的所有項(xiàng)目。除了輸入可迭代之外，sorted()還接受reverse關(guān)鍵字參數(shù)。True如果您希望輸入可迭代對象按降序排序，則可以將此參數(shù)設(shè)置為：

>>>
>>> vowels = "eauoi"

>>> # Sort in ascending order
>>> sorted(vowels)
['a', 'e', 'i', 'o', 'u']

>>> # Sort in descending order
>>> sorted(vowels, reverse=True)
['u', 'o', 'i', 'e', 'a']

當(dāng)您sorted()使用字符串作為參數(shù)調(diào)用并reverse設(shè)置為 時True，您會得到一個包含輸入字符串字符的倒序或降序列表。由于sorted()返回一個list對象，您需要一種方法將該列表轉(zhuǎn)換回字符串。

同樣，我們可以.join()像在前面的部分中一樣使用：

>>>
>>> vowels = "eauoi"

>>> "".join(sorted(vowels, reverse=True))
'uoiea'

在此代碼片段中，您調(diào)用.join()了一個空字符串，它扮演著分隔符的角色。參數(shù) to.join()是調(diào)用sorted()withvowels作為參數(shù)并reverse設(shè)置為 的結(jié)果True。

您還可以利用sorted()以排序和反向順序遍歷字符串：

>>>
>>> for vowel in sorted(vowels, reverse=True):
...     print(vowel)
...
...
u
o
i
e
a

該reverse給的說法sorted()可以讓你排序iterables，包括字符串，按降序排列。因此，如果您需要按逆字母順序排序的字符串字符，那么sorted()適合您。

結(jié)論:

以相反的順序反轉(zhuǎn)和處理字符串可能是編程中的一項(xiàng)常見任務(wù)。Python 提供了一組工具和技術(shù)，可以幫助您快速有效地執(zhí)行字符串反轉(zhuǎn)。在本教程中，您了解了這些工具和技術(shù)以及如何在字符串處理挑戰(zhàn)中利用它們。

總結(jié)：

• 通過切片快速構(gòu)建反向字符串
• 使用reversed()和創(chuàng)建現(xiàn)有字符串的反向副本.join()
• 使用迭代和遞歸手動創(chuàng)建反向字符串
• 以相反的順序循環(huán)遍歷字符串
• 使用降序?qū)ψ址M(jìn)行排序 sorted()

盡管本主題本身可能沒有很多令人興奮的用例，但了解如何反轉(zhuǎn)字符串對于入門級職位的編碼面試很有用。您還會發(fā)現(xiàn)掌握反轉(zhuǎn)字符串的不同方法可以幫助您真正概念化 Python 中字符串的不變性，這是該語言的一個顯著特性。

到此這篇關(guān)于Python 中的反轉(zhuǎn)字符串reversed(),切片 的文章就介紹到這了,更多相關(guān)Python 中的反轉(zhuǎn)字符串 內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論