Strings

String methods

Method	Purpose	Returns	Complexity	Notes
lower()	Convert to lowercase	New string	O(n)	Original string unchanged
upper()	Convert to uppercase	New string	O(n)	Original string unchanged
casefold()	Aggressive lowercase for comparisons	New string	O(n)	Better for case-insensitive matching
strip()	Remove whitespace from both ends	New string	O(n)	Use lstrip() / rstrip() for one side
lstrip()	Remove whitespace from left side	New string	O(n)	Useful for parsing
rstrip()	Remove whitespace from right side	New string	O(n)	Common for file lines
replace(old, new)	Replace substring	New string	O(n)	Replaces all occurrences by default
split(sep)	Split into list	list[str]	O(n)	Common for parsing text
splitlines()	Split multiline text into lines	list[str]	O(n)	Very useful for file/text processing
join(iter)	Join iterable into string	New string	O(n)	Very common interview question
find(sub)	Find first occurrence	int	O(n)	Returns -1 if not found
rfind(sub)	Find last occurrence	int	O(n)	Returns -1 if not found
index(sub)	Find first occurrence	int	O(n)	Raises ValueError if not found
rindex(sub)	Find last occurrence	int	O(n)	Raises ValueError if not found
count(sub)	Count occurrences	int	O(n)	Counts substring matches
startswith(prefix)	Check prefix	bool	O(k)	k = prefix length
endswith(suffix)	Check suffix	bool	O(k)	Common in path checks
partition(sep)	Split once at first separator	tuple	O(n)	Returns (before, sep, after)
rpartition(sep)	Split once at last separator	tuple	O(n)	Useful for paths/domains
removeprefix(x)	Remove prefix if present	New string	O(k)	Cleaner than slicing
removesuffix(x)	Remove suffix if present	New string	O(k)	Great for extensions
isdigit()	Check if all chars are digits	bool	O(n)	Useful for validation
isnumeric()	Check if all chars are numeric	bool	O(n)	Broader than isdigit()
isalpha()	Check if all chars are letters	bool	O(n)	Useful for validation
isalnum()	Check letters/digits only	bool	O(n)	Common input checks
isspace()	Check whitespace only	bool	O(n)	Useful in parsing
islower()	Check lowercase	bool	O(n)	Validation/helper
isupper()	Check uppercase	bool	O(n)	Validation/helper
format(...)	String formatting	New string	O(n)	Older alternative to f-strings

Common string operations

Operation	Purpose	Returns	Complexity	Notes
s[i]	Get character by index	Character	O(1)	Strings are immutable
s[a:b]	Slice substring	New string	O(k)	k = slice size
s[::-1]	Reverse copy	New string	O(n)	Common interview trick
len(s)	String length	int	O(1)	Very common
x in s	Substring / char check	bool	O(n)	Membership test
s1 + s2	Concatenate strings	New string	O(n + m)	Creates new string
s * n	Repeat string	New string	O(n·k)	Common for patterns
for ch in s	Iterate characters	Iterator behavior	O(n) total	Very common
enumerate(s)	Iterate index + char	Iterator	O(n) total	Common in interviews
ord(ch)	Character to Unicode code point	int	O(1)	Useful in algorithms
chr(i)	Code point to character	Character	O(1)	Reverse of ord()

---

Lists

List methods

Method	Purpose	Returns	Complexity	Notes
append(x)	Add single element to end	None	O(1) amortized	Adds whole object as one element
extend(iter)	Add all elements from iterable	None	O(k)	Adds each element individually
pop([i])	Remove and return element	Element	O(1) end, O(n) start	Default is last item
insert(i, x)	Insert element at index	None	O(n)	Shifts elements right
remove(x)	Remove first matching value	None	O(n)	Raises ValueError if not found
index(x)	Find first matching value	Index	O(n)	Raises ValueError if not found
count(x)	Count occurrences of value	int	O(n)	Returns 0 if not found
reverse()	Reverse list in place	None	O(n)	Mutates original list
clear()	Remove all elements	None	O(n)	Keeps same list object
copy()	Shallow copy	New list	O(n)	Same as lst[:]
sort(key=, reverse=)	Sort in place	None	O(n log n)	Stable Timsort
sorted(iter, key=)	Return new sorted list	New list	O(n log n)	Built-in, works on any iterable

