numpy.core.char

module documentation

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_, string_ or unicode_, 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.

Variable array​_function​_dispatch Undocumented
Class chararray chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0, strides=None, order=None)
Function ​_binary​_op​_dispatcher Undocumented
Function ​_center​_dispatcher Undocumented
Function ​_clean​_args Helper function for delegating arguments to Python string functions.
Function ​_code​_dispatcher Undocumented
Function ​_count​_dispatcher Undocumented
Function ​_endswith​_dispatcher Undocumented
Function ​_expandtabs​_dispatcher Undocumented
Function ​_get​_num​_chars 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.
Function ​_join​_dispatcher Undocumented
Function ​_just​_dispatcher Undocumented
Function ​_mod​_dispatcher Undocumented
Function ​_multiply​_dispatcher Undocumented
Function ​_partition​_dispatcher Undocumented
Function ​_replace​_dispatcher Undocumented
Function ​_split​_dispatcher Undocumented
Function ​_splitlines​_dispatcher Undocumented
Function ​_startswith​_dispatcher Undocumented
Function ​_strip​_dispatcher Undocumented
Function ​_to​_string​_or​_unicode​_array Helper function to cast a result back into a string or unicode array if an object array must be used as an intermediary.
Function ​_translate​_dispatcher Undocumented
Function ​_unary​_op​_dispatcher Undocumented
Function ​_use​_unicode Helper function for determining the output type of some string operations.
Function ​_zfill​_dispatcher Undocumented
Function add Return element-wise string concatenation for two arrays of str or unicode.
Function array Create a chararray.
Function asarray Convert the input to a chararray, copying the data only if necessary.
Function capitalize Return a copy of a with only the first character of each element capitalized.
Function center Return a copy of a with its elements centered in a string of length width.
Function count Returns an array with the number of non-overlapping occurrences of substring sub in the range [start, end].
Function decode Calls str.decode element-wise.
Function encode Calls str.encode element-wise.
Function endswith Returns a boolean array which is True where the string element in a ends with suffix, otherwise False.
Function equal Return (x1 == x2) element-wise.
Function expandtabs Return a copy of each string element where all tab characters are replaced by one or more spaces.
Function find For each element, return the lowest index in the string where substring sub is found.
Function greater Return (x1 > x2) element-wise.
Function greater​_equal Return (x1 >= x2) element-wise.
Function index Like find, but raises ValueError when the substring is not found.
Function isalnum Returns true for each element if all characters in the string are alphanumeric and there is at least one character, false otherwise.
Function isalpha Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise.
Function isdecimal For each element, return True if there are only decimal characters in the element.
Function isdigit Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise.
Function islower Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.
Function isnumeric For each element, return True if there are only numeric characters in the element.
Function isspace Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise.
Function istitle Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise.
Function isupper Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise.
Function join Return a string which is the concatenation of the strings in the sequence seq.
Function less Return (x1 < x2) element-wise.
Function less​_equal Return (x1 <= x2) element-wise.
Function ljust Return an array with the elements of a left-justified in a string of length width.
Function lower Return an array with the elements converted to lowercase.
Function lstrip For each element in a, return a copy with the leading characters removed.
Function mod Return (a % i), that is pre-Python 2.6 string formatting (interpolation), element-wise for a pair of array_likes of str or unicode.
Function multiply Return (a * i), that is string multiple concatenation, element-wise.
Function not​_equal Return (x1 != x2) element-wise.
Function partition Partition each element in a around sep.
Function replace For each element in a, return a copy of the string with all occurrences of substring old replaced by new.
Function rfind For each element in a, return the highest index in the string where substring sub is found, such that sub is contained within [start, end].
Function rindex Like rfind, but raises ValueError when the substring sub is not found.
Function rjust Return an array with the elements of a right-justified in a string of length width.
Function rpartition Partition (split) each element around the right-most separator.
Function rsplit For each element in a, return a list of the words in the string, using sep as the delimiter string.
Function rstrip For each element in a, return a copy with the trailing characters removed.
Function split For each element in a, return a list of the words in the string, using sep as the delimiter string.
Function splitlines For each element in a, return a list of the lines in the element, breaking at line boundaries.
Function startswith Returns a boolean array which is True where the string element in a starts with prefix, otherwise False.
Function str​_len Return len(a) element-wise.
Function strip For each element in a, return a copy with the leading and trailing characters removed.
Function swapcase Return element-wise a copy of the string with uppercase characters converted to lowercase and vice versa.
Function title Return element-wise title cased version of string or unicode.
Function translate No summary
Function upper Return an array with the elements converted to uppercase.
Function zfill Return the numeric string left-filled with zeros
Variable ​_globalvar Undocumented
array_function_dispatch =

