Skip to main content
`Ctrl`+`K`

# String functionality

The `numpy.strings` module provides a set of universal functions operating on arrays of type `numpy.str_` or `numpy.bytes_`. For example,

These universal functions are also used in `numpy.char`, which provides the `numpy.char.chararray` array subclass, in order for those routines to get the performance benefits as well.

Note

Prior to NumPy 2.0, all string functionality was in `numpy.char`, which only operated on fixed-width strings. That module will not be getting updates and will be deprecated at some point in the future.

## String operations

`add` |
`center`(a, width[, fillchar]) | Return a copy of a with its elements centered in a string of length width.
`capitalize`(a) | Return a copy of `a` with only the first character of each element capitalized.
`decode`(a[, encoding, errors]) | Calls `bytes.decode` element-wise.
`encode`(a[, encoding, errors]) | Calls `str.encode` element-wise.
`expandtabs`(a[, tabsize]) | Return a copy of each string element where all tab characters are replaced by one or more spaces.
`ljust`(a, width[, fillchar]) | Return an array with the elements of a left-justified in a string of length width.
`lower`(a) | Return an array with the elements converted to lowercase.
`lstrip`(a[, chars]) | For each element in a, return a copy with the leading characters removed.
`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.
`multiply`(a, i) | Return (a * i), that is string multiple concatenation, element-wise.
`partition`(a, sep) | Partition each element in `a` around `sep`.
`replace`(a, old, new[, count]) | For each element in `a`, return a copy of the string with occurrences of substring `old` replaced by `new`.
`rjust`(a, width[, fillchar]) | Return an array with the elements of a right-justified in a string of length width.
`rpartition`(a, sep) | Partition (split) each element around the right-most separator.
`rstrip`(a[, chars]) | For each element in a, return a copy with the trailing characters removed.
`slice`(a[, start, stop, step]) | Slice the strings in a by slices specified by start, stop, step.
`strip`(a[, chars]) | For each element in a, return a copy with the leading and trailing characters removed.
`swapcase`(a) | Return element-wise a copy of the string with uppercase characters converted to lowercase and vice versa.
`title`(a) | Return element-wise title cased version of string or unicode.
`translate`(a, table[, deletechars]) | 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.
`upper`(a) | Return an array with the elements converted to uppercase.
`zfill`(a, width) | Return the numeric string left-filled with zeros.

## Comparison

The `numpy.strings` module also exports the comparison universal functions that can now operate on string arrays as well.

`equal` |
`not_equal` |
`greater_equal` |
`less_equal` |
`greater` |
`less` |

## String information

`count`(a, sub[, start, end]) | Returns an array with the number of non-overlapping occurrences of substring `sub` in the range [`start`, `end`).
`endswith`(a, suffix[, start, end]) | Returns a boolean array which is True where the string element in `a` ends with `suffix`, otherwise False.
`find`(a, sub[, start, end]) | 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`).
`index`(a, sub[, start, end]) | Like `find`, but raises `ValueError` when the substring is not found.
`isalnum` |
`isalpha` |
`isdecimal` |
`isdigit` |
`islower` |
`isnumeric` |
`isspace` |
`istitle` |
`isupper` |
`rfind`(a, sub[, start, end]) | For each element, return the highest index in the string where substring `sub` is found, such that `sub` is contained in the range [`start`, `end`).
`rindex`(a, sub[, start, end]) | Like `rfind`, but raises `ValueError` when the substring sub is not found.
`startswith`(a, prefix[, start, end]) | Returns a boolean array which is True where the string element in `a` starts with `prefix`, otherwise False.
`str_len` |