Common list operations

Operation	Purpose	Returns	Complexity	Notes
lst[i]	Get item by index	Element	O(1)	Negative indexing supported
lst[i] = x	Update item by index	None	O(1)	Mutates list
del lst[i]	Delete item by index	None	O(n)	Shifts elements left
len(lst)	Number of elements	int	O(1)	Very common in interviews
x in lst	Membership check	bool	O(n)	Linear scan
for x in lst	Iterate through elements	Iterator behavior	O(n) total	Most common iteration pattern
enumerate(lst)	Iterate with index + value	Iterator	O(n) total	Common in loops
lst[a:b]	Slice list	New list	O(k)	k = slice size
lst[a:b:c]	Slice with step	New list	O(k)	Useful for stepping
lst[::-1]	Reversed copy	New list	O(n)	Creates new list
lst1 + lst2	Concatenate lists	New list	O(n + m)	Creates new object
lst * n	Repeat list	New list	O(n·k)	Copies references
min(lst)	Smallest value	Element	O(n)	Built-in
max(lst)	Largest value	Element	O(n)	Built-in
sum(lst)	Sum numeric values	Number	O(n)	Built-in

---

Tuples

Tuple methods

Method	Purpose	Returns	Complexity	Notes
count(x)	Count occurrences of value	int	O(n)	Returns 0 if not found
index(x)	Find first matching value	Index	O(n)	Raises ValueError if not found

Quick Reference: Common tuple operations

Operation	Purpose	Returns	Complexity	Notes
tuple(iterable)	Create tuple from iterable	New tuple	O(n)	Very common conversion
(x,)	Create single-element tuple	Tuple	O(1)	Comma is required
t[i]	Get item by index	Element	O(1)	Negative indexing supported
t[a:b]	Slice tuple	New tuple	O(k)	k = slice size
len(t)	Number of elements	int	O(1)	Very common in interviews
x in t	Membership check	bool	O(n)	Linear scan
for x in t	Iterate through elements	Iterator behavior	O(n) total	Common iteration pattern
enumerate(t)	Iterate with index + value	Iterator	O(n) total	Common in loops
t1 + t2	Concatenate tuples	New tuple	O(n + m)	Creates new object
t * n	Repeat tuple	New tuple	O(n·k)	Copies references
min(t)	Smallest value	Element	O(n)	Built-in
max(t)	Largest value	Element	O(n)	Built-in
sum(t)	Sum numeric values	Number	O(n)	Built-in
a, b = t	Tuple unpacking	Variables	O(n)	Very common in practice
a, *rest = t	Extended unpacking	Variables	O(n)	Useful for flexible assignment
hash(t)	Hash immutable tuple	int	O(n)	Only if all elements are hashable
t1 < t2	Lexicographical comparison	bool	O(n)	Compared left to right

---

Dictionaries

Dictionary methods

Method	Purpose	Returns	Complexity	Notes
get(key, default=None)	Safely read value	Value or default	O(1) average	No KeyError if missing
keys()	View of all keys	dict_keys view	O(1)	Dynamic view, not a list
values()	View of all values	dict_values view	O(1)	Dynamic view
items()	View of key-value pairs	dict_items view	O(1)	Very common for iteration
pop(key[, default])	Remove and return value for key	Value	O(1) average	Raises KeyError if missing and no default
popitem()	Remove and return last inserted pair	(key, value) tuple	O(1) average	LIFO in modern Python
update(other)	Merge in values from another mapping / iterable	None	O(k)	Overwrites existing keys
setdefault(key[, default])	Get value, insert default if missing	Value	O(1) average	Useful for grouping/counting
clear()	Remove all items	None	O(n)	Keeps same dict object
copy()	Shallow copy	New dict	O(n)	Nested mutables are still shared
fromkeys(iterable, value=None)	Create new dict with given keys	New dict	O(n)	All keys share same value object

Common dictionary operations

