x\c@sIddlZddlZddlZddlZddlZddljjZddl jj Z ddl j Z ddl mZddlmZmZddlmZmZmZmZmZmZmZmZmZddlmZmZddlm Z ddl!m"Z"ddl#m$Z$ddl%j&j'Z(d=Z)e)d>Z*e+Z,dZ-ej.e/dZ0e1ej.e/dZ2ddZ3e4dej.e4dZ5ej.dZ6ej.dZ7ddde4dZ9dZ:e4dej.dZ;dZ<dZ=ddZ>dd Z?de4d!Z@dd"ZAd#d$ZBd%ZCdd&ZDddd'd(ZEddd'd)ZFd'd*d+ZGddd,ZHddd-ZIdddd.ZJdddd/ZKdd0d1ZLd2ZMdd3ZNd4ZOd5d6ZPd5d7ZQdd8ZRe1e1d9ZSd:ZTd;e$fd<YZUdS(?iN(tzip(tAppendertdeprecate_kwarg( t ensure_objectt is_bool_dtypetis_categorical_dtypet is_integert is_list_liketis_object_dtypetis_ret is_scalartis_string_like(t ABCIndexClasst ABCSeries(tisna(ttake_1d(tNoNewAttributesMixinsutf-8tutf8slatin-1tlatin1s iso-8859-1tmbcstasciisutf-16sutf-32cCsA|gdt|d}||ddds2    (  . ics7tj|d|fd}t||dtS(s 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 `_. **kwargs For compatibility with other string methods. Not used. Returns ------- counts : 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') Int64Index([0, 0, 2, 1], dtype='int64') tflagscstj|S(N(Rtfindall(R((tregex(s2lib/python2.7/site-packages/pandas/core/strings.pytsR(R7tcompileR%tint(R#tpatRBR"((RDs2lib/python2.7/site-packages/pandas/core/strings.pyt str_countgs@csrk|s|tjO}ntjd|jdkrYtjdtddnfd}n[|rfd}nCjfd}td |}t|||d t St|||d t S( s" 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 : default NaN Fill value for missing values. 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 RBisKThis pattern has match groups. To actually get the groups, use str.extract.t stacklevelicstj|S(N(tboolR8(R((RD(s2lib/python2.7/site-packages/pandas/core/strings.pyRE2scs |kS(N((R((RH(s2lib/python2.7/site-packages/pandas/core/strings.pyRE5scs |kS(N((R((t upper_pat(s2lib/python2.7/site-packages/pandas/core/strings.pyRE8scSs |jS(N(tupper(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE9sR( R7t IGNORECASERFtgroupstwarningstwarnt UserWarningRMR%RK(R#RHtcaseRBtnaRDR"tuppered((RHRDRLs2lib/python2.7/site-packages/pandas/core/strings.pyt str_containss {   cs%fd}t|||dtS(s Test if the start of each string element matches a pattern. Equivalent to :meth:`str.startswith`. Parameters ---------- pat : str Character sequence. Regular expressions are not accepted. na : object, default NaN Object shown if element tested is not a string. 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 Specifying `na` to be `False` instead of `NaN`. >>> s.str.startswith('b', na=False) 0 True 1 False 2 False 3 False dtype: bool cs |jS(N(t startswith(R((RH(s2lib/python2.7/site-packages/pandas/core/strings.pyREqsR(R%RK(R#RHRTR"((RHs2lib/python2.7/site-packages/pandas/core/strings.pytstr_startswith>s3cs%fd}t|||dtS(sw Test if the end of each string element matches a pattern. Equivalent to :meth:`str.endswith`. Parameters ---------- pat : str Character sequence. Regular expressions are not accepted. na : object, default NaN Object shown if element tested is not a string. 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 Specifying `na` to be `False` instead of `NaN`. >>> s.str.endswith('t', na=False) 0 True 1 False 2 False 3 False dtype: bool cs |jS(N(tendswith(R((RH(s2lib/python2.7/site-packages/pandas/core/strings.pyREsR(R%RK(R#RHRTR"((RHs2lib/python2.7/site-packages/pandas/core/strings.pyt str_endswithus3c sstpts'tdnt}|r!|ri|d k sW|dkrtdqn1|d kr~t}n|tkr|tj O}n|st dks|str dkrndtj d|fd}qffd}nE|r6tdntrQtd nfd }t ||S( s Replace occurrences of pattern/regex in the Series/Index with some other string. Equivalent to :meth:`str.replace` or :func:`re.sub`. Parameters ---------- pat : string or compiled regex String can be a character sequence or regular expression. .. versionadded:: 0.20.0 `pat` also accepts a compiled regex. repl : string 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`. .. versionadded:: 0.20.0 `repl` also accepts a callable. n : int, default -1 (all) Number of replacements to make from start case : boolean, default None - 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) - re module flags, e.g. re.IGNORECASE - Cannot be set if `pat` is a compiled regex regex : boolean, default True - 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. .. versionadded:: 0.23.0 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) 0 <_sre.SRE_Match object; span=(0, 1), match='f'>oo 1 <_sre.SRE_Match object; span=(0, 1), match='f'>uz 2 NaN dtype: object Reverse every lowercase alphabetic word: >>> repl = lambda m: m.group(0)[::-1] >>> pd.Series(['foo 123', 'bar baz', np.nan]).str.replace(r'[a-z]+', repl) 0 oof 123 1 rab zab 2 NaN dtype: object Using regex groups (extract second group and swap case): >>> pat = r"(?P\w+) (?P\w+) (?P\w+)" >>> repl = lambda m: m.group('two').swapcase() >>> pd.Series(['One Two Three', 'Foo Bar Baz']).str.replace(pat, repl) 0 tWO 1 bAR dtype: object Using a compiled regex with flags >>> regex_pat = re.compile(r'FUZ', flags=re.IGNORECASE) >>> pd.Series(['foo', 'fuz', np.nan]).str.replace(regex_pat, 'bar') 0 foo 1 bar 2 NaN dtype: object s!repl must be a string or callableis9case and flags cannot be set when pat is a compiled regexiRBcsjdd|dS(Ntrepltstringtcount(tsub(R((tcompiledtnR[(s2lib/python2.7/site-packages/pandas/core/strings.pyRE:scs|jS(N(treplace(R((R`RHR[(s2lib/python2.7/site-packages/pandas/core/strings.pyRE<ssCCannot use a compiled regex as replacement pattern with regex=Falses2Cannot use a callable replacement when regex=Falsecs|jS(N(Ra(R((R`RHR[(s2lib/python2.7/site-packages/pandas/core/strings.pyREDsN( R tcallableR&R tNonet ValueErrorR!tFalseR7RNRRFR%( R#RHR[R`RSRBRDtis_compiled_reR"((R_R`RHR[s2lib/python2.7/site-packages/pandas/core/strings.pyt str_replaces,y    * csltr(fd}t||Sd}tjdttjtj||}|SdS(s 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 Index of object 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 Single int repeats string in Series >>> s.str.repeat(repeats=2) 0 aa 1 bb 2 cc Sequence of int repeats corresponding string in Series >>> s.str.repeat(repeats=[1, 2, 3]) 0 a 1 bb 2 ccc cs?ytjj|SWn!tk r:tjj|SXdS(N(R4t binary_typet__mul__R&t text_type(R((trepeats(s2lib/python2.7/site-packages/pandas/core/strings.pytrepos cSs?ytjj||SWn!tk r:tjj||SXdS(N(R4RhRiR&Rj(R(tr((s2lib/python2.7/site-packages/pandas/core/strings.pyRlxs RN( R R%RR-R.tlibopst vec_binoptcomtvalues_from_object(R#RkRlR?((Rks2lib/python2.7/site-packages/pandas/core/strings.pyt str_repeatIs%   csV|s|tjO}ntj|d|t}fd}t|||d|S(sB Determine if each string matches a regular expression. Parameters ---------- pat : string Character sequence or regular expression case : boolean, default True If True, case sensitive flags : int, default 0 (no flags) re module flags, e.g. re.IGNORECASE na : default NaN, fill value for missing values Returns ------- Series/array of boolean values See Also -------- contains : Analogous, but less strict, relying on re.search instead of re.match. extract : Extract matched groups. RBcstj|S(N(RKtmatch(R((RD(s2lib/python2.7/site-packages/pandas/core/strings.pyREsR(R7RNRFRKR%(R#RHRSRBRTRR"((RDs2lib/python2.7/site-packages/pandas/core/strings.pyt str_matchs cCs6yt|jjjSWntk r1dSXdS(N(tlistt groupindextkeystpopt IndexErrorRc(trx((s2lib/python2.7/site-packages/pandas/core/strings.pyt_get_single_group_names csGjdkrtdntjgjfd}|S(s/Used in both extract_noexpand and extract_frameis"pattern contains no capture groupscset|tjsSj|}|r]g|jD]!}|dkrStjn|^q8SSdS(N(R+R4t string_typesR8RORcRR9(R(tmtitem(t empty_rowRD(s2lib/python2.7/site-packages/pandas/core/strings.pyR"s 2(RORdRR9(RDR"((RRDs2lib/python2.7/site-packages/pandas/core/strings.pyt_groups_or_na_funs c Csiddlm}m}tj|d|}t|}|jdkrtjg|D]}||d^qSdt }t |} nt ||rt dnd } tt|jj|jj} gt|jD]} | jd| | ^q} |jr%|d| dt }n:|g|D]}||^q/d| d |jdt }|| fS( s Find groups in each string in the Series using passed regular expression. This function is called from str_extract(expand=False), and can return Series, DataFrame, or Index. i(t DataFrametIndexRBiiRs,only one regex group is supported with IndextcolumnstindexN(tpandasRRR7RFRRORtarrayR.R{R+RdRctdictRRvR,RwtrangetgettemptyR( R#RHRBRRRDt groups_or_natvalR?tnametnamestiR((s2lib/python2.7/site-packages/pandas/core/strings.pyt_str_extract_noexpands& 2'2   c Cs ddlm}tj|d|}t|}tt|jj|jj }gt |j D]}|j d||^qh}t |dkr|d|dtSy |j} Wntk rd } nX|g|D]} || ^qd|d| dtS( s For each subject string in the Series, extract groups from the first match of regular expression pat. This function is called from str_extract(expand=True), and always returns a DataFrame. i(RRBiiRRRN(RRR7RFRRRRvR,RwRRORRR.RR'Rc( R#RHRBRRDRRRRt result_indexR((s2lib/python2.7/site-packages/pandas/core/strings.pyt_str_extract_frames  '2   cCsut|tstdn|r:t|j|d|St|j|d|\}}|j|d|d|SdS(sO 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 : string 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. .. versionadded:: 0.18.0 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[ab])(?P\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 sexpand must be True or FalseRBRtexpandN(R+RKRdRt_origRt_parentt _wrap_result(R#RHRBRR?R((s2lib/python2.7/site-packages/pandas/core/strings.pyt str_extracts ScCstj|d|}|jdkr3tdnt|tr]|jjdt}nt t |j j |j j }gt|jD]}|jd||^q}g}g}|jjdk} x|jD]\} } t| tjr| s| f} nxt|j| D]\} } t| tjrQ| f} ng| D]!}|dkrstjn|^qX}|j|t| | f}|j|q'WqqWddlm}|j|d |jjd g}|j|d |d |}|S( s 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). .. versionadded:: 0.18.0 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\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[ab])(?P\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[ab])?(?P\d)") letter digit match A 0 a 1 1 a 2 B 0 b 1 C 0 NaN 1 RBis"pattern contains no capture groupstdropiti(t MultiIndexRRsRR( R7RFRORdR+R t to_seriest reset_indexR!RRRvR,RwRRRtnlevelst iteritemsR4R|t enumerateRCRtNaNtappendttupleRRt from_tuplesRt_constructor_expanddim(R#RHRBRDRRRt match_listt index_listtis_mit subject_keytsubjecttmatch_it match_tupletgrouptna_tuplet result_keyRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pytstr_extractallVs8K'2 " +  t|cs|jd}y|||}Wn(tk rK||jt|}nXt}x'|jj|D]}|j|qhWt|dh}tj t |t |fdtj }xVt |D]H\}}|||t j|jfd|dd|f>> 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 RRcs |kS(N((R((RH(s2lib/python2.7/site-packages/pandas/core/strings.pyREsN(tfillnaR&tastypetstrtsettsplittupdatetsortedRRRtint64RR0R<R,(R#RttagsttstdummiesRtt((RHs2lib/python2.7/site-packages/pandas/core/strings.pytstr_get_dummiess   *2cCst|j|S(s 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 (R%tjoin(R#R((s2lib/python2.7/site-packages/pandas/core/strings.pytstr_joins>cCs%tj|d|}t|j|S(s7 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 : string Pattern or regular expression. flags : int, default 0 ``re`` module flags, 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 RB(R7RFR%RC(R#RHRBRD((s2lib/python2.7/site-packages/pandas/core/strings.pyt str_findall;sZtleftcsttjs9d}t|jtjn|dkrNdn!|dkrcdn tdd krfd}nfd}t ||d t S( s Return indexes in each strings in the Series/Index where the substring is fully contained between [start:end]. Return -1 on failure. Parameters ---------- sub : str Substring being searched start : int Left edge index end : int Right edge index side : {'left', 'right'}, default 'left' Specifies a starting side, equivalent to ``find`` or ``rfind`` Returns ------- found : Series/Index of integer values s!expected a string object, not {0}Rtfindtrighttrfinds Invalid sidecst|S(N(tgetattr(R((tmethodtstartR^(s2lib/python2.7/site-packages/pandas/core/strings.pyREscst|S(N(R(R((tendRRR^(s2lib/python2.7/site-packages/pandas/core/strings.pyREsRN( R+R4R|R&tformatttypet__name__RdRcR%RG(R#R^RRtsidetmsgR"((RRRR^s2lib/python2.7/site-packages/pandas/core/strings.pytstr_finds!      csttjs9d}t|jtjn|dkrNdn!|dkrcdn tddkrfd}nfd}t ||d t S( Ns!expected a string object, not {0}RRRtrindexs Invalid sidecst|S(N(R(R((RRR^(s2lib/python2.7/site-packages/pandas/core/strings.pyREscst|S(N(R(R((RRRR^(s2lib/python2.7/site-packages/pandas/core/strings.pyREsR( R+R4R|R&RRRRdRcR%RG(R#R^RRRRR"((RRRR^s2lib/python2.7/site-packages/pandas/core/strings.pyt str_indexs!      t cs ttjs9d}t|jtjntdkrZtdntsd}t|jtjn|dkrfd}nN|dkrfd}n-|d krfd }n t d t ||S( s> 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 boths 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 s%fillchar must be a character, not {0}is%fillchar must be a character, not strs&width must be of integer type, not {0}Rcs|jS(N(trjust(R((tfillchartwidth(s2lib/python2.7/site-packages/pandas/core/strings.pyREsRcs|jS(N(tljust(R((RR(s2lib/python2.7/site-packages/pandas/core/strings.pyREstbothcs|jS(N(tcenter(R((RR(s2lib/python2.7/site-packages/pandas/core/strings.pyREss Invalid side( R+R4R|R&RRRRRRdR%(R#RRRRR"((RRs2lib/python2.7/site-packages/pandas/core/strings.pytstr_pads 5! !    csdkrBdks$dkr-dnfd}ntdkrdksldkrudnfd}nBdksdkrdntjfd}t||}|S(Niics|jS(N(R(R((R`RH(s2lib/python2.7/site-packages/pandas/core/strings.pyRE&sics|jS(N(R(R((R`RH(s2lib/python2.7/site-packages/pandas/core/strings.pyRE+scsj|dS(Ntmaxsplit(R(R((R`RD(s2lib/python2.7/site-packages/pandas/core/strings.pyRE0s(RcRR7RFR%(R#RHR`R"tres((R`RHRDs2lib/python2.7/site-packages/pandas/core/strings.pyt str_split!s    csFdksdkr!dnfd}t||}|S(Niics|jS(N(trsplit(R((R`RH(s2lib/python2.7/site-packages/pandas/core/strings.pyRE9s(RcR%(R#RHR`R"R((R`RHs2lib/python2.7/site-packages/pandas/core/strings.pyt str_rsplit5s  cs.t|||fd}t||S(s" 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", "fox", "chameleon"]) >>> s 0 koala 1 fox 2 chameleon dtype: object >>> s.str.slice(start=1) 0 oala 1 ox 2 hameleon dtype: object >>> s.str.slice(stop=2) 0 ko 1 fo 2 ch dtype: object >>> s.str.slice(step=2) 0 kaa 1 fx 2 caeen dtype: object >>> s.str.slice(start=0, stop=5, step=3) 0 kl 1 f 2 cm dtype: object Equivalent behaviour to: >>> s.str[0:5:3] 0 kl 1 f 2 cm dtype: object cs|S(N((R((tobj(s2lib/python2.7/site-packages/pandas/core/strings.pyREs(tsliceR%(R#RtstoptstepR"((Rs2lib/python2.7/site-packages/pandas/core/strings.pyt str_slice>sBcs7dkrdnfd}t||S(s  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 ------- replaced : 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 Rcsp|!dkr}n}d}dk rE|| 7}n|7}dk rl|||7}n|S(NR(Rc(R(t local_stopty(R[RR(s2lib/python2.7/site-packages/pandas/core/strings.pyR"s    N(RcR%(R#RRR[R"((R[RRs2lib/python2.7/site-packages/pandas/core/strings.pytstr_slice_replacesH   Rcss|dkrfd}nH|dkr<fd}n*|dkrZfd}n tdt||S(s  Strip whitespace (including newlines) from each string in the Series/Index. Parameters ---------- to_strip : str or unicode side : {'left', 'right', 'both'}, default 'both' Returns ------- stripped : Series/Index of objects Rcs |jS(N(tstrip(R((tto_strip(s2lib/python2.7/site-packages/pandas/core/strings.pyREsRcs |jS(N(tlstrip(R((R(s2lib/python2.7/site-packages/pandas/core/strings.pyREsRcs |jS(N(trstrip(R((R(s2lib/python2.7/site-packages/pandas/core/strings.pyREss Invalid side(RdR%(R#RRR"((Rs2lib/python2.7/site-packages/pandas/core/strings.pyt str_strips    c s/||d>> 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 Rcsdjj|S(Ns (Rtwrap(ts(ttw(s2lib/python2.7/site-packages/pandas/core/strings.pyRE5s(ttextwrapt TextWrapperR%(R#Rtkwargs((Rs2lib/python2.7/site-packages/pandas/core/strings.pytstr_wraps8 csUdkrfd}n*tjr6tdnfd}t||S(sy Map all characters in the string through the given mapping table. Equivalent to standard :meth:`str.translate`. Note that the optional argument deletechars is only valid if you are using python 2. For python 3, character deletion should be specified via the table argument. Parameters ---------- table : dict (python 3), str or None (python 2) In python 3, 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. In python 2, table is either a string of length 256 or None. If the table argument is None, no translation is applied and the operation simply removes the characters in deletechars. :func:`string.maketrans` is a helper function for making translation tables. deletechars : str, optional (python 2) A string of characters to delete. This argument is only valid in python 2. Returns ------- translated : Series/Index of objects cs |jS(N(t translate(R((ttable(s2lib/python2.7/site-packages/pandas/core/strings.pyRESssdeletechars is not a valid argument for str.translate in python 3. You should simply specify character deletions in the table argumentcs|jS(N(R(R((t deletecharsR(s2lib/python2.7/site-packages/pandas/core/strings.pyREZsN(RcR4tPY3RdR%(R#RRR"((RRs2lib/python2.7/site-packages/pandas/core/strings.pyt str_translate8s   csfd}t||S(s Extract element from each component at specified position. Extract element from lists, tuples, or strings in each element in the Series/Index. Parameters ---------- i : int Position of element to extract. Returns ------- items : Series/Index of objects 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 NaN dtype: object csTt|tr|jSt|ko@t| knrM|StjS(N(R+RRRRR9(R((R(s2lib/python2.7/site-packages/pandas/core/strings.pyR"s  )(R%(R#RR"((Rs2lib/python2.7/site-packages/pandas/core/strings.pytstr_get^s2tstrictcsOtkr!fd}n!tjfd}t||S(s4 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 ------- decoded : Series/Index of objects cs|jS(N(tdecode(R((tencodingterrors(s2lib/python2.7/site-packages/pandas/core/strings.pyREscs|dS(Ni((R((tdecoderR(s2lib/python2.7/site-packages/pandas/core/strings.pyREs(t_cpython_optimized_decoderstcodecst getdecoderR%(R#RRR"((RRRs2lib/python2.7/site-packages/pandas/core/strings.pyt str_decodes  csOtkr!fd}n!tjfd}t||S(s Encode character string in the Series/Index using indicated encoding. Equivalent to :meth:`str.encode`. Parameters ---------- encoding : str errors : str, optional Returns ------- encoded : Series/Index of objects cs|jS(N(tencode(R((RR(s2lib/python2.7/site-packages/pandas/core/strings.pyREscs|dS(Ni((R((tencoderR(s2lib/python2.7/site-packages/pandas/core/strings.pyREs(t_cpython_optimized_encodersRt getencoderR%(R#RRR"((RRRs2lib/python2.7/site-packages/pandas/core/strings.pyt str_encodes  c sFfd}j|_|dk r6||_n td|S(Ncs"t|j}|j|S(N(R%RR(tselfR?(R"tkargs(s2lib/python2.7/site-packages/pandas/core/strings.pytwrapperssProvide docstring(RRct__doc__Rd(R"t docstringRR((R"Rs2lib/python2.7/site-packages/pandas/core/strings.pyt_noarg_wrappers     c s|fd}dfd}tjfd}|rB|n|rN|n|}j|_jrxj|_n|S(Ncs|j|}|j|S(N(RR(RRHR?(R"(s2lib/python2.7/site-packages/pandas/core/strings.pytwrapper1sics(|j|d||}|j|S(NRB(RR(RRHRBRR?(R"(s2lib/python2.7/site-packages/pandas/core/strings.pytwrapper2scs%|j|d|}|j|S(NRT(RR(RRHRTR?(R"(s2lib/python2.7/site-packages/pandas/core/strings.pytwrapper3s(RR9RR (R"RBRTRR R RR((R"s2lib/python2.7/site-packages/pandas/core/strings.pyt _pat_wrappers  csfd}|S(s:Copy a docstring from another source function (if present)csjrj|_n|S(N(R (ttarget(tsource(s2lib/python2.7/site-packages/pandas/core/strings.pytdo_copys ((RR((Rs2lib/python2.7/site-packages/pandas/core/strings.pytcopyst StringMethodsc Bs( eZdZdZedZdZdZee e e j dZ e dZe e e e dZded e&d d?d d@e dAZ3eed>e&d dBd dCe dDZ4eed>e&d dEd dFe dGZ5ee6dHZ7ee8dIdJZ9ee:e dKZ;e<e=dLeZ>e<e?dMeZ@e<eAdMeZBe<eCdLeZDeeEd&edNZFeeGd&dOZHdPedQ>> s.str.split('_') >>> s.str.replace('_', '') cCsQ|j|t||_|jr1|jjn||_||_|jdS(N(t _validateRt_is_categoricalR,t categoriesRRt_freeze(Rtdata((s2lib/python2.7/site-packages/pandas/core/strings.pyt__init__s   cCsddlm}t|tr_t|jr@t|jjpLt|j r_t dnt||rd }t|jr|jj }n |j }||krd}t |n|j d krd }t |qndS( Ni(RsSCan only use .str accessor with string values, which use np.object_ dtype in pandasR\tunicodetmixeds mixed-integersdCan only use .str accessor with string values (i.e. inferred_type is 'string', 'unicode' or 'mixed')is5Can only use .str accessor with Index, not MultiIndex(R\RRs mixed-integer( tpandas.core.indexRR+R RRRR,RR't inferred_typeR(RRt allowed_typestinf_typetmessage((s2lib/python2.7/site-packages/pandas/core/strings.pyR s"  cCsEt|tr4|jd|jd|jd|jS|j|SdS(NRRR(R+RRRRR(Rtkey((s2lib/python2.7/site-packages/pandas/core/strings.pyt __getitem__0s%ccsPd}|j|}x4|jjrK|V|d7}|j|}qWdS(Nii(Rtnotnatany(RRR)((s2lib/python2.7/site-packages/pandas/core/strings.pyt__iter__6s  cCsddlm}m}m}|rX|jrXt|||jdtjj d|}nt |d sxt |d r||S|j dkst |dkr|j dkrtnt}n|tkrlt|j| rld } g|D]} | | ^q}|rltd |D} g|D];} t| d ksP| d tjkrZ| | n| ^q%}qlnt|tstd n|tkr|dkrt|d d}n|dkr|jj}qnt|j|rVt|r|S|rCt|}|j|d|} | jdkr?| jd } n| S||d |SnV|jj} |r|jj}||d|d| S|jj}||d |d| SdS(Ni(RtSeriesRRt fill_valuetndimRiicSst|r|S|gSdS(N(R(R(((s2lib/python2.7/site-packages/pandas/core/strings.pytcons_rowYs css|]}t|VqdS(N(R(t.0R(((s2lib/python2.7/site-packages/pandas/core/strings.pys bsisexpand must be True or FalseRRRR( RRR'RRRRRetcattcodesthasattrR)tAssertionErrorRcR!R+tmaxRRR9RKRdRRRRuRRtget_level_valuesRRt _constructor(RR?t use_codesRRR(RR'RR*R(tmax_lentoutRtcons((s2lib/python2.7/site-packages/pandas/core/strings.pyR>sN!    K        cCsddlm}m}m}t|j|r7|jn |jj}d}t||r|jj| }|r|r||jd|n|g} | |fSt||r|j| }||jd|r|n|g} | |fSt||rS|jj| }|r2|r2|j }||_ng|D]} || ^q9|fSt|t j r|j dkr||d|}g|D]} || ^qt fSt|dt rt|}td|DrUg} t } t } x<|r+|jd} t| ||fp8t| t j o8| j d ksDt} nt| |||t j fsqt| } nt| t j r| j d kpt| ||f}|r| jtkptd | D}| st| |rt|n|j| d |\} }| | } | p%|} qW| rKtjd td dn| | fStd|Dr||d|gt fSnt|dS(s 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, Index, DataFrame, np.ndarray, list-like or list-like of objects that are Series, Index or np.ndarray (1-dim) ignore_index : boolean, default False Determines whether to forcefully align others with index of caller Returns ------- tuple : (others transformed into list of Series, boolean whether FutureWarning should be raised) i(RR'Rsothers must be Series, Index, DataFrame, np.ndarrary or list-like (either containing only strings or containing only objects of type Series/Index/list-like/np.ndarray)Rit allow_setscss!|]}t|dtVqdS(R7N(RRe(R+R(((s2lib/python2.7/site-packages/pandas/core/strings.pys siicss|]}t| VqdS(N(R(R+R(((s2lib/python2.7/site-packages/pandas/core/strings.pys st ignore_indexslist-likes other than Series, Index, or np.ndarray WITHIN another list-like are deprecated and will be removed in a future version.RJicss|]}t| VqdS(N(R(R+R(((s2lib/python2.7/site-packages/pandas/core/strings.pys sN(RRR'RR+RRtequalsR,RRR*R)ReRRuR/RxR!RR.R&t_get_series_listRPRQt FutureWarning(RtothersR8RR'Rtidxterr_msgRQtlosR(t join_warnt depr_warntnxttno_deeptis_legaltwnx((s2lib/python2.7/site-packages/pandas/core/strings.pyR:sh'*      !!!  !  !    c sddlm}m}m}t|tjr=tdn|dkrRd}nt|j |r||j d|j n |j |dkrt t }|dkr|j r|n0|dk r|j rt j||n|jSy%|j|d|dk\}} Wn8tk rn|dkr_tdqotdnX|dkr| rtjd td d n|dkrd n|}t fd |DrQ||ddd|dkr|nddtt|dtdt}j|d|\}g|D]} || ^q8}ngg|D]} t | ^q_} t jg| D]} t | ^q} t jj| dd} |dkr4| j r4t jtdt}t j|| t j| }tg| D]} | |^q|||>> 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 `. i(RR'tconcats'Did you mean to supply a `sep` keyword?RRR8sRAll arrays must be same length, except those having an index if `join` is not NonesIf `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.sA future version of pandas will perform index alignment when `others` is a Series/Index/DataFrame (or a list-like containing one). To disable alignment (the behavior before v.0.23) and silence this warning, use `.values` on any Series/Index/DataFrame in `others`. To enable alignment and silence this warning, pass `join='left'|'outer'|'inner'|'right'`. The future default will be `join='left'`.RJiRc3s%|]}jj|j VqdS(N(RR9(R+R((R(s2lib/python2.7/site-packages/pandas/core/strings.pys sRiRtinnertouterRwtsortRiRRN(#RRR'RFR+R4R|RdRcRRRR%RtwhereRR:RPRQR;RRRetalignRt logical_ortreduceRR.R:R9RRRR(RR<Rtna_repRRR'RFRRQR(tall_colstna_maskst union_maskR?t not_maskedtnmtcol((Rs2lib/python2.7/site-packages/pandas/core/strings.pyR,sh           ! &(4!s Split strings around given separator/delimiter. Splits the string in the Series/Index from the %(side)s, at the specified delimiter string. Equivalent to :meth:`str.%(method)s`. Parameters ---------- pat : str, optional String or regular expression to split on. 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 splitted strings into separate columns. * If ``True``, return DataFrame/MultiIndex expanding dimensionality. * If ``False``, return Series/Index, containing lists of strings. Returns ------- Series, Index, DataFrame or MultiIndex Type matches caller unless ``expand=True`` (see Notes). 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. Examples -------- >>> s = pd.Series(["this is a regular sentence", "https://docs.python.org/3/tutorial/index.html", np.nan]) 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 0 this is a regular 1 https://docs.python.org/3/tutorial/index.html None None None 2 NaN NaN NaN NaN 4 0 sentence 1 None 2 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 Rt beginningRRRicCs+t|j|d|}|j|d|S(NR`R(RRR(RRHR`RR?((s2lib/python2.7/site-packages/pandas/core/strings.pyRT sRRcCs+t|j|d|}|j|d|S(NR`R(RRR(RRHR`RR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR[ ss 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. pat : str, default whitespace .. deprecated:: 0.24.0 Use ``sep`` instead 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 containining 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(levels=[['X', 'Y'], [' '], ['123', '999']], codes=[[0, 1], [0, 0], [0, 1]]) Or an index with tuples with ``expand=False``: >>> idx.str.partition(expand=False) Index([('X', ' ', '123'), ('Y', ' ', '999')], dtype='object') t str_partitiontfirstsF3 elements containing the string itself, followed by two empty stringstreturns>rpartition : Split the string at the last occurrence of `sep`.talsot old_arg_nameRHt new_arg_nameRRcs4fd}t||j}|j|d|S(Ncs |jS(N(t partition(R((R(s2lib/python2.7/site-packages/pandas/core/strings.pyRE sR(R%RR(RRRR"R?((Rs2lib/python2.7/site-packages/pandas/core/strings.pyR\ s tlastsF3 elements containing two empty strings, followed by the string itselfs>partition : Split the string at the first occurrence of `sep`.cs4fd}t||j}|j|d|S(Ncs |jS(N(t rpartition(R((R(s2lib/python2.7/site-packages/pandas/core/strings.pyRE sR(R%RR(RRRR"R?((Rs2lib/python2.7/site-packages/pandas/core/strings.pyR^ s cCst|j|}|j|S(N(RRR(RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR scCst|j|}|j|S(N(RRR(RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR sic Cs=t|j|d|d|d|d|}|j|d|S(NRSRBRTRDR((RVRR(RRHRSRBRTRDR?((s2lib/python2.7/site-packages/pandas/core/strings.pytcontains s! c Cs7t|j|d|d|d|}|j|d|S(NRSRBRTR((RtRR(RRHRSRBRTR?((s2lib/python2.7/site-packages/pandas/core/strings.pyRs s$c Cs:t|j||d|d|d|d|}|j|S(NR`RSRBRD(RgRR(RRHR[R`RSRBRDR?((s2lib/python2.7/site-packages/pandas/core/strings.pyRa scCst|j|}|j|S(N(RrRR(RRkR?((s2lib/python2.7/site-packages/pandas/core/strings.pytrepeat sRcCs+t|j|d|d|}|j|S(NRR(RRR(RRRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pytpad ss Filling %(side)s side of strings in the Series/Index with an additional character. 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 ------- filled : Series/Index of objects Rsleft and rightRcCs|j|ddd|S(NRRR(Ra(RRR((s2lib/python2.7/site-packages/pandas/core/strings.pyR sRRcCs|j|ddd|S(NRRR(Ra(RRR((s2lib/python2.7/site-packages/pandas/core/strings.pyR sRcCs|j|ddd|S(NRRR(Ra(RRR((s2lib/python2.7/site-packages/pandas/core/strings.pyR scCs+t|j|dddd}|j|S(s1 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 boths 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 regular character and the zero is added to the left 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 0-1 1 001 2 1000 3 NaN 4 NaN dtype: object RRRt0(RRR(RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pytzfill s<cCs%t|j|||}|j|S(N(RRR(RRRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyRP scCs%t|j|||}|j|S(N(RRR(RRRR[R?((s2lib/python2.7/site-packages/pandas/core/strings.pyt slice_replaceU sRcCs"t|j||}|j|S(N(RRR(RRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyRZ scCs"t|j||}|j|S(N(RRR(RRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR_ ssz Remove leading and trailing characters. Strip whitespaces (including newlines) or a set of specified characters from each string in the Series/Index from %(side)s. 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/Index of objects 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]) >>> s 0 1. Ant. 1 2. Bee!\n 2 3. Cat?\t 3 NaN dtype: object >>> s.str.strip() 0 1. Ant. 1 2. Bee! 2 3. Cat? 3 NaN dtype: object >>> s.str.lstrip('123.') 0 Ant. 1 Bee!\n 2 Cat?\t 3 NaN dtype: object >>> s.str.rstrip('.!? \n\t') 0 1. Ant 1 2. Bee 2 3. Cat 3 NaN dtype: object >>> s.str.strip('123.!? \n\t') 0 Ant 1 Bee 2 Cat 3 NaN dtype: object Rsleft and right sidesRcCs%t|j|dd}|j|S(NRR(RRR(RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR ss left sideRcCs%t|j|dd}|j|S(NRR(RRR(RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR ss right sideRcCs%t|j|dd}|j|S(NRR(RRR(RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR scKs"t|j||}|j|S(N(RRR(RRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR sRcCs\|jr|jjtn|j}t||\}}|j|d|j d|dtS(NR3RR(RRRRRRRR!(RRRR?R((s2lib/python2.7/site-packages/pandas/core/strings.pyt get_dummies s$cCs"t|j||}|j|S(N(RRR(RRRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR sRBRTcCst||d|d|S(NRBR(R(RRHRBR((s2lib/python2.7/site-packages/pandas/core/strings.pytextract scCst|j|d|S(NRB(RR(RRHRB((s2lib/python2.7/site-packages/pandas/core/strings.pyt extractall ss Return %(side)s indexes in each strings in the Series/Index 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 ------- found : Series/Index of integer values See Also -------- %(also)s Rtlowests/rfind : Return highest indexes in each strings.c Cs1t|j|d|d|dd}|j|S(NRRRR(RRR(RR^RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR s$thighestRs-find : Return lowest indexes in each strings.c Cs1t|j|d|d|dd}|j|S(NRRRR(RRR(RR^RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR scs=ddlfd}t||j}|j|S(sk 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 ------- normalized : Series/Index of objects iNcsjtj|S(N(t normalizeR4tu_safe(R((tformt unicodedata(s2lib/python2.7/site-packages/pandas/core/strings.pyRE s(RmR%RR(RRlR"R?((RlRms2lib/python2.7/site-packages/pandas/core/strings.pyRj s s& Return %(side)s indexes in each strings 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 ------- found : Series/Index of objects See Also -------- %(also)s Rtsimilars0rindex : Return highest indexes in each strings.c Cs1t|j|d|d|dd}|j|S(NRRRR(RRR(RR^RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR' sRs.index : Return lowest indexes in each strings.c Cs1t|j|d|d|dd}|j|S(NRRRR(RRR(RR^RRR?((s2lib/python2.7/site-packages/pandas/core/strings.pyR/ ss Computes 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 RR Rs\ Convert strings in the Series/Index to %(type)s. Equivalent to :meth:`str.%(method)s`. Returns ------- Series/Index of objects 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. 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 t casemethodsRt lowercasetlowert uppercaseRMt titlecasettitlesbe capitalizedt capitalizes be swapcasedtswapcasecCs |jS(N(Rq(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE scCs |jS(N(RM(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE scCs |jS(N(Rt(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE scCs |jS(N(Ru(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE scCs |jS(N(Rv(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE ss 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 seperated by whitespace characters. >>> s5.str.istitle() 0 False 1 True 2 False 3 False dtype: bool t ismethodst alphanumerictisalnumt alphabetictisalphatdigitstisdigitt whitespacetisspacetislowertisuppertistitletnumerict isnumerictdecimalt isdecimalcCs |jS(N(Ry(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyREQ scCs |jS(N(R{(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRET scCs |jS(N(R}(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyREW scCs |jS(N(R(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyREZ scCs |jS(N(R(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE] scCs |jS(N(R(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyRE` scCs |jS(N(R(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyREc scCstj|jS(N(R4RkR(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyREf scCstj|jS(N(R4RkR(R(((s2lib/python2.7/site-packages/pandas/core/strings.pyREi scCs|j|||S(N(R(tclsR((s2lib/python2.7/site-packages/pandas/core/strings.pyt_make_accessorm s (aRt __module__R Rt staticmethodRR#R&R!RcRR9RReR:R,t _shared_docsRRRRR\R^RRRRRRVR_RtRsRgRaRrR`RRaRRRRRcRRRRdRRRRRRRRRRReRRRRIR]RXRWRZRYRRCRRfRRgRRRjRRR RRGRqRMRtRuRvRyR{R}RRRRRRt classmethodR(((s2lib/python2.7/site-packages/pandas/core/strings.pyRsH  #  P pT     T              ?    A              *     0 B                  (sutf-8Rslatin-1Rs iso-8859-1RR(sutf-16sutf-32(VRR7RRPtnumpyRtpandas._libs.libt_libsR0tpandas._libs.opstopsRnt pandas.compatR4Rtpandas.util._decoratorsRRtpandas.core.dtypes.commonRRRRRRR R R tpandas.core.dtypes.genericR R tpandas.core.dtypes.missingRtpandas.core.algorithmsRtpandas.core.baseRtpandas.core.commontcoretcommonRpRRRRRR9R.R%ReR RIR!RVRXRZRcRgRrRtR{RRRRRRRRRRRRRRRRRRRRRR RRR(((s2lib/python2.7/site-packages/pandas/core/strings.pytsn     @  ) E77 :#   ! \ q 3 A ^(L G[ ? & ;