| Server IP : 209.209.40.120 / Your IP : 216.73.217.112 Web Server : Microsoft-IIS/10.0 System : Windows NT NEWWWW 10.0 build 17763 (Windows Server 2019) i586 User : NEWWWW$ ( 0) PHP Version : 8.3.30 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/Python312/Lib/site-packages/pandas/core/strings/__pycache__/ |
Upload File : |
�
. �g�� � � � U d dl mZ d dlZd dlmZ d dlZd dlmZmZm Z m
Z
d dl Z d dl Z
d dlmZ d dlmZmZmZmZmZ d dlmZ d dlmZ d d lmZm Z m Z m Z m Z m Z d d
l!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 dl-m.Z. d dl/m0Z0 erd dl1m2Z2m3Z3 d dl4m5Z5m6Z6m7Z7 i Z8de9d< dZ:e:dz Z; d d!d�Z<d"d�Z= G d� de.� Z>d#d�Z?d$d�Z@d � ZAd%d �ZBd&d �ZCd'd(d �ZDy))� )� annotationsN)�wraps)�
TYPE_CHECKING�Callable�Literal�cast)�lib)� AlignJoin�DtypeObj�F�Scalar�npt)�Appender)�find_stack_level)�
ensure_object�
is_bool_dtype�
is_integer� is_list_like�is_object_dtype�is_re)�
ArrowDtype�CategoricalDtype)� ABCDataFrame�ABCIndex�
ABCMultiIndex� ABCSeries)�isna)�ExtensionArray)�NoNewAttributesMixin)�
extract_array)�Hashable�Iterator)� DataFrame�Index�Serieszdict[str, str]� _shared_docs)zutf-8�utf8zlatin-1�latin1z
iso-8859-1�mbcs�ascii)zutf-16zutf-32c �D ��� | �g n| } h d�t | � z
�d��fd� }|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`.
> �bytes�empty�mixed�string�
mixed-integerc � �� �� �� � j n��t � � �� �fd�� }�|_ t t |� S )Nc �t �� | j �vr d�� d| j � d�}t |� � �| g|��i |��S )NzCannot use .str.z with values of inferred dtype 'z'.)�_inferred_dtype� TypeError)�self�args�kwargs�msg�
allowed_types�func� func_names ����>C:\Python312\Lib\site-packages\pandas/core/strings/accessor.py�wrapperzHforbid_nonstring_types.<locals>._forbid_nonstring_types.<locals>.wrapper� sW �� ��#�#�=�8�&�y�k� 2'�'+�';�';�&<�B�@� � ��n�$���.�t�.�v�.� .� )�__name__r r r )r: r= r; r9 �names ` @��r< �_forbid_nonstring_typesz7forbid_nonstring_types.<locals>._forbid_nonstring_types~ s? �� �%)�\�D�M�M�t� � �t�� /�
� /� %����A�w� � r> )r: r �returnr )�set)� forbiddenr@ rA r9 s ` @r< �forbid_nonstring_typesrE L s4 �� �X �'��Y�I�J�S��N� �M� � #�"r> c �B � � t dg� �� � fd�� }||_ |S )Nr, �r@ c �~ �� t | j j d�� �� � }| j |�dv�� S )N�_str_)� isnumeric� isdecimal��returns_string)�getattr�_data�array� _wrap_result)r5 �resultr@ s �r< r= z _map_and_wrap.<locals>.wrapper� sG �� �:�����)�)�U�4�&�>�:�<��� � � �4�/I�#I� !�
�
r> )rE �__doc__)r@ � docstringr= s ` r< �
_map_and_wraprU � s, �� ��W�I�D�1�
� 2�
� �G�O� �Nr> c � � e Zd ZU dZd�d�Zed� � Zd� Zd�d�Zdde j dddf d�d �Z d
� Z e
g d �� d� d�d
�� Zded< eed ddddddddd�z � e
dg� d�dddd� d�d �� � Z eed d d d d d d d d d�z � e
dg� d�ddd!�d�d"�� � Zd#ed$< eed$ d%d&d'd(�z � e
dg� d�d�d)�� � Z eed$ d*d+d,d(�z � e
dg� d�d�d-�� � Zd.� Z e
dg� d�d/�� Z e
dg� d� d�d0�� Z e
dg� d�d�d1�� Z e
dg� d�d�d2�� Z e
dg� d� d�d3�� Z e
dg� d4� � Z e
dg� d� d�d5�� Z d6ed7< eed7 d8d9d:�z � e
dg� d�d�d;�� � Z eed7 d<d=d:�z � e
dg� d�d�d>�� � Z eed7 d d?d:�z � e
dg� d�d�d@�� � Z e
dg� d�dA�� Z d�dB�Z! e
dg� d�dC�� Z"d�d�dD�Z# e
dg� d�d�dE�� Z$dFedG< eedG dHdIdJdK�z � e
dg� d�dL�� � Z% eedG dMdNdOdK�z � e
dg� d�dP�� � Z& eedG dQdRdSdK�z � e
dg� d�dT�� � Z'dUedV< eedV dWdXdY�z � e
dg� d�dZ�� � Z( eedV dXdWdY�z � e
dg� d�d[�� � Z) e
dg� d�d\�� Z* e
dg� d�d�d]�� Z+ e
dg� d^� � Z, e
dg� d�d�d_�� Z- e
dg� d� d�d`�� Z. e
dg� d� d�da�� Z/ e
dg� d�d�db�� Z0 e
dg� d� d�dc�� Z1 e
dg� d�d�dd�� Z2deedf< eedf dgdfdhdi�z � e
dg� d�d�dj�� � Z3 eedf dkdldmdi�z � e
dg� d�d�dn�� � Z4 e
dg� do� � Z5dpedq< eedq dgdfdqdrds�z � e
dg� d�d�dt�� � Z6 eedq dkdldudvds�z � e
dg� d�d�dw�� � Z7dx� Z8dyedz< i Z9d{e:d|< d}d~d d�e9d~< d�d�d d�e9d�< d�d�d d�e9d�< d�d�d d�e9d�< d�d�d d�e9d�< d�d�d d�e9d�< eedz e9d~ z � e
dg� d�� � � Z; eedz e9d� z � e
dg� d�� � � Z< eedz e9d� z � e
dg� d�� � � Z= eedz e9d� z � e
dg� d�� � � Z> eedz e9d� z � e
dg� d�� � � Z? eedz e9d� z � e
dg� d�� � � Z@d�ed�< d�d�d��e9d�< d�d�d��e9d�< d�d�d��e9d�< d�d�d��e9d�< d}d�d��e9d�< d�d�d��e9d�< d�d�d��e9d�< d�d�d��e9d�< d�d�d��e9d�< eAd�ed� e9d� z ��� ZB eAd�ed� e9d� z ��� ZC eAd�ed� e9d� z ��� ZD eAd�ed� e9d� z ��� ZE eAd�ed� e9d� z ��� ZF eAd�ed� e9d� z ��� ZG eAd�ed� e9d� z ��� ZH eAd�ed� e9d� z ��� ZI eAd�ed� e9d� z ��� ZJy)��
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
c � � ddl m} | j |� | _ t |j
t � | _ t |j
|� | _ || _ d x| _
| _ t |t � r"|j | _
|j | _ | j r|j j n|| _ || _ | j' � y �Nr )� StringDtype)�pandas.core.arrays.string_rZ � _validater3 �
isinstance�dtyper �_is_categorical�
_is_stringrO �_index�_namer �indexr@ �_values�
categories�_parent�_orig�_freeze)r5 �datarZ s r< �__init__zStringMethods.__init__� s� � �:� #�~�~�d� 3�� � )�$�*�*�6F� G�� �$�T�Z�Z��=�����
�#'�'�� �d�j� �d�I� &� �*�*�D�K� ���D�J� 37�2F�2F�t�|�|�.�.�D�� ���
� � � �r> c � � t | t � r t d� �g d�}t | � } t | d| � }t j |d�� }||vr t d� �|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 MultiIndex)r/ r- r, r. r0 re T��skipnaz.Can only use .str accessor with string values!)r] r �AttributeErrorr rN r � infer_dtype)ri r9 �values�inferred_dtypes r< r\ zStringMethods._validate� sh � �. �d�M� *� �G��
�
O�
� �T�"����|�T�2�� � � ���=�� � � .� �!Q�R� R� � r> c �n � | j j j |� }| j |� S �N)rO rP � _str_getitemrQ )r5 �keyrR s r< � __getitem__zStringMethods.__getitem__� s- � ����!�!�.�.�s�3��� � ��(�(r> c �F � t dt | � j � d�� �)N�'z' object is not iterable)r4 �typer? )r5 s r< �__iter__zStringMethods.__iter__� s" � ��!�D��J� /� /�0�0H�I�J�Jr> NTFc
�
� ddl m}m} t |d� r t |d� s/t |t
� r |j
| j d�� }|S |j dk sJ �|�|j dk7 }�n�|d u �r�t | j t � �s�t |j t � �r4dd l }
dd
l
m} dd lm} |
j" j% |j& � }
|
j" j) |
� j+ � }|
j" j- |
� j+ � }|j. r% | |j& j1 d g|z � � }||k r�| s0 | |
j" j3 |j& d|d � � � }n�t5 j6 |d t8 �
� }|j; � }g }|D ]H }t= |� |k r'|d |t= |� z
}t5 j> ||� }|j? |� �J |j& j@ } | |
jC ||�� � }|�|}n tE |� }|
j" jG |j& � j; � jI t= |� |� }tK ||jL � D ��ci c] \ }}| | |
jC |� � �� }}}nztO |� rod� }|D �cg c]
} ||� �� }}|rU| jP sIt) d� |D � � }|D �cg c], }t= |� dk( s|d t4 jR u r||z n|��. }}t |tT � s tW d� �|du r'|�
tY |dd � }|�| j jZ }t | j t � rZt] |� r|S |r@t_ |� }| ja ||�� }|jb dk( r|je d� }|S ||||�� S | j jf } |} tY |dd � } | jP r4t] | � r
|j } n |r| j j } n| } n| �| } |r#| j jh } | ||| | �� }n"| j jj } | ||| | �� }|j
| j d�� }|�|j dk( r||_- |S c c}}w c c}w c c}w )Nr )r$ �
MultiIndex�ndimr^ �strrG � � T)�pa_version_under11p0)�ArrowExtensionArray)�start�stop�return_fixed_size_list)�
fill_valuer^ )ry c �" � t | � r| S | gS rs �r )�xs r< �cons_rowz,StringMethods._wrap_result.<locals>.cons_rowS s � �#�A�� �� !�s�
r> c 3 �2 K � | ] }t |� �� � y �wrs )�len��.0r� s r< � <genexpr>z-StringMethods._wrap_result.<locals>.<genexpr>\ s � �� �!9�Q�#�a�&�!9�s �� expand must be True or FalseFr@ ��names�r@ r^ ��columnsrc r^ )r@ rc r^ ��method)6�pandasr$ r| �hasattrr] r � __finalize__rg r} r r^ r �pyarrow�
pandas.compatr� � pandas.core.arrays.arrow.arrayr� �compute�list_value_length� _pa_array�max�as_py�min�_hasna� fill_null�
list_slice�np�full�object�to_numpyr� �appendry rP �range� list_flatten�reshape�zip�Tr r` �nan�bool�
ValueErrorrN r@ r �list� from_tuples�nlevels�get_level_valuesrc �_constructor_expanddim� _constructor) r5 rR r@ �expandr� rM � returns_boolr^ r$ r| �par� r� �
value_lengths�max_len�min_len�all_nullrp �
new_values�row�nulls�pa_type�labels�label�resr� r� �outrc �_dtype�vdtype�conss r< rQ zStringMethods._wrap_result� s� � �
�
�v�v�&�g�f�g�.F��&�,�/� �,�,�T�Z�Z�e�,�D���M��{�{�Q�� �� �>��[�[�A�%�F�
�t�^�J�t�z�z�8�$D� �&�,�,�
�3�$�>�N� "�
�
� <� <�V�=M�=M� N�
� �*�*�.�.� �7�=�=�?�� �*�*�.�.� �7�=�=�?���=�=� 0� �(�(�2�2�D�6�G�3C�D� �F� �W�$�/�!4� �J�J� 1� 1� &� 0� 0�&'�%,�7;� 2� �"�� $&�7�7�7�t�6�#R��!'� � �!2��%'�
�#)� 3�C� "�3�x�'� 1�(0�1E�7�S��X�3E�(F��&(�i�i��U�&;�� &� -� -�c� 2� 3�
#)�"2�"2�"7�"7��!4�R�X�X�j�w�X�5W�!X���#� !�F� "�7�^�F��J�J�+�+�F�,<�,<�=� �X�Z� �W�S��[�'�2� � '*�&�&�(�(�&;��"��s� �.�r�x�x��}�=�=��� � !��(�#� 06�6�!�(�1�+�6��6��$�/�/� !�!9�&�!9� 9�G� "(� � � (+�1�v��{�a��d�b�f�f�n��G� �!�K� �F� �
�&�$�'� � ;�<� <� �U�?� �|� �v�v�t�4���|� �z�z���� �d�j�j�(� +� �V�$� �
�� �f� �� '� 3� 3�F�$� 3� G���;�;�!�#� �.�.�q�1�C��
� �V�$�e�<�<��J�J�$�$�E�,1�F� �V�W�d�3�F���� ��(� #�\�\�F�#� !�Z�Z� -� -�F� #�F��#� ����z�z�8�8�� �f�d�%�v�N�� �z�z�.�.�� �f�4�u�F�K���(�(����E�(�B�F�� �F�K�K�1�$4� #�� ��M��_�� 7�� s �="S>�5T�*1T c � � ddl m}m} t | j t
� r | j n| j j }t |t � r|gS t |t
� r ||||j �� gS t |t � r|D �cg c] }|| �� c}S t |t j � r,|j dk( r |||�� }|D �cg c] }|| �� c}S t |d�� rg t |� }t d� |D � � r,g }|r&|| j! |j# d� � z }|r�&|S t d � |D � � r |||�� gS t% d
� �c c}w c c}w # t$ $ r
Y t% d
� �w xY w) 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% �rc r^ � )rc F)�
allow_setsc 3 � K � | ]L }t |t t t f� xs+ t |t j
� xr |j d k( �� �N y�w)r� N)r] r r r r� �ndarrayr} r� s r< r� z1StringMethods._get_series_list.<locals>.<genexpr>� sO � �� � � � �q�9�h��"G�H� C�"�1�b�j�j�1�A�a�f�f��k�C��s �AAc 3 �4 K � | ] }t |� �� � y �wrs r� r� s r< r� z1StringMethods._get_series_list.<locals>.<genexpr>� s � �� �=��\�!�_�,�=�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]))r� r# r% r] rg r rc r r^ r r� r� r} r r� �all�_get_series_list�popr4 )r5 �othersr# r% �idxr� �loss r< r� z StringMethods._get_series_list� s{ � �
� '�t�z�z�8� <�d�j�j�$�*�*�BR�BR��
�f�i� (��8�O�
���
)��6��F�L�L�A�B� B�
�� �
-�'-�.�!�F�1�I�.� .�
���
�
�
+�� � �q�0@� �v�S�1�F�'-�.�!�F�1�I�.� .�
�&�U�
3�
7� �f� �� � � $�� �
)+�C� � !�D�$9�$9�&�*�*�Q�-�$H� H�� !� �J��=�f�=�=� "�6�� 5�6�6��
!�
�
��3 /�� /�� �
�� �
!�
�
�%
�s � E&� E+�5 E0 �0 F�F)r, r. r0 �leftc
� �� ddl m}m}m} t |t
� r t
d� �|�d}t | j t � r4 || j | j | j j �� �n | j �|��t �� �t �� }|�%|j � r|j �| � S |�6|j � r&|j t j ||�� � S |j �� S | j! |� }t �fd�|D � � rO ||d |d
k( r|nd t# t% |� � d d �
� }�j' ||�� \ �}|D �
cg c] }
||
�� }}
�g|z D �
cg c]
}
t |
� �� } }
t j( | D �
cg c]
}
t |
� �� c}
� } t j* j- | d�� }
|�}|
j � rmt j. t% �� t0 �� }t j2 ||
t j4 � |
}t7 | D �
cg c] }
|
| �� c}
|� ||< n^|�P|
j � r@t9 | | � D ��cg c] \ }}t j |||� �� } }}t7 | |� }n t7 | |� }t | j j t: � r+| j j j< j }n| j j }t | j t � r@t |� j? � rt0 } |||| j j@ �� }|S |||�jB | j j@ d �� }|jE | j d�� }|S # t $ r} t
d� | �d} ~ ww xY wc c}
w c c}
w c c}
w c c}
w c c}}w )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� z�If `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 �j �K � | ]* }�j j |j � �� �, y �wrs )rc �equals)r� r� ri s �r< r� z$StringMethods.cat.<locals>.<genexpr>� s' �� �� �>�!�4�:�:�$�$�Q�W�W�-�-�>�s �03r� �inner�outerF)�axis�join�keys�sort�copy)r� �r� �r^ )r^ r@ )r^ rc r@ r� �str_catr� )#r� r$ r% r� r] r~ r� rg r r^ r r �anyr� r� �wherer� r� r� �alignrP �
logical_or�reducer- r� �putmaskr� �cat_safer� r re r� r@ rc r� )r5 r� �sep�na_repr� r$ r% r� �na_mask�errr� �all_cols�na_masks�
union_maskrR �
not_masked�nm�colr^ r� �res_serri s @r< �catzStringMethods.cat� su �� �T
�
� �f�c� "� � F�G� G� �;��C� �d�j�j�(� +��$�*�*�D�J�J�d�j�j�>N�>N�O�D��:�:�D� �>� !��&�D��4�j�G��~�'�+�+�-��x�x��g�X��/�/��#�� � �
��x�x�����&�$� ?�@�@��x�x��~�%� ��*�*�6�2�F� �>�v�>� >���� "�g�o�d�7��3�v�;�'���
�F� �:�:�f�4�:�8�L�D�&�)/�0�A�f�Q�i�0�F�0�/3�f�v�o�>��M�!�$�>��>��8�8�h� 7��T�!�W� 7�8���]�]�)�)�(��)�;�
� �>�j�n�n� .� �X�X�c�$�i�v�6�F� �J�J�v�z�2�6�6� 2�$��J�!)�(�*K�Q�1�Z�=�*K�S�!Q�F�:� �
�
�J�N�N�$4� :=�X�x�9P��.5�b�#�����V�S�)��H� � �h��,�F� �h��,�F� �d�j�j�&�&�(8� 9��J�J�$�$�/�/�5�5�E��J�J�$�$�E� �d�j�j�(� +��F�|� � �!� ����e�$�*�*�/�/�B�C� �
� ��e�4�:�:�D�J�J�O�O�RW��G� �&�&�t�z�z�)�&�D�C��
��y � � �B�� �
�� ��& 1��>�� 7�� +L��s6 �O �4 O.�
O3�1O8� O=� !P� O+� O&�&O+a�
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)s� str_split� 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
)�side� pat_regex�pat_description�regex_argument� raises_split�regex_pat_noter� �regex_examplesr, ���)�nr� �regexc � � |du rt |� r t d� �t |� rd}| j j j ||||� }| j j
dk( r+| j j
j j
}n%| j j
t k( rt nd }| j ||||�� S )NF�CCannot use a compiled regex as replacement pattern with regex=FalseT�category�r� rM r^ ) r r� rO rP �
_str_splitr^ re r� rQ )r5 �patr r� r rR r^ s r< r� zStringMethods.splitB s� � �^ �E�>�e�C�j� �U��
� ��:��E����!�!�,�,�S�!�V�U�C�� �:�:� � �z� )��J�J�$�$�/�/�5�5�E� "�j�j� .� .�&� 8�F�d�E�� � � �6�&�� !�
�
r> �endr� zString to split on�rsplit)r r� c �� � | j j j ||�� }| j j t k( rt nd }| j ||||�� S )N)r r )rO rP � _str_rsplitr^ r� rQ )r5 r r r� rR r^ s r< r zStringMethods.rsplit� s\ � � ���!�!�-�-�c�Q�-�7�� �*�*�*�*�f�4��$��� � � �6�&�� !�
�
r> a;
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')
�
str_partition�firstzF3 elements containing the string itself, followed by two empty stringsz>rpartition : Split the string at the last occurrence of `sep`.)r� rB �alsoc �J � | j j j ||� }| j j dk( r+| j j j j }n%| j j t
k( rt
nd }| j
||||�� S �Nr r )rO rP �_str_partitionr^ re r� rQ �r5 r� r� rR r^ s r< � partitionzStringMethods.partition s� � � ���!�!�0�0��f�=�� �:�:� � �z� )��J�J�$�$�/�/�5�5�E� "�j�j� .� .�&� 8�F�d�E�� � � �6�&�� !�
�
r> �lastzF3 elements containing two empty strings, followed by the string itselfz>partition : Split the string at the first occurrence of `sep`.c �J � | j j j ||� }| j j dk( r+| j j j j }n%| j j t
k( rt
nd }| j
||||�� S r )rO rP �_str_rpartitionr^ re r� rQ r s r< �
rpartitionzStringMethods.rpartition s� � � ���!�!�1�1�#�v�>�� �:�:� � �z� )��J�J�$�$�/�/�5�5�E� "�j�j� .� .�&� 8�F�d�E�� � � �6�&�� !�
�
r> c �n � | j j 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
)rO rP �_str_getrQ )r5 �irR s r< �getzStringMethods.get/ s0 � �x ���!�!�*�*�1�-��� � ��(�(r> c �n � | j j 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
)rO rP � _str_joinrQ )r5 r� rR s r< r� zStringMethods.joinn s0 � �~ ���!�!�+�+�C�0��� � ��(�(r> c � � |rCt j |� j r$t j dt
t
� �� | j j j |||||� }| j ||d�� S )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� rM ) �re�compile�groups�warnings�warn� UserWarningr rO rP �
_str_containsrQ )r5 r �case�flags�nar rR s r< �containszStringMethods.contains� so � �~ �R�Z�Z��_�+�+� �M�M�M��+�-�
� ���!�!�/�/��T�5�"�e�L��� � ��B�u� �M�Mr> c �| � | j j j ||||�� }| j ||d�� S )aK
Determine if each string starts with a match of a regular expression.
Parameters
----------
pat : str
Character sequence.
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.
Examples
--------
>>> ser = pd.Series(["horse", "eagle", "donkey"])
>>> ser.str.match("e")
0 False
1 True
2 False
dtype: bool
�r/ r0 r1 Fr' )rO rP �
_str_matchrQ �r5 r r/ r0 r1 rR s r< �matchzStringMethods.match: s@ � �L ���!�!�,�,�S�t�5�R�,�P��� � ��B�u� �M�Mr> c �| � | j j j ||||�� }| j ||d�� S )a)
Determine if each string entirely matches 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
--------
match : Similar, but also returns `True` when only a *prefix* of the string
matches the regular expression.
extract : Extract matched groups.
Examples
--------
>>> ser = pd.Series(["cat", "duck", "dove"])
>>> ser.str.fullmatch(r'd.+')
0 False
1 True
2 True
dtype: bool
r4 Fr' )rO rP �_str_fullmatchrQ r6 s r< � fullmatchzStringMethods.fullmatchc sA � �J ���!�!�0�0��4�u�QS�0�T��� � ��B�u� �M�Mr> c �Z � t |t � st |� s t d� �t |� }|s|�|r5|�|dk7 r.t d� �|r t d� �t |� r t d� �|�d}| j j j ||||||�� }| j |� S )aM
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 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 callabler z9case and flags cannot be set when pat is a compiled regexr
z2Cannot use a callable replacement when regex=FalseT)r r/ r0 r )
r] r~ �callabler4 r r� rO rP � _str_replacerQ ) r5 r �replr r/ r0 r �is_compiled_rerR s r< �replacezStringMethods.replace� s� � �@ �4��%��$� �� ?�@� @� �s��� �E�M� �4�#3�u��z� �O�� � � �U��
� �d�^� � Q�R� R� �<��D����!�!�.�.� ����U�%� /�
�� � � ��(�(r> c �n � | j j 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
)rO rP � _str_repeatrQ )r5 �repeatsrR s r< �repeatzStringMethods.repeat$ s0 � �R ���!�!�-�-�g�6��� � ��(�(r> c �h � t |t � s#dt |� j � �}t |� �t |� dk7 r t d� �t
|� s#dt |� j � �}t |� �| j j j |||�� }| j |� 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 r� z%fillchar must be a character, not str�#width must be of integer type, not �r� �fillchar) r] r~ ry r? r4 r� r rO rP �_str_padrQ )r5 �widthr� rH r8 rR s r< �padzStringMethods.padP s� � �v �(�C�(�6�t�H�~�7N�7N�6O�P�C��C�.� � �x�=�A� �� C�D� D��%� �7��U� �8L�8L�7M�N�C��C�.� ����!�!�*�*�5�t�h�*�O��� � ��(�(r> a�
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.
Examples
--------
For Series.str.center:
>>> ser = pd.Series(['dog', 'bird', 'mouse'])
>>> ser.str.center(8, fillchar='.')
0 ..dog...
1 ..bird..
2 .mouse..
dtype: object
For Series.str.ljust:
>>> ser = pd.Series(['dog', 'bird', 'mouse'])
>>> ser.str.ljust(8, fillchar='.')
0 dog.....
1 bird....
2 mouse...
dtype: object
For Series.str.rjust:
>>> ser = pd.Series(['dog', 'bird', 'mouse'])
>>> ser.str.rjust(8, fillchar='.')
0 .....dog
1 ....bird
2 ...mouse
dtype: object
�str_padzleft and right�center)r� r� c �* � | j |d|�� S )N�bothrG �rK �r5 rJ rH s r< rM zStringMethods.center� � � � �x�x��F�X�x�>�>r> �right�ljustc �* � | j |d|�� S )NrS rG rP rQ s r< rT zStringMethods.ljust� s � � �x�x��G�h�x�?�?r> �rjustc �* � | j |d|�� S )Nr� rG rP rQ s r< rV zStringMethods.rjust� rR r> c �� �� t �� s#dt �� j � �}t |� ��fd�}| j j
j
|� }| j |� 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
rF c �& �� | j �� S rs )�zfill)r� rJ s �r< �<lambda>z%StringMethods.zfill.<locals>.<lambda> s �� �a�g�g�e�n� r> )r ry r? r4 rO rP �_str_maprQ )r5 rJ r8 �frR s ` r< rZ zStringMethods.zfill� s_ �� �z �%� �7��U� �8L�8L�7M�N�C��C�.� � $�����!�!�*�*�1�-��� � ��(�(r> c �r � | j j 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
)rO rP �
_str_slicerQ )r5 r� r� �steprR s r< �slicezStringMethods.slice s4 � �P ���!�!�,�,�U�D�$�?��� � ��(�(r> c �r � | j j 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
)rO rP �_str_slice_replacerQ )r5 r� r� r> rR s r< �
slice_replacezStringMethods.slice_replaceh s4 � �R ���!�!�4�4�U�D�$�G��� � ��(�(r> c �� ���� �t v r��fd�}nt j �� ���fd�}| j j }|j |� }| j
|� S )a%
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
Examples
--------
For Series:
>>> ser = pd.Series([b'cow', b'123', b'()'])
>>> ser.str.decode('ascii')
0 cow
1 123
2 ()
dtype: object
c �( �� | j ��� S rs )�decode)r� �encoding�errorss ��r< r[ z&StringMethods.decode.<locals>.<lambda>� s �� �!�(�(�8�V�4� r> c � �� �| �� d S )Nr � )r� �decoderri s ��r< r[ z&StringMethods.decode.<locals>.<lambda>� s �� �'�!�V�,�Q�/� r> )�_cpython_optimized_decoders�codecs�
getdecoderrO rP r\ rQ )r5 rh ri r] �arrrR rl s `` @r< rg zStringMethods.decode� sU �� �8 �2� 2�4�A� �'�'��1�G�/�A��j�j� � ��� � �a� ��� � ��(�(r> c �t � | j j j ||� }| j |d�� S )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
Examples
--------
>>> ser = pd.Series(['cow', '123', '()'])
>>> ser.str.encode(encoding='ascii')
0 b'cow'
1 b'123'
2 b'()'
dtype: object
FrL )rO rP � _str_encoderQ )r5 rh ri rR s r< �encodezStringMethods.encode� s6 � �2 ���!�!�-�-�h��?��� � ��� �>�>r> aR
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
� str_stripzleft and right sides�stripzleading and trailing)r� r� �positionc �n � | j j j |� }| j |� S rs )rO rP �
_str_striprQ �r5 �to_striprR s r< ru zStringMethods.stripC s/ � � ���!�!�,�,�X�6��� � ��(�(r> z left side�lstrip�leadingc �n � | j j j |� }| j |� S rs )rO rP � _str_lstriprQ ry s r< r{ zStringMethods.lstripP �/ � � ���!�!�-�-�h�7��� � ��(�(r> z
right side�rstrip�trailingc �n � | j j j |� }| j |� S rs )rO rP � _str_rstriprQ ry s r< r� zStringMethods.rstripY r r> a�
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
�
str_removefix�prefix�suffix)r� �
other_sidec �n � | j j j |� }| j |� S rs )rO rP �_str_removeprefixrQ )r5 r� rR s r< � removeprefixzStringMethods.removeprefix� �/ � �
���!�!�3�3�F�;��� � ��(�(r> c �n � | j j j |� }| j |� S rs )rO rP �_str_removesuffixrQ )r5 r� rR s r< � removesuffixzStringMethods.removesuffix� r� r> c �r � | j j j |fi |��}| j |� 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
)rO rP � _str_wraprQ )r5 rJ r7 rR s r< �wrapzStringMethods.wrap� s7 � �p ,����!�!�+�+�E�<�V�<��� � ��(�(r> c �| � | j j j |� \ }}| j ||dd�� S )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@ r� rM )rO rP �_str_get_dummiesrQ )r5 r� rR r@ s r< � get_dummieszStringMethods.get_dummies� sG � �N �z�z�'�'�8�8��=� ���� � � ��� � !�
�
r> c � � | j j j |� }| j j dk( rt nd}| j ||�� S )u
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
Examples
--------
>>> ser = pd.Series(["El niño", "Françoise"])
>>> mytable = str.maketrans({'ñ': 'n', 'ç': 'c'})
>>> ser.str.translate(mytable)
0 El nino
1 Francoise
dtype: object
r� Nr� )rO rP �_str_translater^ r� rQ )r5 �tablerR r^ s r< � translatezStringMethods.translate sL � �8 ���!�!�0�0��7�� �*�*�*�*�h�6��D��� � ��u� �5�5r> c �t � | j j j ||� }| j |d�� S )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')
FrL )rO rP �
_str_countrQ �r5 r r0 rR s r< �countzStringMethods.count, s7 � �B ���!�!�,�,�S�%�8��� � ��� �>�>r> c �� � t |t t f� s#dt |� j � �}t |� �| j j j ||�� }| j |d�� S )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 �r1 FrL )
r] r~ �tuplery r? r4 rO rP �_str_startswithrQ �r5 r r1 r8 rR s r< �
startswithzStringMethods.startswithp si � �@ �#��U�|�,�4�T�#�Y�5G�5G�4H�I�C��C�.� ����!�!�1�1�#�"�1�=��� � ��� �>�>r> c �� � t |t t f� s#dt |� j � �}t |� �| j j j ||�� }| j |d�� S )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� FrL )
r] r~ r� ry r? r4 rO rP �
_str_endswithrQ r� s r< �endswithzStringMethods.endswith� si � �@ �#��U�|�,�4�T�#�Y�5G�5G�4H�I�C��C�.� ����!�!�/�/���/�;��� � ��� �>�>r> c �t � | j j j ||� }| j |d�� S )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
FrL )rO rP � _str_findallrQ r� s r< �findallzStringMethods.findall� s7 � �t ���!�!�.�.�s�E�:��� � ��� �>�>r> c � � ddl m} t |t � s t d� �t j ||�� }|j dk( r t d� �|s4|j dkD r%t | j t � r t d� �| j }t |� }|j dkD xs |}|r�d} t |� }
|j j dk( r ||
|� � } n�| j j j |||�
� } t |t � r
|j }
nd}
|| |
|
|� � } n3t# |� } | j j j |||�
� } | j% | | |� � 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� �r0 �"pattern contains no capture groupsr� z,only one regex group is supported with IndexN)r� r^ )r0 r� r� r� )r� r# r] r� r� r( r) r* rO r �
_result_dtype�_get_group_namesrP �size� _str_extractr rc �_get_single_group_namerQ )r5 r r0 r� r# r �obj� result_dtype�
returns_dfr@ r� rR � result_list� result_indexs r< �extractzStringMethods.extractY
s[ � �h %��&�$�'� � ;�<� <��
�
�3�e�,�� �<�<�1� � � A�B� B��%�,�,��*�z�$�*�*�h�/O� � K�L� L��j�j��$�S�)� ��\�\�A�%�/��
� ��D�&�u�-�G��y�y�~�~��"�"�7�,�G�� #�j�j� .� .� ;� ;��u�Z� <� � �
�c�9�-�#&�9�9�L�#'�L�"� �� �L���
*�%�0�D��Z�Z�%�%�2�2�3�e�J�2�W�F�� � ��d�,� �G�Gr> c �0 � 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_extractallrg )r5 r r0 s r< �
extractallzStringMethods.extractall�
s � �X �d�j�j�#�u�5�5r> aT
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
Examples
--------
For Series.str.find:
>>> ser = pd.Series(["cow_", "duck_", "do_ve"])
>>> ser.str.find("_")
0 3
1 4
2 2
dtype: int64
For Series.str.rfind:
>>> ser = pd.Series(["_cow_", "duck_", "do_v_e"])
>>> ser.str.rfind("_")
0 4
1 4
2 4
dtype: int64
�find�lowestz/rfind : Return highest indexes in each strings.)r� r� r c �� � t |t � s#dt |� j � �}t |� �| j
j j |||� }| j |d�� S )N� expected a string object, not FrL ) r] r~ ry r? r4 rO rP � _str_findrQ �r5 �subr� r r8 rR s r< r� zStringMethods.findV sc � � �#�s�#�2�4��9�3E�3E�2F�G�C��C�.� ����!�!�+�+�C���<��� � ��� �>�>r> �highest�rfindz-find : Return lowest indexes in each strings.c �� � t |t � s#dt |� j � �}t |� �| j
j j |||�� }| j |d�� S �Nr� )r� r FrL ) r] r~ ry r? r4 rO rP �
_str_rfindrQ r� s r< r� zStringMethods.rfindg sf � � �#�s�#�2�4��9�3E�3E�2F�G�C��C�.� ����!�!�,�,�S��3�,�G��� � ��� �>�>r> c �n � | j j j |� }| j |� S )u
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
Examples
--------
>>> ser = pd.Series(['ñ'])
>>> ser.str.normalize('NFC') == ser.str.normalize('NFD')
0 False
dtype: bool
)rO rP �_str_normalizerQ )r5 �formrR s r< � normalizezStringMethods.normalizex s/ � �0 ���!�!�0�0��6��� � ��(�(r> a�
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
Examples
--------
For Series.str.index:
>>> ser = pd.Series(["horse", "eagle", "donkey"])
>>> ser.str.index("e")
0 4
1 0
2 4
dtype: int64
For Series.str.rindex:
>>> ser = pd.Series(["Deer", "eagle", "Sheep"])
>>> ser.str.rindex("e")
0 2
1 4
2 3
dtype: int64
rc z0rindex : Return highest indexes in each strings.)r� �similarr� r c �� � t |t � s#dt |� j � �}t |� �| j
j j |||�� }| j |d�� S r� ) r] r~ ry r? r4 rO rP �
_str_indexrQ r� s r< rc zStringMethods.index� sf � � �#�s�#�2�4��9�3E�3E�2F�G�C��C�.� ����!�!�,�,�S��3�,�G��� � ��� �>�>r> �rindexz.index : Return lowest indexes in each strings.c �� � t |t � s#dt |� j � �}t |� �| j
j j |||�� }| j |d�� S r� ) r] r~ ry r? r4 rO rP � _str_rindexrQ r� s r< r� zStringMethods.rindex� sf � � �#�s�#�2�4��9�3E�3E�2F�G�C��C�.� ����!�!�-�-�c��C�-�H��� � ��� �>�>r> c �p � | j j j � }| j |d�� S )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
FrL )rO rP �_str_lenrQ �r5 rR s r< r� zStringMethods.len� s3 � �\ ���!�!�*�*�,��� � ��� �>�>r> a�
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
� casemethodszdict[str, dict[str, str]]� _doc_args� lowercase�lower)ry r� �version� uppercase�upper� titlecase�titlezbe capitalized�
capitalizez be swapcased�swapcasez
be casefolded�casefoldc �l � | j j j � }| j |� S rs )rO rP �
_str_lowerrQ r� s r< r� zStringMethods.lowerw �- � � ���!�!�,�,�.��� � ��(�(r> c �l � | j j j � }| j |� S rs )rO rP �
_str_upperrQ r� s r< r� zStringMethods.upper} r� r> c �l � | j j j � }| j |� S rs )rO rP �
_str_titlerQ r� s r< r� zStringMethods.title� r� r> c �l � | j j j � }| j |� S rs )rO rP �_str_capitalizerQ r� s r< r� zStringMethods.capitalize� s- � � ���!�!�1�1�3��� � ��(�(r> c �l � | j j j � }| j |� S rs )rO rP �
_str_swapcaserQ r� s r< r� zStringMethods.swapcase� �- � � ���!�!�/�/�1��� � ��(�(r> c �l � | j j j � }| j |� S rs )rO rP �
_str_casefoldrQ r� s r< r� zStringMethods.casefold� r� r> u�
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
� ismethods� alphanumeric�isalnum)ry r� �
alphabetic�isalpha�digits�isdigit�
whitespace�isspace�islower�isupper�istitle�numericrJ �decimalrK )rT )rB �None)rB r" )r� � bool | NonerM r� r� r� )NNNr� )r� �
str | Noner� r
rB zstr | Series | Indexrs )r zstr | re.Pattern | Noner� r� r r� )r� r� )� T)r� r~ r� r� )r� r~ )Tr NT)r/ r� r0 �intr r� )Tr N)r r~ r/ r� r0 r )r/ r� r0 r )r Nr F) r zstr | re.Patternr> zstr | Callabler r r/ r� r0 r r r� )r� r� )rJ r r� z Literal['left', 'right', 'both']rH r~ )r� )rJ r rH r~ )rJ r )NNN)�strict)ri r~ )r� r~ )r� r~ )�|�r )r0 r )r zstr | tuple[str, ...]r1 z
Scalar | NonerB zSeries | Index)r T)r r~ r0 r r� r� rB zDataFrame | Series | Index�r0 r rB r# )r N)r� r )Kr? �
__module__� __qualname__rS rj � staticmethodr\ rv rz r� r� rQ r� rE r� r& r r� r r r r" r� r2 r7 r: r@ rD rK rM rT rV rZ ra rd rg rs ru r{ r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rc r� r� r� �__annotations__r� r� r� r� r� r� rU r� r� r� r� r� r� r� rJ rK rk r> r< rW rW � s� � ��<�& �& � �& �P)�K� � "��6�6� #� "��]� � ]� �
]� �]�~>
�@ � ?�@� � �� � e� �e�
� e�
�
e� A�e�Rx � ���x ��[�!� �-� I�
� � � �' �5B
�C
�E�L �W�I�&� (,�
�
� � !�
�
$�
�
�
� �
� '�ME�N
�. ��[�!��� 3� � � � � �
�
� � �W�I�&�
�B�u�
� '� �
�N � ���d ��_�%�� �T�
�
�� �W�I�&�
� '��
� ��_�%�� �T�
�
�� �W�I�&�
� '��
�=)�~ �W�I�&�?)� '�?)�B �W�I�&�MQ�GN� �GN�-0�GN�FJ�GN� '�GN�R �W�I�&�&N� '�&N�P �W�I�&�%N� '�%N�N �W�I�&�
� ���V)�
�V)� �V)� � V)�
� V)� �
V)� �V)� '�V)�p �W�I�&�))� '�))�V �W�I�&� 28�� F)��F)� /�F)� � F)� '�F)�T- � ���b �l�9�%�1A�X�(V�V�W��W�I�&�?� '� X�?� �l�9�%��G�(L�L�M��W�I�&�@� '� N�@� �l�9�%��7�(K�K�L��W�I�&�?� '� M�?� �W�I�&�A)� '�A)�FI)�V �W�I�&�I)� '�I)�V%)�N �W�I�&�?� '�?�:H � ���X ��[�!�*� �.�
�
�� �W�I�&�)� '��)� ��[�!� �(� �
J� K�� �W�I�&�)� '� �
)� ��[�!� �8��
L� M�� �W�I�&�)� '� �
)� , � ���` ��_�%���(R�R�� �W�I�&�)� '��)� ��_�%���(R�R�� �W�I�&�)� '��)� �W�I�&�8)� '�8)�t �W�I�&�,
� '�,
�\ �W�I�&� 6� '� 6�> �W�I�&�A?� '�A?�F �W�I�&�>B�C?�(�C?�.;�C?� �C?� '�C?�J �W�I�&�>B�C?�(�C?�.;�C?� �C?� '�C?�J �W�I�&�Z?� '�Z?�x �W�I�&�7;�}H��}H� "�}H�04�}H� #�}H� '�}H�~ �W�I�&�K6� '�K6�^+ � ���^ ��V� � � �E�
�
�� �W�I�&�?� '��?� ��V� � � �C�
�
�� �W�I�&�?� '��?� �W�I�&�)� '�)�8- � ���b ��W� � � � �F�
�
�� �W�I�&�?� '��?� ��W� � � � �D�
�
�� �W�I�&�?� '��?�/?�fA � ���T ,.�I�(�-�"-��R�P�I�g��"-��R�P�I�g��"-��R�P�I�g�� � �� �I�l�� � �� �I�j�� � �� �I�j�� �l�=�)�I�g�,>�>�?��W�I�&�)� '� @�)� �l�=�)�I�g�,>�>�?��W�I�&�)� '� @�)� �l�=�)�I�g�,>�>�?��W�I�&�)� '� @�)� �l�=�)�I�l�,C�C�D��W�I�&�)� '� E�)� �l�=�)�I�j�,A�A�B��W�I�&�)� '� C�)� �l�=�)�I�j�,A�A�B��W�I�&�)� '� C�)� K � ���\ %3�i�H�I�i��$0�I�F�I�i��$,� �B�I�i��$0�I�F�I�i��$/�9�E�I�i��$/�9�E�I�i��$/�9�E�I�i��&/�;� G�I�k��&/�;� G�I�k�� ��\�+� 6��9�9M� M��G� ��\�+� 6��9�9M� M��G� ��\�+� 6��9�9M� M��G� ��\�+� 6��9�9M� M��G� ��\�+� 6��9�9M� M��G� ��\�+� 6��9�9M� M��G� ��\�+� 6��9�9M� M��G� ��|�K� 8�9�[�;Q� Q��I� ��|�K� 8�9�[�;Q� Q��Ir> rW c � � t | |� }|S # t $ r5 | D ], }t j |d�� }|dvs� t d|� �� d� Y S w xY w)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.
Trl )r/ r- zpConcatenation requires list-likes containing only strings (or missing values). Offending values found in column N)�cat_corer4 r ro )�list_of_columnsr� rR �columnr^ s r< r� r� Q
s} � �( ��/�3�/�� �M�� �
� &� �F��O�O�F�4�8�E�� /�/� � � #�W�&�� � � � �M�
�s � �)A�A�
Ac � � |dk( r2t j | t �� }t j |d�� S |gdt | � z dz
z }| |ddd�< t j |t �� }t j |d�� S )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� r� N)r� �asarrayr� �sumr� )r r� � arr_of_cols�
list_with_sep� arr_with_seps r< r
r
u
sv � �" �b�y��j�j� ��?� ��v�v�k��*�*��E�Q��_�!5� 5�� 9�:�M�(�M�#�A�#���:�:�m�6�:�L�
�6�6�,�Q� '�'r> c �j � ddl m} t | j t |f� r | j S t
S rY )r[ rZ r] r^ r r� )rp rZ s r< r� r� �
s) � � 7��#�)�)�j�+� 6�7��y�y�� �Mr> c �X � | j r t t | j � � S y rs )�
groupindex�next�iter)r s r< r� r� �
s$ � � ����D��)�)�*�+�+�r> c �� � | j j � D ��ci c] \ }}||��
}}}t | j � D �cg c] }|j d|z |� �� c}S c c}}w c c}w )z�
Get named groups from compiled regex.
Unnamed groups are numbered.
Parameters
----------
regex : compiled regex
Returns
-------
list of column labels
r� )r �itemsr� r* r" )r �k�vr� r! s r< r� r� �
s_ � � $� .� .� 4� 4� 6� 7�d�a��Q��T� 7�E� 7�).�u�|�|�)<� =�A�E�I�I�a�!�e�Q� � =�=��
8�� =s �
A$� A*c �f � t j ||�� }|j dk( r t d� �t | t
� r9| j
� j d�� j | j � } t |� }g }g }| j j dkD }| j � D ]� \ }} t | t � s�|s|f}t |j! | � � D ]m \ }
} t | t � r| f} | D � cg c] } | dk( rt" j$ n| �� }
} |j' |
� t) ||
fz � }|j' |� �o �� ddlm} |j/ || j j0 d gz �
� }t3 | � }| j5 ||||� � }|S c c} w ) Nr� r r� T)�dropr� r� )r| r7 r� )rc r� r^ )r( r) r* r� r] r � to_series� reset_index�astyper^ r� rc r� r r~ � enumerater� r� r� r� r� r� r| r� r� r� r� )rp r r0 r r� �
match_list�
index_list�is_mi� subject_key�subject�match_i� match_tuple�group�na_tuple�
result_keyr| rc r^ rR s r< r� r� �
s� � � �J�J�s�%� (�E� �|�|�q���=�>�>��#�x� ��m�m�o�)�)�t�)�4�;�;�C�I�I�F�� �u�%�G��J��J� �I�I� � �� !�E� #� � � � .� � �W� �g�s� #�� *�n� �(1�%�-�-��2H�(I�
.�$��� �k�3�/�#.�.�K�JU�V��e�r�k�B�F�F�u� <�V��V��!�!�(�+� "�;�'��#;� <�
��!�!�*�-�
.� .� "� � "� "�:�S�Y�Y�_�_��y�5P� "� Q�E� �#� �E�
�
'�
'��%��� (� �F� �M�� Ws � F.rs )rD zlist[str] | Noner@ r� rB zCallable[[F], F])r@ r� rT r� )r z list[npt.NDArray[np.object_]]r� r~ )r r� r� r~ )r �
re.PatternrB r! )r r, rB zlist[Hashable]r r )E�
__future__r rn � functoolsr r( �typingr r r r r+ �numpyr� � pandas._libsr �pandas._typingr
r r r
r �pandas.util._decoratorsr �pandas.util._exceptionsr �pandas.core.dtypes.commonr r r r r r �pandas.core.dtypes.dtypesr r �pandas.core.dtypes.genericr r r r �pandas.core.dtypes.missingr �pandas.core.arraysr �pandas.core.baser �pandas.core.constructionr �collections.abcr! r" r� r# r$ r% r& r �_cpython_optimized_encodersrm rE rU rW r� r
r� r� r� r� rk r> r< �<module>r> s� �� "�
� � �� � � � �� � -� 4�� ��� � ,� -� 1� 2���
� � "� �n� !� � � :�<P� P� � 59�B#� �B#�'1�B#��B#�J �q2�(� q2�he!�H(�6��>�$#r>