Operation	Purpose	Returns	Complexity	Notes
d[key]	Get value by key	Value	O(1) average	Raises KeyError if missing
d[key] = value	Insert or update key	None	O(1) average	Overwrites if key exists
del d[key]	Delete key-value pair	None	O(1) average	Deletes only
len(d)	Number of items	int	O(1)	Very common
key in d	Membership check by key	bool	O(1) average	Checks keys, not values
value in d.values()	Membership check by value	bool	O(n)	Values require scan
for key in d	Iterate keys	Iterator behavior	O(n) total	Default iteration is over keys
for key, value in d.items()	Iterate key-value pairs	Iterator behavior	O(n) total	Most common iteration pattern
dict(iterable_or_mapping)	Create dict from mapping / pairs	New dict	O(n)	Common conversion
{k: v for ...}	Dictionary comprehension	New dict	O(n)	Very common in interviews
`d1	d2`	Merge dictionaries	New dict	O(n + m)
`d1	= d2`	Merge into existing dict	None	O(m)
{**d1, **d2}	Merge via unpacking	New dict	O(n + m)	Common in older code
sorted(d)	Sorted list of keys	New list	O(n log n)	Dict iteration is by key
sorted(d.items(), key=...)	Sort items with custom rule	New list	O(n log n)	Common interview pattern
reversed(d)	Reverse insertion-order keys	Iterator	O(n) total	Modern Python

---

Sets

Set methods

Method	Purpose	Returns	Complexity	Notes
add(x)	Add single element	None	O(1) average	Ignores duplicates automatically
update(iterable)	Add all elements from iterable	None	O(k) average	Adds each element
remove(x)	Remove element	None	O(1) average	Raises KeyError if missing
discard(x)	Remove element safely	None	O(1) average	No error if missing
pop()	Remove and return arbitrary element	Element	O(1) average	Order not guaranteed
clear()	Remove all elements	None	O(n)	Keeps same set object
copy()	Shallow copy	New set	O(n)	Elements are shared references
union(other)	Combine unique elements	New set	O(n + m)	Same as `
intersection(other)	Common elements only	New set	O(min(n,m)) avg	Same as &
difference(other)	Elements only in first set	New set	O(n) avg	Same as -
symmetric_difference(other)	Elements in one but not both	New set	O(n + m)	Same as ^
issubset(other)	Check subset relation	bool	O(n) avg	Same as <=
issuperset(other)	Check superset relation	bool	O(n) avg	Same as >=
isdisjoint(other)	Check no overlap	bool	O(min(n,m)) avg	Very common
intersection_update(other)	In-place intersection	None	O(min(n,m)) avg	Mutates original
difference_update(other)	In-place difference	None	O(n) avg	Mutates original
symmetric_difference_update(other)	In-place XOR	None	O(n + m)	Mutates original

Common set operations

Operation	Purpose	Returns	Complexity	Notes
x in s	Membership check	bool	O(1) average	Major advantage of sets
len(s)	Number of elements	int	O(1)	Very common
for x in s	Iterate elements	Iterator behavior	O(n) total	Order not guaranteed
set(iterable)	Create set from iterable	New set	O(n)	Removes duplicates
set()	Create empty set	New set	O(1)	{} creates dict, not set
{x for x in values}	Set comprehension	New set	O(n)	Very common in interviews
`s1	s2`	Union	New set	O(n + m)
s1 & s2	Intersection	New set	O(min(n,m)) avg	Common interview question
s1 - s2	Difference	New set	O(n) avg	Elements only in left set
s1 ^ s2	Symmetric difference	New set	O(n + m)	XOR behavior
s1 <= s2	Subset check	bool	O(n) avg	Equivalent to issubset()
s1 >= s2	Superset check	bool	O(n) avg	Equivalent to issuperset()
`s1	= s2`	In-place union	None	O(m) avg
s1 &= s2	In-place intersection	None	O(min(n,m)) avg	Mutates left set
s1 -= s2	In-place difference	None	O(n) avg	Mutates left set
s1 ^= s2	In-place XOR	None	O(n + m)	Mutates left set

---