Undocumented

def _binary_op_dispatcher(x1, x2):

Undocumented

def _center_dispatcher(a, width, fillchar=None):

Undocumented

def _clean_args(*args):

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.

def _code_dispatcher(a, encoding=None, errors=None):

Undocumented

def _count_dispatcher(a, sub, start=None, end=None):

Undocumented

def _endswith_dispatcher(a, suffix, start=None, end=None):

Undocumented

def _expandtabs_dispatcher(a, tabsize=None):

Undocumented

def _get_num_chars(a):
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.
def _join_dispatcher(sep, seq):

Undocumented

def _just_dispatcher(a, width, fillchar=None):

Undocumented

def _mod_dispatcher(a, values):

Undocumented

def _multiply_dispatcher(a, i):

Undocumented

def _partition_dispatcher(a, sep):

Undocumented

def _replace_dispatcher(a, old, new, count=None):

Undocumented

def _split_dispatcher(a, sep=None, maxsplit=None):

Undocumented

def _splitlines_dispatcher(a, keepends=None):

Undocumented

def _startswith_dispatcher(a, prefix, start=None, end=None):

Undocumented

def _strip_dispatcher(a, chars=None):

Undocumented

def _to_string_or_unicode_array(result):
Helper function to cast a result back into a string or unicode array if an object array must be used as an intermediary.
def _translate_dispatcher(a, table, deletechars=None):

Undocumented

def _unary_op_dispatcher(a):

Undocumented

def _use_unicode(*args):

Helper function for determining the output type of some string operations.

For an operation on two ndarrays, if at least one is unicode, the result should be unicode.

def _zfill_dispatcher(a, width):

Undocumented

@array_function_dispatch(_binary_op_dispatcher)
def add(x1, x2):

Return element-wise string concatenation for two arrays of str or unicode.

Arrays x1 and x2 must have the same shape.

Parameters

x1 : array_like of str or unicode
Input array.
x2 : array_like of str or unicode
Input array.

Returns

add : ndarray
Output array of string_ or unicode_, depending on input types of the same shape as x1 and x2.
@set_module('numpy.char')
def array(obj, itemsize=None, copy=True, unicode=None, order=None):

Create a chararray.

Note

This class is provided for numarray backward-compatibility. New code (not concerned with numarray compatibility) should use arrays of type string_ or unicode_ and use the free functions in numpy.char for fast vectorized string operations instead.

Versus a regular NumPy array of type str or unicode, 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. str.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 chararray can contain Unicode characters, when false only 8-bit characters. If unicode is None and obj is one of the following:

  • a 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', '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).
@set_module('numpy.char')
def asarray(obj, itemsize=None, unicode=None, order=None):

Convert the input to a chararray, copying the data only if necessary.

Versus a regular NumPy array of type str or unicode, 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. str.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 chararray can contain Unicode characters, when false only 8-bit characters. If unicode is None and obj is one of the following:

  • a 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).
@array_function_dispatch(_unary_op_dispatcher)
def capitalize(a):

Return a copy of a with only the first character of each element capitalized.

Calls str.capitalize element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode
Input array of strings to capitalize.

Returns

out : ndarray
Output array of str or unicode, depending on input types

See Also

str.capitalize

Examples

>>> c = np.array(['a1b2','1b2a','b2a1','2a1b'],'S4'); c
array(['a1b2', '1b2a', 'b2a1', '2a1b'],
    dtype='|S4')
>>> np.char.capitalize(c)
array(['A1b2', '1b2a', 'B2a1', '2a1b'],
    dtype='|S4')
@array_function_dispatch(_center_dispatcher)
def center(a, width, fillchar=' '):

Return a copy of a with its elements centered in a string of length width.

Calls str.center element-wise.

Parameters

a : array_like of str or unicode

width : int
The length of the resulting strings
fillchar : str or unicode, optional
The padding character to use (default is space).

Returns

out : ndarray
Output array of str or unicode, depending on input types

See Also

str.center

@array_function_dispatch(_count_dispatcher)
def count(a, sub, start=0, end=None):

Returns an array with the number of non-overlapping occurrences of substring sub in the range [start, end].

