Ë
|
Kñúh
|
ã ó d Z ddlZddlZddlmZ ddlmZ ddlm Z
|
ddlm Z ddlm Z ddlmZ dd lmZ dd
|
l dd lmZ dd lmZ dd lmZ ddlmZ ddlm Z ddlm Z ddl m!Z!m"Z"m#Z# g d¢Z$ ejJ ejL d¬« Z&d Z' e&e'« d « Z( e&e'« d « Z) e&e'« d « Z* e&e'« d « Z+ e&e'« d « Z, e&e'« d « Z- ed« d « Z ed« d « Z ed« d « Z ed« G d d!e « « Z. ed« d$d"« Z ed« d%d#« Z y)&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)Ú overrides©Úcompare_chararrays)Ú_join)Ú_rsplit)Ú_split)Ú _splitlines)Ú
|
set_module)Ú*)Úmultiply)Ú partition)Ú
|
rpartitioné ©Úarray)Úasarray)Úndarray)Úbytes_Ú characterÚstr_)5ÚequalÚ not_equalÚ greater_equalÚ
|
less_equalÚgreaterÚlessÚstr_lenÚaddr ÚmodÚ
|
capitalizeÚcenterÚcountÚdecodeÚencodeÚendswithÚ
|
expandtabsÚfindÚindexÚisalnumÚisalphaÚisdigitÚislowerÚisspaceÚistitleÚisupperÚjoinÚljustÚlowerÚlstripr ÚreplaceÚrfindÚrindexÚrjustr ÚrsplitÚrstripÚsplitÚ
|
splitlinesÚ
|
startswithÚstripÚswapcaseÚtitleÚ translateÚupperÚzfillÚ isnumericÚ isdecimalr r r Ú chararrayz
|
numpy.char)Úmodulec ó
|
| |fS ©N© ©Úx1Úx2s úKH:\Change_password\venv_build\Lib\site-packages\numpy/_core/defchararray.pyÚ_binary_op_dispatcherrN E s Ø 8Oó c ó t | |dd« S )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 rJ s rM r r I ó ô> b " d¨DÓ 1Ð1rO c ó t | |dd« S )a£
|
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 rJ s rM r r k rQ rO c ó t | |dd« S )aª
|
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 rJ s rM r r s ô@ b " d¨DÓ 1Ð1rO c ó t | |dd« S )a¤
|
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 rJ s rM r r ° rQ rO c ó t | |dd« S )a
|
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 rJ s rM r r Ò ó ô> b " c¨4Ó 0Ð0rO c ó t | |dd« S )a
|
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])
|
|
ú<Tr rJ s rM r r ô rW rO c óL t | |« S # t $ r t d« w xY w)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 `np.bytes_` or `np.str_` dtype
|
|
i : array_like, with any integer dtype
|
|
Returns
|
-------
|
out : ndarray
|
Output array of str or unicode, depending on input types
|
|
Notes
|
-----
|
This is a thin wrapper around np.strings.multiply that raises
|
`ValueError` when ``i`` is not an integer. It only
|
exists for backwards-compatibility.
|
|
Examples
|
--------
|
>>> import numpy as np
|
>>> a = np.array(["a", "b", "c"])
|
>>> np.strings.multiply(a, 3)
|
array(['aaa', 'bbb', 'ccc'], dtype='<U3')
|
>>> i = np.array([1, 2, 3])
|
>>> np.strings.multiply(a, i)
|
array(['a', 'bb', 'ccc'], dtype='<U3')
|
>>> np.strings.multiply(np.array(['a']), i)
|
array(['a', 'aa', 'aaa'], dtype='<U3')
|
>>> 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='<U3')
|
>>> np.strings.multiply(a, i)
|
array([['a', 'bb', 'ccc'],
|
['d', 'ee', 'fff']], dtype='<U3')
|
|
z Can only multiply by integers)Ústrings_multiplyÚ TypeErrorÚ
|
ValueError)ÚaÚis rM r r s0 ð\:Ü 1Ó%Ð%øÜ ò :ÜÐ8Ó9Ð9ð:ús #c óD t j t | |« d¬« S )aF
|
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='<U8')
|
|
See Also
|
--------
|
str.partition
|
|
éÿÿÿÿ©Úaxis)ÚnpÚstackÚstrings_partition©r^ Úseps rM r r J s ôN 88Ô% a¨Ó-°BÔ 7Ð7rO c óD t j t | |« d¬« 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
|
--------
|
>>> import numpy as np
|
>>> a = np.array(['aAaAaA', ' aA ', 'abBABba'])
|
>>> np.char.rpartition(a, 'A')
|
array([['aAaAa', 'A', ''],
|
[' a', 'A', ' '],
|
['abB', 'A', 'Bba']], dtype='<U5')
|
|
ra rb )rd re Ústrings_rpartitionrg s rM r r t s ôR 88Ô& q¨#Ó.°RÔ 8Ð8rO c óÊ e Zd ZdZ d;dZd<dZd Zd Zd Zd Z d Z
|
d
|
Z d Z d Z d Zd Zd Zd Zd Zd Zd=dZej( j e_ d Zd>dZd?dZd@dZd@dZd?dZdAdZ d?dZ d?d Z d Z d Z d Z!d Z"d! Z#d" Z$d# Z%d$ Z&d>d%Z'd& Z(dBd'Z)d( Z*dBd)Z+d?d*Z,d?d+Z-d>d,Z.d- Z/d@d.Z0dBd/Z1d@d0Z2dBd1Z3d?d2Z4dBd3Z5d4 Z6d5 Z7dBd6Z8d7 Z9d8 Z:d9 Z;d: Z<y)CrE aX
|
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 óî |rt }nt }t |« }t |t « r|} d }nd } | t j | |||f|¬« }
|
n t j | |||f||||¬« }
|
| | |
|
d< |
|
S )N©Úorder)ÚbufferÚoffsetÚstridesrn .)r r ÚintÚ
|
isinstanceÚstrr Ú__new__) ÚsubtypeÚshapeÚitemsizeÚunicodero rp rq rn ÚdtypeÚfillerÚselfs rM ru zchararray.__new__/ s á ÜEäEô
|
x=ä fcÔ "àFØFàFà >Ü?? 7¨E°E¸8Ð3DØ).ô0Dô ?? 7¨E°E¸8Ð3DØ*0Ø*0¸'Ø).ô0Dð Ð Ø DIà rO c ój |j j dv r|j t | « « S |S )NÚSUbc)rz ÚcharÚviewÚtype)r| ÚarrÚcontextÚ return_scalars rM Ú__array_wrap__zchararray.__array_wrap__O s, ð 99>>VÑ #Ø88D JÓ'Ð 'Ø
|
rO c óJ | j j dvr t d« y )NÚVSUbcz-Can only create a chararray from string data.)rz r r] )r| Úobjs rM Ú__array_finalize__z chararray.__array_finalize__W s# à ::?? 'Ñ )Ü Ð LÓMÐ Mð *rO c ór t j | |« }t |t « r|j « S |S rH )r Ú __getitem__rs r r9 )r| r Úvals rM r zchararray.__getitem__\ s/ Ü×!Ñ! $¨Ó,Ü c9Ô %Ø::<Ð Ø
|
rO c ó t | |« S )zg
|
Return (self == other) element-wise.
|
|
See Also
|
--------
|
equal
|
)r ©r| Úothers rM Ú__eq__zchararray.__eq__g s ô T5Ó!Ð!rO c ó t | |« S )zk
|
Return (self != other) element-wise.
|
|
See Also
|
--------
|
not_equal
|
)r r s rM Ú__ne__zchararray.__ne__q s ô uÓ%Ð%rO c ó t | |« S )zo
|
Return (self >= other) element-wise.
|
|
See Also
|
--------
|
greater_equal
|
)r r s rM Ú__ge__zchararray.__ge__{ s ô T 5Ó)Ð)rO c ó t | |« S )zl
|
Return (self <= other) element-wise.
|
|
See Also
|
--------
|
less_equal
|
)r r s rM Ú__le__zchararray.__le__
s ô $ Ó&Ð&rO c ó t | |« S )zh
|
Return (self > other) element-wise.
|
|
See Also
|
--------
|
greater
|
)r r s rM Ú__gt__zchararray.__gt__ s ô tUÓ#Ð#rO c ó t | |« S )ze
|
Return (self < other) element-wise.
|
|
See Also
|
--------
|
less
|
)r r s rM Ú__lt__zchararray.__lt__ s ô D%Ó Ð rO c ó t | |« S )z·
|
Return (self + other), that is string concatenation,
|
element-wise for a pair of array_likes of str or unicode.
|
|
See Also
|
--------
|
add
|
©r r s rM Ú__add__zchararray.__add__£ s ô 4Ó Ð rO c ó t || « S )z»
|
Return (other + self), that is string concatenation,
|
element-wise for a pair of array_likes of `bytes_` or `str_`.
|
|
See Also
|
--------
|
add
|
r r s rM Ú__radd__zchararray.__radd__® s ô 5$Ó Ð rO c ó, t t | |« « S ©z
|
Return (self * i), that is string multiple concatenation,
|
element-wise.
|
|
See Also
|
--------
|
multiply
|
©r r ©r| r_ s rM Ú__mul__zchararray.__mul__¹ ó ô x aÓ(Ó)Ð)rO c ó, t t | |« « S r¡ r¢ r£ s rM Ú__rmul__zchararray.__rmul__Ä r¥ rO c ó, t t | |« « S )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 r r£ s rM Ú__mod__zchararray.__mod__Ï s ô s4 |Ó$Ð$rO c ó t S rH )ÚNotImplementedr s rM Ú__rmod__zchararray.__rmod__Û s Ü Ð rO c óD | j « j |||« S )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| rc Úkindrn s rM r¯ zchararray.argsortÞ s ð$ ~~Ó ×'Ñ'¨¨d°EÓ:Ð:rO c ó* t t | « « S )z¨
|
Return a copy of `self` with only the first character of each element
|
capitalized.
|
|
See Also
|
--------
|
char.capitalize
|
|
)r r ©r| s rM r zchararray.capitalizeó s ô z $Ó'Ó(Ð(rO c ó. t t | ||« « S )z
|
Return a copy of `self` with its elements centered in a
|
string of length `width`.
|
|
See Also
|
--------
|
center
|
)r r! ©r| ÚwidthÚfillchars rM r! zchararray.centerÿ s ô vd E¨8Ó4Ó5Ð5rO c ó t | |||« S )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| ÚsubÚstartÚends rM r" zchararray.count
|
ó ô T3 sÓ+Ð+rO c ó t | ||« S )zn
|
Calls ``bytes.decode`` element-wise.
|
|
See Also
|
--------
|
char.decode
|
|
)r# ©r| ÚencodingÚerrorss rM r# zchararray.decode ó ô dH fÓ-Ð-rO c ó t | ||« S )zp
|
Calls :meth:`str.encode` element-wise.
|
|
See Also
|
--------
|
char.encode
|
|
)r$ r¾ s rM r$ zchararray.encode! rÁ rO c ó t | |||« S )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| Úsuffixrº r» s rM r% zchararray.endswith, s ô f e¨SÓ1Ð1rO c ó, t t | |« « S )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 rM r& zchararray.expandtabs8 s ô z $¨Ó0Ó1Ð1rO c ó t | |||« S )z§
|
For each element, return the lowest index in the string where
|
substring `sub` is found.
|
|
See Also
|
--------
|
char.find
|
|
)r' r¸ s rM r' zchararray.findD s ô D#u cÓ*Ð*rO c ó t | |||« S )z
|
Like `find`, but raises :exc:`ValueError` when the substring is not
|
found.
|
|
See Also
|
--------
|
char.index
|
|
)r( r¸ s rM r( zchararray.indexP r¼ rO c ó t | « S )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) r² s rM r) zchararray.isalnum\ ó ô t}Ð rO c ó t | « S )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* r² s rM r* zchararray.isalphai rÊ rO c ó t | « S )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+ r² s rM r+ zchararray.isdigitv ó ô t}Ð rO c ó t | « S )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, r² s rM r, zchararray.islower rÊ rO c ó t | « S )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- r² s rM r- zchararray.isspace rÊ rO c ó t | « S )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. r² s rM r. zchararray.istitle rÍ rO c ó t | « S )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/ r² s rM r/ zchararray.isupper¨ rÊ rO c ó t | |« S )z
|
Return a string which is the concatenation of the strings in the
|
sequence `seq`.
|
|
See Also
|
--------
|
char.join
|
|
)r0 )r| Úseqs rM r0 zchararray.joinµ s ô D#Ð rO c ó. t t | ||« « S )zª
|
Return an array with the elements of `self` left-justified in a
|
string of length `width`.
|
|
See Also
|
--------
|
char.ljust
|
|
)r r1 r´ s rM r1 zchararray.ljustÁ ó ô uT 5¨(Ó3Ó4Ð4rO c ó* t t | « « S )z
|
Return an array with the elements of `self` converted to
|
lowercase.
|
|
See Also
|
--------
|
char.lower
|
|
)r r2 r² s rM r2 zchararray.lowerÍ ó ô uT{Ó#Ð#rO c ó t | |« S )z
|
For each element in `self`, return a copy with the leading characters
|
removed.
|
|
See Also
|
--------
|
char.lstrip
|
|
)r3 ©r| Úcharss rM r3 zchararray.lstripÙ ó ô dEÓ"Ð"rO c ó, t t | |« « S )zu
|
Partition each element in `self` around `sep`.
|
|
See Also
|
--------
|
partition
|
)r r ©r| rh s rM r zchararray.partitionå s ô y sÓ+Ó,Ð,rO c ó. t | ||||« S d« S )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| ÚoldÚnewr" s rM r4 zchararray.replaceï s" ô tS #°Ð0A uÓJÐJÀrÓJÐJrO c ó t | |||« S )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
|
|
)r5 r¸ s rM r5 zchararray.rfindû s ô T3 sÓ+Ð+rO c ó t | |||« S )z£
|
Like `rfind`, but raises :exc:`ValueError` when the substring `sub` is
|
not found.
|
|
See Also
|
--------
|
char.rindex
|
|
)r6 r¸ s rM r6 zchararray.rindex s ô dC ¨Ó,Ð,rO c ó. t t | ||« « S )z«
|
Return an array with the elements of `self`
|
right-justified in a string of length `width`.
|
|
See Also
|
--------
|
char.rjust
|
|
)r r7 r´ s rM r7 zchararray.rjust rÕ rO c ó, t t | |« « S )zv
|
Partition each element in `self` around `sep`.
|
|
See Also
|
--------
|
rpartition
|
)r r rÝ s rM r zchararray.rpartition s ô z $¨Ó,Ó-Ð-rO c ó t | ||« S )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
|
|
)r8 ©r| rh Úmaxsplits rM r8 zchararray.rsplit* s ô dC Ó*Ð*rO c ó t | |« S )z¡
|
For each element in `self`, return a copy with the trailing
|
characters removed.
|
|
See Also
|
--------
|
char.rstrip
|
|
)r9 rÙ s rM r9 zchararray.rstrip6 rÛ rO c ó t | ||« S )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: ræ s rM r: zchararray.splitB s ô T3 Ó)Ð)rO c ó t | |« S )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 rM r; zchararray.splitlinesN s ô $ Ó)Ð)rO c ó t | |||« S )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| Úprefixrº r» s rM r< zchararray.startswithZ s ô $ ¨¨sÓ3Ð3rO c ó t | |« S )z¬
|
For each element in `self`, return a copy with the leading and
|
trailing characters removed.
|
|
See Also
|
--------
|
char.strip
|
|
)r= rÙ s rM r= zchararray.stripf s ô T5Ó!Ð!rO c ó* t t | « « S )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> r² s rM r> zchararray.swapcaser s ô x ~Ó&Ð&rO c ó* t t | « « S )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? r² s rM r? zchararray.title~ s ô uT{Ó#Ð#rO c ó. t t | ||« « S )aB
|
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 rM r@ zchararray.translate s ô y u¨kÓ:Ó;Ð;rO c ó* t t | « « S )z
|
Return an array with the elements of `self` converted to
|
uppercase.
|
|
See Also
|
--------
|
char.upper
|
|
)r rA r² s rM rA zchararray.upper r× rO c ó, t t | |« « S )z
|
Return the numeric string left-filled with zeros in a string of
|
length `width`.
|
|
See Also
|
--------
|
char.zfill
|
|
)r rB )r| rµ s rM rB zchararray.zfill¥ s ô uT 5Ó)Ó*Ð*rO c ó t | « S )z±
|
For each element in `self`, return True if there are only
|
numeric characters in the element.
|
|
See Also
|
--------
|
char.isnumeric
|
|
)rC r² s rM rC zchararray.isnumeric± ó ô Ð rO c ó t | « S )z±
|
For each element in `self`, return True if there are only
|
decimal characters in the element.
|
|
See Also
|
--------
|
char.isdecimal
|
|
)rD r² s rM rD zchararray.isdecimal½ r÷ rO )r FNr NÚC)NF)ra NN)ú )r N)NN)é rH )=Ú__name__Ú
|
__module__Ú __qualname__Ú__doc__ru r
r r r r r r r r r r r¤ r§ r© r¬ r¯ r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- r. r/ r0 r1 r2 r3 r r4 r5 r6 r7 r r8 r9 r: r; r< r= r> r? r@ rA rB rC rD rI rO rM rE rE sA ñLðZ CGØ.1ó ó@òNò
|
ò"ò&ò*ò'ò$ò!ò ò ò *ò *ò
|
%ò ó;ð& oo×-Ñ-GOò
|
)ó 6ó
|
,ó .ó .ó
|
2ó
|
2ó
|
+ó
|
,ò ò ò
|
ò ò ò
|
ò ò
|
ó
|
5ò
|
$ó
|
#ò-ó
|
Kó ,ó
|
-ó
|
5ò.ó
|
+ó
|
#ó
|
*ó
|
*ó
|
4ó
|
"ò
|
'ò $ó <ò
|
$ò
|
+ò
|
ó
|
rO rE c óh t | t t f« rB|t | t « rd}nd}| t | « }t | « |z }t |||| |¬« S t | t
|
t f« r t | « } t | t « r t | j j t « røt | t « s| j t « } |5| j }t | j j t « r|dz }|)t | j j t « rd}nd}|rt }nt }| t | |¬« } |s3|| j k7 s$|st | t « s|r,t | t « r | j# |t% |« f« } | S t | t « r6t | j j t& « r|| j) « } |rt }nt }|t+ | ||d¬« }nt+ | ||f|d¬« }|j t « S )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 <numpy.char.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='<U5')
|
|
TF)rx ry ro rn é rm )rz rn Úsubok)rs Úbytesrt ÚlenrE ÚlistÚtupleÚasnarrayr Ú
|
issubclassrz r r r rx r r Úastyperr ÚobjectÚtolistÚnarray)r rx Úcopyry rn rw rz r s rM r r Ê sÕ ôP #s|Ô$Ø ?Ü#sÔ#Ø à à Ð Ü3xHÜCHÑ$䨸7Ø #¨5ô2ð 2ô #e}Ô%Üsmä#wÕ ¤J¨s¯y©y¯~©~¼yÔ$Iô #yÔ)Ø((9Ó%Cà Ð Ø||Hô #))..¬$Ô/ØQà ?Ü#))..¬$Ô/Ø à á ÜEäEà Ð Ü3 eÔ,CÙ ØS\\Ò)Ù ¤¨C´Ô!6ÙZ¨¬VÔ 4Ø**e¤S¨£]Ð 3Ó4CØ
|
ä#wÔ ¤J¨s¯y©y¯~©~¼vÔ$FØ Ð ð **,Cñ ÜäàÐÜS ¨U¸$Ô?äS ¨Ð 1¸ÀdÔKØ 88IÓ Ð rO c ó" t | |d||¬« S )a¨
|
Convert the input to a `~numpy.char.chararray`, copying the data only if
|
necessary.
|
|
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 <numpy.char.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.
|
|
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='<U5')
|
|
F)r ry rn r )r rx ry rn s rM r r Y s ôr h UØ ¨ô /ð /rO )NTNN)NNN)/rÿ Ú functoolsÚnumpyrd Ú numpy._corer Únumpy._core.multiarrayr Únumpy._core.stringsr r0 r r8 r r: r r; Ú numpy._utilsr
|
Ú numpy.stringsr r[ r rf r rj Únumericr r r r r Ú numerictypesr r r Ú__all__ÚpartialÚarray_function_dispatchrN r r r r r r rE rI rO rM ú<module>r sÉ ðñó" ã Ý !Ý 5õõõõõ $Ü õõõõ %Ý (Ý ß 1Ñ 1ò
|
ð ,)×+Ñ+Ø ×%Ñ%¨lô<Ð òñ Ð.Ó/ñ 2ó 0ð 2ñB Ð.Ó/ñ 2ó 0ð 2ñB Ð.Ó/ñ 2ó 0ð 2ñD Ð.Ó/ñ 2ó 0ð 2ñB Ð.Ó/ñ 1ó 0ð 1ñB Ð.Ó/ñ 1ó 0ð 1ñB LÓñ0:ó ð0:ñf LÓñ&8ó ð&8ñR LÓñ(9ó ð(9ñV LÓôf ó f ó ðf ñR LÓòK ó ðK ñ\ LÓò9/ó ñ9/rO
|
