Reference

Methods

str, bytes, list, dict, and set carry built-in methods, plus a small set on int and float. The set is curated for common operations. Missing variants are noted per section.

tuple and frozenset have no methods. (1, 2).count(1) raises AttributeError. Frozensets use the operators from Set instead.

print("hello".upper())
print([3, 1, 2].count(1))
print({"a": 1}.get("a"))

{}

HELLO
1
1

Output

String methods

Case transforms

upper, lower, capitalize, title, casefold, swapcase.

title titlecases each maximal run of letters.
casefold is the same simple lowercasing as lower. It does not expand characters. 'ß'.casefold() stays 'ß' instead of becoming 'ss'.

print("hello".upper())
print("HELLO".lower())
print("hello world".capitalize())
print("hello WORLD".title())
print("Hello".casefold())
print("Straße".casefold())
print("Hello World".swapcase())

{}

HELLO
hello
Hello world
Hello World
hello
straße
hELLO wORLD

Output

Whitespace

strip, lstrip, rstrip remove whitespace, or any character in the optional string argument.

print("  hi  ".strip())
print("  hi  ".lstrip())
print("  hi  ".rstrip())
print("xxhelloxx".strip("x"))

{}

hi
hi  
  hi
hello

Output

Predicates

isdigit, isalpha, isalnum, isspace, isupper, islower, istitle.

All return False on an empty string.
The cased predicates also require at least one cased character.
Every predicate follows the Unicode 15 character tables. "٣".isdigit() is True and "½".isdigit() is False.

print("123".isdigit())
print("abc".isalpha())
print("abc123".isalnum())
print("   ".isspace())
print("ABC".isupper())
print("abc".islower())
print("Hello World".istitle())

{}

True
True
True
True
True
True
True

Output

Not provided are isascii, isidentifier, isnumeric, isdecimal, and isprintable.

Search and count

find and rfind return a code-point index, or -1 on a miss.
index and rindex raise ValueError on a miss.
count counts non-overlapping occurrences.
startswith and endswith accept a single string or a tuple of strings.
All of these take optional start and end code-point bounds.

print("hello".startswith(("hi", "he")))
print("hello".endswith(("x", "lo")))
print("abcabc".find("c"))
print("abcabc".rfind("c"))
print("abcabc".find("a", 1))
print("hello".find("z"))
print("hello".count("l"))

{}

True
True
2
5
3
-1
2

Output

Split, join, replace

split() with no argument or None splits on whitespace runs.
An explicit separator splits on every occurrence. An empty separator raises ValueError.
split and rsplit take an optional maxsplit.
replace(old, new) takes an optional count cap.
splitlines() drops the line separators and has no keepends mode.
partition and rpartition split once into a (head, sep, tail) tuple.
removeprefix and removesuffix strip an affix when present.

print("a,b,c".split(","))
print("a,b,c".split(",", 1))
print("a b c".rsplit(" ", 1))
print("hello world".split())
print(",".join(["a", "b", "c"]))
print("aaaa".replace("a", "b", 2))
print("foobar".removeprefix("foo"))
print("a\nb\nc".splitlines())
print("foo:bar:baz".partition(":"))
print("foo:bar:baz".rpartition(":"))

{}

['a', 'b', 'c']
['a', 'b,c']
['a b', 'c']
['hello', 'world']
a,b,c
bbaa
bar
['a', 'b', 'c']
('foo', ':', 'bar:baz')
('foo:bar', ':', 'baz')

Output

Padding

center, ljust, rjust take (width[, fill]).
zfill(width) pads with leading zeros after any sign.
Widths are measured in code points, not bytes.
A multi-character fill raises TypeError.
expandtabs([tabsize]) replaces tabs with spaces up to the next tab stop, default 8.

print("abc".center(7, "-"))
print("hi".ljust(5, "."))
print("hi".rjust(5, "."))
print("42".zfill(5))
print("-42".zfill(5))
print("a\tbc".expandtabs(4))
print("ñ".center(5, "*"))

{}

--abc--
hi...
...hi
00042
-0042
a   bc
**ñ**

Output

Not provided are translate, maketrans, and format_map.

Formatting

str.format(*args) fills positional fields.

{} auto-numbers and {0} picks an index.
A spec after : uses the format mini-language.
Keyword fields like {name} are not supported.

The % operator does printf-style formatting.