Calls str.count element-wise.

Parameters

a : array_like of str or unicode

sub : str or unicode
The substring to search for.
start, end : int, optional
Optional arguments start and end are interpreted as slice notation to specify the range in which to count.

Returns

out : ndarray
Output array of ints.

See Also

str.count

Examples

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> np.char.count(c, 'A')
array([3, 1, 1])
>>> np.char.count(c, 'aA')
array([3, 1, 0])
>>> np.char.count(c, 'A', start=1, end=4)
array([2, 1, 1])
>>> np.char.count(c, 'A', start=1, end=3)
array([1, 0, 0])
@array_function_dispatch(_code_dispatcher)
def decode(a, encoding=None, errors=None):

Calls str.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 codecs module.

Parameters

a : array_like of str or unicode

encoding : str, optional
The name of an encoding
errors : str, optional
Specifies how to handle encoding errors

Returns

out : ndarray

See Also

str.decode

Notes

The type of the result will depend on the encoding specified.

Examples

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> np.char.encode(c, encoding='cp037')
array(['\x81\xc1\x81\xc1\x81\xc1', '@@\x81\xc1@@',
    '\x81\x82\xc2\xc1\xc2\x82\x81'],
    dtype='|S7')
@array_function_dispatch(_code_dispatcher)
def encode(a, encoding=None, errors=None):

Calls str.encode element-wise.

The set of available codecs comes from the Python standard library, and may be extended at runtime. For more information, see the codecs module.

Parameters

a : array_like of str or unicode

encoding : str, optional
The name of an encoding
errors : str, optional
Specifies how to handle encoding errors

Returns

out : ndarray

See Also

str.encode

Notes

The type of the result will depend on the encoding specified.

@array_function_dispatch(_endswith_dispatcher)
def endswith(a, suffix, start=0, end=None):

Returns a boolean array which is True where the string element in a ends with suffix, otherwise False.

Calls str.endswith element-wise.

Parameters

a : array_like of str or unicode

suffix : str

start, end : int, optional
With optional start, test beginning at that position. With optional end, stop comparing at that position.

Returns

out : ndarray
Outputs an array of bools.

See Also

str.endswith

Examples

>>> s = np.array(['foo', 'bar'])
>>> s[0] = 'foo'
>>> s[1] = 'bar'
>>> s
array(['foo', 'bar'], dtype='<U3')
>>> np.char.endswith(s, 'ar')
array([False,  True])
>>> np.char.endswith(s, 'a', start=1, end=2)
array([False,  True])
@array_function_dispatch(_binary_op_dispatcher)
def equal(x1, x2):

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.

See Also

not_equal, greater_equal, less_equal, greater, less

@array_function_dispatch(_expandtabs_dispatcher)
def expandtabs(a, tabsize=8):

Return a copy of each string element where all tab characters are replaced by one or more spaces.

Calls 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 of str or unicode
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 str or unicode, depending on input type

See Also

str.expandtabs

@array_function_dispatch(_count_dispatcher)
def find(a, sub, start=0, end=None):

For each element, return the lowest index in the string where substring sub is found.

Calls str.find element-wise.

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 of str or unicode

sub : str or unicode

start, end : int, optional
Optional arguments start and end are interpreted as in slice notation.

Returns

out : ndarray or int
Output array of ints. Returns -1 if sub is not found.

See Also

str.find

@array_function_dispatch(_binary_op_dispatcher)
def greater(x1, x2):

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

@array_function_dispatch(_binary_op_dispatcher)
def greater_equal(x1, x2):

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

@array_function_dispatch(_count_dispatcher)
def index(a, sub, start=0, end=None):

Like find, but raises ValueError when the substring is not found.

Calls str.index element-wise.

Parameters

a : array_like of str or unicode

sub : str or unicode

start, end : int, optional

Returns

out : ndarray
Output array of ints. Returns -1 if sub is not found.

See Also

find, str.find

@array_function_dispatch(_unary_op_dispatcher)
def isalnum(a):

Returns true for each element if all characters in the string are alphanumeric and there is at least one character, false otherwise.

Calls str.isalnum element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.isalnum

@array_function_dispatch(_unary_op_dispatcher)
def isalpha(a):

Returns true for each element if all characters in the string are alphabetic and there is at least one character, false otherwise.

Calls str.isalpha element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of bools

See Also

str.isalpha

@array_function_dispatch(_unary_op_dispatcher)
def isdecimal(a):

