KhFSrSSKrSSKrSSKJr SSKJrJrJ r SSK J r J r Jr SSKJr SS KJr SS K7 SS KJrJrJr SS KJrJrJ r!J"r# /S Qr$\RJ"\RLSS9r&Sr'\&"\'5S5r(\&"\'5S5r)\&"\'5S5r*\&"\'5S5r+\&"\'5S5r,\&"\'5S5r-\"S5S5r\"S5S5r\"S5S5r\"S5"SS\ 55r.\"S5SSj5r \"S5SSj5rg) an This module contains a set of functions for vectorized string operations and methods. .. note:: The `chararray` class exists for backwards compatibility with Numarray, it is not recommended for new development. Starting from numpy 1.4, if one needs arrays of strings, it is recommended to use arrays of `dtype` `object_`, `bytes_` or `str_`, and use the free functions in the `numpy.char` module for fast vectorized string operations. Some methods will only be available if the corresponding string method is available in your version of Python. The preferred alias for `defchararray` is `numpy.char`. N) set_module)bytes_str_ character)ndarrayarrayasarraycompare_chararrays) overrides)*)multiply partition rpartition)_split_rsplit _splitlines_join)5equal not_equal greater_equal less_equalgreaterlessstr_lenaddrmod capitalizecentercountdecodeencodeendswith expandtabsfindindexisalnumisalphaisdigitislowerisspaceistitleisupperjoinljustlowerlstriprreplacerfindrindexrjustrrsplitrstripsplit splitlines startswithstripswapcasetitle translateupperzfill isnumeric isdecimalr r r chararrayz numpy.char)modulecX4$Nx1x2s J/var/www/html/env/lib/python3.13/site-packages/numpy/_core/defchararray.py_binary_op_dispatcherrN8s 8Oc[XSS5$)a* Return (x1 == x2) element-wise. Unlike `numpy.equal`, this comparison is performed by first stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters ---------- x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns ------- out : ndarray Output array of bools. Examples -------- >>> import numpy as np >>> y = "aa " >>> x = "aa" >>> np.char.equal(x, y) array(True) See Also -------- not_equal, greater_equal, less_equal, greater, less z==Tr rJs rMrr<> bdD 11rOc[XSS5$)aK Return (x1 != x2) element-wise. Unlike `numpy.not_equal`, this comparison is performed by first stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters ---------- x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns ------- out : ndarray Output array of bools. See Also -------- equal, greater_equal, less_equal, greater, less Examples -------- >>> import numpy as np >>> x1 = np.array(['a', 'b', 'c']) >>> np.char.not_equal(x1, 'b') array([ True, False, True]) z!=Tr rJs rMrr^rQrOc[XSS5$)aN Return (x1 >= x2) element-wise. Unlike `numpy.greater_equal`, this comparison is performed by first stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters ---------- x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns ------- out : ndarray Output array of bools. See Also -------- equal, not_equal, less_equal, greater, less Examples -------- >>> import numpy as np >>> x1 = np.array(['a', 'b', 'c']) >>> np.char.greater_equal(x1, 'b') array([False, True, True]) z>=Tr rJs rMrrs@ bdD 11rOc[XSS5$)aL Return (x1 <= x2) element-wise. Unlike `numpy.less_equal`, this comparison is performed by first stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters ---------- x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns ------- out : ndarray Output array of bools. See Also -------- equal, not_equal, greater_equal, greater, less Examples -------- >>> import numpy as np >>> x1 = np.array(['a', 'b', 'c']) >>> np.char.less_equal(x1, 'b') array([ True, True, False]) z<=Tr rJs rMrrrQrOc[XSS5$)aH Return (x1 > x2) element-wise. Unlike `numpy.greater`, this comparison is performed by first stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters ---------- x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns ------- out : ndarray Output array of bools. See Also -------- equal, not_equal, greater_equal, less_equal, less Examples -------- >>> import numpy as np >>> x1 = np.array(['a', 'b', 'c']) >>> np.char.greater(x1, 'b') array([False, False, True]) >Tr rJs rMrr> bc4 00rOc[XSS5$)aG Return (x1 < x2) element-wise. Unlike `numpy.greater`, this comparison is performed by first stripping whitespace characters from the end of the string. This behavior is provided for backward-compatibility with numarray. Parameters ---------- x1, x2 : array_like of str or unicode Input arrays of the same shape. Returns ------- out : ndarray Output array of bools. See Also -------- equal, not_equal, greater_equal, less_equal, greater Examples -------- >>> import numpy as np >>> x1 = np.array(['a', 'b', 'c']) >>> np.char.less(x1, 'b') array([True, False, False]) >> 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='[R"[X5SS9$)a 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 -------- >>> import numpy as np >>> x = np.array(["Numpy is nice!"]) >>> np.char.partition(x, " ") array([['Numpy', ' ', 'is nice!']], dtype='[R"[X5SS9$)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 -------- >>> import numpy as np >>> a = np.array(['aAaAaA', ' aA ', 'abBABba']) >>> np.char.rpartition(a, 'A') array([['aAaAa', 'A', ''], [' a', 'A', ' '], ['abB', 'A', 'Bba']], dtype='SjrSrSrSr S r S r S r S r S rSrSrSrSrSrSrS?Sjr\R*R\lSrS@SjrSASjrSBSjrSBSjrSASjrSCSjrSASjrSASjrSr Sr!S r"S!r#S"r$S#r%S$r&S%r'S@S&jr(S'r)SDS(jr*S)r+SDS*jr,SAS+jr-SAS,jr.S@S-jr/S.r0SBS/jr1SDS0jr2SBS1jr3SDS2jr4SAS3jr5SDS4jr6S5r7S6r8SDS7jr9S8r:S9r;S:rg)ErEia\ chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order=None) Provides a convenient view on arrays of string and unicode values. .. note:: The `chararray` class exists for backwards compatibility with Numarray, it is not recommended for new development. Starting from numpy 1.4, if one needs arrays of strings, it is recommended to use arrays of `dtype` `~numpy.object_`, `~numpy.bytes_` or `~numpy.str_`, and use the free functions in the `numpy.char` module for fast vectorized string operations. Versus a NumPy array of dtype `~numpy.bytes_` or `~numpy.str_`, this class adds the following functionality: 1) values automatically have whitespace removed from the end when indexed 2) comparison operators automatically remove whitespace from the end when comparing values 3) vectorized string operations are provided as methods (e.g. `.endswith`) and infix operators (e.g. ``"+", "*", "%"``) chararrays should be created using `numpy.char.array` or `numpy.char.asarray`, rather than this constructor directly. This constructor creates the array, using `buffer` (with `offset` and `strides`) if it is not ``None``. If `buffer` is ``None``, then constructs a new array with `strides` in "C order", unless both ``len(shape) >= 2`` and ``order='F'``, in which case `strides` is in "Fortran order". Methods ------- astype argsort copy count decode dump dumps encode endswith expandtabs fill find flatten getfield index isalnum isalpha isdecimal isdigit islower isnumeric isspace istitle isupper item join ljust lower lstrip nonzero put ravel repeat replace reshape resize rfind rindex rjust rsplit rstrip searchsorted setfield setflags sort split splitlines squeeze startswith strip swapaxes swapcase take title tofile tolist tostring translate transpose upper view zfill Parameters ---------- shape : tuple Shape of the array. itemsize : int, optional Length of each array element, in number of characters. Default is 1. unicode : bool, optional Are the array elements of type unicode (True) or string (False). Default is False. buffer : object exposing the buffer interface or str, optional Memory address of the start of the array data. Default is None, in which case a new array is created. offset : int, optional Fixed stride displacement from the beginning of an axis? Default is 0. Needs to be >=0. strides : array_like of ints, optional Strides for the array (see `~numpy.ndarray.strides` for full description). Default is None. order : {'C', 'F'}, optional The order in which the array data is stored in memory: 'C' -> "row major" order (the default), 'F' -> "column major" (Fortran) order. Examples -------- >>> import numpy as np >>> charar = np.char.chararray((3, 3)) >>> charar[:] = 'a' >>> charar chararray([[b'a', b'a', b'a'], [b'a', b'a', b'a'], [b'a', b'a', b'a']], dtype='|S1') >>> charar = np.char.chararray(charar.shape, itemsize=5) >>> charar[:] = 'abc' >>> charar chararray([[b'abc', b'abc', b'abc'], [b'abc', b'abc', b'abc'], [b'abc', b'abc', b'abc']], dtype='|S5') Nc U(a[nO[n[U5n[U[5(aUn SnOSn Uc[ R "XX4US9n O[ R "XX4UXVUS9n U bXS'U $)Norder)bufferoffsetstridesrn.)rrint isinstancestrr __new__) subtypeshapeitemsizeunicoderorprqrndtypefillerselfs rMruchararray.__new__"s EE x= fc " "FFF >??7E3D).0D??7E3D*0*0).0D  I rOcnURRS;aUR[U55$U$)NSUbc)rzcharviewtype)r|arrcontext return_scalars rM__array_wrap__chararray.__array_wrap__Bs, 99>>V #88DJ' ' rOcNURRS;a [S5eg)NVSUbcz-Can only create a chararray from string data.)rzrr])r|objs rM__array_finalize__chararray.__array_finalize__Js# ::??' )LM M *rOc|[R"X5n[U[5(aUR 5$U$rH)r __getitem__rsrr9)r|rvals rMrchararray.__getitem__Os0!!$, c9 % %::<  rOc[X5$)z? Return (self == other) element-wise. See Also -------- equal )rr|others rM__eq__chararray.__eq__ZsT!!rOc[X5$)zC Return (self != other) element-wise. See Also -------- not_equal )rrs rM__ne__chararray.__ne__ds%%rOc[X5$)zG Return (self >= other) element-wise. See Also -------- greater_equal )rrs rM__ge__chararray.__ge__nsT))rOc[X5$)zD Return (self <= other) element-wise. See Also -------- less_equal )rrs rM__le__chararray.__le__xs$&&rOc[X5$)z@ Return (self > other) element-wise. See Also -------- greater )rrs rM__gt__chararray.__gt__st##rOc[X5$)z= Return (self < other) element-wise. See Also -------- less )rrs rM__lt__chararray.__lt__sD  rOc[X5$)z Return (self + other), that is string concatenation, element-wise for a pair of array_likes of str or unicode. See Also -------- add rrs rM__add__chararray.__add__s4rOc[X5$)z Return (other + self), that is string concatenation, element-wise for a pair of array_likes of `bytes_` or `str_`. See Also -------- add rrs rM__radd__chararray.__radd__s5rOc*[[X55$ze Return (self * i), that is string multiple concatenation, element-wise. See Also -------- multiply r rr|r_s rM__mul__chararray.__mul__x())rOc*[[X55$rrrs rM__rmul__chararray.__rmul__rrOc*[[X55$)z Return (self % i), that is pre-Python 2.6 string formatting (interpolation), element-wise for a pair of array_likes of `bytes_` or `str_`. See Also -------- mod )r rrs rM__mod__chararray.__mod__ss4|$$rOc[$rH)NotImplementedrs rM__rmod__chararray.__rmod__srOcBUR5RXU5$)a Return the indices that sort the array lexicographically. For full documentation see `numpy.argsort`, for which this method is in fact merely a "thin wrapper." Examples -------- >>> c = np.array(['a1b c', '1b ca', 'b ca1', 'Ca1b'], 'S5') >>> c = c.view(np.char.chararray); c chararray(['a1b c', '1b ca', 'b ca1', 'Ca1b'], dtype='|S5') >>> c[c.argsort()] chararray(['1b ca', 'Ca1b', 'a1b c', 'b ca1'], dtype='|S5') ) __array__argsort)r|rckindrns rMrchararray.argsorts$~~''E::rOc*[[U55$)zx Return a copy of `self` with only the first character of each element capitalized. See Also -------- char.capitalize )r r r|s rMr chararray.capitalizesz$'((rOc,[[XU55$)zm Return a copy of `self` with its elements centered in a string of length `width`. See Also -------- center )r r!r|widthfillchars rMr!chararray.centersvd8455rOc[XX#5$)z Returns an array with the number of non-overlapping occurrences of substring `sub` in the range [`start`, `end`]. See Also -------- char.count )r"r|substartends rMr"chararray.countT++rOc[XU5$)zF Calls ``bytes.decode`` element-wise. See Also -------- char.decode )r#r|encodingerrorss rMr#chararray.decode df--rOc[XU5$)zH Calls :meth:`str.encode` element-wise. See Also -------- char.encode )r$rs rMr$chararray.encoderrOc[XX#5$)z Returns a boolean array which is `True` where the string element in `self` ends with `suffix`, otherwise `False`. See Also -------- char.endswith )r%)r|suffixrrs rMr%chararray.endswithse11rOc*[[X55$)z Return a copy of each string element where all tab characters are replaced by one or more spaces. See Also -------- char.expandtabs )r r&)r|tabsizes rMr&chararray.expandtabs+sz$011rOc[XX#5$)zw For each element, return the lowest index in the string where substring `sub` is found. See Also -------- char.find )r'rs rMr'chararray.find7sDu**rOc[XX#5$)zk Like `find`, but raises :exc:`ValueError` when the substring is not found. See Also -------- char.index )r(rs rMr(chararray.indexCrrOc[U5$)z Returns true for each element if all characters in the string are alphanumeric and there is at least one character, false otherwise. See Also -------- char.isalnum )r)rs rMr)chararray.isalnumOt}rOc[U5$)z Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise. See Also -------- char.isalpha )r*rs rMr*chararray.isalpha\rrOc[U5$)z Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise. See Also -------- char.isdigit )r+rs rMr+chararray.isdigitit}rOc[U5$)z Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise. See Also -------- char.islower )r,rs rMr,chararray.islowerurrOc[U5$)z Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise. See Also -------- char.isspace )r-rs rMr-chararray.isspacerrOc[U5$)z Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise. See Also -------- char.istitle )r.rs rMr.chararray.istitlerrOc[U5$)z Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise. See Also -------- char.isupper )r/rs rMr/chararray.isupperrrOc[X5$)zp Return a string which is the concatenation of the strings in the sequence `seq`. See Also -------- char.join )r0)r|seqs rMr0chararray.joinsDrOc,[[XU55$)zz Return an array with the elements of `self` left-justified in a string of length `width`. See Also -------- char.ljust )r r1rs rMr1chararray.ljustuT(344rOc*[[U55$)zd Return an array with the elements of `self` converted to lowercase. See Also -------- char.lower )r r2rs rMr2chararray.loweruT{##rOc[X5$)zp For each element in `self`, return a copy with the leading characters removed. See Also -------- char.lstrip )r3r|charss rMr3chararray.lstripd""rOc*[[X55$)zM Partition each element in `self` around `sep`. See Also -------- partition )r rr|rhs rMrchararray.partitionsy+,,rOc,[XX#bU5$S5$)z For each element in `self`, return a copy of the string with all occurrences of substring `old` replaced by `new`. See Also -------- char.replace ra)r4)r|oldnewr"s rMr4chararray.replacest#0AuJJrJJrOc[XX#5$)z For each element in `self`, return the highest index in the string where substring `sub` is found, such that `sub` is contained within [`start`, `end`]. See Also -------- char.rfind )r5rs rMr5chararray.rfindsT++rOc[XX#5$)zs Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is not found. See Also -------- char.rindex )r6rs rMr6chararray.rindexsd,,rOc,[[XU55$)z{ Return an array with the elements of `self` right-justified in a string of length `width`. See Also -------- char.rjust )r r7rs rMr7chararray.rjustrrOc*[[X55$)zN Partition each element in `self` around `sep`. See Also -------- rpartition )r rrs rMrchararray.rpartitionsz$,--rOc[XU5$)z For each element in `self`, return a list of the words in the string, using `sep` as the delimiter string. See Also -------- char.rsplit )r8r|rhmaxsplits rMr8chararray.rsplitsd**rOc[X5$)zq For each element in `self`, return a copy with the trailing characters removed. See Also -------- char.rstrip )r9rs rMr9chararray.rstrip)rrOc[XU5$)z For each element in `self`, return a list of the words in the string, using `sep` as the delimiter string. See Also -------- char.split )r:rs rMr:chararray.split5sT))rOc[X5$)z For each element in `self`, return a list of the lines in the element, breaking at line boundaries. See Also -------- char.splitlines )r;)r|keependss rMr;chararray.splitlinesAs$))rOc[XX#5$)z Returns a boolean array which is `True` where the string element in `self` starts with `prefix`, otherwise `False`. See Also -------- char.startswith )r<)r|prefixrrs rMr<chararray.startswithMs$33rOc[X5$)z| For each element in `self`, return a copy with the leading and trailing characters removed. See Also -------- char.strip )r=rs rMr=chararray.stripYsT!!rOc*[[U55$)z For each element in `self`, return a copy of the string with uppercase characters converted to lowercase and vice versa. See Also -------- char.swapcase )r r>rs rMr>chararray.swapcaseesx~&&rOc*[[U55$)z For each element in `self`, return a titlecased version of the string: words start with uppercase characters, all remaining cased characters are lowercase. See Also -------- char.title )r r?rs rMr?chararray.titleqsuT{##rOc,[[XU55$)a For each element in `self`, return a copy of the string where all characters occurring in the optional argument `deletechars` are removed, and the remaining characters have been mapped through the given translation table. See Also -------- char.translate )r r@)r|table deletecharss rMr@chararray.translate~syk:;;rOc*[[U55$)zd Return an array with the elements of `self` converted to uppercase. See Also -------- char.upper )r rArs rMrAchararray.upperrrOc*[[X55$)zp Return the numeric string left-filled with zeros in a string of length `width`. See Also -------- char.zfill )r rB)r|rs rMrBchararray.zfillsuT)**rOc[U5$)z For each element in `self`, return True if there are only numeric characters in the element. See Also -------- char.isnumeric )rCrs rMrCchararray.isnumericrOc[U5$)z For each element in `self`, return True if there are only decimal characters in the element. See Also -------- char.isdecimal )rDrs rMrDchararray.isdecimalr.rOrI)rFNrNC)NF)raNN) )rN)NN)rH)?__name__ __module__ __qualname____firstlineno____doc__rurrrrrrrrrrrrrrrrr r r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3rr4r5r6r7rr8r9r:r;r<r=r>r?r@rArBrCrD__static_attributes__rIrOrMrErEsALZCG.1@N "&*'$!     * * %;&oo--GO ) 6 , . . 2 2 + ,         5 $ #- K , - 5. + # * * 4 " ' $ < $ +  rOrEc[U[[45(aDUc[U[5(aSnOSnUc [U5n[U5U-n[ XQUXS9$[U[ [ 45(a [U5n[U[5(GaN[URR[5(Ga$[U[5(dUR[5nUc:URn[URR[5(aUS-nUc.[URR[5(aSnOSnU(a[nO[ nUb [XS9nU(dGXR:wd8U(d[U[5(dU(a1[U[ 5(aUR#U[%U545nU$[U[5(a<[URR[&5(aUcUR)5nU(a[nO[ nUc [+XUSS9nO [+XU4USS9nUR[5$)a Create a `~numpy.char.chararray`. .. note:: This class is provided for numarray backward-compatibility. New code (not concerned with numarray compatibility) should use arrays of type `bytes_` or `str_` and use the free functions in :mod:`numpy.char` for fast vectorized string operations instead. Versus a NumPy array of dtype `bytes_` or `str_`, this class adds the following functionality: 1) values automatically have whitespace removed from the end when indexed 2) comparison operators automatically remove whitespace from the end when comparing values 3) vectorized string operations are provided as methods (e.g. `chararray.endswith `) and infix operators (e.g. ``+, *, %``) Parameters ---------- obj : array of str or unicode-like itemsize : int, optional `itemsize` is the number of characters per scalar in the resulting array. If `itemsize` is None, and `obj` is an object array or a Python list, the `itemsize` will be automatically determined. If `itemsize` is provided and `obj` is of type str or unicode, then the `obj` string will be chunked into `itemsize` pieces. copy : bool, optional If true (default), then the object is copied. Otherwise, a copy will only be made if ``__array__`` returns a copy, if obj is a nested sequence, or if a copy is needed to satisfy any of the other requirements (`itemsize`, unicode, `order`, etc.). unicode : bool, optional When true, the resulting `~numpy.char.chararray` can contain Unicode characters, when false only 8-bit characters. If unicode is None and `obj` is one of the following: - a `~numpy.char.chararray`, - an ndarray of type :class:`str_` or :class:`bytes_` - a Python :class:`str` or :class:`bytes` object, then the unicode setting of the output array will be automatically determined. order : {'C', 'F', 'A'}, optional Specify the order of the array. If order is 'C' (default), then the array will be in C-contiguous order (last-index varies the fastest). If order is 'F', then the returned array will be in Fortran-contiguous order (first-index varies the fastest). If order is 'A', then the returned array may be in any order (either C-, Fortran-contiguous, or even discontiguous). Examples -------- >>> import numpy as np >>> char_array = np.char.array(['hello', 'world', 'numpy','array']) >>> char_array chararray(['hello', 'world', 'numpy', 'array'], dtype='`) and infix operators (e.g. ``+``, ``*``, ``%``) Parameters ---------- obj : array of str or unicode-like itemsize : int, optional `itemsize` is the number of characters per scalar in the resulting array. If `itemsize` is None, and `obj` is an object array or a Python list, the `itemsize` will be automatically determined. If `itemsize` is provided and `obj` is of type str or unicode, then the `obj` string will be chunked into `itemsize` pieces. unicode : bool, optional When true, the resulting `~numpy.char.chararray` can contain Unicode characters, when false only 8-bit characters. If unicode is None and `obj` is one of the following: - a `~numpy.char.chararray`, - an ndarray of type `str_` or `unicode_` - a Python str or unicode object, then the unicode setting of the output array will be automatically determined. order : {'C', 'F'}, optional Specify the order of the array. If order is 'C' (default), then the array will be in C-contiguous order (last-index varies the fastest). If order is 'F', then the returned array will be in Fortran-contiguous order (first-index varies the fastest). Examples -------- >>> import numpy as np >>> np.char.asarray(['hello', 'world']) chararray(['hello', 'world'], dtype='rUs"11BB5!  $++ %%l<./202B./202B./202D./202B./101B./101B L0:0:f L&8&8R L(9(9V Lf f f R LKK\ L9/9/rO