The verbs are %s %r %d %i %u %x %X %o %f %F %e %E %g %G %c %%.
Flags, width, and .precision apply.
* reads the width or precision from the next argument.
A tuple on the right spreads into the fields. Any other value is a single argument.

print("{} and {}".format("a", "b"))
print("{0}-{1}-{0}".format("x", "y"))
print("{:>8}".format("hi"))
print("%d apples, %.1f kg" % (3, 1.5))
print("%05.2f|%-6s|" % (3.1, "hi"))

{}

a and b
x-y-x
      hi
3 apples, 1.5 kg
03.10|hi    |

Output

Encoding

s.encode([encoding]) returns bytes. The encodings are "utf-8" (the default), "utf8", and "ascii".

ASCII raises UnicodeEncodeError on non-ASCII input. It is a subclass of ValueError.
Any other encoding name raises ValueError.

print("café".encode())
print("hi".encode("ascii"))

{}

b'caf\xc3\xa9'
b'hi'

Output

Bytes methods

bytes carries the methods below. bytearray and memoryview do not exist.

Method	Behavior
`decode([encoding[, errors]])`	Returns a string. The encodings match `str.encode`
`hex()`	Lowercase hex with no separator option
`startswith`, `endswith`	Take a single bytes value, no tuple form
`find`, `index`	A byte offset. `find` gives `-1` on a miss and `index` raises `ValueError`
`count`	Non-overlapping occurrences
`replace(old, new[, count])`	Replaces every occurrence, or the first `count`
`split([sep[, maxsplit]])`	Splits on whitespace runs, or on every `sep`
`lower`, `upper`	Change the case of ASCII bytes only
`strip`, `lstrip`, `rstrip`	Trim ASCII whitespace, or any byte in the optional argument
`join(iterable)`	Concatenates an iterable of bytes
`bytes.fromhex(s)`	Parses a hex string, see fromhex

find, index and count take optional start and end byte bounds.

The errors handler of decode takes three values.

"strict" is the default. It raises UnicodeDecodeError, a ValueError, on invalid UTF-8.
"ignore" drops the bad bytes.
"replace" substitutes U+FFFD.

b = b"\x48\x65\x6c\x6c\x6f"

print(b.decode())
print(b.hex())
print(b.startswith(b"He"))
print(b.endswith(b"lo"))
print(b.find(b"ll"))
print(b.count(b"l"))
print(b.replace(b"l", b"L"))
print(b"a,b,c".split(b","))
print(b"ABc".lower())
print(b"  hi  ".strip())
print(b"-".join([b"a", b"b", b"c"]))
print(b"\xff".decode("utf-8", "replace"))

{}

Hello
48656c6c6f
True
True
2
2
b'HeLLo'
[b'a', b'b', b'c']
b'abc'
b'hi'
b'a-b-c'
�

Output

fromhex

bytes.fromhex(s) parses a hex string into bytes. It is called on the type, not on a value.

Each pair of hex digits becomes one byte, in either case.
ASCII whitespace anywhere in s is ignored.
A character that is not a hex digit raises ValueError.
An odd number of digits raises ValueError.

The builtin bytes_fromhex(s) does the same.

print(bytes.fromhex("48 65 6c 6c 6f"))
print(bytes.fromhex("FF00"))

{}

b'Hello'
b'\xff\x00'

Output

List methods

Query

index(value[, start[, end]]) returns the first match and raises ValueError on a miss. Negative bounds count from the end.
count(value) counts matches.
copy() returns a shallow copy.

xs = [1, 2, 3, 2]

print(xs.index(2))
print(xs.index(2, 2))
print(xs.count(2))

ys = xs.copy()
ys.append(99)
print(xs)
print(ys)

{}

1
3
2
[1, 2, 3, 2]
[1, 2, 3, 2, 99]

Output

Mutating

These return None and mutate in place.

append(x) adds one item.
extend(iter) adds every item of any iterable.
insert(i, x) inserts at an index.
remove(x) deletes the first match and raises ValueError on a miss.
pop() removes and returns the last item, pop(i) the item at an index. Both raise IndexError when the index is invalid.
sort() accepts key=fn and reverse=True. It follows the ordering rules of sorted.
reverse() flips in place.
clear() empties the list.

xs = [1, 2, 3]

xs.append(4)
xs.extend(range(5, 7))
xs.insert(0, 99)
print(xs)