For each element, return True if there are only decimal characters in the element.

Calls unicode.isdecimal element-wise.

Decimal characters include digit characters, and all characters that can be used to form decimal-radix numbers, e.g. U+0660, ARABIC-INDIC DIGIT ZERO.

Parameters

a : array_like, unicode
Input array.

Returns

out : ndarray, bool
Array of booleans identical in shape to a.

See Also

unicode.isdecimal

@array_function_dispatch(_unary_op_dispatcher)
def isdigit(a):

Returns true for each element if all characters in the string are digits and there is at least one character, false otherwise.

Calls str.isdigit element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of bools

See Also

str.isdigit

@array_function_dispatch(_unary_op_dispatcher)
def islower(a):

Returns true for each element if all cased characters in the string are lowercase and there is at least one cased character, false otherwise.

Calls str.islower element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of bools

See Also

str.islower

@array_function_dispatch(_unary_op_dispatcher)
def isnumeric(a):

For each element, return True if there are only numeric characters in the element.

Calls unicode.isnumeric element-wise.

Numeric characters include digit characters, and all characters that have the Unicode numeric value property, e.g. U+2155, VULGAR FRACTION ONE FIFTH.

Parameters

a : array_like, unicode
Input array.

Returns

out : ndarray, bool
Array of booleans of same shape as a.

See Also

unicode.isnumeric

@array_function_dispatch(_unary_op_dispatcher)
def isspace(a):

Returns true for each element if there are only whitespace characters in the string and there is at least one character, false otherwise.

Calls str.isspace element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of bools

See Also

str.isspace

@array_function_dispatch(_unary_op_dispatcher)
def istitle(a):

Returns true for each element if the element is a titlecased string and there is at least one character, false otherwise.

Call str.istitle element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of bools

See Also

str.istitle

@array_function_dispatch(_unary_op_dispatcher)
def isupper(a):

Returns true for each element if all cased characters in the string are uppercase and there is at least one character, false otherwise.

Call str.isupper element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of bools

See Also

str.isupper

@array_function_dispatch(_join_dispatcher)
def join(sep, seq):

Return a string which is the concatenation of the strings in the sequence seq.

Calls str.join element-wise.

Parameters

sep : array_like of str or unicode seq : array_like of str or unicode

Returns

out : ndarray
Output array of str or unicode, depending on input types

See Also

str.join

@array_function_dispatch(_binary_op_dispatcher)
def less(x1, x2):

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

@array_function_dispatch(_binary_op_dispatcher)
def less_equal(x1, x2):

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

@array_function_dispatch(_just_dispatcher)
def ljust(a, width, fillchar=' '):

Return an array with the elements of a left-justified in a string of length width.

Calls str.ljust element-wise.

Parameters

a : array_like of str or unicode

width : int
The length of the resulting strings
fillchar : str or unicode, optional
The character to use for padding

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.ljust

@array_function_dispatch(_unary_op_dispatcher)
def lower(a):

Return an array with the elements converted to lowercase.

Call str.lower element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like, {str, unicode}
Input array.

Returns

out : ndarray, {str, unicode}
Output array of str or unicode, depending on input type

See Also

str.lower

Examples

>>> c = np.array(['A1B C', '1BCA', 'BCA1']); c
array(['A1B C', '1BCA', 'BCA1'], dtype='<U5')
>>> np.char.lower(c)
array(['a1b c', '1bca', 'bca1'], dtype='<U5')
@array_function_dispatch(_strip_dispatcher)
def lstrip(a, chars=None):

For each element in a, return a copy with the leading characters removed.

Calls str.lstrip element-wise.

Parameters

a : array-like, {str, unicode}
Input array.
chars : {str, unicode}, optional
The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a prefix; rather, all combinations of its values are stripped.

Returns

out : ndarray, {str, unicode}
Output array of str or unicode, depending on input type

See Also

str.lstrip

Examples

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')

The 'a' variable is unstripped from c[1] because whitespace leading.

>>> np.char.lstrip(c, 'a')
array(['AaAaA', '  aA  ', 'bBABba'], dtype='<U7')

>>> np.char.lstrip(c, 'A') # leaves c unchanged
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, '')).all()
... # XXX: is this a regression? This used to return True
... # np.char.lstrip(c,'') does not modify c at all.
False
>>> (np.char.lstrip(c, ' ') == np.char.lstrip(c, None)).all()
True
@array_function_dispatch(_mod_dispatcher)
def mod(a, values):

