strip(chars=whitespace) — remove leading and trailing bytes that are in chars.lstrip(chars=whitespace) — remove only leading bytes.rstrip(chars=whitespace) — remove only trailing bytes.With no argument, the default character set is ASCII whitespace. Pass a byteset to trim an arbitrary set of bytes.
import stringzilla as sz
assert sz.String(" hi ").strip() == "hi"
assert sz.String("xxhi").lstrip("x") == "hi"
assert sz.String("hi!!").rstrip("!") == "hi"translate(table, inplace=False, start=0, end=len) applies a byte-to-byte mapping in a single pass. table is either a 256-byte string/bytes lookup table or a dict mapping bytes to bytes, spelled as characters below U+0100.
A str input is translated as its UTF-8 bytes and decoded back, so a table that breaks the encoding raises UnicodeDecodeError.
With inplace=True the buffer is rewritten in place and None is returned; otherwise a new bytes/str is returned.
A non-256-byte table raises ValueError; a non-string, non-dict table raises TypeError.
import stringzilla as sz
assert sz.String("abc").translate({"a": "A"}) == b"Abc"
table = bytes(range(256)).translate(bytes.maketrans(b"abc", b"ABC"))
assert sz.String("cabbage").translate(table) == b"CABBAge"Strings.translate(table) takes the same tables and maps every string of a collection in one call, returning a new Strings, as Escaping and Normalizing Collections describes.
decode(encoding='utf-8', errors='strict') decodes the bytes to a Python str, mirroring bytes.decode.
import stringzilla as sz
assert sz.String("abc").decode() == "abc"lstripRemove leading characters from a string.def lstrip(
text: _StringLike,
chars: _StringLike | None = None,
*,
capabilities: Capability | None = None,
) -> StringReturns: String: A new string with leading characters removed.
text_StringLike | The string object. | |
|---|---|---|
chars_StringLike | None | Characters to remove, defaulting to whitespace. | |
capabilitiesCapability | None | Capabilities to run, defaulting to the CPU's enabled ones. |
>>> sz.String(' hi').lstrip() == 'hi'
True
rstripRemove trailing characters from a string.def rstrip(
text: _StringLike,
chars: _StringLike | None = None,
*,
capabilities: Capability | None = None,
) -> StringReturns: String: A new string with trailing characters removed.
text_StringLike | The string object. | |
|---|---|---|
chars_StringLike | None | Characters to remove, defaulting to whitespace. | |
capabilitiesCapability | None | Capabilities to run, defaulting to the CPU's enabled ones. |
>>> sz.String('hi ').rstrip() == 'hi'
True
stripRemove leading and trailing characters from a string.def strip(
text: _StringLike,
chars: _StringLike | None = None,
*,
capabilities: Capability | None = None,
) -> StringReturns: String: A new string with leading and trailing characters removed.
text_StringLike | The string object. | |
|---|---|---|
chars_StringLike | None | Characters to remove, defaulting to whitespace. | |
capabilitiesCapability | None | Capabilities to run, defaulting to the CPU's enabled ones. |
>>> sz.String(' hi ').strip() == 'hi'
True
decodeDecode the bytes into a Unicode string with a given encoding.def decode(
text: _StringLike,
encoding: str = 'utf-8',
errors: str = 'strict',
) -> strReturns: str: The decoded Unicode string. Raises: UnicodeDecodeError: If decoding fails.
text_StringLike | The string object. | |
|---|---|---|
encodingstr | The encoding to use, defaulting to 'utf-8'. | |
errorsstr | Error handling scheme, defaulting to 'strict'. |
>>> sz.String('abc').decode() == 'abc'
True
write_toWrite the string to a file.def write_to(text: _StringLike, filename: str) -> NoneReturns: None.
text_StringLike | The string object. | |
|---|---|---|
filenamestr | The file path to write to. |
>>> import os, tempfile
>>> path = os.path.join(tempfile.gettempdir(), 'sz_demo.bin')
>>> sz.String('payload').write_to(path)
offset_withinReturn the raw byte offset of this StringZilla string within a larger StringZilla string.def offset_within(text: _StringLike, larger: String) -> intReturns: int: The byte offset where 'self' is found within 'larger', or -1 if not found.
text_StringLike | The substring. | |
|---|---|---|
largerString | The larger string to search within. |
>>> big = sz.String('hello world')
>>> big[6:].offset_within(big)
6
translatePerform transformation of a string using a look-up table.def translate(
text: _StringLike,
table: str | bytes | dict[str, str],
inplace: bool = False,
start: int = 0,
end: int | None = None,
*,
capabilities: Capability | None = None,
) -> None | str | bytesReturns: Union[None, str, bytes]: If inplace is False, a translated copy of the [start, end) slice is returned, otherwise None. Raises: ValueError: If the table is not 256 bytes long, or a dict names a character above U+00FF. UnicodeDecodeError: If a str input translates into malformed UTF-8. TypeError: If the table is not a string or dictionary.
text_StringLike | The string object. | |
|---|---|---|
tablestr | bytes | dict[str, str] | A 256-byte string, or a dict mapping characters below U+0100 to such. | |
inplacebool | If True, the string is modified in place, defaulting to False. | |
startint | The starting index for translation, defaulting to 0. | |
endint | None | The ending index for translation, defaulting to the string length. | |
capabilitiesCapability | None | Capabilities to run, defaulting to the CPU's enabled ones. |
>>> sz.String('abc').translate({'a': 'A'}) == b'Abc'
True