-iSrSSKrSSKrSSKrSSKJrJrJrJrJ r J r J r SSKJ r SSKJr SSKJrJr SSKJrJrJrJrJrJrJrJrJrJrJrJrJ r J!r!J"r"J#r#J$r$J%r%J&r&J'r'J(r(J)r)J*r*J+r+J,r,J-r-J.r.J/r/ SSKJ0r1 SS KJ2r3 SS KJ4r5 SS KJ6r7 SS KJ8r9 SS KJ:r; SSKJ\>"5 /SQr?\R"\R5RrC\R"\SS9rSrESrFSrGSrH\"S5\"\H5S55r SrI\"S5\"\I5S55rJ\"S5SDSj5r4\"S5SDSj5r8\"S5SDSj5r6\"S5SDSj5r:\"S5SDSj5r0\"S5SDSj5r<\"S5SDS j5r2SES!jrK\"S5\"\K5SES"j55rL\"S5\"\K5SES#j55rMSFS$jrN\"S5\"\N5SGS%j55rOSFS&jrP\"S5\"\P5SHS'j55rQ\"S5\"\P5SHS(j55rR\"S5\"\P5SHS)j55rSS*rT\"S5\"\T5S+55rU\"S5SFS,j5rV\"S5SFS-j5rW\"S5SFS.j5rXS/rY\"S5\"\Y5S055rZ\"S5\"\Y5S155r[\"S5\"\Y5S255r\\"S5\"\Y5S355r]\"S5\"\Y5S455r^SFS5jr_\"S5\"\_5SIS6j55r`S7ra\"\a5S85rbSES9jrc\"\c5SES:j5rd\"\c5SES;j5reSFS<jrf\"\f5SFS=j5rgS>rh\"S5\"\h5S?55ri\"S5\"\h5S@55rjSFSAjrk\"S5\"\k5SFSBj55rl\"S5S\RS4SCj5rng)JzK This module contains a set of functions for vectorized string operations. N)addequalgreater greater_equalless less_equal not_equal)multiply) _vec_string)array_function_dispatch set_module)_center _expandtabs_expandtabs_length_ljust _lstrip_chars_lstrip_whitespace _partition_partition_index_replace_rjust _rpartition_rpartition_index _rstrip_chars_rstrip_whitespace_slice _strip_chars_strip_whitespace_zfillisalnumisalpha isdecimalisdigitislower isnumericisspaceistitleisupperstr_len)count)endswith)find)index)rfind)rindex) startswithc [[[[[[ [ [[[4 HnSUl URUl M g)N numpy.strings) r r!r"r#r$r%r&r'r(r) __module____name__ __qualname__)ufuncs F/var/www/html/venv/lib/python3.13/site-packages/numpy/_core/strings.py_override___module__r8Ms:)Wgy''+"^^ ).rr rrrrrr r!r#r&r r$r(r'r"r%r)r,r.r-r/r*r0r+lstriprstripstripreplace expandtabscenterljustrjustzfill partition rpartitionsliceupperlowerswapcase capitalizetitlemoddecodeencode translater2)modulec[URR[R5(aUR S-$UR $)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_itemsizeas r7_get_num_charsrZss5 !'',,((zzQ ::r9c[R"U5nURS:XaURUR5$[R"UR 55n[ UR[RR5(a$UR[UR55$UR[UR5"[U555$)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) rUasarraysizeastyperStolist isinstancedtypes StringDTyperTrZ)resultoutput_dtype_likerets r7_to_bytes_or_str_arrayrf~s  #45 {{a}}.4455 **V]]_ %C#))299+@+@AAzz$066788 ::d,223N34GH IIr9cJ/nUHnUc U$URU5 M U$)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. )append)argsnewargschks r7 _clean_argsrls5G ;  N s Nr9cU4$N)rYis r7_multiply_dispatcherrq 4Kr9c[R"U5n[R"U5n[R"UR[R5(d[ SURS35e[R "US5nURRS:XaX-$[U5n[R"U[R[R "US5- :5(a [S5eX!-nURRUR53n[R"XRUS9n[!XUS9$) a 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 -------- >>> import numpy as np >>> 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='>> import numpy as np >>> a = np.array(["NumPy is a %s library"]) >>> np.strings.mod(a, values=["Python"]) array(['NumPy is a Python library'], dtype='>> a = np.array([b'%d bytes', b'%d bits']) >>> values = np.array([8, 64]) >>> np.strings.mod(a, values) array([b'8 bytes', b'64 bits'], dtype='|S7') __mod__rfr rUobject_rs r7rKrKs(D "Arzz9vi8! ==r9c0UbUO[n[XX#5$)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 -------- >>> import numpy as np >>> a = np.array(["NumPy is a Python library"]) >>> np.strings.find(a, "Python") array([11]) )MAX _find_ufuncrYsubstartends r7r,r,sD#cC qu **r9c0UbUO[n[XX#5$)ai 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 Examples -------- >>> import numpy as np >>> a = np.array(["Computer Science"]) >>> np.strings.rfind(a, "Science", start=0, end=None) array([9]) >>> np.strings.rfind(a, "Science", start=0, end=8) array([-1]) >>> b = np.array(["Computer Science", "Science"]) >>> np.strings.rfind(b, "Science", start=0, end=None) array([9, 0]) )r _rfind_ufuncrs r7r.r.5sN#cC  ++r9c0UbUO[n[XX#5$)a 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 -------- >>> import numpy as np >>> a = np.array(["Computer Science"]) >>> np.strings.index(a, "Science", start=0, end=None) array([9]) )r _index_ufuncrs r7r-r-`s<#cC  ++r9c0UbUO[n[XX#5$)a Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is not found. Parameters ---------- a : array-like, with `np.bytes_` or `np.str_` dtype sub : array-like, with `np.bytes_` or `np.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]) )r _rindex_ufuncrs r7r/r/s<#cC  ,,r9c0UbUO[n[XX#5$)ak 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 -------- >>> import numpy as np >>> 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]) )r _count_ufuncrs r7r*r*sR#cC  ++r9c0UbUO[n[XX#5$)a 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 Examples -------- >>> import numpy as np >>> s = np.array(['foo', 'bar']) >>> s array(['foo', 'bar'], dtype='>> np.strings.startswith(s, 'fo') array([True, False]) >>> np.strings.startswith(s, 'o', start=1, end=2) array([True, False]) )r_startswith_ufunc)rYprefixrrs r7r0r0sJ#cC Q 33r9c0UbUO[n[XX#5$)a 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 -------- >>> import numpy as np >>> 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]) )r_endswith_ufunc)rYsuffixrrs r7r+r+sJ#cC 1e 11r9cU4$rnrorYencodingerrorss r7_code_dispatcherr#rrr9c [[U[RS[ X55[R "S55$)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 -------- >>> import numpy as np >>> 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='>> import numpy as np >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.encode(a, encoding='cp037') array([b'ÁÁÁ', b'@@Á@@', b'‚ÂÁ‚'], dtype='|S7') rMr9)rfr rUrrlbytes_rs r7rMrMXs4R "Arzz8[-JK # r9cU4$rnro)rYtabsizes r7_expandtabs_dispatcherrrrr9c\[R"U5n[R"U5nURRS:Xa [ X5$[ X5nURRUR 53n[R"XRUS9n[ XUS9$)a 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 -------- >>> import numpy as np >>> a = np.array([' Hello world']) >>> np.strings.expandtabs(a, tabsize=4) # doctest: +SKIP array([' Hello world'], dtype='r>sR aAmmG$Gww||s1&&$Q0K77<<.!2 34I --!2!2) DC qs ++r9cU4$rnro)rYwidthfillchars r7_just_dispatcherrrrr9cR[R"U5n[R"UR[R5(d[ SURS35e[R"U5n[R"U5n[R "[U5S:g5(a [ S5e[R"X5RS:Xa [XU5$URURSS9n[R"[U5U5nURRUR53n[R"URURUR5n[R "XUS9n[XX%S 9$) a Return a copy of `a` with its elements centered in a string of length `width`. 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 ----- While it is possible for ``a`` and ``fillchar`` to have different dtypes, passing a non-ASCII character in ``fillchar`` when ``a`` is of dtype "S" is not allowed, and a ``ValueError`` is raised. Examples -------- >>> import numpy as np >>> 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(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='>> import numpy as np >>> c = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.ljust(c, width=3) array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.ljust(c, width=9) array(['aAaAaA ', ' aA ', 'abBABba '], dtype='>> import numpy as np >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.rjust(a, width=3) array(['aAaAaA', ' aA ', 'abBABba'], dtype='>> np.strings.rjust(a, width=9) array([' aAaAaA', ' aA ', ' abBABba'], dtype='>> import numpy as np >>> np.strings.zfill(['1', '-1', '+1'], 3) array(['001', '-01', '+01'], dtype='>> import numpy as np >>> 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_ )rrrYcharss r7r:r:s V }!!$$  ""r9c4Uc [U5$[X5$)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 -------- >>> import numpy as np >>> 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='>> import numpy as np >>> 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='>> import numpy as np >>> c = np.array(['a1b c', '1bca', 'bca1']); c array(['a1b c', '1bca', 'bca1'], dtype='>> np.strings.upper(c) array(['A1B C', '1BCA', 'BCA1'], dtype='>> import numpy as np >>> c = np.array(['A1B C', '1BCA', 'BCA1']); c array(['A1B C', '1BCA', 'BCA1'], dtype='>> np.strings.lower(c) array(['a1b c', '1bca', 'bca1'], dtype='>> import numpy as np >>> 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') rHrrs r7rHrHs#J JJqME ukk: 66r9cZ[R"U5n[XRS5$)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 -------- >>> import numpy as np >>> 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') rIrrs r7rIrIs#J JJqME ukk< 88r9cZ[R"U5n[XRS5$)a 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 -------- >>> import numpy as np >>> 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') rJrrs r7rJrJs#N JJqME ukk7 33r9cU4$rnro)rYoldnewr*s r7_replace_dispatcherrrrr9c"[R"U5n[R"UR[R5(d[ SURS35e[R"U5n[ USS5n[R"U5n[ USS5n[R"U5n[R"XAU5RS:Xa [XAX#5$URnURU=(d USS9nURU=(d USS9n[R"[R5Rn[XASU5n [R"US:U [R "X55n [#U5U [#U5[#U5- --n URRU R53n [R$"XJR&U S 9n [XAX)U S 9$) 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 -------- >>> import numpy as np >>> 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='>";??#4"56I --#4#4I FC Ccs 33r9cX4$rnrosepseqs r7_join_dispatcherrZs :r9cP[[U[RSU45U5$)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 -------- >>> import numpy as np >>> 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='>> import numpy as np >>> 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 rUrrlrs r7_splitrs+R  2::w H(= = ??r9c T[U[RSU/[U5-5$)af 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 -------- >>> import numpy as np >>> 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 rsplitrrs r7_rsplitrs-T  2::x#X)>!> @@r9cU4$rnrorYkeependss r7_splitlines_dispatcherrrrr9cL[U[RS[U55$)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 Examples -------- >>> np.char.splitlines("first line\nsecond line") array(list(['first line', 'second line']), dtype=object) >>> a = np.array(["first\nsecond", "third\nfourth"]) >>> np.char.splitlines(a) array([list(['first', 'second']), list(['third', 'fourth'])], dtype=object) splitlinesrrs r7 _splitlinesrs$D  2::|[%: <>> import numpy as np >>> x = np.array(["Numpy is nice!"]) >>> np.strings.partition(x, " ") (array(['Numpy'], dtype='>> import numpy as np >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.strings.rpartition(a, 'A') (array(['aAaAa', ' a', 'abB'], dtype='>> import numpy as np >>> 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='>> import numpy as np >>> a = np.array(['hello', 'world']) >>> np.strings.slice(a, 2) array(['he', 'wo'], dtype='>> np.strings.slice(a, 2, None) array(['llo', 'rld'], dtype='>> np.strings.slice(a, 1, 5, 2) array(['el', 'ol'], dtype='>> np.strings.slice(a, np.array([1, 2]), np.array([4, 5])) array(['ell', 'rld'], dtype='>> b = np.array(['hello world', 'γεια σου κόσμε', '你好世界', '👋 🌍'], ... dtype=np.dtypes.StringDType()) >>> np.strings.slice(b, -2) array(['hello wor', 'γεια σου κόσ', '你好', '👋'], dtype=StringDType()) >>> np.strings.slice(b, -2, None) array(['ld', 'με', '世界', ' 🌍'], dtype=StringDType()) >>> np.strings.slice(b, [3, -10, 2, -3], [-1, -2, -1, 3]) array(['lo worl', ' σου κόσ', '世', '👋 🌍'], dtype=StringDType()) >>> np.strings.slice(b, None, None, -1) array(['dlrow olleh', 'εμσόκ υοσ αιεγ', '界世好你', '🌍 👋'], dtype=StringDType()) Nrvrtz for operand 'step'rzslice step cannot be zero)rU_NoValuer{r|rSr}r~r ValueErrorrrintprminr)rYrstopsteps r7rErEsB r{{ | == D ==RZZ 0 0+DJJ<7JKLL vvdai455 }288BGG#4#8#8!< |xxq"((277"3"7"7"''9J9N9NO !D ''r9)rN)NNrn)) ))o__doc__ functoolsrnumpyrUrrrrrrr r rnumpy._core.multiarrayr numpy._core.overridesr r numpy._core.umathrrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*rr+rr,rr-rr.rr/rr0rr8__all__rrrrpartialrZrfrlrqrrKrrLrMrr>rr?r@rArrBr:r;r<rrFrGrHrIrJrr=rrrrrrrrrCrDrrNrrEror9r7r)s  /E< , ( hhrxx#++O5J"" O-.<*/<*~ O)!=*!=H O"+"+J O',',T O,,B O--B O),),X O%4%4P O%2%2P O)*,+,^ O)*)+)X O/00,10,f O)*@0+@0F O)*</+</~ O)*</+</~ O*++%,+%\ O,#,#^ O'#'#T O+"+"\ O-.!4/!4H O-.!4/!4H O-.$7/$7N O-.$9/$9N O-.&4/&4R O,-<4.<4~)*!;+!;H*+)?,)?X*+*@,*@Z/0"<1"