免費(fèi)AI編程助手
Pandas 處理文本字符串
序列和索引包含一些列的字符操作方法，這可以使我們輕易操作數(shù)組中的各個(gè)元素。最重要的是，這些方法可以自動(dòng)跳過 缺失/NA 值。這些方法可以在str屬性中訪問到，并且基本上和python內(nèi)建的（標(biāo)量）字符串方法同名：
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')
索引的字符串方法在清理或者轉(zhuǎn)換數(shù)據(jù)表列的時(shí)候非常有用。例如，你的列中或許會(huì)包含首位的白空格：
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')
這些字符串方法可以被用來清理需要的列。這里，我們想清理開頭和結(jié)尾的白空格，將所有的名稱都換為小寫，并且將其余的空格都替換為下劃線：
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
小貼士
如果你有一個(gè)序列，里面有很多重復(fù)的值 （即，序列中唯一元素的數(shù)量遠(yuǎn)小于序列的長(zhǎng)度），將原有序列轉(zhuǎn)換為一種分類類型，然后使用.str. 或者 .dt.方法，則會(huì)獲得更快的速度。 速度的差異來源于，在分類類型的序列中，字符操作只是在categories中完成的，而不是針對(duì)序列中的每一個(gè)元素。
請(qǐng)注意，相比于字符串類型的序列，帶.categories類型的 分類 類別的 序列有一些限制（例如，你不能像其中的元素追加其他的字串：s + " " + s 將不能正確工作，如果s是一個(gè)分類類型的序列。并且，.str 中，那些可以對(duì) 列表（list） 類型的元素進(jìn)行操作的方法，在分類序列中也無法使用。
警告
v.0.25.0版以前， .str訪問器只會(huì)進(jìn)行最基本的類型檢查。 從v.0.25.0起，序列的類型會(huì)被自動(dòng)推斷出來，并且會(huì)更為激進(jìn)地使用恰當(dāng)?shù)念愋汀?/p>
一般來說 .str 訪問器只傾向于針對(duì)字符串類型工作。只有在個(gè)別的情況下，才能對(duì)非字符串類型工作，但是這也將會(huì)在未來的版本中被逐步修正
#拆分和替換字符串
類似split的方法返回一個(gè)列表類型的序列：
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 方法或者 [] 方法進(jìn)行讀?。?/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方法可以輕易地將這種返回展開為一個(gè)數(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相似，不同的是，這個(gè)切分的方向是反的。即，從字串的尾端向首段切分：
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 方法默認(rèn)使用 正則表達(dá)式:
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
一定要時(shí)時(shí)記得，是正則表達(dá)式，因此要格外小心。例如，因?yàn)檎齽t表達(dá)式中的*$*符號(hào),下列代碼將會(huì)導(dǎo)致一些麻煩：
# 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. 新加入
如果你只是向單純地替換字符 (等價(jià)于python中的 str.replace())，你可以將可選參數(shù) regex 設(shè)置為 False，而不是傻傻地轉(zhuǎn)義所有符號(hào)。這種情況下，pat 和 repl 就都將作為普通字符對(duì)待：
# 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 方法也可以傳入一個(gè)可調(diào)用對(duì)象作為替換值。它針對(duì)每一個(gè) pat 通過re.sub()調(diào)用?？烧{(diào)用對(duì)象應(yīng)只具有一個(gè)形參（一個(gè)正則表達(dá)式對(duì)象）并且返回一個(gè)字符串。
# 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 方法也可以接受一個(gè)來自re.compile()編譯過的正則表達(dá)式對(duì)象，來做為表達(dá)式。所有的標(biāo)記都應(yīng)該被包含在這個(gè)已經(jīng)編譯好的正則表達(dá)式對(duì)象中。
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)使用編譯的正則對(duì)象中繼續(xù)傳入flags 參數(shù)，并進(jìn)行替換，將會(huì)導(dǎo)致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提供了不同的方法將序列或索引與他們自己或者其他的對(duì)象進(jìn)行拼接，所有的方法都是基于各自的cat()resp. Index.str.cat.
#將單個(gè)序列拼接為一個(gè)完整字符串
序列或索引的內(nèi)容可以進(jìn)行拼接：
In [41]: s = pd.Series(['a', 'b', 'c', 'd'])
In [42]: s.str.cat(sep=',')
Out[42]: 'a,b,c,d'
如果沒有額外聲明，sep 即分隔符默認(rèn)為空字串，即sep=''：
In [43]: s.str.cat()
Out[43]: 'abcd'
默認(rèn)情況下，缺失值會(huì)被忽略。使用na_rep參數(shù)，可以對(duì)缺失值進(jìn)行賦值：
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'
#拼接序列和其他類列表型對(duì)象為新的序列
cat()的第一個(gè)參數(shù)為類列表對(duì)象，但必須要確保長(zhǎng)度與序列或索引相同.
In [47]: s.str.cat(['A', 'B', 'C', 'D'])
Out[47]:
0 aA
1 bB
2 cC
3 dD
dtype: object
任何一端的缺失值都會(huì)導(dǎo)致之中結(jié)果為缺失值，除非使用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ù)組對(duì)象為新的序列
v0.23.0. 新加入
others 參數(shù)可以是二維的。此時(shí)，行數(shù)需要與序列或索引的長(zhǎng)度相同。
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
#對(duì)齊拼接序列與帶索引的對(duì)象成為新的序列
v0.23.0.新加入
對(duì)于拼接序列或者數(shù)據(jù)表，我們可以使用 join關(guān)鍵字來對(duì)齊索引。
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 關(guān)鍵字， cat()方法將會(huì)滾回到0.23.0版之前，即（無對(duì)齊）模式。但如果任何的索引不一致時(shí)，將會(huì)拋出一個(gè) FutureWarning 警告，因?yàn)樵谖磥淼陌姹局?，默認(rèn)行為將改為join='left' 。
join 的選項(xiàng)為（'left', 'outer', 'inner', 'right'）中的一個(gè)。 特別的，對(duì)齊操作使得兩個(gè)對(duì)象可以是不同的長(zhǎng)度。
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
當(dāng)others是一個(gè)數(shù)據(jù)表時(shí)，也可以執(zhí)行相同的對(duì)齊操作：
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
#將一個(gè)序列與多個(gè)對(duì)象拼接為一個(gè)新的序列
所有的一維，類列表對(duì)象都可以任意組合進(jìn)一個(gè)類列表的容器（包括迭代器，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）必須與序列或索引有相同的長(zhǎng)度。但是，只要禁用對(duì)齊join=None，那么序列或索引就可以是任意長(zhǎng)度。
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
如果在一個(gè)包含不同的索引的others列表上使用join='right'，所有索引的并集將會(huì)被作為最終拼接的基礎(chǔ)：
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進(jìn)行索引
你可以使用 []方法來直接索引定位。如果你的索引超過了字符串的結(jié)尾，將返回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
#提取子字符串
#提取第一個(gè)匹配的對(duì)象 (extract)
警告
在 0.18.0中，extract擁有了 expand 參數(shù)。當(dāng) expand=False時(shí)， 將返回一個(gè)序列，索引或者數(shù)據(jù)表， 這取決于原對(duì)象和正則表達(dá)式（之前的版本也是如此）。當(dāng) expand=True時(shí)，它則總是返回一個(gè)DataFrame，這樣可以更加一致，并且減少用戶的混淆。 Expand=True 從0.23.0版本之后成為默認(rèn)值。
extract 方法接受一個(gè)至少含有一個(gè)捕獲組的 正則表達(dá)式
使用超過一個(gè)捕獲組的正則表達(dá)式則會(huì)提取并返回一個(gè)數(shù)據(jù)表，每一列為一個(gè)捕獲組。
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
沒有成功匹配的元素將會(huì)返回一行NaN。因此，一個(gè)序列的混亂的字符串可以被‘轉(zhuǎn)換’為一個(gè)類似索引的序列或數(shù)據(jù)表。返回的內(nèi)容會(huì)更為清爽，而且不需要使用get()方法來訪問元組中的成員或者re.match對(duì)象。返回的類型將總是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
也可以被使用。注意，任何有名稱的捕獲組，其名稱都會(huì)被用做列名，否則將會(huì)直接使用數(shù)字。
如果僅使用正則表達(dá)式捕獲一個(gè)組，而expand=True，那么仍然將返回一個(gè)數(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，則會(huì)返回一個(gè)序列。
In [83]: pd.Series(['a1', 'b2', 'c3']).str.extract(r'[ab](\d)', expand=False)
Out[83]:
0 1
1 2
2 NaN
dtype: object
在索引上使用正則表達(dá)式，并且僅捕獲一個(gè)組時(shí)，將會(huì)返回一個(gè)數(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，則返回一個(gè)Index。
In [87]: s.index.str.extract("(?P<letter>[a-zA-Z])", expand=False)
Out[87]: Index(['A', 'B', 'C'], dtype='object', name='letter')
如果在索引上使用正則并捕獲多個(gè)組，則返回一個(gè)數(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
下面的表格總結(jié)了extract (expand=False)時(shí)的行為（輸入對(duì)象在第一列，捕獲組的數(shù)量在第一行）
| 1 group | >1 group |
|---|---|
| Index | Index |
| Series | Series |
#提取所有的匹配 (extractall)
v0.18.0. 新加入
不同于 extract（只返回第一個(gè)匹配）
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總是返回一個(gè)帶有行多重索引的數(shù)據(jù)表，最后一級(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
當(dāng)所有的對(duì)象字串都只有一個(gè)匹配時(shí)，
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。 它返回一個(gè)數(shù)據(jù)表，其中包含與Series.str.estractall相同的結(jié)果，使用默認(rèn)索引（從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
#測(cè)試匹配或包含模式的字符串
你可以檢查是否一個(gè)元素包含一個(gè)可以匹配到的正則表達(dá)式：
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
或者是否元素完整匹配一個(gè)正則表達(dá)式
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ū)別是是否嚴(yán)格匹配。match嚴(yán)格基于re.match，而contains基于re.search。
類似match, contains, startswith 和 endswith 可以傳入一個(gè)額外的na參數(shù)，因此，因此缺失值在匹配時(shí)可以被認(rèn)為是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
#建立一個(gè)指示變量
你從字符串列可以抽出一個(gè)啞變量。例如，是否他們由|分割:
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，它返回一個(gè)多重索引：
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() | 索引每一個(gè)元素（返回第i個(gè)元素） |
| join() | 使用傳入的分隔符依次拼接每一個(gè)元素 |
| get_dummies() | 用分隔符切分字符串，并返回一個(gè)含有啞變量的數(shù)據(jù)表 |
| contains() | 返回一個(gè)布爾矩陣表明是每個(gè)元素包含字符串或正則表達(dá)式 |
| replace() | 將匹配到的子串或正則表達(dá)式替換為另外的字符串，或者一個(gè)可調(diào)用對(duì)象的返回值 |
| repeat() | 值復(fù)制（s.str.repeat(3)等價(jià)于x * 3） |
| pad() | 將白空格插入到字符串的左、右或者兩端 |
| center() | 等價(jià)于str.center |
| ljust() | 等價(jià)于str.ljust |
| rjust() | 等價(jià)于str.rjust |
| zfill() | 等價(jià)于str.zfill |
| wrap() | 將長(zhǎng)字符串轉(zhuǎn)換為不長(zhǎng)于給定長(zhǎng)度的行 |
| slice() | 將序列中的每一個(gè)字符串切片 |
| slice_replace() | 用傳入的值替換每一個(gè)字串中的切片 |
| count() | 對(duì)出現(xiàn)符合的規(guī)則進(jìn)行計(jì)數(shù) |
| startswith() | 等價(jià)于str.startswith(pat) |
| endswith() | 等價(jià)于 str.endswith(pat) |
| findall() | 返回每一個(gè)字串中出現(xiàn)的所有滿足樣式或正則的匹配 |
| match() | 素調(diào)用 re.match，并以列表形式返回匹配到的組 |
| extract() | Call 對(duì)每一個(gè)元素調(diào)用 re.search, 并以數(shù)據(jù)表的形式返回。行對(duì)應(yīng)原有的一個(gè)元素，列對(duì)應(yīng)所有捕獲的組 |
| extractall() | 一個(gè)元素調(diào)用 re.findall, 并以數(shù)據(jù)表的形式返回。行對(duì)應(yīng)原有的一個(gè)元素，列對(duì)應(yīng)所有捕獲的組 |
| len() | 計(jì)算字符串長(zhǎng)度 |
| strip() | 等價(jià)于str.strip |
| rstrip() | 等價(jià)于str.rstrip |
| lstrip() | 等價(jià)于str.lstrip |
| partition() | 等價(jià)于 str.partition |
| rpartition() | 等價(jià)于 str.rpartition |
| lower() | 等價(jià)于 str.lower |
| casefold() | 等價(jià)于 str.casefold |
| upper() | 等價(jià)于 str.upper |
| find() | 等價(jià)于str.find |
| rfind() | 等價(jià)于 str.rfind |
| index() | 等價(jià)于 str.index |
| rindex() | 等價(jià)于 str.rindex |
| capitalize() | 等價(jià)于 str.capitalize |
| swapcase() | 等價(jià)于 str.swapcase |
| normalize() | 返回Unicode 標(biāo)注格式。等價(jià)于 unicodedata.normalize |
| translate() | 等價(jià)于 str.translate |
| isalnum() | 等價(jià)于 str.isalnum |
| isalpha() | 等價(jià)于 str.isalpha |
| isdigit() | 等價(jià)于 str.isdigit |
| isspace() | 等價(jià)于 str.isspace |
| islower() | 等價(jià)于 str.islower |
| isupper() | 等價(jià)于 str.isupper |
| istitle() | 等價(jià)于 str.istitle |
| isnumeric() | 等價(jià)于 str.isnumeric |
| isdecimal() | 等價(jià)于 str.isdecimal |
更多建議：