U
|
¬ý°d¿® ã @ s¸ U d dl mZ d dlZd dlmZ d dlZd dlmZmZm Z m
|
Z
|
m Z d dl Z d dl Zd dlmZ d dlmZmZmZmZ d dlmZ d dlmZ d d lmZm Z m Z m Z m Z m Z m!Z! d d
|
l"m#Z#m$Z$m%Z%m&Z& d d l'm(Z( d d l)m*Z* d d l+m,Z, d dl-m.Z. erd dl/m0Z0m1Z1m2Z2 i Z3de4d< dZ5e5d Z6d3ddddddZ7dd Z8G d d d e,Z9d d d d!d"Z:d d d d#d$Z;d%d& Z<d'd(d)d*d+Z=d'd,d)d-d.Z>d4d/d0d1d2Z?dS )5é )Ú annotationsN)Úwraps)Ú TYPE_CHECKINGÚCallableÚHashableÚLiteralÚcast)Úlib)Ú AlignJoinÚDtypeObjÚFÚScalar)ÚAppender)Úfind_stack_level)Ú ensure_objectÚ is_bool_dtypeÚis_categorical_dtypeÚ
|
is_integerÚ is_list_likeÚis_object_dtypeÚis_re)Ú ABCDataFrameÚABCIndexÚ ABCMultiIndexÚ ABCSeries©Úisna)Ú
|
ArrowDtype)ÚNoNewAttributesMixin)Ú extract_array)Ú DataFrameÚIndexÚSerieszdict[str, str]Ú _shared_docs)zutf-8Úutf8zlatin-1Úlatin1z
|
iso-8859-1ÚmbcsÚascii)zutf-16zutf-32zlist[str] | Nonez
|
str | NonezCallable[[F], F])Ú forbiddenÚnameÚreturnc s@ | dkr g n| } dddddht | ddd fd d
|
}|S ) aý
|
Decorator to forbid specific types for a method of StringMethods.
|
|
For calling `.str.{method}` on a Series or Index, it is necessary to first
|
initialize the :class:`StringMethods` object, and then call the method.
|
However, different methods allow different input types, and so this can not
|
be checked during :meth:`StringMethods.__init__`, but must be done on a
|
per-method basis. This decorator exists to facilitate this process, and
|
make it explicit which (inferred) types are disallowed by the method.
|
|
:meth:`StringMethods.__init__` allows the *union* of types its different
|
methods allow (after skipping NaNs; see :meth:`StringMethods._validate`),
|
namely: ['string', 'empty', 'bytes', 'mixed', 'mixed-integer'].
|
|
The default string types ['string', 'empty'] are allowed for all methods.
|
For the additional types ['bytes', 'mixed', 'mixed-integer'], each method
|
then needs to forbid the types it is not intended for.
|
|
Parameters
|
----------
|
forbidden : list-of-str or None
|
List of forbidden non-string types, may be one or more of
|
`['bytes', 'mixed', 'mixed-integer']`.
|
name : str, default None
|
Name of the method to use in the error message. By default, this is
|
None, in which case the name from the method being wrapped will be
|
copied. However, for working with further wrappers (like _pat_wrapper
|
and _noarg_wrapper), it is necessary to specify the name.
|
|
Returns
|
-------
|
func : wrapper
|
The method to which the decorator is applied, with an added check that
|
enforces the inferred type to not be in the list of forbidden types.
|
|
Raises
|
------
|
TypeError
|
If the inferred type of the underlying data is in `forbidden`.
|
NÚstringÚemptyÚbytesÚmixedú mixed-integerr )Úfuncr* c s: d kr j nt fdd}|_ tt|S )Nc s6 | j kr&d d| j d}t|| f||S )NzCannot use .str.z with values of inferred dtype 'z'.)Ú_inferred_dtypeÚ TypeError)ÚselfÚargsÚkwargsÚmsg)Ú allowed_typesr0 Ú func_name© úSd:\z\workplace\vscode\pyvenv\venv\Lib\site-packages\pandas/core/strings/accessor.pyÚwrappery s
|
|
ÿzHforbid_nonstring_types.<locals>._forbid_nonstring_types.<locals>.wrapper)Ú__name__r r r )r0 r; ©r7 r) )r0 r8 r: Ú_forbid_nonstring_typesv s
|
z7forbid_nonstring_types.<locals>._forbid_nonstring_types)Úset)r( r) r> r9 r= r: Úforbid_nonstring_typesD s ,ÿr@ c s$ t dg d fdd}||_|S )Nr- ©r) c s t | jjd }| |¡S )NZ_str_)ÚgetattrÚ_dataÚarrayÚ _wrap_result©r3 ÚresultrA r9 r: r; s z _map_and_wrap.<locals>.wrapper)r@ Ú__doc__)r) Ú docstringr; r9 rA r: Ú _map_and_wrap s rJ c @ sâ e Zd ZU dZddddZedd Zdd Zd
|
d
|
ej d d fd dddddZ
|
dd Z e dddgdûddddd Z d ed < eed d d d!d"d#d$d%d&d' e dgdüd(d d
|
d)d*dd d+d,d-Zeed d.d/d0d/d/d/d1d/d' e dgdýd(d d2dd3d4d5Zd6ed7< eed7 d8d9d:d; e dgdþd=dd>d?d@Zeed7 dAdBdCd; e dgdÿd=dd>dDdEZdFdG Ze dgdHdI Ze dgd ddKddLdMdNZe dgdddKdOdPdQZe dgdddKdOdRdSZe dgddTdUdKd dKddVdWdXZe dgdYdZ Ze dgdd[d=d\d]d^Zd_ed`< eed` dadbdc e dgdd=dddedfZ eed` dgdhdc e dgdd=dddidjZ eed` ddkdc e dgdd=dddldmZ e dgdndo Z ddpdqZ e dgd drdsZ!d
|
d=dudvdwZ"e dgd d=dudxdyZ#dzed{< eed{ d|d}d~d e dgd ddZ$eed{ dddd e dgd d
dZ%eed{ dddd e dgdddZ&ded< eed ddd e dgdd Z'eed ddd e dgdd Z(e dgdd Z)e dgdd=dddZ*e dgdd Z+e dgddKdddZ,e dgdd d¡d¢d£d¤d¥Z-e dgdd d¡d¢d£d¦d§Z.e dgddKdd¨d©Z/e dgdd=dKddªd«d¬dZ0e dgddKdd®d¯Z1d°ed±< eed± d²d±d³d´ e dgddKdµd¶d·Z2eed± d¸d¹dºd´ e dgddKdµd»d¼Z3e dgd½d¾ Z4d¿edÀ< eedÀ d²d±dÀdÁd e dgddKdµdÃdÄZ5eedÀ d¸d¹dÅdÆd e dgddKdµdÇdÈZ6dÉdÊ Z7dËedÌ< i Z8dÍe9dÎ< dÏdÐd/dÑe8dÐ< dÒdÓd/dÑe8dÓ< dÔdÕd/dÑe8dÕ< dÖd×d/dÑe8d×< dØdÙd/dÑe8dÙ< dÚdÛd/dÑe8dÛ< eedÌ e8dÐ e dgdÜdÝ Z:eedÌ e8dÓ e dgdÞdß Z;eedÌ e8dÕ e dgdàdá Z<eedÌ e8d× e dgdâdã Z=eedÌ e8dÙ e dgdädå Z>eedÌ e8dÛ e dgdædç Z?dèedé< dêdëdìe8dë< dídîdìe8dî< dïdðdìe8dð< dñdòdìe8dò< dÏdódìe8dó< dÒdôdìe8dô< dÔdõdìe8dõ< död÷dìe8d÷< dødùdìe8dù< e@dëedé e8dë dúZAe@dîedé e8dî dúZBe@dðedé e8dð dúZCe@dòedé e8dò dúZDe@dóedé e8dó dúZEe@dôedé e8dô dúZFe@dõedé e8dõ dúZGe@d÷edé e8d÷ dúZHe@dùedé e8dù dúZId
|
S ( Ú StringMethodsaß
|
Vectorized string functions for Series and Index.
|
|
NAs stay NA unless handled otherwise by a particular method.
|
Patterned after Python's string methods, with some inspiration from
|
R's stringr package.
|
|
Examples
|
--------
|
>>> s = pd.Series(["A_Str_Series"])
|
>>> s
|
0 A_Str_Series
|
dtype: object
|
|
>>> s.str.split("_")
|
0 [A, Str, Series]
|
dtype: object
|
|
>>> s.str.replace("_", "")
|
0 AStrSeries
|
dtype: object
|
ÚNone)r* c C s ddl m} | |¡| _t|j| _t|j|| _|| _ d | _
|
| _ t|t r^|j | _
|
|j| _ | jrl|jjn|| _|| _| ¡ d S ©Nr )Ú StringDtype)Úpandas.core.arrays.string_rN Ú _validater1 r ÚdtypeZ_is_categoricalÚ
|
isinstanceÚ
|
_is_stringrC Ú_indexÚ_namer Úindexr) Z_valuesÚ
|
categoriesÚ_parentÚ_origZ_freeze)r3 ÚdatarN r9 r9 r: Ú__init__² s
|
zStringMethods.__init__c C sV t | trtddddddg}t| } t| d| }tj|dd }||krRtd
|
|S ) a
|
Auxiliary function for StringMethods, infers and checks dtype of data.
|
|
This is a "first line of defence" at the creation of the StringMethods-
|
object, and just checks that the dtype is in the
|
*union* of the allowed types over all string methods below; this
|
restriction is then refined on a per-method basis using the decorator
|
@forbid_nonstring_types (more info in the corresponding docstring).
|
|
This really should exclude all series/index with any non-string values,
|
but that isn't practical for performance reasons until we have a str
|
dtype (GH 9343 / 13877)
|
|
Parameters
|
----------
|
data : The content of the Series
|
|
Returns
|
-------
|
dtype : inferred dtype of data
|
z5Can only use .str accessor with Index, not MultiIndexr+ r, r- r. r/ rW T©Zskipnaz.Can only use .str accessor with string values!)rR r ÚAttributeErrorr rB r Ú infer_dtype)rZ r7 ÚvaluesZinferred_dtyper9 r9 r: rP Å s
|
ÿ zStringMethods._validatec C s | j j |¡}| |¡S ©N)rC rD Z _str_getitemrE )r3 ÚkeyrG r9 r9 r: Ú __getitem__î s zStringMethods.__getitem__NTFz bool | NoneÚbool)ÚexpandÚreturns_stringÚ returns_boolc sÄ ddl m}m} t|dr$t|dsBt|tr>|j| jdd}|S |jdk sPt |d krf|jdk}n|d krjt| jt
|
sjt|j t rdd l dd
|
lm j |j ¡ ¡ ¡ ¡ | ¡ ¡ rÚ|j d g ¡|_|d k rè|} nt} fd d t| t| ¡ D }nVt |rjd d fdd|D }|rj| j sjtdd |D fdd|D }t|t s~t d|dkr°|d krt |dd }|d kr°| jj!}t| jt
|
rt"|rÌ|S |rt#|}|j$||d}
|
|
|
j%dkrþ|
|
&d¡}
|
|
|
S |||dS n°| jj'} t |dd } | j rTt"| r>|j } n|rN| jj } n| } n| } |rx| jj(}|||| | d}n| jj)}|||| | d}|j| jdd}|d k r¼|jdkr¼||_!|S d S )Nr )r! Ú
|
MultiIndexÚndimrQ ÚstrrA é é T)ÚArrowExtensionArrayc s i | ]\}}| |¡qS r9 )rD )Ú.0ÚlabelÚres)rl Úpar9 r: Ú
|
<dictcomp> s ÿ z.StringMethods._wrap_result.<locals>.<dictcomp>c S s t | r | S | gS d S r` ©r ©Úxr9 r9 r: Úcons_row& s z,StringMethods._wrap_result.<locals>.cons_rowc s g | ] } |qS r9 r9 ©rm rt )ru r9 r: Ú
|
<listcomp>, s z.StringMethods._wrap_result.<locals>.<listcomp>c s s | ]}t |V qd S r` )Úlenrv r9 r9 r: Ú <genexpr>/ s z-StringMethods._wrap_result.<locals>.<genexpr>c s2 g | ]*}t |d ks"|d tjkr*| n|qS )r )rx ÚnpÚnanrv )Úmax_lenr9 r: rw 0 s ÿú expand must be True or FalseFr) ©Únames©ÚcolumnsrV rQ )r) rV rQ ©Úmethod)*Úpandasr! rg ÚhasattrrR r Ú __finalize__rY rh ÚAssertionErrorr rQ r ZpyarrowZ pandas.core.arrays.arrow.arrayrl ZcomputeÚmaxrC Zcombine_chunksZ value_lengthsZas_pyr ÚanyZ fill_nullÚrangeÚzipÚtolistr rS rc Ú
|
ValueErrorrB r) r ÚlistÚ from_tuplesÚnlevelsZget_level_valuesrV Ú_constructor_expanddimZ _constructor)r3 rG r) rd Ú
|
fill_valuere rf r! rg ÚlabelsÚoutrV ZvdtyperQ Zconsr9 )rl ru r| rp r: rE ò s
|
ÿ þ
|
|
þ
|
|
|
|
|
|
|
zStringMethods._wrap_resultc s ddl m}m} t| jtr"| jn| jj}t tr: gS t trV| | jdgS t t rr fdd D S t t
|
j r¦ j dkr¦| |d fdd D S t d d
|
rt td d D rðg } rì|| d¡¡ }qÒ|S td d D r| |dgS tddS )añ
|
Auxiliary function for :meth:`str.cat`. Turn potentially mixed input
|
into a list of Series (elements without an index must match the length
|
of the calling Series/Index).
|
|
Parameters
|
----------
|
others : Series, DataFrame, np.ndarray, list-like or list-like of
|
Objects that are either Series, Index or np.ndarray (1-dim).
|
|
Returns
|
-------
|
list of Series
|
Others transformed into list of Series.
|
r )r r" ©rV rQ c s g | ] } | qS r9 r9 rv ©Úothersr9 r: rw s z2StringMethods._get_series_list.<locals>.<listcomp>é )rV c s g | ] } | qS r9 r9 rv r r9 r: rw s F)Z
|
allow_setsc s s2 | ]*}t |ttfp(t |tjo(|jd kV qdS )rk N)rR r r rz Úndarrayrh rv r9 r9 r: ry s þz1StringMethods._get_series_list.<locals>.<genexpr>c s s | ]}t | V qd S r` rr rv r9 r9 r: ry ¤ s z£others must be Series, Index, DataFrame, np.ndarray or list-like (either containing only strings or containing only objects of type Series/Index/np.ndarray[1-dim])N)r r r" rR rY r rV r rQ r rz r rh r r ÚallÚ_get_series_listÚpopr2 )r3 r r r" ÚidxZlosr9 r r: r q s2
|
|
|
ýÿz StringMethods._get_series_listr- r. r/ Úleftr
|
zstr | Series | Index)Újoinr* c
|
s¤ ddl m}m}m} ttr&td|dkr2d}t| jtrV|| j| j| jj d n| j dkrÂt
|
t }dkr| ¡ r| | ¡S dk r¸| ¡ r¸| t | ¡¡S | ¡S z| ¡W n. tk
|
rþ } ztd| W 5 d} ~ X Y nX t fdd D rf|d
|
|d kr,|nd ttd d d j|d\ fddD dd g D }
|
t dd |
|
D ¡} tjj| dd} dkrø| ¡ røtjt td} t | | tj¡ | tfdd|
|
D || < nBdk r0| ¡ r0fddt | |
|
D }
|
t|
|
|} n
|
t|
|
|} t| jtr\|| t| jj d}nDt | jj rpd}n| jj }|| | j | jj d d}|j | jdd}|S ) ae
|
Concatenate strings in the Series/Index with given separator.
|
|
If `others` is specified, this function concatenates the Series/Index
|
and elements of `others` element-wise.
|
If `others` is not passed, then all values in the Series/Index are
|
concatenated into a single string with a given `sep`.
|
|
Parameters
|
----------
|
others : Series, Index, DataFrame, np.ndarray or list-like
|
Series, Index, DataFrame, np.ndarray (one- or two-dimensional) and
|
other list-likes of strings must have the same length as the
|
calling Series/Index, with the exception of indexed objects (i.e.
|
Series/Index/DataFrame) if `join` is not None.
|
|
If others is a list-like that contains a combination of Series,
|
Index or np.ndarray (1-dim), then all elements will be unpacked and
|
must satisfy the above criteria individually.
|
|
If others is None, the method returns the concatenation of all
|
strings in the calling Series/Index.
|
sep : str, default ''
|
The separator between the different elements/columns. By default
|
the empty string `''` is used.
|
na_rep : str or None, default None
|
Representation that is inserted for all missing values:
|
|
- If `na_rep` is None, and `others` is None, missing values in the
|
Series/Index are omitted from the result.
|
- If `na_rep` is None, and `others` is not None, a row containing a
|
missing value in any of the columns (before concatenation) will
|
have a missing value in the result.
|
join : {'left', 'right', 'outer', 'inner'}, default 'left'
|
Determines the join-style between the calling Series/Index and any
|
Series/Index/DataFrame in `others` (objects without an index need
|
to match the length of the calling Series/Index). To disable
|
alignment, use `.values` on any Series/Index/DataFrame in `others`.
|
|
Returns
|
-------
|
str, Series or Index
|
If `others` is None, `str` is returned, otherwise a `Series/Index`
|
(same type as caller) of objects is returned.
|
|
See Also
|
--------
|
split : Split each string in the Series/Index.
|
join : Join lists contained as elements in the Series/Index.
|
|
Examples
|
--------
|
When not passing `others`, all values are concatenated into a single
|
string:
|
|
>>> s = pd.Series(['a', 'b', np.nan, 'd'])
|
>>> s.str.cat(sep=' ')
|
'a b d'
|
|
By default, NA values in the Series are ignored. Using `na_rep`, they
|
can be given a representation:
|
|
>>> s.str.cat(sep=' ', na_rep='?')
|
'a b ? d'
|
|
If `others` is specified, corresponding values are concatenated with
|
the separator. Result will be a Series of strings.
|
|
>>> s.str.cat(['A', 'B', 'C', 'D'], sep=',')
|
0 a,A
|
1 b,B
|
2 NaN
|
3 d,D
|
dtype: object
|
|
Missing values will remain missing in the result, but can again be
|
represented using `na_rep`
|
|
>>> s.str.cat(['A', 'B', 'C', 'D'], sep=',', na_rep='-')
|
0 a,A
|
1 b,B
|
2 -,C
|
3 d,D
|
dtype: object
|
|
If `sep` is not specified, the values are concatenated without
|
separation.
|
|
>>> s.str.cat(['A', 'B', 'C', 'D'], na_rep='-')
|
0 aA
|
1 bB
|
2 -C
|
3 dD
|
dtype: object
|
|
Series with different indexes can be aligned before concatenation. The
|
`join`-keyword works as in other methods.
|
|
>>> t = pd.Series(['d', 'a', 'e', 'c'], index=[3, 0, 4, 2])
|
>>> s.str.cat(t, join='left', na_rep='-')
|
0 aa
|
1 b-
|
2 -c
|
3 dd
|
dtype: object
|
>>>
|
>>> s.str.cat(t, join='outer', na_rep='-')
|
0 aa
|
1 b-
|
2 -c
|
3 dd
|
4 -e
|
dtype: object
|
>>>
|
>>> s.str.cat(t, join='inner', na_rep='-')
|
0 aa
|
2 -c
|
3 dd
|
dtype: object
|
>>>
|
>>> s.str.cat(t, join='right', na_rep='-')
|
3 dd
|
0 aa
|
4 -e
|
2 -c
|
dtype: object
|
|
For more examples, see :ref:`here <text.concatenate>`.
|
r )r! r" Úconcatz'Did you mean to supply a `sep` keyword?NÚ r zIf `others` contains arrays or lists (or other list-likes without an index), these must all be of the same length as the calling Series/Index.c 3 s | ]} j |j ¡ V qd S r` )rV Úequalsrv )rZ r9 r: ry _ s z$StringMethods.cat.<locals>.<genexpr>rk ÚinnerÚouterF)Úaxisr ÚkeysÚsortÚcopy)r c s g | ] } | qS r9 r9 rv r r9 r: rw j s z%StringMethods.cat.<locals>.<listcomp>c S s g | ] }t |qS r9 )r rv r9 r9 r: rw l s c S s g | ] }t |qS r9 r rv r9 r9 r: rw m s ©r¥ ©rQ c s g | ] }| qS r9 r9 rv )Ú
|
not_maskedr9 r: rw w s c s g | ]\}}t | |¡qS r9 )rz Úwhere)rm ÚnmÚcol)Úna_repr9 r: rw z s )rQ r) )rQ rV r) r¨ Zstr_catr )!r r! r" r rR ri r rY r rQ r r r r rz r¬ r r rx ZalignrD Ú
|
logical_orÚreducer, ÚobjectZputmaskr{ Úcat_safer r) r rV r )r3 r Úsepr¯ r r! r" r Zna_maskÚerrZall_colsZna_masksZ
|
union_maskrG r rQ Zres_serr9 )rZ r¯ r« r r: Úcat s
|
|
ÿü
|
ú
|
ÿ
|
ÿzStringMethods.cataÉ
|
Split strings around given separator/delimiter.
|
|
Splits the string in the Series/Index from the %(side)s,
|
at the specified delimiter string.
|
|
Parameters
|
----------
|
pat : str%(pat_regex)s, optional
|
%(pat_description)s.
|
If not specified, split on whitespace.
|
n : int, default -1 (all)
|
Limit number of splits in output.
|
``None``, 0 and -1 will be interpreted as return all splits.
|
expand : bool, default False
|
Expand the split strings into separate columns.
|
|
- If ``True``, return DataFrame/MultiIndex expanding dimensionality.
|
- If ``False``, return Series/Index, containing lists of strings.
|
%(regex_argument)s
|
Returns
|
-------
|
Series, Index, DataFrame or MultiIndex
|
Type matches caller unless ``expand=True`` (see Notes).
|
%(raises_split)s
|
See Also
|
--------
|
Series.str.split : Split strings around given separator/delimiter.
|
Series.str.rsplit : Splits string around given separator/delimiter,
|
starting from the right.
|
Series.str.join : Join lists contained as elements in the Series/Index
|
with passed delimiter.
|
str.split : Standard library version for split.
|
str.rsplit : Standard library version for rsplit.
|
|
Notes
|
-----
|
The handling of the `n` keyword depends on the number of found splits:
|
|
- If found splits > `n`, make first `n` splits only
|
- If found splits <= `n`, make all splits
|
- If for a certain row the number of found splits < `n`,
|
append `None` for padding up to `n` if ``expand=True``
|
|
If using ``expand=True``, Series and Index callers return DataFrame and
|
MultiIndex objects, respectively.
|
%(regex_pat_note)s
|
Examples
|
--------
|
>>> s = pd.Series(
|
... [
|
... "this is a regular sentence",
|
... "https://docs.python.org/3/tutorial/index.html",
|
... np.nan
|
... ]
|
... )
|
>>> s
|
0 this is a regular sentence
|
1 https://docs.python.org/3/tutorial/index.html
|
2 NaN
|
dtype: object
|
|
In the default setting, the string is split by whitespace.
|
|
>>> s.str.split()
|
0 [this, is, a, regular, sentence]
|
1 [https://docs.python.org/3/tutorial/index.html]
|
2 NaN
|
dtype: object
|
|
Without the `n` parameter, the outputs of `rsplit` and `split`
|
are identical.
|
|
>>> s.str.rsplit()
|
0 [this, is, a, regular, sentence]
|
1 [https://docs.python.org/3/tutorial/index.html]
|
2 NaN
|
dtype: object
|
|
The `n` parameter can be used to limit the number of splits on the
|
delimiter. The outputs of `split` and `rsplit` are different.
|
|
>>> s.str.split(n=2)
|
0 [this, is, a regular sentence]
|
1 [https://docs.python.org/3/tutorial/index.html]
|
2 NaN
|
dtype: object
|
|
>>> s.str.rsplit(n=2)
|
0 [this is a, regular, sentence]
|
1 [https://docs.python.org/3/tutorial/index.html]
|
2 NaN
|
dtype: object
|
|
The `pat` parameter can be used to split by other characters.
|
|
>>> s.str.split(pat="/")
|
0 [this is a regular sentence]
|
1 [https:, , docs.python.org, 3, tutorial, index...
|
2 NaN
|
dtype: object
|
|
When using ``expand=True``, the split elements will expand out into
|
separate columns. If NaN is present, it is propagated throughout
|
the columns during the split.
|
|
>>> s.str.split(expand=True)
|
0 1 2 3 4
|
0 this is a regular sentence
|
1 https://docs.python.org/3/tutorial/index.html None None None None
|
2 NaN NaN NaN NaN NaN
|
|
For slightly more complex use cases like splitting the html document name
|
from a url, a combination of parameter settings can be used.
|
|
>>> s.str.rsplit("/", n=1, expand=True)
|
0 1
|
0 this is a regular sentence None
|
1 https://docs.python.org/3/tutorial index.html
|
2 NaN NaN
|
%(regex_examples)sZ str_splitZ beginningz or compiled regexz(String or regular expression to split ona
|
regex : bool, default None
|
Determines if the passed-in pattern is a regular expression:
|
|
- If ``True``, assumes the passed-in pattern is a regular expression
|
- If ``False``, treats the pattern as a literal string.
|
- If ``None`` and `pat` length is 1, treats `pat` as a literal string.
|
- If ``None`` and `pat` length is not 1, treats `pat` as a regular expression.
|
- Cannot be set to False if `pat` is a compiled regex
|
|
.. versionadded:: 1.4.0
|
zÀ
|
Raises
|
------
|
ValueError
|
* if `regex` is False and `pat` is a compiled regex
|
z]
|
Use of `regex =False` with a `pat` as a compiled regex will raise an error.
|
ÚsplitaI
|
Remember to escape special characters when explicitly using regular expressions.
|
|
>>> s = pd.Series(["foo and bar plus baz"])
|
>>> s.str.split(r"and|plus", expand=True)
|
0 1 2
|
0 foo bar baz
|
|
Regular expressions can be used to handle urls or file names.
|
When `pat` is a string and ``regex=None`` (the default), the given `pat` is compiled
|
as a regex only if ``len(pat) != 1``.
|
|
>>> s = pd.Series(['foojpgbar.jpg'])
|
>>> s.str.split(r".", expand=True)
|
0 1
|
0 foojpgbar jpg
|
|
>>> s.str.split(r"\.jpg", expand=True)
|
0 1
|
0 foojpgbar
|
|
When ``regex=True``, `pat` is interpreted as a regex
|
|
>>> s.str.split(r"\.jpg", regex=True, expand=True)
|
0 1
|
0 foojpgbar
|
|
A compiled regex can be passed as `pat`
|
|
>>> import re
|
>>> s.str.split(re.compile(r"\.jpg"), expand=True)
|
0 1
|
0 foojpgbar
|
|
When ``regex=False``, `pat` is interpreted as the string itself
|
|
>>> s.str.split(r"\.jpg", regex=False, expand=True)
|
0
|
0 foojpgbar.jpg
|
)ÚsideZ pat_regexZpat_descriptionZregex_argumentZ raises_splitZregex_pat_noter Zregex_exampleséÿÿÿÿ)Únrd Úregexzstr | re.Pattern | None)Úpatrd r» c C sH |dkrt |rtdt |r$d}| jj ||||¡}| j|||dS )NFúCCannot use a compiled regex as replacement pattern with regex=FalseT)re rd )r r rC rD Z
|
_str_splitrE )r3 r¼ rº rd r» rG r9 r9 r: r· s OÿzStringMethods.splitÚendr¡ zString to split onÚrsplit)rº rd )rd c C s" | j jj||d}| j|||dS )N)rº ©rd re )rC rD Z _str_rsplitrE )r3 r¼ rº rd rG r9 r9 r: r¿ g s zStringMethods.rsplita;
|
Split the string at the %(side)s occurrence of `sep`.
|
|
This method splits the string at the %(side)s occurrence of `sep`,
|
and returns 3 elements containing the part before the separator,
|
the separator itself, and the part after the separator.
|
If the separator is not found, return %(return)s.
|
|
Parameters
|
----------
|
sep : str, default whitespace
|
String to split on.
|
expand : bool, default True
|
If True, return DataFrame/MultiIndex expanding dimensionality.
|
If False, return Series/Index.
|
|
Returns
|
-------
|
DataFrame/MultiIndex or Series/Index of objects
|
|
See Also
|
--------
|
%(also)s
|
Series.str.split : Split strings around given separators.
|
str.partition : Standard library version.
|
|
Examples
|
--------
|
|
>>> s = pd.Series(['Linda van der Berg', 'George Pitt-Rivers'])
|
>>> s
|
0 Linda van der Berg
|
1 George Pitt-Rivers
|
dtype: object
|
|
>>> s.str.partition()
|
0 1 2
|
0 Linda van der Berg
|
1 George Pitt-Rivers
|
|
To partition by the last space instead of the first one:
|
|
>>> s.str.rpartition()
|
0 1 2
|
0 Linda van der Berg
|
1 George Pitt-Rivers
|
|
To partition by something different than a space:
|
|
>>> s.str.partition('-')
|
0 1 2
|
0 Linda van der Berg
|
1 George Pitt - Rivers
|
|
To return a Series containing tuples instead of a DataFrame:
|
|
>>> s.str.partition('-', expand=False)
|
0 (Linda van der Berg, , )
|
1 (George Pitt, -, Rivers)
|
dtype: object
|
|
Also available on indices:
|
|
>>> idx = pd.Index(['X 123', 'Y 999'])
|
>>> idx
|
Index(['X 123', 'Y 999'], dtype='object')
|
|
Which will create a MultiIndex:
|
|
>>> idx.str.partition()
|
MultiIndex([('X', ' ', '123'),
|
('Y', ' ', '999')],
|
)
|
|
Or an index with tuples with ``expand=False``:
|
|
>>> idx.str.partition(expand=False)
|
Index([('X', ' ', '123'), ('Y', ' ', '999')], dtype='object')
|
Z str_partitionÚfirstzF3 elements containing the string itself, followed by two empty stringsz>rpartition : Split the string at the last occurrence of `sep`.)r¸ r* Úalsoú ri )r´ rd c C s | j j ||¡}| j|||dS ©NrÀ )rC rD Z_str_partitionrE ©r3 r´ rd rG r9 r9 r: Ú partitionË s zStringMethods.partitionÚlastzF3 elements containing two empty strings, followed by the string itselfz>partition : Split the string at the first occurrence of `sep`.c C s | j j ||¡}| j|||dS rÄ )rC rD Z_str_rpartitionrE rÅ r9 r9 r: Ú
|
rpartitionÙ s zStringMethods.rpartitionc C s | j j |¡}| |¡S )aì
|
Extract element from each component at specified position or with specified key.
|
|
Extract element from lists, tuples, dict, or strings in each element in the
|
Series/Index.
|
|
Parameters
|
----------
|
i : int or hashable dict label
|
Position or key of element to extract.
|
|
Returns
|
-------
|
Series or Index
|
|
Examples
|
--------
|
>>> s = pd.Series(["String",
|
... (1, 2, 3),
|
... ["a", "b", "c"],
|
... 123,
|
... -456,
|
... {1: "Hello", "2": "World"}])
|
>>> s
|
0 String
|
1 (1, 2, 3)
|
2 [a, b, c]
|
3 123
|
4 -456
|
5 {1: 'Hello', '2': 'World'}
|
dtype: object
|
|
>>> s.str.get(1)
|
0 t
|
1 2
|
2 b
|
3 NaN
|
4 NaN
|
5 Hello
|
dtype: object
|
|
>>> s.str.get(-1)
|
0 g
|
1 3
|
2 c
|
3 NaN
|
4 NaN
|
5 None
|
dtype: object
|
|
Return element with given key
|
|
>>> s = pd.Series([{"name": "Hello", "value": "World"},
|
... {"name": "Goodbye", "value": "Planet"}])
|
>>> s.str.get('name')
|
0 Hello
|
1 Goodbye
|
dtype: object
|
)rC rD Z_str_getrE )r3 ÚirG r9 r9 r: Úgetç s <zStringMethods.getc C s | j j |¡}| |¡S )a
|
Join lists contained as elements in the Series/Index with passed delimiter.
|
|
If the elements of a Series are lists themselves, join the content of these
|
lists using the delimiter passed to the function.
|
This function is an equivalent to :meth:`str.join`.
|
|
Parameters
|
----------
|
sep : str
|
Delimiter to use between list entries.
|
|
Returns
|
-------
|
Series/Index: object
|
The list entries concatenated by intervening occurrences of the
|
delimiter.
|
|
Raises
|
------
|
AttributeError
|
If the supplied Series contains neither strings nor lists.
|
|
See Also
|
--------
|
str.join : Standard library version of this method.
|
Series.str.split : Split strings around given separator/delimiter.
|
|
Notes
|
-----
|
If any of the list items is not a string object, the result of the join
|
will be `NaN`.
|
|
Examples
|
--------
|
Example with a list that contains non-string elements.
|
|
>>> s = pd.Series([['lion', 'elephant', 'zebra'],
|
... [1.1, 2.2, 3.3],
|
... ['cat', np.nan, 'dog'],
|
... ['cow', 4.5, 'goat'],
|
... ['duck', ['swan', 'fish'], 'guppy']])
|
>>> s
|
0 [lion, elephant, zebra]
|
1 [1.1, 2.2, 3.3]
|
2 [cat, nan, dog]
|
3 [cow, 4.5, goat]
|
4 [duck, [swan, fish], guppy]
|
dtype: object
|
|
Join all lists using a '-'. The lists containing object(s) of types other
|
than str will produce a NaN.
|
|
>>> s.str.join('-')
|
0 lion-elephant-zebra
|
1 NaN
|
2 NaN
|
3 NaN
|
4 NaN
|
dtype: object
|
)rC rD Z _str_joinrE )r3 r´ rG r9 r9 r: r & s ?zStringMethods.joinr Úint)ÚcaseÚflagsr» c C sH |r"t |¡jr"tjdtt d | jj |||||¡}| j
|
||ddS )aO
|
Test if pattern or regex is contained within a string of a Series or Index.
|
|
Return boolean Series or Index based on whether a given pattern or regex is
|
contained within a string of a Series or Index.
|
|
Parameters
|
----------
|
pat : str
|
Character sequence or regular expression.
|
case : bool, default True
|
If True, case sensitive.
|
flags : int, default 0 (no flags)
|
Flags to pass through to the re module, e.g. re.IGNORECASE.
|
na : scalar, optional
|
Fill value for missing values. The default depends on dtype of the
|
array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,
|
``pandas.NA`` is used.
|
regex : bool, default True
|
If True, assumes the pat is a regular expression.
|
|
If False, treats the pat as a literal string.
|
|
Returns
|
-------
|
Series or Index of boolean values
|
A Series or Index of boolean values indicating whether the
|
given pattern is contained within the string of each element
|
of the Series or Index.
|
|
See Also
|
--------
|
match : Analogous, but stricter, relying on re.match instead of re.search.
|
Series.str.startswith : Test if the start of each string element matches a
|
pattern.
|
Series.str.endswith : Same as startswith, but tests the end of string.
|
|
Examples
|
--------
|
Returning a Series of booleans using only a literal pattern.
|
|
>>> s1 = pd.Series(['Mouse', 'dog', 'house and parrot', '23', np.NaN])
|
>>> s1.str.contains('og', regex=False)
|
0 False
|
1 True
|
2 False
|
3 False
|
4 NaN
|
dtype: object
|
|
Returning an Index of booleans using only a literal pattern.
|
|
>>> ind = pd.Index(['Mouse', 'dog', 'house and parrot', '23.0', np.NaN])
|
>>> ind.str.contains('23', regex=False)
|
Index([False, False, False, True, nan], dtype='object')
|
|
Specifying case sensitivity using `case`.
|
|
>>> s1.str.contains('oG', case=True, regex=True)
|
0 False
|
1 False
|
2 False
|
3 False
|
4 NaN
|
dtype: object
|
|
Specifying `na` to be `False` instead of `NaN` replaces NaN values
|
with `False`. If Series or Index does not contain NaN values
|
the resultant dtype will be `bool`, otherwise, an `object` dtype.
|
|
>>> s1.str.contains('og', na=False, regex=True)
|
0 False
|
1 True
|
2 False
|
3 False
|
4 False
|
dtype: bool
|
|
Returning 'house' or 'dog' when either expression occurs in a string.
|
|
>>> s1.str.contains('house|dog', regex=True)
|
0 False
|
1 True
|
2 True
|
3 False
|
4 NaN
|
dtype: object
|
|
Ignoring case sensitivity using `flags` with regex.
|
|
>>> import re
|
>>> s1.str.contains('PARROT', flags=re.IGNORECASE, regex=True)
|
0 False
|
1 False
|
2 True
|
3 False
|
4 NaN
|
dtype: object
|
|
Returning any digit using regular expression.
|
|
>>> s1.str.contains('\\d', regex=True)
|
0 False
|
1 False
|
2 False
|
3 True
|
4 NaN
|
dtype: object
|
|
Ensure `pat` is a not a literal pattern when `regex` is set to True.
|
Note in the following example one might expect only `s2[1]` and `s2[3]` to
|
return `True`. However, '.0' as a regex matches any character
|
followed by a 0.
|
|
>>> s2 = pd.Series(['40', '40.0', '41', '41.0', '35'])
|
>>> s2.str.contains('.0', regex=True)
|
0 True
|
1 True
|
2 False
|
3 True
|
4 False
|
dtype: bool
|
zwThis pattern is interpreted as a regular expression, and has match groups. To actually get the groups, use str.extract.)Ú
|
stacklevelF©r re ) ÚreÚcompileÚgroupsÚwarningsÚwarnÚ UserWarningr rC rD Z _str_containsrE )r3 r¼ rÌ rÍ Únar» rG r9 r9 r: Úcontainsh s üzStringMethods.contains)rÌ rÍ c C s& | j jj||||d}| j||ddS )a
|
Determine if each string starts with a match of a regular expression.
|
|
Parameters
|
----------
|
pat : str
|
Character sequence or regular expression.
|
case : bool, default True
|
If True, case sensitive.
|
flags : int, default 0 (no flags)
|
Regex module flags, e.g. re.IGNORECASE.
|
na : scalar, optional
|
Fill value for missing values. The default depends on dtype of the
|
array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,
|
``pandas.NA`` is used.
|
|
Returns
|
-------
|
Series/Index/array of boolean values
|
|
See Also
|
--------
|
fullmatch : Stricter matching that requires the entire string to match.
|
contains : Analogous, but less strict, relying on re.search instead of
|
re.match.
|
extract : Extract matched groups.
|
©rÌ rÍ rÖ FrÏ )rC rD Z
|
_str_matchrE ©r3 r¼ rÌ rÍ rÖ rG r9 r9 r: Úmatchò s zStringMethods.matchc C s& | j jj||||d}| j||ddS )a
|
Determine if each string entirely matches a regular expression.
|
|
.. versionadded:: 1.1.0
|
|
Parameters
|
----------
|
pat : str
|
Character sequence or regular expression.
|
case : bool, default True
|
If True, case sensitive.
|
flags : int, default 0 (no flags)
|
Regex module flags, e.g. re.IGNORECASE.
|
na : scalar, optional
|
Fill value for missing values. The default depends on dtype of the
|
array. For object-dtype, ``numpy.nan`` is used. For ``StringDtype``,
|
``pandas.NA`` is used.
|
|
Returns
|
-------
|
Series/Index/array of boolean values
|
|
See Also
|
--------
|
match : Similar, but also returns `True` when only a *prefix* of the string
|
matches the regular expression.
|
extract : Extract matched groups.
|
rØ FrÏ )rC rD Z_str_fullmatchrE rÙ r9 r9 r: Ú fullmatch s zStringMethods.fullmatchzstr | re.Patternzstr | Callable)r¼ Úreplrº rÌ rÍ r» c C s t |tst|stdt|}|s.|dkrL|rj|dk sB|dkrjtdn |rZtdnt|rjtd|dkrvd}| jjj||||||d}| |¡S ) a[
|
Replace each occurrence of pattern/regex in the Series/Index.
|
|
Equivalent to :meth:`str.replace` or :func:`re.sub`, depending on
|
the regex value.
|
|
Parameters
|
----------
|
pat : str or compiled regex
|
String can be a character sequence or regular expression.
|
repl : str or callable
|
Replacement string or a callable. The callable is passed the regex
|
match object and must return a replacement string to be used.
|
See :func:`re.sub`.
|
n : int, default -1 (all)
|
Number of replacements to make from start.
|
case : bool, default None
|
Determines if replace is case sensitive:
|
|
- If True, case sensitive (the default if `pat` is a string)
|
- Set to False for case insensitive
|
- Cannot be set if `pat` is a compiled regex.
|
|
flags : int, default 0 (no flags)
|
Regex module flags, e.g. re.IGNORECASE. Cannot be set if `pat` is a compiled
|
regex.
|
regex : bool, default False
|
Determines if the passed-in pattern is a regular expression:
|
|
- If True, assumes the passed-in pattern is a regular expression.
|
- If False, treats the pattern as a literal string
|
- Cannot be set to False if `pat` is a compiled regex or `repl` is
|
a callable.
|
|
Returns
|
-------
|
Series or Index of object
|
A copy of the object with all matching occurrences of `pat` replaced by
|
`repl`.
|
|
Raises
|
------
|
ValueError
|
* if `regex` is False and `repl` is a callable or `pat` is a compiled
|
regex
|
* if `pat` is a compiled regex and `case` or `flags` is set
|
|
Notes
|
-----
|
When `pat` is a compiled regex, all flags should be included in the
|
compiled regex. Use of `case`, `flags`, or `regex=False` with a compiled
|
regex will raise an error.
|
|
Examples
|
--------
|
When `pat` is a string and `regex` is True (the default), the given `pat`
|
is compiled as a regex. When `repl` is a string, it replaces matching
|
regex patterns as with :meth:`re.sub`. NaN value(s) in the Series are
|
left as is:
|
|
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f.', 'ba', regex=True)
|
0 bao
|
1 baz
|
2 NaN
|
dtype: object
|
|
When `pat` is a string and `regex` is False, every `pat` is replaced with
|
`repl` as with :meth:`str.replace`:
|
|
>>> pd.Series(['f.o', 'fuz', np.nan]).str.replace('f.', 'ba', regex=False)
|
0 bao
|
1 fuz
|
2 NaN
|
dtype: object
|
|
When `repl` is a callable, it is called on every `pat` using
|
:func:`re.sub`. The callable should expect one positional argument
|
(a regex object) and return a string.
|
|
To get the idea:
|
|
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace('f', repr, regex=True)
|
0 <re.Match object; span=(0, 1), match='f'>oo
|
1 <re.Match object; span=(0, 1), match='f'>uz
|
2 NaN
|
dtype: object
|
|
Reverse every lowercase alphabetic word:
|
|
>>> repl = lambda m: m.group(0)[::-1]
|
>>> ser = pd.Series(['foo 123', 'bar baz', np.nan])
|
>>> ser.str.replace(r'[a-z]+', repl, regex=True)
|
0 oof 123
|
1 rab zab
|
2 NaN
|
dtype: object
|
|
Using regex groups (extract second group and swap case):
|
|
>>> pat = r"(?P<one>\w+) (?P<two>\w+) (?P<three>\w+)"
|
>>> repl = lambda m: m.group('two').swapcase()
|
>>> ser = pd.Series(['One Two Three', 'Foo Bar Baz'])
|
>>> ser.str.replace(pat, repl, regex=True)
|
0 tWO
|
1 bAR
|
dtype: object
|
|
Using a compiled regex with flags
|
|
>>> import re
|
>>> regex_pat = re.compile(r'FUZ', flags=re.IGNORECASE)
|
>>> pd.Series(['foo', 'fuz', np.nan]).str.replace(regex_pat, 'bar', regex=True)
|
0 foo
|
1 bar
|
2 NaN
|
dtype: object
|
z!repl must be a string or callableNr z9case and flags cannot be set when pat is a compiled regexr½ z2Cannot use a callable replacement when regex=FalseT)rº rÌ rÍ r» )
|
rR ri Úcallabler2 r r rC rD Z _str_replacerE ) r3 r¼ rÜ rº rÌ rÍ r» Zis_compiled_rerG r9 r9 r: Úreplace3 s4 ÿÿ ÿzStringMethods.replacec C s | j j |¡}| |¡S )am
|
Duplicate each string in the Series or Index.
|
|
Parameters
|
----------
|
repeats : int or sequence of int
|
Same value for all (int) or different value per (sequence).
|
|
Returns
|
-------
|
Series or pandas.Index
|
Series or Index of repeated string objects specified by
|
input parameter repeats.
|
|
Examples
|
--------
|
>>> s = pd.Series(['a', 'b', 'c'])
|
>>> s
|
0 a
|
1 b
|
2 c
|
dtype: object
|
|
Single int repeats string in Series
|
|
>>> s.str.repeat(repeats=2)
|
0 aa
|
1 bb
|
2 cc
|
dtype: object
|
|
Sequence of int repeats corresponding string in Series
|
|
>>> s.str.repeat(repeats=[1, 2, 3])
|
0 a
|
1 bb
|
2 ccc
|
dtype: object
|
)rC rD Z _str_repeatrE )r3 ZrepeatsrG r9 r9 r: ÚrepeatÌ s )zStringMethods.repeatz"Literal[('left', 'right', 'both')]©r¸ Úfillcharc C st t |ts"dt|j }t|t|dkr6tdt|sVdt|j }t|| jjj |||d}|
|
|¡S )aì
|
Pad strings in the Series/Index up to width.
|
|
Parameters
|
----------
|
width : int
|
Minimum width of resulting string; additional characters will be filled
|
with character defined in `fillchar`.
|
side : {'left', 'right', 'both'}, default 'left'
|
Side from which to fill resulting string.
|
fillchar : str, default ' '
|
Additional character for filling, default is whitespace.
|
|
Returns
|
-------
|
Series or Index of object
|
Returns Series or Index with minimum number of char in object.
|
|
See Also
|
--------
|
Series.str.rjust : Fills the left side of strings with an arbitrary
|
character. Equivalent to ``Series.str.pad(side='left')``.
|
Series.str.ljust : Fills the right side of strings with an arbitrary
|
character. Equivalent to ``Series.str.pad(side='right')``.
|
Series.str.center : Fills both sides of strings with an arbitrary
|
character. Equivalent to ``Series.str.pad(side='both')``.
|
Series.str.zfill : Pad strings in the Series/Index by prepending '0'
|
character. Equivalent to ``Series.str.pad(side='left', fillchar='0')``.
|
|
Examples
|
--------
|
>>> s = pd.Series(["caribou", "tiger"])
|
>>> s
|
0 caribou
|
1 tiger
|
dtype: object
|
|
>>> s.str.pad(width=10)
|
0 caribou
|
1 tiger
|
dtype: object
|
|
>>> s.str.pad(width=10, side='right', fillchar='-')
|
0 caribou---
|
1 tiger-----
|
dtype: object
|
|
>>> s.str.pad(width=10, side='both', fillchar='-')
|
0 -caribou--
|
1 --tiger---
|
dtype: object
|
z"fillchar must be a character, not rk z%fillchar must be a character, not strú#width must be of integer type, not rà ) rR ri Útyper< r2 rx r rC rD Z_str_padrE )r3 Úwidthr¸ rá r6 rG r9 r9 r: Úpadø s ;
|
zStringMethods.pada
|
Pad %(side)s side of strings in the Series/Index.
|
|
Equivalent to :meth:`str.%(method)s`.
|
|
Parameters
|
----------
|
width : int
|
Minimum width of resulting string; additional characters will be filled
|
with ``fillchar``.
|
fillchar : str
|
Additional character for filling, default is whitespace.
|
|
Returns
|
-------
|
Series/Index of objects.
|
Zstr_padzleft and rightÚcenter)r¸ r )rá c C s | j |d|dS )NZbothrà ©rå ©r3 rä rá r9 r9 r: ræ U s zStringMethods.centerÚrightÚljustc C s | j |d|dS )Nré rà rç rè r9 r9 r: rê Z s zStringMethods.ljustÚrjustc C s | j |d|dS )Nr rà rç rè r9 r9 r: rë _ s zStringMethods.rjustc sD t s dt j }t| fdd}| jj |¡}| |¡S )a2
|
Pad strings in the Series/Index by prepending '0' characters.
|
|
Strings in the Series/Index are padded with '0' characters on the
|
left of the string to reach a total string length `width`. Strings
|
in the Series/Index with length greater or equal to `width` are
|
unchanged.
|
|
Parameters
|
----------
|
width : int
|
Minimum length of resulting string; strings with length less
|
than `width` be prepended with '0' characters.
|
|
Returns
|
-------
|
Series/Index of objects.
|
|
See Also
|
--------
|
Series.str.rjust : Fills the left side of strings with an arbitrary
|
character.
|
Series.str.ljust : Fills the right side of strings with an arbitrary
|
character.
|
Series.str.pad : Fills the specified sides of strings with an arbitrary
|
character.
|
Series.str.center : Fills both sides of strings with an arbitrary
|
character.
|
|
Notes
|
-----
|
Differs from :meth:`str.zfill` which has special handling
|
for '+'/'-' in the string.
|
|
Examples
|
--------
|
>>> s = pd.Series(['-1', '1', '1000', 10, np.nan])
|
>>> s
|
0 -1
|
1 1
|
2 1000
|
3 10
|
4 NaN
|
dtype: object
|
|
Note that ``10`` and ``NaN`` are not strings, therefore they are
|
converted to ``NaN``. The minus sign in ``'-1'`` is treated as a
|
special character and the zero is added to the right of it
|
(:meth:`str.zfill` would have moved it to the left). ``1000``
|
remains unchanged as it is longer than `width`.
|
|
>>> s.str.zfill(3)
|
0 -01
|
1 001
|
2 1000
|
3 NaN
|
4 NaN
|
dtype: object
|
râ c s
|
| ¡S r` )Úzfillrs ©rä r9 r: Ú<lambda>¤ ó z%StringMethods.zfill.<locals>.<lambda>)r rã r< r2 rC rD Ú_str_maprE )r3 rä r6 ÚfrG r9 rí r: rì d s = zStringMethods.zfillc C s | j j |||¡}| |¡S )au
|
Slice substrings from each element in the Series or Index.
|
|
Parameters
|
----------
|
start : int, optional
|
Start position for slice operation.
|
stop : int, optional
|
Stop position for slice operation.
|
step : int, optional
|
Step size for slice operation.
|
|
Returns
|
-------
|
Series or Index of object
|
Series or Index from sliced substring from original string object.
|
|
See Also
|
--------
|
Series.str.slice_replace : Replace a slice with a string.
|
Series.str.get : Return element at position.
|
Equivalent to `Series.str.slice(start=i, stop=i+1)` with `i`
|
being the position.
|
|
Examples
|
--------
|
>>> s = pd.Series(["koala", "dog", "chameleon"])
|
>>> s
|
0 koala
|
1 dog
|
2 chameleon
|
dtype: object
|
|
>>> s.str.slice(start=1)
|
0 oala
|
1 og
|
2 hameleon
|
dtype: object
|
|
>>> s.str.slice(start=-1)
|
0 a
|
1 g
|
2 n
|
dtype: object
|
|
>>> s.str.slice(stop=2)
|
0 ko
|
1 do
|
2 ch
|
dtype: object
|
|
>>> s.str.slice(step=2)
|
0 kaa
|
1 dg
|
2 caeen
|
dtype: object
|
|
>>> s.str.slice(start=0, stop=5, step=3)
|
0 kl
|
1 d
|
2 cm
|
dtype: object
|
|
Equivalent behaviour to:
|
|
>>> s.str[0:5:3]
|
0 kl
|
1 d
|
2 cm
|
dtype: object
|
)rC rD Z
|
_str_slicerE )r3 ÚstartÚstopÚsteprG r9 r9 r: Úslice¨ s HzStringMethods.slicec C s | j j |||¡}| |¡S )añ
|
Replace a positional slice of a string with another value.
|
|
Parameters
|
----------
|
start : int, optional
|
Left index position to use for the slice. If not specified (None),
|
the slice is unbounded on the left, i.e. slice from the start
|
of the string.
|
stop : int, optional
|
Right index position to use for the slice. If not specified (None),
|
the slice is unbounded on the right, i.e. slice until the
|
end of the string.
|
repl : str, optional
|
String for replacement. If not specified (None), the sliced region
|
is replaced with an empty string.
|
|
Returns
|
-------
|
Series or Index
|
Same type as the original object.
|
|
See Also
|
--------
|
Series.str.slice : Just slicing without replacement.
|
|
Examples
|
--------
|
>>> s = pd.Series(['a', 'ab', 'abc', 'abdc', 'abcde'])
|
>>> s
|
0 a
|
1 ab
|
2 abc
|
3 abdc
|
4 abcde
|
dtype: object
|
|
Specify just `start`, meaning replace `start` until the end of the
|
string with `repl`.
|
|
>>> s.str.slice_replace(1, repl='X')
|
0 aX
|
1 aX
|
2 aX
|
3 aX
|
4 aX
|
dtype: object
|
|
Specify just `stop`, meaning the start of the string to `stop` is replaced
|
with `repl`, and the rest of the string is included.
|
|
>>> s.str.slice_replace(stop=2, repl='X')
|
0 X
|
1 X
|
2 Xc
|
3 Xdc
|
4 Xcde
|
dtype: object
|
|
Specify `start` and `stop`, meaning the slice from `start` to `stop` is
|
replaced with `repl`. Everything before or after `start` and `stop` is
|
included as is.
|
|
>>> s.str.slice_replace(start=1, stop=3, repl='X')
|
0 aX
|
1 aX
|
2 aX
|
3 aXc
|
4 aXde
|
dtype: object
|
)rC rD Z_str_slice_replacerE )r3 rò ró rÜ rG r9 r9 r: Ú slice_replaceó s IzStringMethods.slice_replaceÚstrict)Úerrorsc sL t krfdd}nt ¡ fdd}| jj}| |¡}| |¡S )aO
|
Decode character string in the Series/Index using indicated encoding.
|
|
Equivalent to :meth:`str.decode` in python2 and :meth:`bytes.decode` in
|
python3.
|
|
Parameters
|
----------
|
encoding : str
|
errors : str, optional
|
|
Returns
|
-------
|
Series or Index
|
c s | ¡S r` )Údecoders )Úencodingrø r9 r: rî R rï z&StringMethods.decode.<locals>.<lambda>c s | d S )Nr r9 rs )Údecoderrø r9 r: rî U rï )Ú_cpython_optimized_decodersÚcodecsÚ
|
getdecoderrC rD rð rE )r3 rú rø rñ ÚarrrG r9 )rû rú rø r: rù ? s
|
|
zStringMethods.decodec C s | j j ||¡}| j|ddS )a
|
Encode character string in the Series/Index using indicated encoding.
|
|
Equivalent to :meth:`str.encode`.
|
|
Parameters
|
----------
|
encoding : str
|
errors : str, optional
|
|
Returns
|
-------
|
Series/Index of objects
|
F©re )rC rD Z _str_encoderE )r3 rú rø rG r9 r9 r: Úencode[ s zStringMethods.encodeaR
|
Remove %(position)s characters.
|
|
Strip whitespaces (including newlines) or a set of specified characters
|
from each string in the Series/Index from %(side)s.
|
Replaces any non-strings in Series with NaNs.
|
Equivalent to :meth:`str.%(method)s`.
|
|
Parameters
|
----------
|
to_strip : str or None, default None
|
Specifying the set of characters to be removed.
|
All combinations of this set of characters will be stripped.
|
If None then whitespaces are removed.
|
|
Returns
|
-------
|
Series or Index of object
|
|
See Also
|
--------
|
Series.str.strip : Remove leading and trailing characters in Series/Index.
|
Series.str.lstrip : Remove leading characters in Series/Index.
|
Series.str.rstrip : Remove trailing characters in Series/Index.
|
|
Examples
|
--------
|
>>> s = pd.Series(['1. Ant. ', '2. Bee!\n', '3. Cat?\t', np.nan, 10, True])
|
>>> s
|
0 1. Ant.
|
1 2. Bee!\n
|
2 3. Cat?\t
|
3 NaN
|
4 10
|
5 True
|
dtype: object
|
|
>>> s.str.strip()
|
0 1. Ant.
|
1 2. Bee!
|
2 3. Cat?
|
3 NaN
|
4 NaN
|
5 NaN
|
dtype: object
|
|
>>> s.str.lstrip('123.')
|
0 Ant.
|
1 Bee!\n
|
2 Cat?\t
|
3 NaN
|
4 NaN
|
5 NaN
|
dtype: object
|
|
>>> s.str.rstrip('.!? \n\t')
|
0 1. Ant
|
1 2. Bee
|
2 3. Cat
|
3 NaN
|
4 NaN
|
5 NaN
|
dtype: object
|
|
>>> s.str.strip('123.!? \n\t')
|
0 Ant
|
1 Bee
|
2 Cat
|
3 NaN
|
4 NaN
|
5 NaN
|
dtype: object
|
Z str_stripzleft and right sidesÚstripzleading and trailing)r¸ r Úpositionc C s | j j |¡}| |¡S r` )rC rD Z
|
_str_striprE ©r3 Zto_striprG r9 r9 r: r º s
|
zStringMethods.stripz left sideÚlstripÚleadingc C s | j j |¡}| |¡S r` )rC rD Z _str_lstriprE r r9 r9 r: r Ç s zStringMethods.lstripz
|
right sideÚrstripZtrailingc C s | j j |¡}| |¡S r` )rC rD Z _str_rstriprE r r9 r9 r: r Ð s zStringMethods.rstripa
|
Remove a %(side)s from an object series.
|
|
If the %(side)s is not present, the original string will be returned.
|
|
Parameters
|
----------
|
%(side)s : str
|
Remove the %(side)s of the string.
|
|
Returns
|
-------
|
Series/Index: object
|
The Series or Index with given %(side)s removed.
|
|
See Also
|
--------
|
Series.str.remove%(other_side)s : Remove a %(other_side)s from an object series.
|
|
Examples
|
--------
|
>>> s = pd.Series(["str_foo", "str_bar", "no_prefix"])
|
>>> s
|
0 str_foo
|
1 str_bar
|
2 no_prefix
|
dtype: object
|
>>> s.str.removeprefix("str_")
|
0 foo
|
1 bar
|
2 no_prefix
|
dtype: object
|
|
>>> s = pd.Series(["foo_str", "bar_str", "no_suffix"])
|
>>> s
|
0 foo_str
|
1 bar_str
|
2 no_suffix
|
dtype: object
|
>>> s.str.removesuffix("_str")
|
0 foo
|
1 bar
|
2 no_suffix
|
dtype: object
|
Z str_removefixÚprefixÚsuffix)r¸ Z
|
other_sidec C s | j j |¡}| |¡S r` )rC rD Z_str_removeprefixrE )r3 r rG r9 r9 r: Ú removeprefix s zStringMethods.removeprefixc C s | j j |¡}| |¡S r` )rC rD Z_str_removesuffixrE )r3 r rG r9 r9 r: Ú removesuffix s zStringMethods.removesuffixc K s | j jj|f|}| |¡S )a
|
Wrap strings in Series/Index at specified line width.
|
|
This method has the same keyword parameters and defaults as
|
:class:`textwrap.TextWrapper`.
|
|
Parameters
|
----------
|
width : int
|
Maximum line width.
|
expand_tabs : bool, optional
|
If True, tab characters will be expanded to spaces (default: True).
|
replace_whitespace : bool, optional
|
If True, each whitespace character (as defined by string.whitespace)
|
remaining after tab expansion will be replaced by a single space
|
(default: True).
|
drop_whitespace : bool, optional
|
If True, whitespace that, after wrapping, happens to end up at the
|
beginning or end of a line is dropped (default: True).
|
break_long_words : bool, optional
|
If True, then words longer than width will be broken in order to ensure
|
that no lines are longer than width. If it is false, long words will
|
not be broken, and some lines may be longer than width (default: True).
|
break_on_hyphens : bool, optional
|
If True, wrapping will occur preferably on whitespace and right after
|
hyphens in compound words, as it is customary in English. If false,
|
only whitespaces will be considered as potentially good places for line
|
breaks, but you need to set break_long_words to false if you want truly
|
insecable words (default: True).
|
|
Returns
|
-------
|
Series or Index
|
|
Notes
|
-----
|
Internally, this method uses a :class:`textwrap.TextWrapper` instance with
|
default settings. To achieve behavior matching R's stringr library str_wrap
|
function, use the arguments:
|
|
- expand_tabs = False
|
- replace_whitespace = True
|
- drop_whitespace = True
|
- break_long_words = False
|
- break_on_hyphens = False
|
|
Examples
|
--------
|
>>> s = pd.Series(['line to be wrapped', 'another line to be wrapped'])
|
>>> s.str.wrap(12)
|
0 line to be\nwrapped
|
1 another line\nto be\nwrapped
|
dtype: object
|
)rC rD Z _str_wraprE )r3 rä r5 rG r9 r9 r: Úwrap s 8zStringMethods.wrapú|)r´ c C s$ | j j |¡\}}| j||dddS )aS
|
Return DataFrame of dummy/indicator variables for Series.
|
|
Each string in Series is split by sep and returned as a DataFrame
|
of dummy/indicator variables.
|
|
Parameters
|
----------
|
sep : str, default "|"
|
String to split on.
|
|
Returns
|
-------
|
DataFrame
|
Dummy variables corresponding to values of the Series.
|
|
See Also
|
--------
|
get_dummies : Convert categorical variable into dummy/indicator
|
variables.
|
|
Examples
|
--------
|
>>> pd.Series(['a|b', 'a', 'a|c']).str.get_dummies()
|
a b c
|
0 1 1 0
|
1 1 0 0
|
2 1 0 1
|
|
>>> pd.Series(['a|b', np.nan, 'a|c']).str.get_dummies()
|
a b c
|
0 1 1 0
|
1 0 0 0
|
2 1 0 1
|
TF)r) rd re )rC rD Z_str_get_dummiesrE )r3 r´ rG r) r9 r9 r: Ú get_dummiesT s 'üzStringMethods.get_dummiesc C s | j j |¡}| |¡S )a
|
Map all characters in the string through the given mapping table.
|
|
Equivalent to standard :meth:`str.translate`.
|
|
Parameters
|
----------
|
table : dict
|
Table is a mapping of Unicode ordinals to Unicode ordinals, strings, or
|
None. Unmapped characters are left untouched.
|
Characters mapped to None are deleted. :meth:`str.maketrans` is a
|
helper function for making translation tables.
|
|
Returns
|
-------
|
Series or Index
|
)rC rD Z_str_translaterE )r3 ÚtablerG r9 r9 r: Ú translate s zStringMethods.translate©rÍ c C s | j j ||¡}| j|ddS )aB
|
Count occurrences of pattern in each string of the Series/Index.
|
|
This function is used to count the number of times a particular regex
|
pattern is repeated in each of the string elements of the
|
:class:`~pandas.Series`.
|
|
Parameters
|
----------
|
pat : str
|
Valid regular expression.
|
flags : int, default 0, meaning no flags
|
Flags for the `re` module. For a complete list, `see here
|
<https://docs.python.org/3/howto/regex.html#compilation-flags>`_.
|
**kwargs
|
For compatibility with other string methods. Not used.
|
|
Returns
|
-------
|
Series or Index
|
Same type as the calling object containing the integer counts.
|
|
See Also
|
--------
|
re : Standard library module for regular expressions.
|
str.count : Standard library version, without regular expression support.
|
|
Notes
|
-----
|
Some characters need to be escaped when passing in `pat`.
|
eg. ``'$'`` has a special meaning in regex and must be escaped when
|
finding this literal character.
|
|
Examples
|
--------
|
>>> s = pd.Series(['A', 'B', 'Aaba', 'Baca', np.nan, 'CABA', 'cat'])
|
>>> s.str.count('a')
|
0 0.0
|
1 0.0
|
2 2.0
|
3 2.0
|
4 NaN
|
5 0.0
|
6 1.0
|
dtype: float64
|
|
Escape ``'$'`` to find the literal dollar sign.
|
|
>>> s = pd.Series(['$', 'B', 'Aab$', '$$ca', 'C$B$', 'cat'])
|
>>> s.str.count('\\$')
|
0 1
|
1 0
|
2 1
|
3 2
|
4 2
|
5 0
|
dtype: int64
|
|
This is also available on Index
|
|
>>> pd.Index(['A', 'A', 'Aaba', 'cat']).str.count('a')
|
Index([0, 0, 2, 1], dtype='int64')
|
Fr )rC rD Z
|
_str_countrE ©r3 r¼ rÍ rG r9 r9 r: Úcount s AzStringMethods.countzstr | tuple[str, ...]z Scalar | NonezSeries | Index)r¼ rÖ r* c C sF t |ttfs&dt|j }t|| jjj||d}| j |ddS )a|
|
Test if the start of each string element matches a pattern.
|
|
Equivalent to :meth:`str.startswith`.
|
|
Parameters
|
----------
|
pat : str or tuple[str, ...]
|
Character sequence or tuple of strings. Regular expressions are not
|
accepted.
|
na : object, default NaN
|
Object shown if element tested is not a string. The default depends
|
on dtype of the array. For object-dtype, ``numpy.nan`` is used.
|
For ``StringDtype``, ``pandas.NA`` is used.
|
|
Returns
|
-------
|
Series or Index of bool
|
A Series of booleans indicating whether the given pattern matches
|
the start of each string element.
|
|
See Also
|
--------
|
str.startswith : Python standard library string method.
|
Series.str.endswith : Same as startswith, but tests the end of string.
|
Series.str.contains : Tests if string element contains a pattern.
|
|
Examples
|
--------
|
>>> s = pd.Series(['bat', 'Bear', 'cat', np.nan])
|
>>> s
|
0 bat
|
1 Bear
|
2 cat
|
3 NaN
|
dtype: object
|
|
>>> s.str.startswith('b')
|
0 True
|
1 False
|
2 False
|
3 NaN
|
dtype: object
|
|
>>> s.str.startswith(('b', 'B'))
|
0 True
|
1 True
|
2 False
|
3 NaN
|
dtype: object
|
|
Specifying `na` to be `False` instead of `NaN`.
|
|
>>> s.str.startswith('b', na=False)
|
0 True
|
1 False
|
2 False
|
3 False
|
dtype: bool
|
ú expected a string or tuple, not ©rÖ Fr )
|
rR ri Útuplerã r< r2 rC rD Z_str_startswithrE ©r3 r¼ rÖ r6 rG r9 r9 r: Ú
|
startswithÝ s
|
@zStringMethods.startswithc C sF t |ttfs&dt|j }t|| jjj||d}| j |ddS )ap
|
Test if the end of each string element matches a pattern.
|
|
Equivalent to :meth:`str.endswith`.
|
|
Parameters
|
----------
|
pat : str or tuple[str, ...]
|
Character sequence or tuple of strings. Regular expressions are not
|
accepted.
|
na : object, default NaN
|
Object shown if element tested is not a string. The default depends
|
on dtype of the array. For object-dtype, ``numpy.nan`` is used.
|
For ``StringDtype``, ``pandas.NA`` is used.
|
|
Returns
|
-------
|
Series or Index of bool
|
A Series of booleans indicating whether the given pattern matches
|
the end of each string element.
|
|
See Also
|
--------
|
str.endswith : Python standard library string method.
|
Series.str.startswith : Same as endswith, but tests the start of string.
|
Series.str.contains : Tests if string element contains a pattern.
|
|
Examples
|
--------
|
>>> s = pd.Series(['bat', 'bear', 'caT', np.nan])
|
>>> s
|
0 bat
|
1 bear
|
2 caT
|
3 NaN
|
dtype: object
|
|
>>> s.str.endswith('t')
|
0 True
|
1 False
|
2 False
|
3 NaN
|
dtype: object
|
|
>>> s.str.endswith(('t', 'T'))
|
0 True
|
1 False
|
2 True
|
3 NaN
|
dtype: object
|
|
Specifying `na` to be `False` instead of `NaN`.
|
|
>>> s.str.endswith('t', na=False)
|
0 True
|
1 False
|
2 False
|
3 False
|
dtype: bool
|
r r Fr )
|
rR ri r rã r< r2 rC rD Z _str_endswithrE r r9 r9 r: Úendswith# s
|
@zStringMethods.endswithc C s | j j ||¡}| j|ddS )aP
|
|
Find all occurrences of pattern or regular expression in the Series/Index.
|
|
Equivalent to applying :func:`re.findall` to all the elements in the
|
Series/Index.
|
|
Parameters
|
----------
|
pat : str
|
Pattern or regular expression.
|
flags : int, default 0
|
Flags from ``re`` module, e.g. `re.IGNORECASE` (default is 0, which
|
means no flags).
|
|
Returns
|
-------
|
Series/Index of lists of strings
|
All non-overlapping matches of pattern or regular expression in each
|
string of this Series/Index.
|
|
See Also
|
--------
|
count : Count occurrences of pattern or regular expression in each string
|
of the Series/Index.
|
extractall : For each string in the Series, extract groups from all matches
|
of regular expression and return a DataFrame with one row for each
|
match and one column for each group.
|
re.findall : The equivalent ``re`` function to all non-overlapping matches
|
of pattern or regular expression in string, as a list of strings.
|
|
Examples
|
--------
|
>>> s = pd.Series(['Lion', 'Monkey', 'Rabbit'])
|
|
The search for the pattern 'Monkey' returns one match:
|
|
>>> s.str.findall('Monkey')
|
0 []
|
1 [Monkey]
|
2 []
|
dtype: object
|
|
On the other hand, the search for the pattern 'MONKEY' doesn't return any
|
match:
|
|
>>> s.str.findall('MONKEY')
|
0 []
|
1 []
|
2 []
|
dtype: object
|
|
Flags can be added to the pattern or regular expression. For instance,
|
to find the pattern 'MONKEY' ignoring the case:
|
|
>>> import re
|
>>> s.str.findall('MONKEY', flags=re.IGNORECASE)
|
0 []
|
1 [Monkey]
|
2 []
|
dtype: object
|
|
When the pattern matches more than one string in the Series, all matches
|
are returned:
|
|
>>> s.str.findall('on')
|
0 [on]
|
1 [on]
|
2 []
|
dtype: object
|
|
Regular expressions are supported too. For instance, the search for all the
|
strings ending with the word 'on' is shown next:
|
|
>>> s.str.findall('on$')
|
0 [on]
|
1 []
|
2 []
|
dtype: object
|
|
If the pattern is found more than once in the same string, then a list of
|
multiple strings is returned:
|
|
>>> s.str.findall('b')
|
0 []
|
1 []
|
2 [b, b]
|
dtype: object
|
Fr )rC rD Z _str_findallrE r r9 r9 r: Úfindalli s ZzStringMethods.findallzDataFrame | Series | Index)r¼ rÍ rd r* c C s ddl m} t|ts tdtj||d}|jdkr>td|s`|jdkr`t| jt r`td| j}t
|
|}|jdkpz|}|râd} t |}
|
|j j dkr¦||
|
|d } qþ| jj j|||d
|
} t|trÌ|j} nd} || |
|
| |d } n t|} | jj j|||d
|
} | j| | d S ) a)
|
|
Extract capture groups in the regex `pat` as columns in a DataFrame.
|
|
For each subject string in the Series, extract groups from the
|
first match of regular expression `pat`.
|
|
Parameters
|
----------
|
pat : str
|
Regular expression pattern with capturing groups.
|
flags : int, default 0 (no flags)
|
Flags from the ``re`` module, e.g. ``re.IGNORECASE``, that
|
modify regular expression matching for things like case,
|
spaces, etc. For more details, see :mod:`re`.
|
expand : bool, default True
|
If True, return DataFrame with one column per capture group.
|
If False, return a Series/Index if there is one capture group
|
or DataFrame if there are multiple capture groups.
|
|
Returns
|
-------
|
DataFrame or Series or Index
|
A DataFrame with one row for each subject string, and one
|
column for each group. Any capture group names in regular
|
expression pat will be used for column names; otherwise
|
capture group numbers will be used. The dtype of each result
|
column is always object, even when no match is found. If
|
``expand=False`` and pat has only one capture group, then
|
return a Series (if subject is a Series) or Index (if subject
|
is an Index).
|
|
See Also
|
--------
|
extractall : Returns all matches (not just the first match).
|
|
Examples
|
--------
|
A pattern with two groups will return a DataFrame with two columns.
|
Non-matches will be NaN.
|
|
>>> s = pd.Series(['a1', 'b2', 'c3'])
|
>>> s.str.extract(r'([ab])(\d)')
|
0 1
|
0 a 1
|
1 b 2
|
2 NaN NaN
|
|
A pattern may contain optional groups.
|
|
>>> s.str.extract(r'([ab])?(\d)')
|
0 1
|
0 a 1
|
1 b 2
|
2 NaN 3
|
|
Named groups will become column names in the result.
|
|
>>> s.str.extract(r'(?P<letter>[ab])(?P<digit>\d)')
|
letter digit
|
0 a 1
|
1 b 2
|
2 NaN NaN
|
|
A pattern with one group will return a DataFrame with one column
|
if expand=True.
|
|
>>> s.str.extract(r'[ab](\d)', expand=True)
|
0
|
0 1
|
1 2
|
2 NaN
|
|
A pattern with one group will return a Series if expand=False.
|
|
>>> s.str.extract(r'[ab](\d)', expand=False)
|
0 1
|
1 2
|
2 NaN
|
dtype: object
|
r )r r} r ú"pattern contains no capture groupsrk z,only one regex group is supported with IndexN)r rQ )rÍ rd r rA )r r rR rc r rÐ rÑ rÒ rC r Ú _result_dtypeÚ_get_group_namesrD ÚsizeZ _str_extractr rV Ú_get_single_group_namerE )r3 r¼ rÍ rd r r» ÚobjZ result_dtypeZ
|
returns_dfr) r rG Z result_listZ result_indexr9 r9 r: ÚextractÆ sB T
|
|
ÿ
|
ÿzStringMethods.extractc C s t | j||S )aü
|
Extract capture groups in the regex `pat` as columns in DataFrame.
|
|
For each subject string in the Series, extract groups from all
|
matches of regular expression pat. When each subject string in the
|
Series has exactly one match, extractall(pat).xs(0, level='match')
|
is the same as extract(pat).
|
|
Parameters
|
----------
|
pat : str
|
Regular expression pattern with capturing groups.
|
flags : int, default 0 (no flags)
|
A ``re`` module flag, for example ``re.IGNORECASE``. These allow
|
to modify regular expression matching for things like case, spaces,
|
etc. Multiple flags can be combined with the bitwise OR operator,
|
for example ``re.IGNORECASE | re.MULTILINE``.
|
|
Returns
|
-------
|
DataFrame
|
A ``DataFrame`` with one row for each match, and one column for each
|
group. Its rows have a ``MultiIndex`` with first levels that come from
|
the subject ``Series``. The last level is named 'match' and indexes the
|
matches in each item of the ``Series``. Any capture group names in
|
regular expression pat will be used for column names; otherwise capture
|
group numbers will be used.
|
|
See Also
|
--------
|
extract : Returns first match only (not all matches).
|
|
Examples
|
--------
|
A pattern with one group will return a DataFrame with one column.
|
Indices with no matches will not appear in the result.
|
|
>>> s = pd.Series(["a1a2", "b1", "c1"], index=["A", "B", "C"])
|
>>> s.str.extractall(r"[ab](\d)")
|
0
|
match
|
A 0 1
|
1 2
|
B 0 1
|
|
Capture group names are used for column names of the result.
|
|
>>> s.str.extractall(r"[ab](?P<digit>\d)")
|
digit
|
match
|
A 0 1
|
1 2
|
B 0 1
|
|
A pattern with two groups will return a DataFrame with two columns.
|
|
>>> s.str.extractall(r"(?P<letter>[ab])(?P<digit>\d)")
|
letter digit
|
match
|
A 0 a 1
|
1 a 2
|
B 0 b 1
|
|
Optional groups that do not match are NaN in the result.
|
|
>>> s.str.extractall(r"(?P<letter>[ab])?(?P<digit>\d)")
|
letter digit
|
match
|
A 0 a 1
|
1 a 2
|
B 0 b 1
|
C 0 NaN 1
|
)Ústr_extractallrY )r3 r¼ rÍ r9 r9 r: Ú
|
extractallF
|
s LzStringMethods.extractalla
|
Return %(side)s indexes in each strings in the Series/Index.
|
|
Each of returned indexes corresponds to the position where the
|
substring is fully contained between [start:end]. Return -1 on
|
failure. Equivalent to standard :meth:`str.%(method)s`.
|
|
Parameters
|
----------
|
sub : str
|
Substring being searched.
|
start : int
|
Left edge index.
|
end : int
|
Right edge index.
|
|
Returns
|
-------
|
Series or Index of int.
|
|
See Also
|
--------
|
%(also)s
|
ÚfindZlowestz/rfind : Return highest indexes in each strings.)r¸ r r )rò c C sB t |ts"dt|j }t|| jj |||¡}| j|ddS )Nú expected a string object, not Fr ) rR ri rã r< r2 rC rD Z _str_findrE ©r3 Úsubrò r¾ r6 rG r9 r9 r: r$ ¯
|
s
|
|
|
zStringMethods.findZhighestÚrfindz-find : Return lowest indexes in each strings.c C sD t |ts"dt|j }t|| jjj|||d}| j|ddS ©Nr% )rò r¾ Fr ) rR ri rã r< r2 rC rD Z
|
_str_rfindrE r& r9 r9 r: r( À
|
s
|
|
|
zStringMethods.rfindc C s | j j |¡}| |¡S )a`
|
Return the Unicode normal form for the strings in the Series/Index.
|
|
For more information on the forms, see the
|
:func:`unicodedata.normalize`.
|
|
Parameters
|
----------
|
form : {'NFC', 'NFKC', 'NFD', 'NFKD'}
|
Unicode form.
|
|
Returns
|
-------
|
Series/Index of objects
|
)rC rD Z_str_normalizerE )r3 ÚformrG r9 r9 r: Ú normalizeÑ
|
s zStringMethods.normalizeau
|
Return %(side)s indexes in each string in Series/Index.
|
|
Each of the returned indexes corresponds to the position where the
|
substring is fully contained between [start:end]. This is the same
|
as ``str.%(similar)s`` except instead of returning -1, it raises a
|
ValueError when the substring is not found. Equivalent to standard
|
``str.%(method)s``.
|
|
Parameters
|
----------
|
sub : str
|
Substring being searched.
|
start : int
|
Left edge index.
|
end : int
|
Right edge index.
|
|
Returns
|
-------
|
Series or Index of object
|
|
See Also
|
--------
|
%(also)s
|
rV z0rindex : Return highest indexes in each strings.)r¸ Zsimilarr r c C sD t |ts"dt|j }t|| jjj|||d}| j|ddS r) ) rR ri rã r< r2 rC rD Z
|
_str_indexrE r& r9 r9 r: rV s
|
|
zStringMethods.indexÚrindexz.index : Return lowest indexes in each strings.c C sD t |ts"dt|j }t|| jjj|||d}| j|ddS r) ) rR ri rã r< r2 rC rD Z _str_rindexrE r& r9 r9 r: r, s
|
|
zStringMethods.rindexc C s | j j ¡ }| j|ddS )a
|
Compute the length of each element in the Series/Index.
|
|
The element may be a sequence (such as a string, tuple or list) or a collection
|
(such as a dictionary).
|
|
Returns
|
-------
|
Series or Index of int
|
A Series or Index of integer values indicating the length of each
|
element in the Series or Index.
|
|
See Also
|
--------
|
str.len : Python built-in function returning the length of an object.
|
Series.size : Returns the length of the Series.
|
|
Examples
|
--------
|
Returns the length (number of characters) in a string. Returns the
|
number of entries for dictionaries, lists or tuples.
|
|
>>> s = pd.Series(['dog',
|
... '',
|
... 5,
|
... {'foo' : 'bar'},
|
... [2, 3, 5, 7],
|
... ('one', 'two', 'three')])
|
>>> s
|
0 dog
|
1
|
2 5
|
3 {'foo': 'bar'}
|
4 [2, 3, 5, 7]
|
5 (one, two, three)
|
dtype: object
|
>>> s.str.len()
|
0 3.0
|
1 0.0
|
2 NaN
|
3 1.0
|
4 4.0
|
5 3.0
|
dtype: float64
|
Fr )rC rD Z_str_lenrE rF r9 r9 r: rx & s . zStringMethods.lena³
|
Convert strings in the Series/Index to %(type)s.
|
%(version)s
|
Equivalent to :meth:`str.%(method)s`.
|
|
Returns
|
-------
|
Series or Index of object
|
|
See Also
|
--------
|
Series.str.lower : Converts all characters to lowercase.
|
Series.str.upper : Converts all characters to uppercase.
|
Series.str.title : Converts first character of each word to uppercase and
|
remaining to lowercase.
|
Series.str.capitalize : Converts first character to uppercase and
|
remaining to lowercase.
|
Series.str.swapcase : Converts uppercase to lowercase and lowercase to
|
uppercase.
|
Series.str.casefold: Removes all case distinctions in the string.
|
|
Examples
|
--------
|
>>> s = pd.Series(['lower', 'CAPITALS', 'this is a sentence', 'SwApCaSe'])
|
>>> s
|
0 lower
|
1 CAPITALS
|
2 this is a sentence
|
3 SwApCaSe
|
dtype: object
|
|
>>> s.str.lower()
|
0 lower
|
1 capitals
|
2 this is a sentence
|
3 swapcase
|
dtype: object
|
|
>>> s.str.upper()
|
0 LOWER
|
1 CAPITALS
|
2 THIS IS A SENTENCE
|
3 SWAPCASE
|
dtype: object
|
|
>>> s.str.title()
|
0 Lower
|
1 Capitals
|
2 This Is A Sentence
|
3 Swapcase
|
dtype: object
|
|
>>> s.str.capitalize()
|
0 Lower
|
1 Capitals
|
2 This is a sentence
|
3 Swapcase
|
dtype: object
|
|
>>> s.str.swapcase()
|
0 LOWER
|
1 capitals
|
2 THIS IS A SENTENCE
|
3 sWaPcAsE
|
dtype: object
|
Z casemethodszdict[str, dict[str, str]]Ú _doc_argsZ lowercaseÚlower)rã r ÚversionZ uppercaseÚupperZ titlecaseÚtitlezbe capitalizedÚ
|
capitalizez be swapcasedÚswapcasez be casefoldedÚcasefoldc C s | j j ¡ }| |¡S r` )rC rD Z
|
_str_lowerrE rF r9 r9 r: r. µ s zStringMethods.lowerc C s | j j ¡ }| |¡S r` )rC rD Z
|
_str_upperrE rF r9 r9 r: r0 » s zStringMethods.upperc C s | j j ¡ }| |¡S r` )rC rD Z
|
_str_titlerE rF r9 r9 r: r1 Á s zStringMethods.titlec C s | j j ¡ }| |¡S r` )rC rD Z_str_capitalizerE rF r9 r9 r: r2 Ç s zStringMethods.capitalizec C s | j j ¡ }| |¡S r` )rC rD Z _str_swapcaserE rF r9 r9 r: r3 Í s zStringMethods.swapcasec C s | j j ¡ }| |¡S r` )rC rD Z _str_casefoldrE rF r9 r9 r: r4 Ó s zStringMethods.casefolduï
|
Check whether all characters in each string are %(type)s.
|
|
This is equivalent to running the Python string method
|
:meth:`str.%(method)s` for each element of the Series/Index. If a string
|
has zero characters, ``False`` is returned for that check.
|
|
Returns
|
-------
|
Series or Index of bool
|
Series or Index of boolean values with the same length as the original
|
Series/Index.
|
|
See Also
|
--------
|
Series.str.isalpha : Check whether all characters are alphabetic.
|
Series.str.isnumeric : Check whether all characters are numeric.
|
Series.str.isalnum : Check whether all characters are alphanumeric.
|
Series.str.isdigit : Check whether all characters are digits.
|
Series.str.isdecimal : Check whether all characters are decimal.
|
Series.str.isspace : Check whether all characters are whitespace.
|
Series.str.islower : Check whether all characters are lowercase.
|
Series.str.isupper : Check whether all characters are uppercase.
|
Series.str.istitle : Check whether all characters are titlecase.
|
|
Examples
|
--------
|
**Checks for Alphabetic and Numeric Characters**
|
|
>>> s1 = pd.Series(['one', 'one1', '1', ''])
|
|
>>> s1.str.isalpha()
|
0 True
|
1 False
|
2 False
|
3 False
|
dtype: bool
|
|
>>> s1.str.isnumeric()
|
0 False
|
1 False
|
2 True
|
3 False
|
dtype: bool
|
|
>>> s1.str.isalnum()
|
0 True
|
1 True
|
2 True
|
3 False
|
dtype: bool
|
|
Note that checks against characters mixed with any additional punctuation
|
or whitespace will evaluate to false for an alphanumeric check.
|
|
>>> s2 = pd.Series(['A B', '1.5', '3,000'])
|
>>> s2.str.isalnum()
|
0 False
|
1 False
|
2 False
|
dtype: bool
|
|
**More Detailed Checks for Numeric Characters**
|
|
There are several different but overlapping sets of numeric characters that
|
can be checked for.
|
|
>>> s3 = pd.Series(['23', '³', 'â
', ''])
|
|
The ``s3.str.isdecimal`` method checks for characters used to form numbers
|
in base 10.
|
|
>>> s3.str.isdecimal()
|
0 True
|
1 False
|
2 False
|
3 False
|
dtype: bool
|
|
The ``s.str.isdigit`` method is the same as ``s3.str.isdecimal`` but also
|
includes special digits, like superscripted and subscripted digits in
|
unicode.
|
|
>>> s3.str.isdigit()
|
0 True
|
1 True
|
2 False
|
3 False
|
dtype: bool
|
|
The ``s.str.isnumeric`` method is the same as ``s3.str.isdigit`` but also
|
includes other characters that can represent quantities such as unicode
|
fractions.
|
|
>>> s3.str.isnumeric()
|
0 True
|
1 True
|
2 True
|
3 False
|
dtype: bool
|
|
**Checks for Whitespace**
|
|
>>> s4 = pd.Series([' ', '\t\r\n ', ''])
|
>>> s4.str.isspace()
|
0 True
|
1 True
|
2 False
|
dtype: bool
|
|
**Checks for Character Case**
|
|
>>> s5 = pd.Series(['leopard', 'Golden Eagle', 'SNAKE', ''])
|
|
>>> s5.str.islower()
|
0 True
|
1 False
|
2 False
|
3 False
|
dtype: bool
|
|
>>> s5.str.isupper()
|
0 False
|
1 False
|
2 True
|
3 False
|
dtype: bool
|
|
The ``s5.str.istitle`` method checks for whether all words are in title
|
case (whether only the first letter of each word is capitalized). Words are
|
assumed to be as any sequence of non-numeric characters separated by
|
whitespace characters.
|
|
>>> s5.str.istitle()
|
0 False
|
1 True
|
2 False
|
3 False
|
dtype: bool
|
Z ismethodsZ alphanumericÚisalnum)rã r Z
|
alphabeticÚisalphaÚdigitsÚisdigitÚ
|
whitespaceÚisspaceÚislowerÚisupperÚistitleÚnumericÚ isnumericÚdecimalÚ isdecimal)rI )NNNr )N)N)rà T)rà T)Tr NT)Tr N)Tr N)r¹ Nr F)r rà )rà )rà )rà )NNN)NNN)r÷ )r÷ )N)N)N)r )r )N)N)r )r T)r )r N)r N)r N)r N)Jr< Ú
|
__module__Ú __qualname__rH r[ Ú staticmethodrP rb rz r{ rE r r@ r¶ r# r r· r¿ rÆ rÈ rÊ r r× rÚ rÛ rÞ rß rå ræ rê rë rì rõ rö rù r r r r r
|
r r r r r r r r r! r# r$ r( r+ rV r, rx r- Ú__annotations__r. r0 r1 r2 r3 r4 rJ r5 r6 r8 r: r; r< r= r? rA r9 r9 r9 r: rK s
|
|
(ù< û hþÿ| æÿÿF þúøÿÿ þÿRüÿÿ üÿÿ ?
|
A ÿ
|
ù
|
+ üJþÿ
|
C KK þÿLýÿÿ
|
ÿÿ
|
ÿÿþÿ0ÿ ÿ
|
:.
|
CÿEÿE\ ÿOþÿýÿÿýÿÿ
|
þÿ üÿÿ üÿÿ 3þÿJ ý
|
ý
|
ý
|
þÿ ÿ ÿ ÿ ÿ ÿ ÿ ÿ ÿ ÿrK r ri )Úlist_of_columnsr´ c C sX zt | |}W nD tk
|
rR | D ]*}tj|dd}|dkr"td| dq"Y nX |S )a"
|
Auxiliary function for :meth:`str.cat`.
|
|
Same signature as cat_core, but handles TypeErrors in concatenation, which
|
happen if the arrays in list_of columns have the wrong dtypes or content.
|
|
Parameters
|
----------
|
list_of_columns : list of numpy arrays
|
List of arrays to be concatenated with sep;
|
these arrays may not contain NaNs!
|
sep : string
|
The separator string for concatenating the columns.
|
|
Returns
|
-------
|
nd.array
|
The concatenation of list_of_columns with sep.
|
Tr\ )r+ r, zpConcatenation requires list-likes containing only strings (or missing values). Offending values found in column N)Úcat_corer2 r r^ )rF r´ rG ÚcolumnrQ r9 r9 r: r³ s ÿü
|
r³ c C sd |dkr$t j| td}t j|ddS |gdt| d }| |ddd
< t j|td}t j|ddS )a
|
Auxiliary function for :meth:`str.cat`
|
|
Parameters
|
----------
|
list_of_columns : list of numpy arrays
|
List of arrays to be concatenated with sep;
|
these arrays may not contain NaNs!
|
sep : string
|
The separator string for concatenating the columns.
|
|
Returns
|
-------
|
nd.array
|
The concatenation of list_of_columns with sep.
|
r¡ rª r r© r rk N)rz Zasarrayr² Úsumrx )rF r´ Z arr_of_colsZ list_with_sepZ arr_with_sepr9 r9 r: rG ³ s rG c C s& ddl m} t| j|r | jS tS d S rM )rO rN rR rQ r² )rÿ rN r9 r9 r: r Î s r z
|
re.Patternr )r» r* c C s | j rtt| j S d S d S r` )Ú
|
groupindexÚnextÚiter©r» r9 r9 r: r Ú s r zlist[Hashable]c s, dd | j ¡ D fddt| jD S )z¾
|
Get named groups from compiled regex.
|
|
Unnamed groups are numbered.
|
|
Parameters
|
----------
|
regex : compiled regex
|
|
Returns
|
-------
|
list of column labels
|
c S s i | ]\}}||qS r9 r9 )rm ÚkÚvr9 r9 r: rq ï s z$_get_group_names.<locals>.<dictcomp>c s g | ]} d | |¡qS )rk )rÊ )rm rÉ r~ r9 r: rw ð s z$_get_group_names.<locals>.<listcomp>)rJ Úitemsr rÒ rM r9 r~ r: r á s r rË r c C s t j||d}|jdkr tdt| tr:| ¡ jdd} t|}g }g }| j j
|
dk}| ¡ D ]t\}} t| t r^|sz|f}t | | ¡D ]H\}
|
} t| t r | f} dd | D } | | ¡ t||
|
f } | | ¡ qq^dd lm} |j|| j jd
|
g d }t| }| j||||d }|S ) Nr r r T)Zdroprk c S s g | ]}|d krt jn|qS )r¡ )rz ÚNaN)rm Úgroupr9 r9 r: rw s z"str_extractall.<locals>.<listcomp>)rg rÚ r~ )rV r rQ )rÐ rÑ rÒ r rR r Z to_seriesZ reset_indexr rV r rP ri Ú enumerater Úappendr r rg r r r r )rÿ r¼ rÍ r» r Z
|
match_listZ
|
index_listZis_miZ subject_keyÚsubjectZmatch_iZ match_tupleZna_tupleZ
|
result_keyrg rV rQ rG r9 r9 r: r" ó s<
|
|
|
|
|
ÿr" )N)r )@Ú
|
__future__r rý Ú functoolsr rÐ Útypingr r r r r rÓ Únumpyrz Z pandas._libsr Zpandas._typingr
|
r r r Zpandas.util._decoratorsr Zpandas.util._exceptionsr Zpandas.core.dtypes.commonr r r r r r r Zpandas.core.dtypes.genericr r r r Zpandas.core.dtypes.missingr Z pandas.core.arrays.arrow.dtyper Zpandas.core.baser Zpandas.core.constructionr r r r! r" r# rE Z_cpython_optimized_encodersrü r@ rJ rK r³ rG r r r r" r9 r9 r9 r: Ú<module> sp $ ÿE
|
$
|