Return (a % i), that is pre-Python 2.6 string formatting (interpolation), element-wise for a pair of array_likes of str or unicode.

Parameters

a : array_like of str or unicode

values : array_like of values
These values will be element-wise interpolated into the string.

Returns

out : ndarray
Output array of str or unicode, depending on input types

See Also

str.__mod__

@array_function_dispatch(_multiply_dispatcher)
def multiply(a, i):

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 of str or unicode

i : array_like of ints

Returns

out : ndarray
Output array of str or unicode, depending on input types
@array_function_dispatch(_binary_op_dispatcher)
def not_equal(x1, x2):

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

@array_function_dispatch(_partition_dispatcher)
def partition(a, sep):

Partition each element in a around sep.

Calls 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, {str, unicode}
Input array
sep : {str, unicode}
Separator to split each string element in a.

Returns

out : ndarray, {str, unicode}
Output array of str or unicode, depending on input type. The output array will have an extra dimension with 3 elements per input element.

See Also

str.partition

@array_function_dispatch(_replace_dispatcher)
def replace(a, old, new, count=None):

For each element in a, return a copy of the string with all occurrences of substring old replaced by new.

Calls str.replace element-wise.

Parameters

a : array-like of str or unicode

old, new : str or unicode

count : int, optional
If the optional argument count is given, only the first count occurrences are replaced.

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.replace

@array_function_dispatch(_count_dispatcher)
def rfind(a, sub, start=0, end=None):

For each element in a, return the highest index in the string where substring sub is found, such that sub is contained within [start, end].

Calls str.rfind element-wise.

Parameters

a : array-like of str or unicode

sub : str or unicode

start, end : int, optional
Optional arguments start and end are interpreted as in slice notation.

Returns

out : ndarray
Output array of ints. Return -1 on failure.

See Also

str.rfind

@array_function_dispatch(_count_dispatcher)
def rindex(a, sub, start=0, end=None):

Like rfind, but raises ValueError when the substring sub is not found.

Calls str.rindex element-wise.

Parameters

a : array-like of str or unicode

sub : str or unicode

start, end : int, optional

Returns

out : ndarray
Output array of ints.

See Also

rfind, str.rindex

@array_function_dispatch(_just_dispatcher)
def rjust(a, width, fillchar=' '):

Return an array with the elements of a right-justified in a string of length width.

Calls str.rjust element-wise.

Parameters

a : array_like of str or unicode

width : int
The length of the resulting strings
fillchar : str or unicode, optional
The character to use for padding

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.rjust

@array_function_dispatch(_partition_dispatcher)
def rpartition(a, sep):

Partition (split) each element around the right-most separator.

Calls 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 of str or unicode
Input array
sep : str or unicode
Right-most separator to split each element in array.

Returns

out : ndarray
Output array of string or unicode, depending on input type. The output array will have an extra dimension with 3 elements per input element.

See Also

str.rpartition

@array_function_dispatch(_split_dispatcher)
def rsplit(a, sep=None, maxsplit=None):

For each element in a, return a list of the words in the string, using sep as the delimiter string.

Calls str.rsplit element-wise.

Except for splitting from the right, rsplit behaves like split.

Parameters

a : array_like of str or unicode

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

@array_function_dispatch(_strip_dispatcher)
def rstrip(a, chars=None):

For each element in a, return a copy with the trailing characters removed.

Calls str.rstrip element-wise.

Parameters

a : array-like of str or unicode

chars : str or unicode, optional
The chars argument is a string specifying the set of characters to be removed. If omitted or None, the chars argument defaults to removing whitespace. The chars argument is not a suffix; rather, all combinations of its values are stripped.

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.rstrip

Examples

>>> c = np.array(['aAaAaA', 'abBABba'], dtype='S7'); c
array(['aAaAaA', 'abBABba'],
    dtype='|S7')
>>> np.char.rstrip(c, b'a')
array(['aAaAaA', 'abBABb'],
    dtype='|S7')
>>> np.char.rstrip(c, b'A')
array(['aAaAa', 'abBABba'],
    dtype='|S7')
@array_function_dispatch(_split_dispatcher)
def split(a, sep=None, maxsplit=None):

For each element in a, return a list of the words in the string, using sep as the delimiter string.

Calls str.split element-wise.

Parameters

a : array_like of str or unicode

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.

Returns

out : ndarray
Array of list objects

See Also

str.split, rsplit

