numpy.core.char

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

Arrays x1 and x2 must have the same shape.

Create a chararray.

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. +, *, %)

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. +, *,``%``)

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.

>>> 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')

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

Calls str.center element-wise.

>>> c = np.array(['a1b2','1b2a','b2a1','2a1b']); c
array(['a1b2', '1b2a', 'b2a1', '2a1b'], dtype='<U4')
>>> np.char.center(c, width=9)
array(['   a1b2  ', '   1b2a  ', '   b2a1  ', '   2a1b  '], dtype='<U9')
>>> np.char.center(c, width=9, fillchar='*')
array(['***a1b2**', '***1b2a**', '***b2a1**', '***2a1b**'], dtype='<U9')
>>> np.char.center(c, width=1)
array(['a', '1', 'b', '2'], dtype='<U1')

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

Calls str.count element-wise.

>>> 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])

Calls bytes.decode element-wise.

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

>>> c = np.array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@',
...               b'\x81\x82\xc2\xc1\xc2\x82\x81'])
>>> c
array([b'\x81\xc1\x81\xc1\x81\xc1', b'@@\x81\xc1@@',
...    b'\x81\x82\xc2\xc1\xc2\x82\x81'], dtype='|S7')
>>> np.char.decode(c, encoding='cp037')
array(['aAaAaA', '  aA  ', 'abBABba'], dtype='<U7')

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.

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

Calls str.endswith element-wise.

>>> 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])

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.

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.

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].

>>> a = np.array(["NumPy is a Python library"])
>>> np.char.find(a, "Python", start=0, end=None)
array([11])

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.

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.

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

Calls str.index element-wise.

>>> a = np.array(["Computer Science"])
>>> np.char.index(a, "Science", start=0, end=None)
array([9])

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.

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.

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.

>>> np.char.isdecimal(['12345', '4.99', '123ABC', ''])
array([ True, False, False, False])

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.

>>> a = np.array(['a', 'b', '0'])
>>> np.char.isdigit(a)
array([False, False,  True])
>>> a = np.array([['a', 'b', '0'], ['c', '1', '2']])
>>> np.char.isdigit(a)
array([[False, False,  True], [False,  True,  True]])

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.

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.

>>> np.char.isnumeric(['123', '123abc', '9.0', '1/4', 'VIII'])
array([ True, False, False, False, False])

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.

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.

Return 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.

>>> str = "GHC"
>>> np.char.isupper(str)
array(True)
>>> a = np.array(["hello", "HELLO", "Hello"])
>>> np.char.isupper(a)
array([False,  True, False])

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

Calls str.join element-wise.

>>> np.char.join('-', 'osd')
array('o-s-d', dtype='<U5')

>>> np.char.join(['-', '.'], ['ghc', 'osd'])
array(['g-h-c', 'o.s.d'], dtype='<U5')

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.

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.

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

Calls str.ljust element-wise.

Return an array with the elements converted to lowercase.

Call str.lower element-wise.

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

>>> 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')

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

Calls str.lstrip element-wise.

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

>>> 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

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

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).

>>> a = np.array(["a", "b", "c"])
>>> np.char.multiply(x, 3)
array(['aaa', 'bbb', 'ccc'], dtype='<U3')
>>> i = np.array([1, 2, 3])
>>> np.char.multiply(a, i)
array(['a', 'bb', 'ccc'], dtype='<U3')
>>> np.char.multiply(np.array(['a']), i)
array(['a', 'aa', 'aaa'], dtype='<U3')
>>> a = np.array(['a', 'b', 'c', 'd', 'e', 'f']).reshape((2, 3))
>>> np.char.multiply(a, 3)
array([['aaa', 'bbb', 'ccc'],
       ['ddd', 'eee', 'fff']], dtype='<U3')
>>> np.char.multiply(a, i)
array([['a', 'bb', 'ccc'],
       ['d', 'ee', 'fff']], dtype='<U3')

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.

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.

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.

>>> a = np.array(["That is a mango", "Monkeys eat mangos"])
>>> np.char.replace(a, 'mango', 'banana')
array(['That is a banana', 'Monkeys eat bananas'], dtype='<U19')

>>> a = np.array(["The dish is fresh", "This is it"])
>>> np.char.replace(a, 'is', 'was')
array(['The dwash was fresh', 'Thwas was it'], dtype='<U19')

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.

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

Calls str.rindex element-wise.

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

Calls str.rjust element-wise.

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.

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.

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

Calls str.rstrip element-wise.

>>> 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')

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.

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

Calls str.splitlines element-wise.

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

Calls str.startswith element-wise.

Return len(a) element-wise.

>>> a = np.array(['Grace Hopper Conference', 'Open Source Day'])
>>> np.char.str_len(a)
array([23, 15])
>>> a = np.array([u'Р', u'о'])
>>> np.char.str_len(a)
array([1, 1])
>>> a = np.array([['hello', 'world'], [u'Р', u'о']])
>>> np.char.str_len(a)
array([[5, 5], [1, 1]])

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

Calls str.strip element-wise.

>>> 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')

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.

>>> 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')

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.

>>> 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')

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.

Return an array with the elements converted to uppercase.

Calls str.upper element-wise.

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

>>> 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')

Return the numeric string left-filled with zeros

Calls str.zfill element-wise.