xs.remove(99)
print(xs.pop(), xs)
print(xs.pop(0), xs)

{}

[99, 1, 2, 3, 4, 5, 6]
6 [1, 2, 3, 4, 5]
1 [2, 3, 4, 5]

Output

Dict methods

Views

keys, values, items return views that read the dict live. A view taken earlier shows later changes. The keys and items views take the set operators and isdisjoint.

d = {"a": 1, "b": 2, "c": 3}

print(d.keys())
print(d.values())
print(d.items())

k = d.keys()
d["d"] = 4
print(k)
print(k & {"a", "z"})

{}

dict_keys(['a', 'b', 'c'])
dict_values([1, 2, 3])
dict_items([('a', 1), ('b', 2), ('c', 3)])
dict_keys(['a', 'b', 'c', 'd'])
{'a'}

Output

Lookup

get(key) returns the value or None. get(key, default) returns default on a miss.

d = {"a": 1}

print(d.get("a"))
print(d.get("z"))
print(d.get("z", 0))

{}

1
None
0

Output

Mutation

update(src) merges a dict, an iterable of length-2 pairs, or keyword arguments.
pop(key) removes and returns the value. It raises KeyError on a miss unless a default is given.
popitem() removes and returns the last inserted (key, value) pair. It raises KeyError on an empty dict.
setdefault(key, default) inserts only when the key is missing and returns the stored value.
clear() empties the dict in place. Aliases see the change.
copy() returns a shallow copy.
dict.fromkeys(iterable[, value]) builds a new dict that maps each key to value, default None.

d = {"a": 1}

d.update({"b": 2, "a": 99})
d.update([("c", 3)], e=5)
print(d)

print(d.pop("a"), d)
print(d.pop("missing", "fallback"))
print(d.setdefault("b", 0))
print(dict.fromkeys(["x", "y"], 0))
print(d.popitem())

{}

{'a': 99, 'b': 2, 'c': 3, 'e': 5}
99 {'b': 2, 'c': 3, 'e': 5}
fallback
2
{'x': 0, 'y': 0}
('e', 5)

Output

Set methods

Mutation

add(x) inserts.
remove(x) deletes and raises KeyError on a miss.
discard(x) deletes silently.
pop() removes and returns an arbitrary element. It raises KeyError on an empty set.
update(*iterables) inserts from any number of iterables.
clear() empties the set.
copy() returns a shallow copy.

s = {1, 2, 3}

s.add(4)
print(s)

s.remove(2)
s.discard(99)
print(s)

print(s.pop() in {1, 3, 4})

s.clear()
print(s)

{}

{4, 3, 2, 1}
{4, 3, 1}
True
set()

Output

Algebra

union, intersection, difference return fresh sets and accept any number of iterable arguments.
symmetric_difference takes exactly one.
intersection_update, difference_update, symmetric_difference_update mutate the receiver.
issubset, issuperset, isdisjoint test relations.

The named methods accept any iterable. The operator forms are in Set.

print(sorted({1, 2}.union([2, 3], range(4, 6))))

s = {1, 2, 3, 4}
s.intersection_update({2, 4, 6})
print(sorted(s))

print({1, 2}.issubset({1, 2, 3}))
print({1, 2, 3}.issuperset({1}))
print({1, 2}.isdisjoint({3, 4}))

{}

[1, 2, 3, 4, 5]
[2, 4]
True
True
True

Output

int and float methods

int carries these methods. Arguments pass by position only.

bit_length() gives the bits needed for the absolute value, 0 for zero.
bit_count() gives the number of set bits.
to_bytes([length[, byteorder]]) writes the value unsigned, with length 1 and byteorder "big" by default. A negative value or one that does not fit raises OverflowError.
int.from_bytes(bytes[, byteorder]) is called on the type. It reads the bytes unsigned, "big" by default. A value past the signed 128-bit range raises OverflowError.

float carries is_integer().

print((255).bit_length())
print((255).bit_count())
print((1000).to_bytes(2, "big"))
print((1000).to_bytes(2, "little"))
print(int.from_bytes(b"\x03\xe8", "big"))
print((3.0).is_integer())
print((3.5).is_integer())

{}

8
8
b'\x03\xe8'
b'\xe8\x03'
1000
True
False

Output

The builtins int_to_bytes and int_from_bytes are the same methods as functions, with every argument required.