KhhSrSSKrSSKrSSKJrJrJrJrJrJ r J r J r SSK Jr SSKJr SSKJrJrJrJrJrJrJrJrJrJrJrJrJ r!J"r#J$r%J&r'J(r)J*r*J+r+J,r,J-r-J.r.J/r/J0r0J1r1J2r2J3r3J4r4J5r5J6r6J7r7J8r8J9r9J:r: Sr;\;"5 /SQr<\Rz"\R|5R~r@S rAS rBS rC\"S 5S 5r \"S 5S5rD\"S 5S-Sj5r\"S 5S-Sj5r\"S 5S-Sj5r \"S 5S-Sj5r"\"S 5S-Sj5r$\"S 5S-Sj5r&\"S 5S-Sj5r(\"S 5S.Sj5rE\"S 5S.Sj5rF\"S 5S/Sj5rG\"S 5S0Sj5rH\"S 5S0Sj5rI\"S 5S0Sj5rJ\"S 5S5rK\"S 5S1Sj5rL\"S 5S1Sj5rM\"S 5S1Sj5rN\"S 5S 5rO\"S 5S!5rP\"S 5S"5rQ\"S 5S#5rR\"S 5S$5rS\"S 5S2S%j5rTS&rUS.S'jrVS.S(jrWS1S)jrX\"S 5S*5rY\"S 5S+5rZ\"S 5S1S,j5r[g)3zK This module contains a set of functions for vectorized string operations. N)equal not_equalless less_equalgreater greater_equaladdmultiply) _vec_string) set_module)"isalphaisdigitisspaceisalnumislowerisupperistitle isdecimal isnumericstr_lenfindrfindindexrindexcount startswithendswith_lstrip_whitespace _lstrip_chars_rstrip_whitespace _rstrip_chars_strip_whitespace _strip_chars_replace_expandtabs_length _expandtabs_center_ljust_rjust_zfill _partition_partition_index _rpartition_rpartition_indexc [[[[[[ [ [[[4 HnSUl URUl M g)N numpy.strings) rr rrrrrrrr __module____name__ __qualname__)ufuncs E/var/www/html/env/lib/python3.13/site-packages/numpy/_core/strings.py_override___module__r64s:)Wgy''+"^^ )-rrrrrrr r r rrrrrrrrrrrrrrrrlstriprstripstripreplace expandtabscenterljustrjustzfill partition rpartitionupperlowerswapcase capitalizetitlemoddecodeencode translatec[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_itemsize)as r5_get_num_charsrUWs5 !'',,((zzQ ::r7c[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) rQasarraysizeastyperOtolist isinstancedtypes StringDTyperPrU)resultoutput_dtype_likerets r5_to_bytes_or_str_arrayrabs  #45 {{a}}.4455 **V]]_ %C#))299+@+@AAzz$066788 ::d,223N34GH IIr7cJ/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 r5 _clean_argsrgss5G ;  N s Nr7r0c[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__rar rQobject_)rTvaluess r5rHrHs(B "Arzz9vi8! ==r7c0UbUO[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_ufuncrTsubstartends r5rrsD#cC qu **r7c0UbUO[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 r5rrsN#cC  ++r7c0UbUO[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 r5rr:s<#cC  ++r7c0UbUO[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 r5rr\s<#cC  ,,r7c0UbUO[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 r5rr~sR#cC  ++r7c0UbUO[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)rTprefixrrs r5rrsJ#cC Q 33r7c0UbUO[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)rTsuffixrrs r5rrsJ#cC 1e 11r7c [[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') rJr7)rar rQrrgbytes_rs r5rJrJ-s4P "Arzz8[-JK # r7c\[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='>> 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='r>6R MM% E ==bjj 1 1+EKK=8LMNN aA}}X&H vvgh1$%% CE E ~~a"''3.a))qwwU3H JJwqz5 )E   hnn EE77<<. .I --i 8C !H ..r7cR[R"U5n[R"UR[R5(d[ SURS35e[R"U5n[R"U5n[R "[U5S:g5(a [ S5e[R"X5RS:Xa [XU5$URURSS9n[R"[U5U5n[R"URURUR5nURRUR53n[R "XUS9n[XX%S 9$) a( Return an array with the elements of `a` right-justified 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.rjust 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 >>> 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=' MM% E ==bjj 1 1+EKK=8LMNN aAww||sa JJwqz5 )E    5E77<<. .I --i 8C ! $$r7c4Uc [U5$[X5$)a For each element in `a`, return a copy with the leading 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.lstrip Examples -------- >>> 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_ )rrrTcharss r5r8r8s V }!!$$  ""r7c4Uc [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') rErrs r5rErEUs#H JJqME ukk: 66r7cZ[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') rFrrs r5rFrF}s#H JJqME ukk< 88r7cZ[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') rGrrs r5rGrGs#L JJqME ukk7 33r7c"[R"U5n[R"UR[R5(d[ SURS35e[R"U5n[ USS5n[R"U5n[ USS5n[R"U5n[R"XAU5RS:Xa [XAX#5$URnURU(aUOUSS9nURU(aUOUSS9n[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 33r7cP[[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 rQrrgrTrmaxsplits r5_splitr3s+P  2::w H(= = ??r7c 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 r5_rsplitr_s-R  2::x#X)>!> @@r7cL[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) splitlinesr)rTkeependss r5 _splitlinesrs$B  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='r?r@r8r9r:rCrDrErFrGr;rrrrrArBrKr7r5rs  /,#########L, ( hhrxxJ"" O<*<*~ O!=!=H O"+"+J O',',T O,,B O--B O),),X O%4%4P O%2%2P O,,^ O))X O0,0,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"