a LfK@sdZddlZddlZddlmZmZmZmZmZm Z m Z m Z ddl mZddlmZmZmZmZmZmZmZmZmZmZmZmZmZm Z!m"Z#m$Z%m&Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0gdZ1e2ej3j4Z5ddZ6d d Z7d d Z8d dZ ddZ9dPddZdQddZdRddZdSddZ dTddZ"dUddZ$dVddZ&dWdd Z:dXd!d"Z;dYd$d%Zd\d+d,Z?d]d-d.Z@d^d/d0ZAd_d1d2ZBd3d4ZCd5d6ZDd7d8ZEd9d:ZFd;d<ZGd=d>ZHd`d@dAZIdBdCZJdadDdEZKdbdFdGZLdcdHdIZMdJdKZNdLdMZOdddNdOZPdS)ezK This module contains a set of functions for vectorized string operations. N)equal not_equalless less_equalgreater greater_equaladdmultiply) _vec_string)isalphaisdigitisspaceisalnumislowerisupperistitle isdecimal isnumericstr_lenfindrfindindexrindexcount startswithendswith_lstrip_whitespace _lstrip_chars_rstrip_whitespace _rstrip_chars_strip_whitespace _strip_chars_replace_expandtabs_length _expandtabs)+rrrrrrrr r r r rrrrrrrrrrrrrrlstriprstripstripreplace expandtabscenterljustrjustzfillupperlowerswapcase capitalizetitlemoddecodeencode translatecCs t|jjtjr|jdS|jS)z Helper function that returns the number of characters per field in a string or unicode array. This is to abstract out the fact that for a unicode array this is itemsize / 4. ) issubclassdtypetypenpstr_itemsize)ar?L/var/www/ai-form-bot/venv/lib/python3.9/site-packages/numpy/_core/strings.py_get_num_charsBs rAcCsft|}|jdkr ||jSt|}t|jtjjrN|t |jS|t |jt |S)z Helper function to cast a result back into an array with the appropriate dtype if an object array must be used as an intermediary. r) r;asarraysizeZastyper9tolist isinstancedtypes StringDTyper:rA)resultZoutput_dtype_likeretr?r?r@_to_bytes_or_str_arrayMs   rJcGs(g}|D]}|durq$||q|S)a! Helper function for delegating arguments to Python string functions. Many of the Python string operations that have optional arguments do not use 'None' to indicate a default value. In these cases, we need to remove all None arguments, and those following them. N)append)argsZnewargsZchkr?r?r@ _clean_args^s  rMcCst|}t|}t|jtjs6td|jdt|d}|jjdkrV||St|}t |t j t|dkrt d||}|jj| }tj||j|d}t|||dS) aQ Return (a * i), that is string multiple concatenation, element-wise. Values in ``i`` of less than 0 are treated as 0 (which yields an empty string). Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype i : array_like, with any integer dtype Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types Examples -------- >>> a = np.array(["a", "b", "c"]) >>> np.strings.multiply(a, 3) array(['aaa', 'bbb', 'ccc'], dtype='>> i = np.array([1, 2, 3]) >>> np.strings.multiply(a, i) array(['a', 'bb', 'ccc'], dtype='>> np.strings.multiply(np.array(['a']), i) array(['a', 'aa', 'aaa'], dtype='>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3)) >>> np.strings.multiply(a, 3) array([['aaa', 'bbb', 'ccc'], ['ddd', 'eee', 'fff']], dtype='>> np.strings.multiply(a, i) array([['a', 'bb', 'ccc'], ['d', 'ee', 'fff']], dtype='iZa_len buffersizes out_dtyperSr?r?r@r os'    r cCstt|tjd|f|S)a Return (a % i), that is pre-Python 2.6 string formatting (interpolation), element-wise for a pair of array_likes of str or unicode. Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype values : array_like of values These values will be element-wise interpolated into the string. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types __mod__rJr r;object_)r>valuesr?r?r@r3sr3cCs|dur |nt}t||||S)a For each element, return the lowest index in the string where substring ``sub`` is found, such that ``sub`` is contained in the range [``start``, ``end``). Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype sub : array_like, with `np.bytes_` or `np.str_` dtype The substring to search for. start, end : array_like, with any integer dtype The range to look in, interpreted as in slice notation. Returns ------- y : ndarray Output array of ints See Also -------- str.find Examples -------- >>> a = np.array(["NumPy is a Python library"]) >>> np.strings.find(a, "Python") array([11]) N)MAX _find_ufuncr>substartendr?r?r@rs rcCs|dur |nt}t||||S)aj For each element, return the highest index in the string where substring ``sub`` is found, such that ``sub`` is contained in the range [``start``, ``end``). Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype The substring to search for. start, end : array_like, with any integer dtype The range to look in, interpreted as in slice notation. Returns ------- y : ndarray Output array of ints See Also -------- str.rfind N)rh _rfind_ufuncrjr?r?r@rsrcCs|dur |nt}t||||S)aM Like `find`, but raises :exc:`ValueError` when the substring is not found. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype start, end : array_like, with any integer dtype, optional Returns ------- out : ndarray Output array of ints. See Also -------- find, str.index Examples -------- >>> a = np.array(["Computer Science"]) >>> np.strings.index(a, "Science", start=0, end=None) array([9]) N)rh _index_ufuncrjr?r?r@rsrcCs|dur |nt}t||||S)aY Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is not found. Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype sub : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype start, end : array-like, with any integer dtype, optional Returns ------- out : ndarray Output array of ints. See Also -------- rfind, str.rindex Examples -------- >>> a = np.array(["Computer Science"]) >>> np.strings.rindex(a, "Science", start=0, end=None) array([9]) N)rh _rindex_ufuncrjr?r?r@r'srcCs|dur |nt}t||||S)a Returns an array with the number of non-overlapping occurrences of substring ``sub`` in the range [``start``, ``end``). Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sub : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype The substring to search for. start, end : array_like, with any integer dtype The range to look in, interpreted as in slice notation. Returns ------- y : ndarray Output array of ints See Also -------- str.count Examples -------- >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> c array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.count(c, 'A') array([3, 1, 1]) >>> np.strings.count(c, 'aA') array([3, 1, 0]) >>> np.strings.count(c, 'A', start=1, end=4) array([2, 1, 1]) >>> np.strings.count(c, 'A', start=1, end=3) array([1, 0, 0]) N)rh _count_ufuncrjr?r?r@rHs'rcCs|dur |nt}t||||S)aT Returns a boolean array which is `True` where the string element in ``a`` starts with ``prefix``, otherwise `False`. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype prefix : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype start, end : array_like, with any integer dtype With ``start``, test beginning at that position. With ``end``, stop comparing at that position. Returns ------- out : ndarray Output array of bools See Also -------- str.startswith N)rh_startswith_ufunc)r>prefixrlrmr?r?r@rssrcCs|dur |nt}t||||S)aN Returns a boolean array which is `True` where the string element in ``a`` ends with ``suffix``, otherwise `False`. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype suffix : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype start, end : array_like, with any integer dtype With ``start``, test beginning at that position. With ``end``, stop comparing at that position. Returns ------- out : ndarray Output array of bools See Also -------- str.endswith Examples -------- >>> s = np.array(['foo', 'bar']) >>> s array(['foo', 'bar'], dtype='>> np.strings.endswith(s, 'ar') array([False, True]) >>> np.strings.endswith(s, 'a', start=1, end=2) array([False, True]) N)rh_endswith_ufunc)r>suffixrlrmr?r?r@rs#rcCs"tt|tjdt||tdS)a Calls :meth:`bytes.decode` element-wise. The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the :mod:`codecs` module. Parameters ---------- a : array_like, with ``bytes_`` dtype encoding : str, optional The name of an encoding errors : str, optional Specifies how to handle encoding errors Returns ------- out : ndarray See Also -------- :py:meth:`bytes.decode` Notes ----- The type of the result will depend on the encoding specified. Examples -------- >>> c = np.array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', ... b'\x81\x82\xc2\xc1\xc2\x82\x81']) >>> c array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@', b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7') >>> np.strings.decode(c, encoding='cp037') array(['aAaAaA', ' aA ', 'abBABba'], dtype='encodingerrorsr?r?r@r4s)r4cCs"tt|tjdt||tdS)u5 Calls :meth:`str.encode` element-wise. The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the :mod:`codecs` module. Parameters ---------- a : array_like, with ``StringDType`` or ``str_`` dtype encoding : str, optional The name of an encoding errors : str, optional Specifies how to handle encoding errors Returns ------- out : ndarray See Also -------- str.encode Notes ----- The type of the result will depend on the encoding specified. Examples -------- >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.encode(a, encoding='cp037') array([b'ÁÁÁ', b'@@Á@@', b'‚ÂÁ‚'], dtype='|S7') r5)rJr r;rfrMbytes_rwr?r?r@r5s&r5cCs~t|}t|}|jjdkr@t|j|j}tj||d}n0t||}|jj|}tj||j|d}t |||dS)ai Return a copy of each string element where all tab characters are replaced by one or more spaces. Calls :meth:`str.expandtabs` element-wise. Return a copy of each string element where all tab characters are replaced by one or more spaces, depending on the current column and the given `tabsize`. The column number is reset to zero after each newline occurring in the string. This doesn't understand other non-printing characters or escape sequences. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array tabsize : int, optional Replace tabs with `tabsize` number of spaces. If not given defaults to 8 spaces. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input type See Also -------- str.expandtabs Examples -------- >>> a = np.array([' Hello world']) >>> np.strings.expandtabs(a, tabsize=4) # doctest: +SKIP array([' Hello world'], dtype='tabsizerQrSrbrcr?r?r@r)s&    r) cCs\t|}t|}tt|j}t|jtjr@tj |}t |t |j|d||fS)a Return a copy of `a` with its elements centered in a string of length `width`. Calls :meth:`str.center` element-wise. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype width : array_like, with any integer dtype The length of the resulting strings, unless ``width < str_len(a)``. fillchar : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Optional padding character to use (default is space). Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.center Notes ----- This function is intended to work with arrays of strings. The fill character is not applied to numeric types. Examples -------- >>> c = np.array(['a1b2','1b2a','b2a1','2a1b']); c array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='>> np.strings.center(c, width=9) array([' a1b2 ', ' 1b2a ', ' b2a1 ', ' 2a1b '], dtype='>> np.strings.center(c, width=9, fillchar='*') array(['***a1b2**', '***1b2a**', '***b2a1**', '***2a1b**'], dtype='>> np.strings.center(c, width=1) array(['a', '1', 'b', '2'], dtype='widthfillchara_arr width_arrrCr?r?r@r*Cs*   r*cCsxt|}t|}tt|j}t|jtjr@tj |}t |jtj j rX|j}nt |j|}t||d||fS)ac Return an array with the elements of `a` left-justified in a string of length `width`. Calls :meth:`str.ljust` element-wise. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype width : array_like, with any integer dtype The length of the resulting strings, unless ``width < str_len(a)``. fillchar : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Optional character to use for padding (default is space). Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.ljust Examples -------- >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.ljust(c, width=3) array(['aAa', ' a', 'abB'], dtype='rrrrrCZ res_dtyper?r?r@r+vs    r+cCsxt|}t|}tt|j}t|jtjr@tj |}t |jtj j rX|j}nt |j|}t||d||fS)aa Return an array with the elements of `a` right-justified in a string of length `width`. Calls :meth:`str.rjust` element-wise. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype width : array_like, with any integer dtype The length of the resulting strings, unless ``width < str_len(a)``. fillchar : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Optional padding character to use (default is space). Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.rjust Examples -------- >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.rjust(a, width=3) array(['aAa', ' a', 'abB'], dtype='>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> c array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.lstrip(c, 'a') array(['AaAaA', ' aA ', 'bBABba'], dtype='>> np.strings.lstrip(c, 'A') # leaves c unchanged array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> (np.strings.lstrip(c, ' ') == np.strings.lstrip(c, '')).all() np.False_ >>> (np.strings.lstrip(c, ' ') == np.strings.lstrip(c)).all() np.True_ N)rrr>charsr?r?r@r%s)r%cCs|durt|St||S)a For each element in `a`, return a copy with the trailing characters removed. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype chars : scalar with the same dtype as ``a``, optional The ``chars`` argument is a string specifying the set of characters to be removed. If ``None``, the ``chars`` argument defaults to removing whitespace. The ``chars`` argument is not a prefix or suffix; rather, all combinations of its values are stripped. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.rstrip Examples -------- >>> c = np.array(['aAaAaA', 'abBABba']) >>> c array(['aAaAaA', 'abBABba'], dtype='>> np.strings.rstrip(c, 'a') array(['aAaAaA', 'abBABb'], dtype='>> np.strings.rstrip(c, 'A') array(['aAaAa', 'abBABba'], dtype='>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> c array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.strip(c) array(['aAaAaA', 'aA', 'abBABba'], dtype='>> np.strings.strip(c, 'a') array(['AaAaA', ' aA ', 'bBABb'], dtype='>> np.strings.strip(c, 'A') array(['aAaAa', ' aA ', 'abBABba'], dtype='t|}t|}tt|j}t|t|j|d|fS)a= Return the numeric string left-filled with zeros Calls :meth:`str.zfill` element-wise. Parameters ---------- a : array_like, with ``StringDType``, ``bytes_`` or ``str_`` dtype Input array. width : int Width of string to left-fill elements in `a`. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.zfill Examples -------- >>> np.strings.zfill('1', 3) array('001', dtype='rrrrCr?r?r@r-Us   r-cCst|}t||jdS)a Return an array with the elements converted to uppercase. Calls :meth:`str.upper` element-wise. For 8-bit strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.upper Examples -------- >>> c = np.array(['a1b c', '1bca', 'bca1']); c array(['a1b c', '1bca', 'bca1'], dtype='>> np.strings.upper(c) array(['A1B C', '1BCA', 'BCA1'], dtype='rr?r?r@r.ys r.cCst|}t||jdS)a Return an array with the elements converted to lowercase. Call :meth:`str.lower` element-wise. For 8-bit strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.lower Examples -------- >>> c = np.array(['A1B C', '1BCA', 'BCA1']); c array(['A1B C', '1BCA', 'BCA1'], dtype='>> np.strings.lower(c) array(['a1b c', '1bca', 'bca1'], dtype='>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5'); c array(['a1B c', '1b Ca', 'b Ca1', 'cA1b'], dtype='|S5') >>> np.strings.swapcase(c) array(['A1b C', '1B cA', 'B cA1', 'Ca1B'], dtype='|S5') r0rrr?r?r@r0s" r0cCst|}t||jdS)a Return a copy of ``a`` with only the first character of each element capitalized. Calls :meth:`str.capitalize` element-wise. For byte strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array of strings to capitalize. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.capitalize Examples -------- >>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4'); c array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='|S4') >>> np.strings.capitalize(c) array(['A1b2', '1b2a', 'B2a1', '2a1b'], dtype='|S4') r1rrr?r?r@r1s" r1cCst|}t||jdS)aI Return element-wise title cased version of string or unicode. Title case words start with uppercase characters, all remaining cased characters are lowercase. Calls :meth:`str.title` element-wise. For 8-bit strings, this method is locale-dependent. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.title Examples -------- >>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c array(['a1b c', '1b ca', 'b ca1', 'ca1b'], dtype='|S5') >>> np.strings.title(c) array(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'], dtype='|S5') r2rrr?r?r@r2 s$ r2c Cst|}|j}tj|t|d|d}tj|t|d|d}t|}|jjdkr`t||||Sttjj}t ||d|}t |dk|t ||}t ||t |t |}|jj|} tj ||j| d} t||||| dS)a For each element in ``a``, return a copy of the string with occurrences of substring ``old`` replaced by ``new``. Parameters ---------- a : array_like, with ``bytes_`` or ``str_`` dtype old, new : array_like, with ``bytes_`` or ``str_`` dtype count : array_like, with ``int_`` dtype If the optional argument ``count`` is given, only the first ``count`` occurrences are replaced. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.replace Examples -------- >>> a = np.array(["That is a mango", "Monkeys eat mangos"]) >>> np.strings.replace(a, 'mango', 'banana') array(['That is a banana', 'Monkeys eat bananas'], dtype='>> a = np.array(["The dish is fresh", "This is it"]) >>> np.strings.replace(a, 'is', 'was') array(['The dwash was fresh', 'Thwas was it'], dtype='oldnewrZarrZa_dtZ max_int64countsrbrcrSr?r?r@r(3s$   r(cCstt|tjd|f|S)a Return a string which is the concatenation of the strings in the sequence `seq`. Calls :meth:`str.join` element-wise. Parameters ---------- sep : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype seq : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types See Also -------- str.join Examples -------- >>> np.strings.join('-', 'osd') # doctest: +SKIP array('o-s-d', dtype='>> np.strings.join(['-', '.'], ['ghc', 'osd']) # doctest: +SKIP array(['g-h-c', 'o.s.d'], dtype='>> x = np.array("Numpy is nice!") >>> np.strings.split(x, " ") # doctest: +SKIP array(list(['Numpy', 'is', 'nice!']), dtype=object) # doctest: +SKIP >>> np.strings.split(x, " ", 1) # doctest: +SKIP array(list(['Numpy', 'is nice!']), dtype=object) # doctest: +SKIP See Also -------- str.split, rsplit splitr r;rfrMr>rmaxsplitr?r?r@_splits'rcCst|tjd|gt|S)a For each element in `a`, return a list of the words in the string, using `sep` as the delimiter string. Calls :meth:`str.rsplit` element-wise. Except for splitting from the right, `rsplit` behaves like `split`. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype sep : str or unicode, optional If `sep` is not specified or None, any whitespace string is a separator. maxsplit : int, optional If `maxsplit` is given, at most `maxsplit` splits are done, the rightmost ones. Returns ------- out : ndarray Array of list objects See Also -------- str.rsplit, split Examples -------- >>> a = np.array(['aAaAaA', 'abBABba']) >>> np.strings.rsplit(a, 'A') # doctest: +SKIP array([list(['a', 'a', 'a', '']), # doctest: +SKIP list(['abB', 'Bba'])], dtype=object) # doctest: +SKIP rsplitrrr?r?r@_rsplits(rcCst|tjdt|S)a For each element in `a`, return a list of the lines in the element, breaking at line boundaries. Calls :meth:`str.splitlines` element-wise. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype keepends : bool, optional Line breaks are not included in the resulting list unless keepends is given and true. Returns ------- out : ndarray Array of list objects See Also -------- str.splitlines splitlinesr)r>keependsr?r?r@ _splitlinessrcCstt|tjd|f|S)aS Partition each element in `a` around `sep`. Calls :meth:`str.partition` element-wise. For each element in `a`, split the element as the first occurrence of `sep`, and return 3 strings containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return 3 strings containing the string itself, followed by two empty strings. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array sep : {str, unicode} Separator to split each string element in `a`. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types. The output array will have an extra dimension with 3 elements per input element. Examples -------- >>> x = np.array(["Numpy is nice!"]) >>> np.strings.partition(x, " ") # doctest: +SKIP array([['Numpy', ' ', 'is nice!']], dtype='rr?r?r@ _partitions%rcCstt|tjd|f|S)a Partition (split) each element around the right-most separator. Calls :meth:`str.rpartition` element-wise. For each element in `a`, split the element as the last occurrence of `sep`, and return 3 strings containing the part before the separator, the separator itself, and the part after the separator. If the separator is not found, return 3 strings containing the string itself, followed by two empty strings. Parameters ---------- a : array-like, with ``StringDType``, ``bytes_``, or ``str_`` dtype Input array sep : str or unicode Right-most separator to split each element in array. Returns ------- out : ndarray Output array of ``StringDType``, ``bytes_`` or ``str_`` dtype, depending on input types. The output array will have an extra dimension with 3 elements per input element. See Also -------- str.rpartition Examples -------- >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.rpartition(a, 'A') # doctest: +SKIP array([['aAaAa', 'A', ''], # doctest: +SKIP [' a', 'A', ' '], # doctest: +SKIP ['abB', 'A', 'Bba']], dtype='>> a = np.array(['a1b c', '1bca', 'bca1']) >>> table = a[0].maketrans('abc', '123') >>> deletechars = ' ' >>> np.char.translate(a, table, deletechars) array(['112 3', '1231', '2311'], dtype='tableZ deletecharsrr?r?r@r6Us#   r6)rN)rN)rN)rN)rN)rN)rN)NN)NN)r|)r~)r~)r~)N)N)N)r)NN)NN)N)N)Q__doc__r[numpyr;rrrrrrrr r`Znumpy._core.multiarrayr Znumpy._core.umathr r r rrrrrrrrrirrnrrorrprrqrrrrrtrrrrr r!r"r#r$__all__rrr^rhrArJrMr3r4r5r)r*r+r,r%r&r'r-r.r/r0r1r2r(rrrrrrr6r?r?r?r@sT( p > $  ! +  ' . + 3 3 - . . ) -$##&&( 7# + , )+