@array_function_dispatch(_splitlines_dispatcher)
def splitlines(a, keepends=None):

For each element in a, return a list of the lines in the element, breaking at line boundaries.

Calls str.splitlines element-wise.

Parameters

a : array_like of str or unicode

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

@array_function_dispatch(_startswith_dispatcher)
def startswith(a, prefix, start=0, end=None):

Returns a boolean array which is True where the string element in a starts with prefix, otherwise False.

Calls str.startswith element-wise.

Parameters

a : array_like of str or unicode

prefix : str

start, end : int, optional
With optional start, test beginning at that position. With optional end, stop comparing at that position.

Returns

out : ndarray
Array of booleans

See Also

str.startswith

@array_function_dispatch(_unary_op_dispatcher)
def str_len(a):

Return len(a) element-wise.

Parameters

a : array_like of str or unicode

Returns

out : ndarray
Output array of integers

See Also

builtins.len

@array_function_dispatch(_strip_dispatcher)
def strip(a, chars=None):

For each element in a, return a copy with the leading and trailing characters removed.

Calls str.strip element-wise.

Parameters

a : array-like of str or unicode

chars : str or unicode, optional
The chars argument is a string specifying the set of characters to be removed. If omitted or 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 str or unicode, depending on input type

See Also

str.strip

Examples

>>> c = np.array(['aAaAaA', '  aA  ', 'abBABba'])
>>> c
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')
>>> np.char.strip(c)
array(['aAaAaA', 'aA', 'abBABba'], dtype='<U7')
>>> np.char.strip(c, 'a') # 'a' unstripped from c[1] because whitespace leads
array(['AaAaA', '  aA  ', 'bBABb'], dtype='<U7')
>>> np.char.strip(c, 'A') # 'A' unstripped from c[1] because (unprinted) ws trails
array(['aAaAa', '  aA  ', 'abBABba'], dtype='<U7')
@array_function_dispatch(_unary_op_dispatcher)
def swapcase(a):

Return element-wise a copy of the string with uppercase characters converted to lowercase and vice versa.

Calls str.swapcase element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like, {str, unicode}
Input array.

Returns

out : ndarray, {str, unicode}
Output array of str or unicode, depending on input type

See Also

str.swapcase

Examples

>>> c=np.array(['a1B c','1b Ca','b Ca1','cA1b'],'S5'); c
array(['a1B c', '1b Ca', 'b Ca1', 'cA1b'],
    dtype='|S5')
>>> np.char.swapcase(c)
array(['A1b C', '1B cA', 'B cA1', 'Ca1B'],
    dtype='|S5')
@array_function_dispatch(_unary_op_dispatcher)
def title(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 str.title element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like, {str, unicode}
Input array.

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.title

Examples

>>> c=np.array(['a1b c','1b ca','b ca1','ca1b'],'S5'); c
array(['a1b c', '1b ca', 'b ca1', 'ca1b'],
    dtype='|S5')
>>> np.char.title(c)
array(['A1B C', '1B Ca', 'B Ca1', 'Ca1B'],
    dtype='|S5')
@array_function_dispatch(_translate_dispatcher)
def translate(a, table, deletechars=None):

For each element in a, 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.

Calls str.translate element-wise.

Parameters

a : array-like of str or unicode

table : str of length 256

deletechars : str

Returns

out : ndarray
Output array of str or unicode, depending on input type

See Also

str.translate

@array_function_dispatch(_unary_op_dispatcher)
def upper(a):

Return an array with the elements converted to uppercase.

Calls str.upper element-wise.

For 8-bit strings, this method is locale-dependent.

Parameters

a : array_like, {str, unicode}
Input array.

Returns

out : ndarray, {str, unicode}
Output array of str or unicode, depending on input type

See Also

str.upper

Examples

>>> c = np.array(['a1b c', '1bca', 'bca1']); c
array(['a1b c', '1bca', 'bca1'], dtype='<U5')
>>> np.char.upper(c)
array(['A1B C', '1BCA', 'BCA1'], dtype='<U5')
@array_function_dispatch(_zfill_dispatcher)
def zfill(a, width):

Return the numeric string left-filled with zeros

Calls str.zfill element-wise.

Parameters

a : array_like, {str, unicode}
Input array.
width : int
Width of string to left-fill elements in a.

Returns

out : ndarray, {str, unicode}
Output array of str or unicode, depending on input type

See Also

str.zfill

_globalvar: int =

Undocumented