.Str: ClassType
.Str.
'''
Return a capitalized version of the string.
More specifically, make the first character have upper case and the rest lower
case.
'''
'''erg,python
assert "hello".capitalize() == "Hello"
assert "HELLO".capitalize() == "Hello"
'''
capitalize: (self: .Str) -> .Str
'''
Return a version of the string suitable for caseless comparisons.
'''
'''erg,python
assert "camelCase".casefold() == "camelcase"
assert "CamelCase".casefold() == "camelcase"
assert "FULLCAPS".casefold() == "fullcaps"
assert "snake_case".casefold() == "snake_case"
'''
casefold: (self: .Str) -> .Str
'''
Return a centered string of length width.
Padding is done using the specified fill character (default is a space).
'''
'''erg,python
assert "hello".center(10) == " hello "
assert "hello".center(10, "-") == "--hello---"
'''
center: (self: .Str, width: Nat, fillchar := .Str) -> .Str
'''
Return the number of non-overlapping occurrences of substring `sub` in
string `S[start:end]`. Optional arguments `start` and `end` are
interpreted as in slice notation.
'''
'''erg,python
assert "hello".count("l") == 2
assert "hello".count("l", 0, 3) == 1
'''
count: (self: .Str, sub: .Str, start := Nat, end := Nat) -> Nat
'''
Encode the string using the codec registered for encoding.
* `encoding`:
The encoding in which to encode the string.
* `errors`:
The error handling scheme to use for encoding errors.
The default is `"strict"` meaning that encoding errors raise a
`UnicodeEncodeError`. Other possible values are `"ignore"`, `"replace"` and
`"xmlcharrefreplace"` as well as any other name registered with
`codecs.register_error` that can handle `UnicodeEncodeErrors`.
'''
'''erg
assert "hello".encode() == bytes "hello", "utf-8"
assert "hello".encode("utf-8") == bytes "hello", "utf-8"
'''
encode: (self: .Str, encoding := .Str, errors := .Str) -> Bytes
'''
Return True if the string ends with the specified suffix, False otherwise.
'''
'''erg,python
assert "hello".endswith("o")
assert "hello".endswith("llo")
assert not "hello".endswith("llo", 0, 2)
'''
endswith: (self: .Str, suffix: .Str, start := Nat, end := Nat) -> Bool
'''
Return a copy where all tab characters are expanded using spaces.
If `tabsize` is not given, a tab size of 8 characters is assumed.
'''
'''erg,python
assert "hello\tworld".expandtabs() == "hello world"
assert "hello\tworld".expandtabs(4) == "hello world"
'''
expandtabs: (self: .Str, tabsize := Nat) -> .Str
'''
Return the lowest index in `S` where substring `sub` is found,
such that sub is contained within `S[start:end]`.
Optional arguments `start` and `end` are interpreted as in slice notation.
Return -1 on failure.
'''
'''erg,python
assert "hello".find("l") == 2
assert "hello".find("l", 3) == 3
assert "hello".find("l", 3, 4) == -1
'''
find: (self: .Str, sub: .Str, start := Nat, end := Nat) -> Nat or {-1}
'''
Return a formatted version of `S`, using substitutions from `args` and `kwargs`.
The substitutions are identified by braces ('{' and '}').
'''
'''erg
assert "hello".format() == "hello"
assert "hello {}".format("world") == "hello world"
assert "hello {0}".format("world") == "hello world"
assert "hello {0} {1}".format("world", "again") == "hello world again"
assert "hello {1} {0}".format("world", "again") == "hello again world"
'''
format: (self: .Str, *args: Obj) -> .Str
'''
Return a formatted version of `S`, using substitutions from `mapping`.
The substitutions are identified by braces ('{' and '}').
'''
'''erg,python
assert "hello {name}".format_map({"name": "world"}) == "hello world"
'''
format_map: (self: .Str, mapping: .Dict) -> .Str
'''
Return the lowest index in `S` where substring `sub` is found,
such that `sub` is contained within `S[start:end]`.
Optional arguments `start` and `end` are interpreted as in slice notation.
Raises `ValueError` when the substring is not found.
'''
'''erg,python
assert "hello".index("l") == 2
assert "hello".index("l", 3) == 3
'''
index: (self: .Str, sub: .Str, start := Nat, end := Nat) -> Nat
isalnum: (self: .Str) -> Bool
isalpha: (self: .Str) -> Bool
isascii: (self: .Str) -> Bool
isdecimal: (self: .Str) -> Bool
isdigit: (self: .Str) -> Bool
isidentifier: (self: .Str) -> Bool
islower: (self: .Str) -> Bool
isnumeric: (self: .Str) -> Bool
isprintable: (self: .Str) -> Bool
isspace: (self: .Str) -> Bool
istitle: (self: .Str) -> Bool
isupper: (self: .Str) -> Bool
join: (self: .Str, iterable: Iterable Str) -> .Str
ljust: (self: .Str, width: Nat, fillchar := .Str) -> .Str
lower: (self: .Str) -> .Str
lstrip: (self: .Str, chars := .Str) -> .Str
'''
Return a translation table usable for `str.translate()`.
If there is only one argument, it must be a dictionary mapping Unicode
ordinals (integers) or characters to Unicode ordinals, strings or None.
Character keys will be then converted to ordinals.
If there are two arguments, they must be strings of equal length, and
in the resulting dictionary, each character in `x` will be mapped to the
character at the same position in `y`. If there is a third argument, it
must be a string, whose characters will be mapped to None in the result.
'''
maketrans: ((self: .Str, x: {Str: Str}) -> {Nat: Str}) and ((self: .Str, x: .Str, y: .Str) -> {Nat: Nat}) and (self: .Str, x: .Str, y: .Str, z := .Str) -> {Nat: Nat, Nat: NoneType}
'''
Partition the string into three parts using the given separator.
This will search for the separator in the string. If the separator is found,
returns a 3-tuple containing the part before the separator, the separator
itself, and the part after it.
If the separator is not found, returns a 3-tuple containing the original string
and two empty strings.
'''
partition: (self: .Str, sep: .Str) -> (.Str, .Str, .Str)
removeprefix: (self: .Str, prefix: .Str) -> .Str
removesuffix: (self: .Str, suffix: .Str) -> .Str
replace: (self: .Str, old: .Str, new: .Str, count := Nat) -> .Str
rfind: (self: .Str, sub: .Str, start := Nat, end := Nat) -> Nat or {-1}
rindex: (self: .Str, sub: .Str, start := Nat, end := Nat) -> Nat
rjust: (self: .Str, width: Nat, fillchar := .Str) -> .Str
rpartition: (self: .Str, sep: .Str) -> (.Str, .Str, .Str)
rsplit: (self: .Str, sep := .Str, maxsplit := Nat) -> [Str; _]
rstrip: (self: .Str, chars := .Str) -> .Str
split: (self: .Str, sep := .Str, maxsplit := Nat) -> [Str; _]
splitlines: (self: .Str, keepends := Bool) -> [Str; _]
startswith: (self: .Str, prefix: .Str, start := Nat, end := Nat) -> Bool
strip: (self: .Str, chars := .Str) -> .Str
swapcase: (self: .Str) -> .Str
title: (self: .Str) -> .Str
translate: (self: .Str, table: {Nat: Nat or NoneType}) -> .Str
upper: (self: .Str) -> .Str
zfill: (self: .Str, width: Nat) -> .Str
'''
Returns the substring of the string starting at the given index.
'''
'''erg
assert "abcde".from(2) == "cde"
'''
from: (self: Str, nth: Nat) -> Str