免費AI編程助手
Pandas 處理文本字符串
序列和索引包含一些列的字符操作方法，這可以使我們輕易操作數(shù)組中的各個元素。最重要的是，這些方法可以自動跳過 缺失/NA 值。這些方法可以在str屬性中訪問到，并且基本上和python內建的（標量）字符串方法同名：
In [1]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
In [2]: s.str.lower()
Out[2]:
0 a
1 b
2 c
3 aaba
4 baca
5 NaN
6 caba
7 dog
8 cat
dtype: object
In [3]: s.str.upper()
Out[3]:
0 A
1 B
2 C
3 AABA
4 BACA
5 NaN
6 CABA
7 DOG
8 CAT
dtype: object
In [4]: s.str.len()
Out[4]:
0 1.0
1 1.0
2 1.0
3 4.0
4 4.0
5 NaN
6 4.0
7 3.0
8 3.0
dtype: float64
In [5]: idx = pd.Index([' jack', 'jill ', ' jesse ', 'frank'])
In [6]: idx.str.strip()
Out[6]: Index(['jack', 'jill', 'jesse', 'frank'], dtype='object')
In [7]: idx.str.lstrip()
Out[7]: Index(['jack', 'jill ', 'jesse ', 'frank'], dtype='object')
In [8]: idx.str.rstrip()
Out[8]: Index([' jack', 'jill', ' jesse', 'frank'], dtype='object')
索引的字符串方法在清理或者轉換數(shù)據(jù)表列的時候非常有用。例如，你的列中或許會包含首位的白空格：
In [9]: df = pd.DataFrame(np.random.randn(3, 2),
...: columns=[' Column A ', ' Column B '], index=range(3))
...:
In [10]: df
Out[10]:
Column A Column B
0 0.469112 -0.282863
1 -1.509059 -1.135632
2 1.212112 -0.173215
Since df.columns is an Index object, we can use the .str accessor
In [11]: df.columns.str.strip()
Out[11]: Index(['Column A', 'Column B'], dtype='object')
In [12]: df.columns.str.lower()
Out[12]: Index([' column a ', ' column b '], dtype='object')
這些字符串方法可以被用來清理需要的列。這里，我們想清理開頭和結尾的白空格，將所有的名稱都換為小寫，并且將其余的空格都替換為下劃線：
In [13]: df.columns = df.columns.str.strip().str.lower().str.replace(' ', '_')
In [14]: df
Out[14]:
column_a column_b
0 0.469112 -0.282863
1 -1.509059 -1.135632
2 1.212112 -0.173215
小貼士
如果你有一個序列，里面有很多重復的值 （即，序列中唯一元素的數(shù)量遠小于序列的長度），將原有序列轉換為一種分類類型，然后使用.str. 或者 .dt.方法，則會獲得更快的速度。 速度的差異來源于，在分類類型的序列中，字符操作只是在categories中完成的，而不是針對序列中的每一個元素。
請注意，相比于字符串類型的序列，帶.categories類型的 分類 類別的 序列有一些限制（例如，你不能像其中的元素追加其他的字串：s + " " + s 將不能正確工作，如果s是一個分類類型的序列。并且，.str 中，那些可以對 列表（list） 類型的元素進行操作的方法，在分類序列中也無法使用。
警告
v.0.25.0版以前， .str訪問器只會進行最基本的類型檢查。 從v.0.25.0起，序列的類型會被自動推斷出來，并且會更為激進地使用恰當?shù)念愋汀?/p>
一般來說 .str 訪問器只傾向于針對字符串類型工作。只有在個別的情況下，才能對非字符串類型工作，但是這也將會在未來的版本中被逐步修正
#拆分和替換字符串
類似split的方法返回一個列表類型的序列：
In [15]: s2 = pd.Series(['a_b_c', 'c_d_e', np.nan, 'f_g_h'])
In [16]: s2.str.split('_')
Out[16]:
0 [a, b, c]
1 [c, d, e]
2 NaN
3 [f, g, h]
dtype: object
切分后的列表中的元素可以通過 get 方法或者 [] 方法進行讀?。?/p>
In [17]: s2.str.split('_').str.get(1)
Out[17]:
0 b
1 d
2 NaN
3 g
dtype: object
In [18]: s2.str.split('_').str[1]
Out[18]:
0 b
1 d
2 NaN
3 g
dtype: object
使用expand方法可以輕易地將這種返回展開為一個數(shù)據(jù)表.
In [19]: s2.str.split('_', expand=True)
Out[19]:
0 1 2
0 a b c
1 c d e
2 NaN NaN NaN
3 f g h
同樣，我們也可以限制切分的次數(shù)：
In [20]: s2.str.split('_', expand=True, n=1)
Out[20]:
0 1
0 a b_c
1 c d_e
2 NaN NaN
3 f g_h
rsplit與split相似，不同的是，這個切分的方向是反的。即，從字串的尾端向首段切分：
In [21]: s2.str.rsplit('_', expand=True, n=1)
Out[21]:
0 1
0 a_b c
1 c_d e
2 NaN NaN
3 f_g h
replace 方法默認使用 正則表達式:
In [22]: s3 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca',
....: '', np.nan, 'CABA', 'dog', 'cat'])
....:
In [23]: s3
Out[23]:
0 A
1 B
2 C
3 Aaba
4 Baca
5
6 NaN
7 CABA
8 dog
9 cat
dtype: object
In [24]: s3.str.replace('^.a|dog', 'XX-XX ', case=False)
Out[24]:
0 A
1 B
2 C
3 XX-XX ba
4 XX-XX ca
5
6 NaN
7 XX-XX BA
8 XX-XX
9 XX-XX t
dtype: object
一定要時時記得，是正則表達式，因此要格外小心。例如，因為正則表達式中的*$*符號,下列代碼將會導致一些麻煩：
# Consider the following badly formatted financial data
In [25]: dollars = pd.Series(['12', '-$10', '$10,000'])
# This does what you'd naively expect:
In [26]: dollars.str.replace('$', '')
Out[26]:
0 12
1 -10
2 10,000
dtype: object
# But this doesn't:
In [27]: dollars.str.replace('-$', '-')
Out[27]:
0 12
1 -$10
2 $10,000
dtype: object
# We need to escape the special character (for >1 len patterns)
In [28]: dollars.str.replace(r'-\$', '-')
Out[28]:
0 12
1 -10
2 $10,000
dtype: object
v0.23.0. 新加入
如果你只是向單純地替換字符 (等價于python中的 str.replace())，你可以將可選參數(shù) regex 設置為 False，而不是傻傻地轉義所有符號。這種情況下，pat 和 repl 就都將作為普通字符對待：
# These lines are equivalent
In [29]: dollars.str.replace(r'-\$', '-')
Out[29]:
0 12
1 -10
2 $10,000
dtype: object
In [30]: dollars.str.replace('-$', '-', regex=False)
Out[30]:
0 12
1 -10
2 $10,000
dtype: object
v0.20.0. 新加入
replace 方法也可以傳入一個可調用對象作為替換值。它針對每一個 pat 通過re.sub()調用?？烧{用對象應只具有一個形參（一個正則表達式對象）并且返回一個字符串。
# Reverse every lowercase alphabetic word
In [31]: pat = r'[a-z]+'
In [32]: def repl(m):
....: return m.group(0)[::-1]
....:
In [33]: pd.Series(['foo 123', 'bar baz', np.nan]).str.replace(pat, repl)
Out[33]:
0 oof 123
1 rab zab
2 NaN
dtype: object
# Using regex groups
In [34]: pat = r"(?P<one>\w+) (?P<two>\w+) (?P<three>\w+)"
In [35]: def repl(m):
....: return m.group('two').swapcase()
....:
In [36]: pd.Series(['Foo Bar Baz', np.nan]).str.replace(pat, repl)
Out[36]:
0 bAR
1 NaN
dtype: object
v0.20.0. 新加入
replace 方法也可以接受一個來自re.compile()編譯過的正則表達式對象，來做為表達式。所有的標記都應該被包含在這個已經(jīng)編譯好的正則表達式對象中。
In [37]: import re
In [38]: regex_pat = re.compile(r'^.a|dog', flags=re.IGNORECASE)
In [39]: s3.str.replace(regex_pat, 'XX-XX ')
Out[39]:
0 A
1 B
2 C
3 XX-XX ba
4 XX-XX ca
5
6 NaN
7 XX-XX BA
8 XX-XX
9 XX-XX t
dtype: object
如果在已經(jīng)使用編譯的正則對象中繼續(xù)傳入flags 參數(shù)，并進行替換，將會導致ValueError。
In [40]: s3.str.replace(regex_pat, 'XX-XX ', flags=re.IGNORECASE)
---------------------------------------------------------------------------
ValueError: case and flags cannot be set when pat is a compiled regex
#拼接
Pandas提供了不同的方法將序列或索引與他們自己或者其他的對象進行拼接，所有的方法都是基于各自的cat()resp. Index.str.cat.
#將單個序列拼接為一個完整字符串
序列或索引的內容可以進行拼接：
In [41]: s = pd.Series(['a', 'b', 'c', 'd'])
In [42]: s.str.cat(sep=',')
Out[42]: 'a,b,c,d'
如果沒有額外聲明，sep 即分隔符默認為空字串，即sep=''：
In [43]: s.str.cat()
Out[43]: 'abcd'
默認情況下，缺失值會被忽略。使用na_rep參數(shù)，可以對缺失值進行賦值：
In [44]: t = pd.Series(['a', 'b', np.nan, 'd'])
In [45]: t.str.cat(sep=',')
Out[45]: 'a,b,d'
In [46]: t.str.cat(sep=',', na_rep='-')
Out[46]: 'a,b,-,d'
#拼接序列和其他類列表型對象為新的序列
cat()的第一個參數(shù)為類列表對象，但必須要確保長度與序列或索引相同.
In [47]: s.str.cat(['A', 'B', 'C', 'D'])
Out[47]:
0 aA
1 bB
2 cC
3 dD
dtype: object
任何一端的缺失值都會導致之中結果為缺失值，除非使用na_rep：
In [48]: s.str.cat(t)
Out[48]:
0 aa
1 bb
2 NaN
3 dd
dtype: object
In [49]: s.str.cat(t, na_rep='-')
Out[49]:
0 aa
1 bb
2 c-
3 dd
dtype: object
#拼接序列與類數(shù)組對象為新的序列
v0.23.0. 新加入
others 參數(shù)可以是二維的。此時，行數(shù)需要與序列或索引的長度相同。
In [50]: d = pd.concat([t, s], axis=1)
In [51]: s
Out[51]:
0 a
1 b
2 c
3 d
dtype: object
In [52]: d
Out[52]:
0 1
0 a a
1 b b
2 NaN c
3 d d
In [53]: s.str.cat(d, na_rep='-')
Out[53]:
0 aaa
1 bbb
2 c-c
3 ddd
dtype: object
#對齊拼接序列與帶索引的對象成為新的序列
v0.23.0.新加入
對于拼接序列或者數(shù)據(jù)表，我們可以使用 join關鍵字來對齊索引。
In [54]: u = pd.Series(['b', 'd', 'a', 'c'], index=[1, 3, 0, 2])
In [55]: s
Out[55]:
0 a
1 b
2 c
3 d
dtype: object
In [56]: u
Out[56]:
1 b
3 d
0 a
2 c
dtype: object
In [57]: s.str.cat(u)
Out[57]:
0 ab
1 bd
2 ca
3 dc
dtype: object
In [58]: s.str.cat(u, join='left')
Out[58]:
0 aa
1 bb
2 cc
3 dd
dtype: object
警告
如果不使用join 關鍵字， cat()方法將會滾回到0.23.0版之前，即（無對齊）模式。但如果任何的索引不一致時，將會拋出一個 FutureWarning 警告，因為在未來的版本中，默認行為將改為join='left' 。
join 的選項為（'left', 'outer', 'inner', 'right'）中的一個。 特別的，對齊操作使得兩個對象可以是不同的長度。
In [59]: v = pd.Series(['z', 'a', 'b', 'd', 'e'], index=[-1, 0, 1, 3, 4])
In [60]: s
Out[60]:
0 a
1 b
2 c
3 d
dtype: object
In [61]: v
Out[61]:
-1 z
0 a
1 b
3 d
4 e
dtype: object
In [62]: s.str.cat(v, join='left', na_rep='-')
Out[62]:
0 aa
1 bb
2 c-
3 dd
dtype: object
In [63]: s.str.cat(v, join='outer', na_rep='-')
Out[63]:
-1 -z
0 aa
1 bb
2 c-
3 dd
4 -e
dtype: object
當others是一個數(shù)據(jù)表時，也可以執(zhí)行相同的對齊操作：
In [64]: f = d.loc[[3, 2, 1, 0], :]
In [65]: s
Out[65]:
0 a
1 b
2 c
3 d
dtype: object
In [66]: f
Out[66]:
0 1
3 d d
2 NaN c
1 b b
0 a a
In [67]: s.str.cat(f, join='left', na_rep='-')
Out[67]:
0 aaa
1 bbb
2 c-c
3 ddd
dtype: object
#將一個序列與多個對象拼接為一個新的序列
所有的一維，類列表對象都可以任意組合進一個類列表的容器（包括迭代器，dict-視圖等）：
In [68]: s
Out[68]:
0 a
1 b
2 c
3 d
dtype: object
In [69]: u
Out[69]:
1 b
3 d
0 a
2 c
dtype: object
In [70]: s.str.cat([u, u.to_numpy()], join='left')
Out[70]:
0 aab
1 bbd
2 cca
3 ddc
dtype: object
除了那些有索引的，所有傳入沒有索引的元素（如np.ndarray）必須與序列或索引有相同的長度。但是，只要禁用對齊join=None，那么序列或索引就可以是任意長度。
In [71]: v
Out[71]:
-1 z
0 a
1 b
3 d
4 e
dtype: object
In [72]: s.str.cat([v, u, u.to_numpy()], join='outer', na_rep='-')
Out[72]:
-1 -z--
0 aaab
1 bbbd
2 c-ca
3 dddc
4 -e--
dtype: object
如果在一個包含不同的索引的others列表上使用join='right'，所有索引的并集將會被作為最終拼接的基礎：
In [73]: u.loc[[3]]
Out[73]:
3 d
dtype: object
In [74]: v.loc[[-1, 0]]
Out[74]:
-1 z
0 a
dtype: object
In [75]: s.str.cat([u.loc[[3]], v.loc[[-1, 0]]], join='right', na_rep='-')
Out[75]:
-1 --z
0 a-a
3 dd-
dtype: object
#使用.str進行索引
你可以使用 []方法來直接索引定位。如果你的索引超過了字符串的結尾，將返回NaN。
In [76]: s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan,
....: 'CABA', 'dog', 'cat'])
....:
In [77]: s.str[0]
Out[77]:
0 A
1 B
2 C
3 A
4 B
5 NaN
6 C
7 d
8 c
dtype: object
In [78]: s.str[1]
Out[78]:
0 NaN
1 NaN
2 NaN
3 a
4 a
5 NaN
6 A
7 o
8 a
dtype: object
#提取子字符串
#提取第一個匹配的對象 (extract)
警告
在 0.18.0中，extract擁有了 expand 參數(shù)。當 expand=False時， 將返回一個序列，索引或者數(shù)據(jù)表， 這取決于原對象和正則表達式（之前的版本也是如此）。當 expand=True時，它則總是返回一個DataFrame，這樣可以更加一致，并且減少用戶的混淆。 Expand=True 從0.23.0版本之后成為默認值。
extract 方法接受一個至少含有一個捕獲組的 正則表達式
使用超過一個捕獲組的正則表達式則會提取并返回一個數(shù)據(jù)表，每一列為一個捕獲組。
In [79]: pd.Series(['a1', 'b2', 'c3']).str.extract(r'([ab])(\d)', expand=False)
Out[79]:
0 1
0 a 1
1 b 2
2 NaN NaN
沒有成功匹配的元素將會返回一行NaN。因此，一個序列的混亂的字符串可以被‘轉換’為一個類似索引的序列或數(shù)據(jù)表。返回的內容會更為清爽，而且不需要使用get()方法來訪問元組中的成員或者re.match對象。返回的類型將總是object類，即使匹配失敗，返回的全是NaN。
有名稱的捕獲組，如：
In [80]: pd.Series(['a1', 'b2', 'c3']).str.extract(r'(?P<letter>[ab])(?P<digit>\d)',
....: expand=False)
....:
Out[80]:
letter digit
0 a 1
1 b 2
2 NaN NaN
可選組類似，如：
In [81]: pd.Series(['a1', 'b2', '3']).str.extract(r'([ab])?(\d)', expand=False)
Out[81]:
0 1
0 a 1
1 b 2
2 NaN 3
也可以被使用。注意，任何有名稱的捕獲組，其名稱都會被用做列名，否則將會直接使用數(shù)字。
如果僅使用正則表達式捕獲一個組，而expand=True，那么仍然將返回一個數(shù)據(jù)表。
In [82]: pd.Series(['a1', 'b2', 'c3']).str.extract(r'[ab](\d)', expand=True)
Out[82]:
0
0 1
1 2
2 NaN
如果expand=False，則會返回一個序列。
In [83]: pd.Series(['a1', 'b2', 'c3']).str.extract(r'[ab](\d)', expand=False)
Out[83]:
0 1
1 2
2 NaN
dtype: object
在索引上使用正則表達式，并且僅捕獲一個組時，將會返回一個數(shù)據(jù)表，如果expand=True。
In [84]: s = pd.Series(["a1", "b2", "c3"], ["A11", "B22", "C33"])
In [85]: s
Out[85]:
A11 a1
B22 b2
C33 c3
dtype: object
In [86]: s.index.str.extract("(?P<letter>[a-zA-Z])", expand=True)
Out[86]:
letter
0 A
1 B
2 C
如果expand=False，則返回一個Index。
In [87]: s.index.str.extract("(?P<letter>[a-zA-Z])", expand=False)
Out[87]: Index(['A', 'B', 'C'], dtype='object', name='letter')
如果在索引上使用正則并捕獲多個組，則返回一個數(shù)據(jù)表，如果expand=True。
In [88]: s.index.str.extract("(?P<letter>[a-zA-Z])([0-9]+)", expand=True)
Out[88]:
letter 1
0 A 11
1 B 22
2 C 33
如果 expand=False，則拋出ValueError。
>>> s.index.str.extract("(?P<letter>[a-zA-Z])([0-9]+)", expand=False)
ValueError: only one regex group is supported with Index
下面的表格總結了extract (expand=False)時的行為（輸入對象在第一列，捕獲組的數(shù)量在第一行）
| 1 group | >1 group |
|---|---|
| Index | Index |
| Series | Series |
#提取所有的匹配 (extractall)
v0.18.0. 新加入
不同于 extract（只返回第一個匹配）
In [89]: s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"])
In [90]: s
Out[90]:
A a1a2
B b1
C c1
dtype: object
In [91]: two_groups = '(?P<letter>[a-z])(?P<digit>[0-9])'
In [92]: s.str.extract(two_groups, expand=True)
Out[92]:
letter digit
A a 1
B b 1
C c 1
extractall方法返回所有的匹配。extractall總是返回一個帶有行多重索引的數(shù)據(jù)表，最后一級多重索引被命名為match，它指出匹配的順序
In [93]: s.str.extractall(two_groups)
Out[93]:
letter digit
match
A 0 a 1
1 a 2
B 0 b 1
C 0 c 1
當所有的對象字串都只有一個匹配時，
In [94]: s = pd.Series(['a3', 'b3', 'c2'])
In [95]: s
Out[95]:
0 a3
1 b3
2 c2
dtype: object
extractall(pat).xs(0, level='match') 的返回與extract(pat)相同。
In [96]: extract_result = s.str.extract(two_groups, expand=True)
In [97]: extract_result
Out[97]:
letter digit
0 a 3
1 b 3
2 c 2
In [98]: extractall_result = s.str.extractall(two_groups)
In [99]: extractall_result
Out[99]:
letter digit
match
0 0 a 3
1 0 b 3
2 0 c 2
In [100]: extractall_result.xs(0, level="match")
Out[100]:
letter digit
0 a 3
1 b 3
2 c 2
索引也支持.str.extractall。 它返回一個數(shù)據(jù)表，其中包含與Series.str.estractall相同的結果，使用默認索引（從0開始）
v0.19.0. 新加入
In [101]: pd.Index(["a1a2", "b1", "c1"]).str.extractall(two_groups)
Out[101]:
letter digit
match
0 0 a 1
1 a 2
1 0 b 1
2 0 c 1
In [102]: pd.Series(["a1a2", "b1", "c1"]).str.extractall(two_groups)
Out[102]:
letter digit
match
0 0 a 1
1 a 2
1 0 b 1
2 0 c 1
#測試匹配或包含模式的字符串
你可以檢查是否一個元素包含一個可以匹配到的正則表達式：
In [103]: pattern = r'[0-9][a-z]'
In [104]: pd.Series(['1', '2', '3a', '3b', '03c']).str.contains(pattern)
Out[104]:
0 False
1 False
2 True
3 True
4 True
dtype: bool
或者是否元素完整匹配一個正則表達式
In [105]: pd.Series(['1', '2', '3a', '3b', '03c']).str.match(pattern)
Out[105]:
0 False
1 False
2 True
3 True
4 False
dtype: bool
match和contains的區(qū)別是是否嚴格匹配。match嚴格基于re.match，而contains基于re.search。
類似match, contains, startswith 和 endswith 可以傳入一個額外的na參數(shù)，因此，因此缺失值在匹配時可以被認為是True或者False：
In [106]: s4 = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'dog', 'cat'])
In [107]: s4.str.contains('A', na=False)
Out[107]:
0 True
1 False
2 False
3 True
4 False
5 False
6 True
7 False
8 False
dtype: bool
#建立一個指示變量
你從字符串列可以抽出一個啞變量。例如，是否他們由|分割:
In [108]: s = pd.Series(['a', 'a|b', np.nan, 'a|c'])
In [109]: s.str.get_dummies(sep='|')
Out[109]:
a b c
0 1 0 0
1 1 1 0
2 0 0 0
3 1 0 1
索引也支持get_dummies，它返回一個多重索引：
v0.18.1. 新加入
In [110]: idx = pd.Index(['a', 'a|b', np.nan, 'a|c'])
In [111]: idx.str.get_dummies(sep='|')
Out[111]:
MultiIndex([(1, 0, 0),
(1, 1, 0),
(0, 0, 0),
(1, 0, 1)],
names=['a', 'b', 'c'])
參見 get_dummies()#方法總覽
| 方法 | 描述 |
|---|---|
| cat() | 拼接字符串 |
| split() | 基于分隔符切分字符串 |
| rsplit() | 基于分隔符，逆向切分字符串 |
| get() | 索引每一個元素（返回第i個元素） |
| join() | 使用傳入的分隔符依次拼接每一個元素 |
| get_dummies() | 用分隔符切分字符串，并返回一個含有啞變量的數(shù)據(jù)表 |
| contains() | 返回一個布爾矩陣表明是每個元素包含字符串或正則表達式 |
| replace() | 將匹配到的子串或正則表達式替換為另外的字符串，或者一個可調用對象的返回值 |
| repeat() | 值復制（s.str.repeat(3)等價于x * 3） |
| pad() | 將白空格插入到字符串的左、右或者兩端 |
| center() | 等價于str.center |
| ljust() | 等價于str.ljust |
| rjust() | 等價于str.rjust |
| zfill() | 等價于str.zfill |
| wrap() | 將長字符串轉換為不長于給定長度的行 |
| slice() | 將序列中的每一個字符串切片 |
| slice_replace() | 用傳入的值替換每一個字串中的切片 |
| count() | 對出現(xiàn)符合的規(guī)則進行計數(shù) |
| startswith() | 等價于str.startswith(pat) |
| endswith() | 等價于 str.endswith(pat) |
| findall() | 返回每一個字串中出現(xiàn)的所有滿足樣式或正則的匹配 |
| match() | 素調用 re.match，并以列表形式返回匹配到的組 |
| extract() | Call 對每一個元素調用 re.search, 并以數(shù)據(jù)表的形式返回。行對應原有的一個元素，列對應所有捕獲的組 |
| extractall() | 一個元素調用 re.findall, 并以數(shù)據(jù)表的形式返回。行對應原有的一個元素，列對應所有捕獲的組 |
| len() | 計算字符串長度 |
| strip() | 等價于str.strip |
| rstrip() | 等價于str.rstrip |
| lstrip() | 等價于str.lstrip |
| partition() | 等價于 str.partition |
| rpartition() | 等價于 str.rpartition |
| lower() | 等價于 str.lower |
| casefold() | 等價于 str.casefold |
| upper() | 等價于 str.upper |
| find() | 等價于str.find |
| rfind() | 等價于 str.rfind |
| index() | 等價于 str.index |
| rindex() | 等價于 str.rindex |
| capitalize() | 等價于 str.capitalize |
| swapcase() | 等價于 str.swapcase |
| normalize() | 返回Unicode 標注格式。等價于 unicodedata.normalize |
| translate() | 等價于 str.translate |
| isalnum() | 等價于 str.isalnum |
| isalpha() | 等價于 str.isalpha |
| isdigit() | 等價于 str.isdigit |
| isspace() | 等價于 str.isspace |
| islower() | 等價于 str.islower |
| isupper() | 等價于 str.isupper |
| istitle() | 等價于 str.istitle |
| isnumeric() | 等價于 str.isnumeric |
| isdecimal() | 等價于 str.isdecimal |
更多建議：