×
Slice Notation
# reverse
word = input()
print(word[::-1])
----------------------
#slicing with a step - skips letters
print(text[::2])
word = input()
print(word[::-1])
----------------------
#slicing with a step - skips letters
print(text[::2])
×
.replace()
>> Replace by index - use slicing:
# Strings are immutable: assignment via index like name[0] = 'b' won’t work, you need slicing:
name = 'Yoana'
new_name = 'b' + name[1:] # oana
print(new_name)
# Output: Boana
my_list = [10, 20, 30, 40]
my_list[1] = 99
print(my_list)
# Output: [10, 99, 30, 40]
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['b'] = 99
print(my_dict)
# Output: {'a': 1, 'b': 99, 'c': 3}
>> Replace by char - use .replace(old, new):
# .replace() is a string method only. It cannot be called on lists, dicts, numbers, or other types.
text = "banana"
new_text = text.replace('b', 'c')
print(new_text)
# Output: canana
# By default str.replace(old, new) replaces all occurrences of old in the string. To replace only the first occurrence of a substring in Python, use the third argument of .replace():
text = "hello world, hello universe, hello everyone"
new_text = text.replace("hello", "hi", 1)
print(new_text)
# Output: hi world, hello universe, hello everyone
# Strings are immutable: assignment via index like name[0] = 'b' won’t work, you need slicing:
name = 'Yoana'
new_name = 'b' + name[1:] # oana
print(new_name)
# Output: Boana
my_list = [10, 20, 30, 40]
my_list[1] = 99
print(my_list)
# Output: [10, 99, 30, 40]
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict['b'] = 99
print(my_dict)
# Output: {'a': 1, 'b': 99, 'c': 3}
>> Replace by char - use .replace(old, new):
# .replace() is a string method only. It cannot be called on lists, dicts, numbers, or other types.
text = "banana"
new_text = text.replace('b', 'c')
print(new_text)
# Output: canana
# By default str.replace(old, new) replaces all occurrences of old in the string. To replace only the first occurrence of a substring in Python, use the third argument of .replace():
text = "hello world, hello universe, hello everyone"
new_text = text.replace("hello", "hi", 1)
print(new_text)
# Output: hi world, hello universe, hello everyone
×
Ranges
# regular
range(start=0, stop=stop -1, step=1)
for a in range(5): # (0, 5, 1)
print(a)
0
1
2
3
4
----------------------
# reverse
range(start=n, stop=stop +1, step=-1)
for a in range(5, 0, -1):
print(a)
5
4
3
2
1
word = "hello"
for i in range((len(word) -1), -1, -1):
print(word[i], end='')
# Output: olleh
----------------------
#shape illustration
n = int(input())
for i in range(1, n + 1):
print('*' * i)
for k in range(n -1, 0, -1):
print('*' * k)
# Output:
*
**
***
****
*****
****
***
**
*
range(start=0, stop=stop -1, step=1)
for a in range(5): # (0, 5, 1)
print(a)
0
1
2
3
4
----------------------
# reverse
range(start=n, stop=stop +1, step=-1)
for a in range(5, 0, -1):
print(a)
5
4
3
2
1
word = "hello"
for i in range((len(word) -1), -1, -1):
print(word[i], end='')
# Output: olleh
----------------------
#shape illustration
n = int(input())
for i in range(1, n + 1):
print('*' * i)
for k in range(n -1, 0, -1):
print('*' * k)
# Output:
*
**
***
****
*****
****
***
**
*
×
for + else
for item in iterable:
if condition:
break # If this runs, 'else' is skipped
else:
print("No break occurred") # Runs only if the loop wasn't broken
if condition:
break # If this runs, 'else' is skipped
else:
print("No break occurred") # Runs only if the loop wasn't broken
×
break vs continue
for i in range(10):
if i == 5:
break # stop loop when i == 5
print(i)
# breaks the loop
______________
for line in file:
if line.strip() == '':
continue # skip empty lines
process(line)
#used to skip things, does not reset the loop
if i == 5:
break # stop loop when i == 5
print(i)
# breaks the loop
______________
for line in file:
if line.strip() == '':
continue # skip empty lines
process(line)
#used to skip things, does not reset the loop
×
Printing } in f-string
"{{" → prints "{"
"}}" → prints "}"
"}}" → prints "}"
×
SyntaxError: f-string: expecting '}'
Use single quotes inside double-quoted f-strings:
f"Hello, {'John'}"
Or use double quotes inside single-quoted f-strings:
f'Hello, {"John"}'
Python gets confused when it sees the same quote type inside and outside — it can’t tell where the string ends.
Use single quotes inside double-quoted f-strings:
Rule applies even in {}, ex:
f"You've ordered pizza {self.name} prepared with {", ".join(f'{i}: {q}' for i, q in self.ingredients.items())} and the price will be {self.price}lv."
(this will raise the error still)
f"Hello, {'John'}"
Or use double quotes inside single-quoted f-strings:
f'Hello, {"John"}'
Python gets confused when it sees the same quote type inside and outside — it can’t tell where the string ends.
Use single quotes inside double-quoted f-strings:
Rule applies even in {}, ex:
f"You've ordered pizza {self.name} prepared with {", ".join(f'{i}: {q}' for i, q in self.ingredients.items())} and the price will be {self.price}lv."
(this will raise the error still)
×
end=
name = "Alice"
print(f"Hello, {name}", end=' ')
print("How are you?")
# Output:Hello, Alice How are you?
# keep it out of the f str
# end='\n' is the default behavior of Python’s print() function.
print(f"Hello, {name}", end=' ')
print("How are you?")
# Output:Hello, Alice How are you?
# keep it out of the f str
# end='\n' is the default behavior of Python’s print() function.
×
sep=
print(1, 2, 3, sep='-')
# Output: 1-2-3
print('apple', 'banana', 'cherry', sep='\n')
# Output:
apple
banana
cherry
fruits = ['apple', 'banana', 'cherry']
print(*fruits, sep=', ')
# Output: apple, banana, cherry
fruits = {'apple': 5, 'banana': 3, 'cherry': 7}
items = [f"{key}:{value}" for key, value in fruits.items()] # Create a list of "key:value" strings
print(*items, sep=', ', end=' ENDED HERE\n')
# Output: apple:5, banana:3, cherry:7 ENDED HERE
items = [f"{k}:{v}" for k, v in fruits.items()]
print(*items, sep='\n')
# Output:
apple:5
banana:3
cherry:7
# Output: 1-2-3
print('apple', 'banana', 'cherry', sep='\n')
# Output:
apple
banana
cherry
fruits = ['apple', 'banana', 'cherry']
print(*fruits, sep=', ')
# Output: apple, banana, cherry
fruits = {'apple': 5, 'banana': 3, 'cherry': 7}
items = [f"{key}:{value}" for key, value in fruits.items()] # Create a list of "key:value" strings
print(*items, sep=', ', end=' ENDED HERE\n')
# Output: apple:5, banana:3, cherry:7 ENDED HERE
items = [f"{k}:{v}" for k, v in fruits.items()]
print(*items, sep='\n')
# Output:
apple:5
banana:3
cherry:7
×
.join()
# joins elements of an iterable (like a list of strings) into a single string.
numbers = [1, 2, 4, 7, 14]
print(" + ".join(map(str, numbers)))
# Output: 1 + 2 + 4 + 7 + 14
# str.join() only works with strings, so we map to str
words = ['Python', 'is', 'awesome']
# Output:
print('\n'.join(words))
Python
is
Awesome
word = "hello"
print(', '.join(word))
# Output: h, e, l, l, o
data = {'a': 1, 'b': 2, 'c': 3}
print(', '.join(data.keys()))
# Output: a, b, c
numbers = [1, 2, 4, 7, 14]
print(" + ".join(map(str, numbers)))
# Output: 1 + 2 + 4 + 7 + 14
# str.join() only works with strings, so we map to str
words = ['Python', 'is', 'awesome']
# Output:
print('\n'.join(words))
Python
is
Awesome
word = "hello"
print(', '.join(word))
# Output: h, e, l, l, o
data = {'a': 1, 'b': 2, 'c': 3}
print(', '.join(data.keys()))
# Output: a, b, c
×
Concatenation
# joining strings together to form one longer string
print('100% Complete!' + "\n" + '[%%%%%%%%%%]')
100% Complete!
[%%%%%%%%%%]
print('ba' + 'na' + 'na')
# Output: banana
return (f"Hotel {self.name} has {self.guests} total guests"
f"\nFree rooms: {', '.join(map(str, free))}"
f"\nTaken rooms: {', '.join(map(str, taken))}")
• Each line inside the parentheses is an f-string (formatted string literal).
• When you put string literals one after another inside parentheses, Python automatically concatenates them into one string.
• So this is the same as writing:
return (f"Hotel {self.name} has {self.guests} total guests" + f"\nFree rooms: {', '.join(map(str, free))}" + f"\nTaken rooms: {', '.join(map(str, taken))}")
print('100% Complete!' + "\n" + '[%%%%%%%%%%]')
100% Complete!
[%%%%%%%%%%]
print('ba' + 'na' + 'na')
# Output: banana
return (f"Hotel {self.name} has {self.guests} total guests"
f"\nFree rooms: {', '.join(map(str, free))}"
f"\nTaken rooms: {', '.join(map(str, taken))}")
• Each line inside the parentheses is an f-string (formatted string literal).
• When you put string literals one after another inside parentheses, Python automatically concatenates them into one string.
• So this is the same as writing:
return (f"Hotel {self.name} has {self.guests} total guests" + f"\nFree rooms: {', '.join(map(str, free))}" + f"\nTaken rooms: {', '.join(map(str, taken))}")
×
# the result is always a string, no matter what type self.hours is.
string formatting for numbers
:.2f
________________________________
n = 35.75432345
formatted_number = "%.2f" % n
print(formatted_number)
# Output: '35.75'
# it is a str now
price = 3.14159
print(f"Price: {price:.2f}")
# Output: Price: 3.14
# all is 1 str
:02d
________________________________
class Time:
def __init__(self, hours):
self.hours = hours
def formatted_hours(self):
return f"{self.hours:02d}"
t = Time(5)
print(t.formatted_hours())
# Output: 05
:02d → the format specification:
0 → pad with zeros
2 → width = 2 characters
d → integer (decimal)
Example:
hours = 5
print(f"{hours:02d}")
# Output: 05
hours = 12
print(f"{hours:02d}")
# Output: 12
So :02d means:
print as a 2-digit integer, left-padded with zeros if necessary.
________________________________
n = 35.75432345
formatted_number = "%.2f" % n
print(formatted_number)
# Output: '35.75'
# it is a str now
price = 3.14159
print(f"Price: {price:.2f}")
# Output: Price: 3.14
# all is 1 str
:02d
________________________________
class Time:
def __init__(self, hours):
self.hours = hours
def formatted_hours(self):
return f"{self.hours:02d}"
t = Time(5)
print(t.formatted_hours())
# Output: 05
:02d → the format specification:
0 → pad with zeros
2 → width = 2 characters
d → integer (decimal)
Example:
hours = 5
print(f"{hours:02d}")
# Output: 05
hours = 12
print(f"{hours:02d}")
# Output: 12
So :02d means:
print as a 2-digit integer, left-padded with zeros if necessary.
# the result is always a string, no matter what type self.hours is.
×
# You can't use \n (or any backslash) inside {} in an f-string. This is invalid: f"{\n'.join(...)}"
return f"Section {self.name}: {'\n'.join(t.details() for t in self.tasks)}"
Fix:
Move the expression outside:
joined = '\n'.join(t.details() for t in self.tasks)
return f"Section {self.name}: {joined}"
\n in f-string
# You can't use \n (or any backslash) inside {} in an f-string. This is invalid: f"{\n'.join(...)}"
return f"Section {self.name}: {'\n'.join(t.details() for t in self.tasks)}"
Fix:
Move the expression outside:
joined = '\n'.join(t.details() for t in self.tasks)
return f"Section {self.name}: {joined}"
×
whitespaces, .strip()
# If a string is empty or contains only white spaces, calling .strip() on it will return an empty string.
value = " " # only spaces
value.strip() # returns ""
# So, to check whether a string is empty or only spaces:
if not value.strip():
raise ValueError("Name cannot be empty or just whitespace!")
# In Python, the empty string "" is considered falsy, which means it behaves like False in a boolean context, hence 'if not' can be used.
value = " " # only spaces
value.strip() # returns ""
# So, to check whether a string is empty or only spaces:
if not value.strip():
raise ValueError("Name cannot be empty or just whitespace!")
# In Python, the empty string "" is considered falsy, which means it behaves like False in a boolean context, hence 'if not' can be used.
×
str(), repr(), !r, !s
return '{' + ', '.join(f"{kvp[0]!r}: {kvp[1]!r}" for kvp in self.array) + '}'
# the !r in an f-string is a conversion flag that tells Python to use the repr() of the expression instead of str().
{'name': 'Peter', 'age': 25}
#Notice that !r includes the quotes around "Peter", because that’s how repr() shows strings.
• !r → use repr()
f"{x!r}" Calls repr(x) inside f-string
• {} (default) → use str()
f"{x!s}" Calls str(x) inside f-string
f"{x}" Calls str(x) inside f-string
str() → Meant to return a “nice” or human-readable representation of an object. Used by print() by default.
s = "Hello\nWorld"
print(str(s))
# Output:
Hello
World
# Notice that the newline is interpreted; it prints on two lines.
repr() → Meant to return an “official” or unambiguous representation of an object. Shows all escape characters, quotes, etc.
s = "Hello\nWorld"
print(repr(s))
# Output: 'Hello\nWorld'
# Notice the \n is visible, and quotes are included.
# the !r in an f-string is a conversion flag that tells Python to use the repr() of the expression instead of str().
{'name': 'Peter', 'age': 25}
#Notice that !r includes the quotes around "Peter", because that’s how repr() shows strings.
• !r → use repr()
f"{x!r}" Calls repr(x) inside f-string
• {} (default) → use str()
f"{x!s}" Calls str(x) inside f-string
f"{x}" Calls str(x) inside f-string
str() → Meant to return a “nice” or human-readable representation of an object. Used by print() by default.
s = "Hello\nWorld"
print(str(s))
# Output:
Hello
World
# Notice that the newline is interpreted; it prints on two lines.
repr() → Meant to return an “official” or unambiguous representation of an object. Shows all escape characters, quotes, etc.
s = "Hello\nWorld"
print(repr(s))
# Output: 'Hello\nWorld'
# Notice the \n is visible, and quotes are included.
×
unpacking operator *
The * in print(*fruits, sep=', ') is the unpacking operator.
Without *:
fruits = ['apple', 'banana', 'cherry']
print(fruits)
# Output: ['apple', 'banana', 'cherry']
# It prints the list as a list, with brackets and quotes.
With *:
print(fruits)
# Output: apple banana cherry
# The * unpacks the list, so print receives the items as if you had written:
print('apple', 'banana', 'cherry')
Without *:
fruits = ['apple', 'banana', 'cherry']
print(fruits)
# Output: ['apple', 'banana', 'cherry']
# It prints the list as a list, with brackets and quotes.
With *:
print(fruits)
# Output: apple banana cherry
# The * unpacks the list, so print receives the items as if you had written:
print('apple', 'banana', 'cherry')
×
>> Methods
s = {1, 2, 3}
The add() method only takes a single element at a time. If you try to pass a list or another iterable, it will treat the whole thing as one element
s.add(4) # {1,2,3,4}
s.add([5, 6]) # adds the *list itself* as one element
print(s) # {1, 2, 3, 4, [5, 6]} <-- note the list inside
The update() method lets you add multiple elements to a set at once, and you can pass it any iterable — like a list, tuple, or even another set. It adds all the elements that aren’t already in the set.
s.update([3,5]) # {1,2,3,4,5}
If you use remove(x) on a set and x is not in the set, Python will raise a KeyError.
s.remove(2) # {1,3,4,5}
If you want to avoid an error when the element might not exist, use discard(x) instead:
s.discard(10) # {1,3,4,5} (no error)
set.pop() does not remove the “last” element because sets in Python are unordered. It removes and returns an arbitrary element—which element you get is unpredictable.
elem = s.pop() # removes and returns an arbitrary element
clear() removes all elements from the set, leaving it empty. It doesn’t return anything.
s.clear() # s becomes set()
Sets
{} → empty dictionary, not set.
set() → empty set.
{1,} → a set with one element (the comma is optional but allowed for single-element sets).
1. Union (| or .union())
A = {1, 2, 3}
B = {3, 4, 5}
A | B # {1, 2, 3, 4, 5}
A.union(B) # {1, 2, 3, 4, 5}
2. Intersection (& or .intersection())
A = {1, 2, 3}
B = {3, 4, 5}
A & B # {3}
A.intersection(B) # {3}
3. Difference (- or .difference())
A = {1, 2, 3}
B = {3, 4, 5}
A - B # {1, 2}
B - A # {4, 5}
A.difference(B) # {1, 2}
4. Symmetric Difference (^ or .symmetric_difference())
A = {1, 2, 3}
B = {3, 4, 5}
A ^ B # {1, 2, 4, 5}
A.symmetric_difference(B) # {1, 2, 4, 5}
5. Subset (<=, <) & Superset (>=, >)
A = {1, 2}
B = {1, 2, 3}
A <= B # True (A is a subset of B)
B >= A # True (B is a superset of A)
print(A < B) # True
print(B > A) # True
A.issubset(B) # True
B.issuperset(A) # True
set() → empty set.
{1,} → a set with one element (the comma is optional but allowed for single-element sets).
1. Union (| or .union())
A = {1, 2, 3}
B = {3, 4, 5}
A | B # {1, 2, 3, 4, 5}
A.union(B) # {1, 2, 3, 4, 5}
2. Intersection (& or .intersection())
A = {1, 2, 3}
B = {3, 4, 5}
A & B # {3}
A.intersection(B) # {3}
3. Difference (- or .difference())
A = {1, 2, 3}
B = {3, 4, 5}
A - B # {1, 2}
B - A # {4, 5}
A.difference(B) # {1, 2}
4. Symmetric Difference (^ or .symmetric_difference())
A = {1, 2, 3}
B = {3, 4, 5}
A ^ B # {1, 2, 4, 5}
A.symmetric_difference(B) # {1, 2, 4, 5}
5. Subset (<=, <) & Superset (>=, >)
A = {1, 2}
B = {1, 2, 3}
A <= B # True (A is a subset of B)
B >= A # True (B is a superset of A)
print(A < B) # True
print(B > A) # True
A.issubset(B) # True
B.issuperset(A) # True
>> Methods
s = {1, 2, 3}
The add() method only takes a single element at a time. If you try to pass a list or another iterable, it will treat the whole thing as one element
s.add(4) # {1,2,3,4}
s.add([5, 6]) # adds the *list itself* as one element
print(s) # {1, 2, 3, 4, [5, 6]} <-- note the list inside
The update() method lets you add multiple elements to a set at once, and you can pass it any iterable — like a list, tuple, or even another set. It adds all the elements that aren’t already in the set.
s.update([3,5]) # {1,2,3,4,5}
If you use remove(x) on a set and x is not in the set, Python will raise a KeyError.
s.remove(2) # {1,3,4,5}
If you want to avoid an error when the element might not exist, use discard(x) instead:
s.discard(10) # {1,3,4,5} (no error)
set.pop() does not remove the “last” element because sets in Python are unordered. It removes and returns an arbitrary element—which element you get is unpredictable.
elem = s.pop() # removes and returns an arbitrary element
clear() removes all elements from the set, leaving it empty. It doesn’t return anything.
s.clear() # s becomes set()
×
Lists
# list[index] = calls the value at that position; the first position is 0 and the last is (len(list) - 1)
letters = ['a', 'b', 'c', 'd']
print(letters[0]) # 'a' → first element
print(letters[2]) # 'c' → third element
print(letters[-1]) # 'd' → last element using negative index
# list.index(letter) = calls the index
letters = ['a', 'b', 'c', 'd']
print(letters.index('b')) # 1 → 'b' is at index 1
print(letters.index('d')) # 3 → 'd' is at index 3
>> Slice Lists:
start = [10, 20, 30, 40, 50]
middle = 2
left = start[0:middle + 1] # Elements from index 0 up to middle (inclusive)
right = start[middle + 1:] # Elements from index middle+1 to the end
print(left) # [10, 20, 30]
print(right) # [40, 50]
# does not work for deque, needs to be converted to list
>> List Comprehension:
[expression for item in iterable if condition]
squares = [x**2 for x in range(5)]
print(squares) # Output: [0, 1, 4, 9, 16]
>> Replace:
fruits = ['apple', 'banana', 'cherry']
fruits[1] = 'blueberry'
print(fruits)
# Output: ['apple', 'blueberry', 'cherry']
# in Python, replacing an element in a list must be done using its index. Lists are ordered and mutable, so you can assign a new value to a specific position.
>> Reference object:
### shallow copy
list_a = [1, 2, 3]
list_b = list_a[:]
list_b[0] = 5
print(list_a) # Output: [1, 2, 3]
`list_b = list_a[:]` creates a shallow copy of `list_a`. `list_b` is now a new object, so modifying it does not affect the original `list_a`.
### reference
list_b = list_a
list_b[0] = 5
print(list_a) # Output: [5, 2, 3]
list_b would be just another reference to the same list object. Modifying list_b would also change list_a
### shallow copy - nested
list_a = [[1, 2], [3, 4]]
list_b = list_a[:] # shallow copy
list_b[0][0] = 9
print(list_a) # Output: [[9, 2], [3, 4]]
Shallow copies only copy the top-level list. If the list contains nested lists or mutable objects, those inner objects are shared. So, changes to nested objects will affect the original, even with a shallow copy.
letters = ['a', 'b', 'c', 'd']
print(letters[0]) # 'a' → first element
print(letters[2]) # 'c' → third element
print(letters[-1]) # 'd' → last element using negative index
# list.index(letter) = calls the index
letters = ['a', 'b', 'c', 'd']
print(letters.index('b')) # 1 → 'b' is at index 1
print(letters.index('d')) # 3 → 'd' is at index 3
>> Slice Lists:
start = [10, 20, 30, 40, 50]
middle = 2
left = start[0:middle + 1] # Elements from index 0 up to middle (inclusive)
right = start[middle + 1:] # Elements from index middle+1 to the end
print(left) # [10, 20, 30]
print(right) # [40, 50]
# does not work for deque, needs to be converted to list
>> List Comprehension:
[expression for item in iterable if condition]
squares = [x**2 for x in range(5)]
print(squares) # Output: [0, 1, 4, 9, 16]
>> Replace:
fruits = ['apple', 'banana', 'cherry']
fruits[1] = 'blueberry'
print(fruits)
# Output: ['apple', 'blueberry', 'cherry']
# in Python, replacing an element in a list must be done using its index. Lists are ordered and mutable, so you can assign a new value to a specific position.
>> Reference object:
### shallow copy
list_a = [1, 2, 3]
list_b = list_a[:]
list_b[0] = 5
print(list_a) # Output: [1, 2, 3]
`list_b = list_a[:]` creates a shallow copy of `list_a`. `list_b` is now a new object, so modifying it does not affect the original `list_a`.
### reference
list_b = list_a
list_b[0] = 5
print(list_a) # Output: [5, 2, 3]
list_b would be just another reference to the same list object. Modifying list_b would also change list_a
### shallow copy - nested
list_a = [[1, 2], [3, 4]]
list_b = list_a[:] # shallow copy
list_b[0][0] = 9
print(list_a) # Output: [[9, 2], [3, 4]]
Shallow copies only copy the top-level list. If the list contains nested lists or mutable objects, those inner objects are shared. So, changes to nested objects will affect the original, even with a shallow copy.
×
input transformations
str -> list[str]:
name = 'Yoana'
name_list = list(name)
['Y', 'o', 'a', 'n', 'a']
str -> list[int]:
nums = '1, 2, 3, 4, 5'
nums_list = [int(item) for item in nums.split(', ')]
[1, 2, 3, 4, 5] # list of integers
num = 46473829
print((list(map(int, str(num)))))
[4, 6, 4, 7, 3, 8, 2, 9] # list of integers
lowercase
x = (input().lower().split(' '))
SCREAMING IN CAPS LOCK
['screaming', 'in', 'caps', 'lock']
name = 'Yoana'
name_list = list(name)
['Y', 'o', 'a', 'n', 'a']
str -> list[int]:
nums = '1, 2, 3, 4, 5'
nums_list = [int(item) for item in nums.split(', ')]
[1, 2, 3, 4, 5] # list of integers
num = 46473829
print((list(map(int, str(num)))))
[4, 6, 4, 7, 3, 8, 2, 9] # list of integers
lowercase
x = (input().lower().split(' '))
SCREAMING IN CAPS LOCK
['screaming', 'in', 'caps', 'lock']
×
.split()
.split() is a string method.
It splits a string into a list of substrings based on a separator.
By default, the separator is any whitespace (spaces, tabs, newlines).
text = "Hello world Python"
words = text.split()
print(words)
# Output: ['Hello', 'world', 'Python']
Using a custom separator
You can pass a string as the separator:
text = "apple,banana,cherry"
fruits = text.split(",")
print(fruits)
# Output: ['apple', 'banana', 'cherry']
Limiting the number of splits
You can also limit how many splits are made using the maxsplit argument:
text = "one two three four"
print(text.split(maxsplit=2))
# Output: ['one', 'two', 'three four']
It splits a string into a list of substrings based on a separator.
By default, the separator is any whitespace (spaces, tabs, newlines).
text = "Hello world Python"
words = text.split()
print(words)
# Output: ['Hello', 'world', 'Python']
Using a custom separator
You can pass a string as the separator:
text = "apple,banana,cherry"
fruits = text.split(",")
print(fruits)
# Output: ['apple', 'banana', 'cherry']
Limiting the number of splits
You can also limit how many splits are made using the maxsplit argument:
text = "one two three four"
print(text.split(maxsplit=2))
# Output: ['one', 'two', 'three four']
×
To remove all occurrences:
lst = [1, 2, 3, 2, 4, 2]
while 2 in lst:
lst.remove(2)
print(lst) # [1, 3, 4]
lst = [1, 2, 3, 2, 4, 2]
lst = [x for x in lst if x != 2]
print(lst) # [1, 3, 4]
.remove(), .pop(), .popitem()
>>> .pop()
Works on lists (and also dictionaries, but differently).
Removes and returns an element at a given index. If no index is given, it removes the last element at (index = -1)
lst = [10, 20, 30, 40]
# Pop last element
x = lst.pop()
print(x) # 40
print(lst) # [10, 20, 30]
# Pop element at index 1
y = lst.pop(1)
print(y) # 20
print(lst) # [10, 30]
>>> .pop() with dictionaries:
d = {'a': 1, 'b': 2}
value = d.pop('a')
print(value) # 1
print(d) # {'b': 2}
For dicts, .pop(key) removes the key and returns its value.
>>> .popitem()
Removes the last inserted key-value pair (or first if last=False).
Designed specifically for “pop the last entry” without needing the key:
d = {'a': 1, 'b': 2, 'c': 3}
# Remove the first inserted item
first_item = d.popitem(last=False)
print(first_item) # ('a', 1)
print(d) # {'b': 2, 'c': 3}
# Remove the last inserted item
last_item = d.popitem() # last=True by default
print(last_item) # ('c', 3)
print(d) # {'b': 2}
In Python 3.7+, dictionaries preserve insertion order, so you can pop the “last key” using .popitem(). The reason is that .pop() in a dict requires you to specify a key. Unlike lists, dictionaries aren’t indexed by position, they are keyed collections. You cannot just call .pop() with no arguments like you do for a list, because “the last item” isn’t inherently known to the method—it’s keyed, not indexed.
.remove()
Works only on lists.
Removes the first occurrence of a specific value.
Does not return the value.
lst = [10, 20, 30, 20]
lst.remove(20)
print(lst) # [10, 30, 20]
# Removes the first 20, not all of them.
Works on lists (and also dictionaries, but differently).
Removes and returns an element at a given index. If no index is given, it removes the last element at (index = -1)
lst = [10, 20, 30, 40]
# Pop last element
x = lst.pop()
print(x) # 40
print(lst) # [10, 20, 30]
# Pop element at index 1
y = lst.pop(1)
print(y) # 20
print(lst) # [10, 30]
>>> .pop() with dictionaries:
d = {'a': 1, 'b': 2}
value = d.pop('a')
print(value) # 1
print(d) # {'b': 2}
For dicts, .pop(key) removes the key and returns its value.
>>> .popitem()
Removes the last inserted key-value pair (or first if last=False).
Designed specifically for “pop the last entry” without needing the key:
d = {'a': 1, 'b': 2, 'c': 3}
# Remove the first inserted item
first_item = d.popitem(last=False)
print(first_item) # ('a', 1)
print(d) # {'b': 2, 'c': 3}
# Remove the last inserted item
last_item = d.popitem() # last=True by default
print(last_item) # ('c', 3)
print(d) # {'b': 2}
In Python 3.7+, dictionaries preserve insertion order, so you can pop the “last key” using .popitem(). The reason is that .pop() in a dict requires you to specify a key. Unlike lists, dictionaries aren’t indexed by position, they are keyed collections. You cannot just call .pop() with no arguments like you do for a list, because “the last item” isn’t inherently known to the method—it’s keyed, not indexed.
.remove()
Works only on lists.
Removes the first occurrence of a specific value.
Does not return the value.
lst = [10, 20, 30, 20]
lst.remove(20)
print(lst) # [10, 30, 20]
# Removes the first 20, not all of them.
To remove all occurrences:
lst = [1, 2, 3, 2, 4, 2]
while 2 in lst:
lst.remove(2)
print(lst) # [1, 3, 4]
lst = [1, 2, 3, 2, 4, 2]
lst = [x for x in lst if x != 2]
print(lst) # [1, 3, 4]
×
>>> Multiple values per 1 key:
dict = {}
index = int(input())
for i in range(index):
key = input()
val = input()
if key not in dict:
dict[key] = []
dict[key].append(val)
Dicts
>>> How it works:
Python’s built-in dict is a hash table under the hood.
>>> Dict Comprehension
letters = input().split(', ')
dict = {i: ord(i) for i in letters}
print(dict)
>>>Unpacking
1. dict.items()
d = {'x': 1, 'y': 2}
for key, value in d.items():
print(key, value)
# Output:
# x 1
# y 2
print(list(d.items()))
# Output: [('x', 1), ('y', 2)]
skills = [f"=== {skill_name} - {skill_mana}" for skill_name, skill_mana in self.skills.items()]
print(skills)
#Output: ['=== farting - 50', '=== crying - 50']
2. dict.keys()
d = {'a': 10, 'b': 20}
for key in d.keys():
print(key)
#Output:
# a
# b
print(list(d.keys()))
#Output: ['a', 'b']
3. dict.values()
d = {'apple': 5, 'banana': 3}
for value in d.values():
print(value)
# Output:
# 5
# 3
print(list(d.values()))
# Output: [5, 3]
3. The dictionary view object wrapper:
self.rented_books = {
"john_doe": {"The Hobbit": 5},
"jane_smith": {"1984": 3}
}
print(self.rented_books.values())
# Output: dict_values([{'The Hobbit': 5}, {'1984': 3}])
self.rented_books.values() returns a dict_values object (a special view). It’s not wrapped in parentheses (...), but in a dict_values([...]) wrapper.
It shows up anytime you call one of these methods on a dict:
.keys() → dict_keys([...])
.values() → dict_values([...])
.items() → dict_items([...])
d = {"a": 1, "b": 2}
print(d.keys()) # dict_keys(['a', 'b'])
print(d.values()) # dict_values([1, 2])
print(d.items()) # dict_items([('a', 1), ('b', 2)])
# Convert to list for clearer visualization:
print(list(self.rented_books.values()))
# Output: [{'The Hobbit': 5}, {'1984': 3}]
# Convert to tuple for clearer visualization:
print(tuple(self.rented_books.values()))
# Output: ({'The Hobbit': 5}, {'1984': 3})
# Iterate and print each inner dict separately:
for books in self.rented_books.values():
print(books)
# Output:
# {'The Hobbit': 5}
# {'1984': 3}
4. Single key unpacking:
(curr_position, coor), = choose_position(current_player).items()
choose_position(current_player) must return a dictionary (or dict-like object).
.items() gives you a view of key-value pairs as (key, value) tuples.
The trailing comma in the assignment (...), = ... means you expect exactly one item from the dict.
(curr_position, coor) unpacks that single (key, value) pair into:
curr_position = the key
coor = the value
# This only works if the dictionary has exactly one key-value pair.
Python’s built-in dict is a hash table under the hood.
>>> Dict Comprehension
letters = input().split(', ')
dict = {i: ord(i) for i in letters}
print(dict)
>>>Unpacking
1. dict.items()
d = {'x': 1, 'y': 2}
for key, value in d.items():
print(key, value)
# Output:
# x 1
# y 2
print(list(d.items()))
# Output: [('x', 1), ('y', 2)]
skills = [f"=== {skill_name} - {skill_mana}" for skill_name, skill_mana in self.skills.items()]
print(skills)
#Output: ['=== farting - 50', '=== crying - 50']
2. dict.keys()
d = {'a': 10, 'b': 20}
for key in d.keys():
print(key)
#Output:
# a
# b
print(list(d.keys()))
#Output: ['a', 'b']
3. dict.values()
d = {'apple': 5, 'banana': 3}
for value in d.values():
print(value)
# Output:
# 5
# 3
print(list(d.values()))
# Output: [5, 3]
3. The dictionary view object wrapper:
self.rented_books = {
"john_doe": {"The Hobbit": 5},
"jane_smith": {"1984": 3}
}
print(self.rented_books.values())
# Output: dict_values([{'The Hobbit': 5}, {'1984': 3}])
self.rented_books.values() returns a dict_values object (a special view). It’s not wrapped in parentheses (...), but in a dict_values([...]) wrapper.
It shows up anytime you call one of these methods on a dict:
.keys() → dict_keys([...])
.values() → dict_values([...])
.items() → dict_items([...])
d = {"a": 1, "b": 2}
print(d.keys()) # dict_keys(['a', 'b'])
print(d.values()) # dict_values([1, 2])
print(d.items()) # dict_items([('a', 1), ('b', 2)])
# Convert to list for clearer visualization:
print(list(self.rented_books.values()))
# Output: [{'The Hobbit': 5}, {'1984': 3}]
# Convert to tuple for clearer visualization:
print(tuple(self.rented_books.values()))
# Output: ({'The Hobbit': 5}, {'1984': 3})
# Iterate and print each inner dict separately:
for books in self.rented_books.values():
print(books)
# Output:
# {'The Hobbit': 5}
# {'1984': 3}
4. Single key unpacking:
(curr_position, coor), = choose_position(current_player).items()
choose_position(current_player) must return a dictionary (or dict-like object).
.items() gives you a view of key-value pairs as (key, value) tuples.
The trailing comma in the assignment (...), = ... means you expect exactly one item from the dict.
(curr_position, coor) unpacks that single (key, value) pair into:
curr_position = the key
coor = the value
# This only works if the dictionary has exactly one key-value pair.
>>> Multiple values per 1 key:
dict = {}
index = int(input())
for i in range(index):
key = input()
val = input()
if key not in dict:
dict[key] = []
dict[key].append(val)
×
sorted()
>>> Sorting Dict By Values
my_dict = {'apple': 3, 'banana': 1, 'orange': 2}
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1]))
print(sorted_dict)
# Output: {'banana': 1, 'orange': 2, 'apple': 3}
# You're telling Python: "Sort using the value part of each (key, value) pair (index 1 of the item tuple)"
my_dict = {'apple': 3, 'banana': 1, 'orange': 2}
sorted_dict = dict(sorted(my_dict.items(), key=lambda item: item[1]))
print(sorted_dict)
# Output: {'banana': 1, 'orange': 2, 'apple': 3}
# You're telling Python: "Sort using the value part of each (key, value) pair (index 1 of the item tuple)"
Sorting a List of Dictionaries
ships = [ {'name': 'Titan', 'hit_strength': 80}, {'name': 'Aegis', 'hit_strength': 100}, {'name': 'Blazer', 'hit_strength': 100}, ]
# Sort by hit_strength DESC, then name ASC
sorted_ships = sorted(ships, key=lambda x: (-x['hit_strength'], x['name'])) print(sorted_ships)
# Output: [{'name': 'Aegis', 'hit_strength': 100}, {'name': 'Blazer', 'hit_strength': 100}, {'name': 'Titan', 'hit_strength': 80} ]
Sorting a List of Tuples or Lists
ships = [('Titan', 80), ('Aegis', 100), ('Blazer', 100), ]
# Sort by hit_strength DESC, then name ASC
sorted_ships = sorted(ships, key=lambda x: (-x[1], x[0])) print(sorted_ships)
Same idea, just index-based access.
Sorting a List of Objects
class Ship:
def __init__(self, name, hit_strength):
self.name = name
self.hit_strength = hit_strength
def __repr__(self):
return f"{self.name} ({self.hit_strength})"
ships = [Ship("Titan", 80), Ship("Aegis", 100), Ship("Blazer", 100), ]
# Sort by hit_strength DESC, then name ASC
sorted_ships = sorted(ships, key=lambda x: (-x.hit_strength, x.name))
# Output: [Aegis (100), Blazer (100), Titan (80)]
ships = [ {'name': 'Titan', 'hit_strength': 80}, {'name': 'Aegis', 'hit_strength': 100}, {'name': 'Blazer', 'hit_strength': 100}, ]
# Sort by hit_strength DESC, then name ASC
sorted_ships = sorted(ships, key=lambda x: (-x['hit_strength'], x['name'])) print(sorted_ships)
# Output: [{'name': 'Aegis', 'hit_strength': 100}, {'name': 'Blazer', 'hit_strength': 100}, {'name': 'Titan', 'hit_strength': 80} ]
Sorting a List of Tuples or Lists
ships = [('Titan', 80), ('Aegis', 100), ('Blazer', 100), ]
# Sort by hit_strength DESC, then name ASC
sorted_ships = sorted(ships, key=lambda x: (-x[1], x[0])) print(sorted_ships)
Same idea, just index-based access.
Sorting a List of Objects
class Ship:
def __init__(self, name, hit_strength):
self.name = name
self.hit_strength = hit_strength
def __repr__(self):
return f"{self.name} ({self.hit_strength})"
ships = [Ship("Titan", 80), Ship("Aegis", 100), Ship("Blazer", 100), ]
# Sort by hit_strength DESC, then name ASC
sorted_ships = sorted(ships, key=lambda x: (-x.hit_strength, x.name))
# Output: [Aegis (100), Blazer (100), Titan (80)]
×
.get(), .setdefault()
>>> .get()
d = {"a": 1, "b": 2}
print(d.get("a")) # 1
print(d.get("z")) # None (instead of KeyError)
print(d.get("z", 99)) # 99 (custom default)
Safer than [] because it won’t crash if key missing.
You can provide a default return value.
>>> .setdefault()
d = {"a": 1, "b": 2}
print(d.setdefault("b", 100)) # 2 (already exists, keeps value)
print(d.setdefault("z", 100)) # 100 (adds key if missing)
print(d) # {'a': 1, 'b': 2, 'z': 100}
Returns the value if key exists.
Otherwise, sets it to the given default and returns that.
d = {"a": 1, "b": 2}
print(d.get("a")) # 1
print(d.get("z")) # None (instead of KeyError)
print(d.get("z", 99)) # 99 (custom default)
Safer than [] because it won’t crash if key missing.
You can provide a default return value.
>>> .setdefault()
d = {"a": 1, "b": 2}
print(d.setdefault("b", 100)) # 2 (already exists, keeps value)
print(d.setdefault("z", 100)) # 100 (adds key if missing)
print(d) # {'a': 1, 'b': 2, 'z': 100}
Returns the value if key exists.
Otherwise, sets it to the given default and returns that.
>>> Update the quantity of a specific ingredient in the dictionary.
self.ingredients = {"flour": 2}
ingredient = "flour"
quantity = 3
self.ingredients[ingredient] = self.ingredients.get(ingredient, 0) + quantity
1. self.ingredients.get(ingredient, 0):
- Checks if the ingredient exists in the dictionary.
- If it does, returns its current amount.
- If not, returns 0.
2. + quantity:
- Adds the new quantity to the existing amount (or 0 if it's new).
3. self.ingredients[ingredient] = ...:
- Stores the new total back in the dictionary. If they key did not exist, it created key: 0
# {"flour": 5} if "flour" was 2 and we added 3
# {"sugar": 3} if "sugar" was not in the dictionary before
self.ingredients = {"flour": 2}
ingredient = "flour"
quantity = 3
self.ingredients[ingredient] = self.ingredients.get(ingredient, 0) + quantity
1. self.ingredients.get(ingredient, 0):
- Checks if the ingredient exists in the dictionary.
- If it does, returns its current amount.
- If not, returns 0.
2. + quantity:
- Adds the new quantity to the existing amount (or 0 if it's new).
3. self.ingredients[ingredient] = ...:
- Stores the new total back in the dictionary. If they key did not exist, it created key: 0
# {"flour": 5} if "flour" was 2 and we added 3
# {"sugar": 3} if "sugar" was not in the dictionary before
×
numbers = [1, 2, 3, 4]
# Find the first even number
first_even = next((n for n in numbers if n % 2 == 0), None)
print(first_even)
# Output: 2
next()
my_dict = {"a": 1, "b": 2, "c": 3}
value = 2
key = next((k for k, v in my_dict.items() if v == value), None)
if key:
print(key)
# Output: 'b'
my_dict = {
"fruits": ["apple", "banana"],
"vegetables": ["carrot", "broccoli"],
"snacks": ["chips", "banana"]
}
value = "banana"
key = next((k for k, v in my_dict.items() if value in v), None)
if key:
print(key)
# Output: 'fruits' (first match)
value = 2
key = next((k for k, v in my_dict.items() if v == value), None)
if key:
print(key)
# Output: 'b'
my_dict = {
"fruits": ["apple", "banana"],
"vegetables": ["carrot", "broccoli"],
"snacks": ["chips", "banana"]
}
value = "banana"
key = next((k for k, v in my_dict.items() if value in v), None)
if key:
print(key)
# Output: 'fruits' (first match)
numbers = [1, 2, 3, 4]
# Find the first even number
first_even = next((n for n in numbers if n % 2 == 0), None)
print(first_even)
# Output: 2
×
all()
conditions = [True, True, True]
print(all(conditions))
# Output: True
conditions = [True, False, True]
print(all(conditions))
# Output: False
print(all(conditions))
# Output: True
conditions = [True, False, True]
print(all(conditions))
# Output: False
×
any()
conditions = [False, False, True]
print(any(conditions))
# Output: True
conditions = [False, False, False]
print(any(conditions))
# Output: False
marks = [85, 90, 78]
print(all(m >= 40 for m in marks))
# Output: True
marks = [85, 30, 78]
print(all(m >= 40 for m in marks))
# Output: False
print(any(conditions))
# Output: True
conditions = [False, False, False]
print(any(conditions))
# Output: False
marks = [85, 90, 78]
print(all(m >= 40 for m in marks))
# Output: True
marks = [85, 30, 78]
print(all(m >= 40 for m in marks))
# Output: False
×
reduce()
×
isinstance()
isinstance(object, classinfo)
item = 3.14
if isinstance(item, float):
print("Item is a float.")
else:
print("Item is NOT a float.")
>>> with class:
class Animal:
pass
class Dog(Animal):
pass
d = Dog()
print(isinstance(d, Dog)) # True
print(isinstance(d, Animal)) # True, because Dog is a subclass of Animal
# Using a tuple in isinstance lets you check if the object is an instance of any of several classes.
if not isinstance(food, (Vegetable, Fruit)):
raise TypeError(f"{self.__class__.__name__} does not eat {food.__class__.__name__}!")
This means:
• If food is not a Vegetable or a Fruit, raise the error.
• If it is either Vegetable or Fruit (or subclasses), it passes.
item = 3.14
if isinstance(item, float):
print("Item is a float.")
else:
print("Item is NOT a float.")
>>> with class:
class Animal:
pass
class Dog(Animal):
pass
d = Dog()
print(isinstance(d, Dog)) # True
print(isinstance(d, Animal)) # True, because Dog is a subclass of Animal
# Using a tuple in isinstance lets you check if the object is an instance of any of several classes.
if not isinstance(food, (Vegetable, Fruit)):
raise TypeError(f"{self.__class__.__name__} does not eat {food.__class__.__name__}!")
This means:
• If food is not a Vegetable or a Fruit, raise the error.
• If it is either Vegetable or Fruit (or subclasses), it passes.
×
__getitem__, __setitem__
When you write:
table["name"] = "Peter"
Python internally calls the special method:
table.__setitem__("name", "Peter")
For example, to get the value back, you can write:
print(table["name"])
which calls:
table.__getitem__("name")
and returns "Peter".
table["name"] = "Peter"
Python internally calls the special method:
table.__setitem__("name", "Peter")
For example, to get the value back, you can write:
print(table["name"])
which calls:
table.__getitem__("name")
and returns "Peter".
×
Tuples
A tuple is an ordered, immutable collection of items.
Defined using parentheses (), e.g., my_tuple = (1, 2, 3).
Can store heterogeneous data (integers, strings, lists, etc.).
Indexing and slicing are supported (like lists).
Immutable → values cannot be changed after creation.
Useful for storing fixed collections of data (e.g., coordinates, database records).
Support nesting: tuples inside tuples.
Can be used as dictionary keys (unlike lists).
Defined using parentheses (), e.g., my_tuple = (1, 2, 3).
Can store heterogeneous data (integers, strings, lists, etc.).
Indexing and slicing are supported (like lists).
Immutable → values cannot be changed after creation.
Useful for storing fixed collections of data (e.g., coordinates, database records).
Support nesting: tuples inside tuples.
Can be used as dictionary keys (unlike lists).
×
comparison dunder methods
== __eq__(self, other) Equality
!= __ne__(self, other) Not equal
< __lt__(self, other) Less than
<= __le__(self, other) Less than or equal
> __gt__(self, other) Greater than
>= __ge__(self, other) Greater than or equal
class Box:
def __init__(self, volume):
self.volume = volume
def __lt__(self, other):
return self.volume < other.volume
def __eq__(self, other):
return self.volume == other.volume
b1 = Box(10)
b2 = Box(20)
print(b1 < b2) # True
print(b1 == b2) # False
!= __ne__(self, other) Not equal
< __lt__(self, other) Less than
<= __le__(self, other) Less than or equal
> __gt__(self, other) Greater than
>= __ge__(self, other) Greater than or equal
class Box:
def __init__(self, volume):
self.volume = volume
def __lt__(self, other):
return self.volume < other.volume
def __eq__(self, other):
return self.volume == other.volume
b1 = Box(10)
b2 = Box(20)
print(b1 < b2) # True
print(b1 == b2) # False
×
Comparing objects and str
self.tasks is a list that holds objects from another class.
if task_name not in self.tasks: -> if str not in object = nono
# Correct way: find the object by its 'name' attribute:
t = next((t for t in self.tasks if t.name == task_name), None)
If not t:
return f"Could not find task with the name {task_name}"
t.completed =T rue
return f"Completed task {task_name}"
if task_name not in self.tasks: -> if str not in object = nono
# Correct way: find the object by its 'name' attribute:
t = next((t for t in self.tasks if t.name == task_name), None)
If not t:
return f"Could not find task with the name {task_name}"
t.completed =T rue
return f"Completed task {task_name}"
×
super()
>Bad:
def __init__(self, name: str, quantity: int):
super().__init__(name, quantity)
self.quantity = 10
Behavior:
• Whatever value is passed in as quantity, it gets ignored — self.quantity is always overwritten to 10.
• So this is a bit misleading to the caller, who might pass quantity=5 expecting it to be used.
>Good:
def __init__(self, name: str, quantity=10):
super().__init__(name, quantity)
Behavior:
• If quantity is not passed, it defaults to 10.
• But if the user does pass a specific value, it is used.
• This is flexible, clean, and expected behavior in Python.
def __init__(self, name: str, quantity: int):
super().__init__(name, quantity)
self.quantity = 10
Behavior:
• Whatever value is passed in as quantity, it gets ignored — self.quantity is always overwritten to 10.
• So this is a bit misleading to the caller, who might pass quantity=5 expecting it to be used.
>Good:
def __init__(self, name: str, quantity=10):
super().__init__(name, quantity)
Behavior:
• If quantity is not passed, it defaults to 10.
• But if the user does pass a specific value, it is used.
• This is flexible, clean, and expected behavior in Python.
×
@property
def username(self):
return self.__username
@username.setter
def username(self, value):
if len(value) < 5 or len(value) > 15:
raise ValueError("The username must be between 5 and 15 characters.")
self.__username = value
Getter/setter
@property
def username(self):
return self.__username
@username.setter
def username(self, value):
if len(value) < 5 or len(value) > 15:
raise ValueError("The username must be between 5 and 15 characters.")
self.__username = value
×
Math symbols in py
3 * 2 # multiply
3 ** 2 # exponent = stepenuvane
----------------------
# modulo division
5 % 2 # → 1 (remainder)
# 5 // 2 # → 2 (quotient)
2 % 0 = ZeroDivisionError
--
# good for checking odd and even nums
5 % 2 = 1 # odd
4 % 2 = 0 # even
----------------------
# Integer Division (//)
5 // 2 = 2
4 // 2 = 2
5.0 // 2 = 2.0
ZeroDivisionError applies 5 // 0 = bad
----------------------
# Normal Division (/)
5 / 2 # Output: 2.5
4 / 2 # Output: 2.0
ZeroDivisionError applies 5 / 0 = nono
3 ** 2 # exponent = stepenuvane
----------------------
# modulo division
5 % 2 # → 1 (remainder)
# 5 // 2 # → 2 (quotient)
2 % 0 = ZeroDivisionError
--
# good for checking odd and even nums
5 % 2 = 1 # odd
4 % 2 = 0 # even
----------------------
# Integer Division (//)
5 // 2 = 2
4 // 2 = 2
5.0 // 2 = 2.0
ZeroDivisionError applies 5 // 0 = bad
----------------------
# Normal Division (/)
5 / 2 # Output: 2.5
4 / 2 # Output: 2.0
ZeroDivisionError applies 5 / 0 = nono
×
Neat math tricks
take the last digit
n % 10
567 % 10 = 7
take all digits but the last
x // 10
452 // 10 = 45
#x needs to be longer than 1 digit for this one
3 // 10 = 0
check if num is divisable
if num1 % num2 == 0:
print("Divisible")
else:
print("Not Divisible")
num = int(input())
n % 10
567 % 10 = 7
take all digits but the last
x // 10
452 // 10 = 45
#x needs to be longer than 1 digit for this one
3 // 10 = 0
check if num is divisable
if num1 % num2 == 0:
print("Divisible")
else:
print("Not Divisible")
num = int(input())
×
unittest
import unittest
from project.hero import Hero # class we will test
class TestHero(unittest.TestCase):
def setUp(self):
self.hero = Hero('Yoana', 5, 100.00, 70.00) #create object to test
def test_init(self):
self.assertEqual('Yoana', self.hero.username)
...
def test_battle_self(self):
with self.assertRaises(Exception) as ex: # catch exception msg as str and compare it
self.hero.battle(Hero('Yoana', 5, 100.00, 70.00))
self.assertEqual("You cannot fight yourself", str(ex.exception))
def test_battle_self_zero_or_below(self):
self.hero = Hero('Yoana', 5, 0.00, 70.00)
with self.assertRaises(Exception) as ex:
self.hero.battle(Hero('Rengin', 5, 0.00, 70.00))
self.assertEqual("Your health is lower than or equal to 0. You need to rest", str(ex.exception))
while __name__ == '__main__':
unittest.main()
from project.hero import Hero # class we will test
class TestHero(unittest.TestCase):
def setUp(self):
self.hero = Hero('Yoana', 5, 100.00, 70.00) #create object to test
def test_init(self):
self.assertEqual('Yoana', self.hero.username)
...
def test_battle_self(self):
with self.assertRaises(Exception) as ex: # catch exception msg as str and compare it
self.hero.battle(Hero('Yoana', 5, 100.00, 70.00))
self.assertEqual("You cannot fight yourself", str(ex.exception))
def test_battle_self_zero_or_below(self):
self.hero = Hero('Yoana', 5, 0.00, 70.00)
with self.assertRaises(Exception) as ex:
self.hero.battle(Hero('Rengin', 5, 0.00, 70.00))
self.assertEqual("Your health is lower than or equal to 0. You need to rest", str(ex.exception))
while __name__ == '__main__':
unittest.main()
×
File Handling
# 1. Read (default)
with open("example.txt", "r") as f:
print(f.read()) # Reads whole file
# 2. Write (overwrites existing)
with open("example.txt", "w") as f:
f.write("New content replaces old!")
# 3. Append (adds to existing file)
with open("example.txt", "a") as f:
f.write("\nThis line is appended.")
# 4. Create new file (error if file exists)
with open("newfile.txt", "x") as f:
f.write("This file is newly created.")
# 5. Binary read
with open("image.png", "rb") as f:
data = f.read()
# 6. Binary write
with open("copy.png", "wb") as f:
f.write(data)
Text files → "r", "w", "a", "x"
Binary files → "rb", "wb", "ab", "xb"
A binary file stores data in raw bytes rather than human-readable text.
Unlike text files, you cannot open it in a normal text editor and expect to read it properly.
Examples: images, videos, audio files, PDFs, executable files.
Files like .png, .mp3, .mp4 are stored as bytes, not text.
To read, process, or copy them, you need to handle them in binary mode.
Example: creating a copy of an image, or uploading a video in a program.
Some apps don’t store the image as a file.
Instead, they store the raw bytes of the image (binary) in a database column (often BLOB = Binary Large Object).
Pros:
Everything is in one place (database).
Easier to back up and manage.
Cons:
Can make the database large.
Serving images may be slightly slower.
with open("example.txt", "r") as f:
print(f.read()) # Reads whole file
# 2. Write (overwrites existing)
with open("example.txt", "w") as f:
f.write("New content replaces old!")
# 3. Append (adds to existing file)
with open("example.txt", "a") as f:
f.write("\nThis line is appended.")
# 4. Create new file (error if file exists)
with open("newfile.txt", "x") as f:
f.write("This file is newly created.")
# 5. Binary read
with open("image.png", "rb") as f:
data = f.read()
# 6. Binary write
with open("copy.png", "wb") as f:
f.write(data)
Text files → "r", "w", "a", "x"
Binary files → "rb", "wb", "ab", "xb"
A binary file stores data in raw bytes rather than human-readable text.
Unlike text files, you cannot open it in a normal text editor and expect to read it properly.
Examples: images, videos, audio files, PDFs, executable files.
Files like .png, .mp3, .mp4 are stored as bytes, not text.
To read, process, or copy them, you need to handle them in binary mode.
Example: creating a copy of an image, or uploading a video in a program.
Some apps don’t store the image as a file.
Instead, they store the raw bytes of the image (binary) in a database column (often BLOB = Binary Large Object).
Pros:
Everything is in one place (database).
Easier to back up and manage.
Cons:
Can make the database large.
Serving images may be slightly slower.
×
setattr()
>>> What does setattr do?
Python has built-in functions like setattr to dynamically assign attributes to objects.
setattr(self, 'red_bull_team', RedBullTeam(budget))
is exactly the same as writing:
self.red_bull_team = RedBullTeam(budget)
But setattr lets you do it dynamically, meaning you don’t need to hard-code "red_bull_team" — you can get that name from a variable.
team_class = RedBullTeam
attr_name = 'red_bull_team'
budget = 10_000_000
setattr(self, attr_name, team_class(budget))
It’s doing:
self.red_bull_team = RedBullTeam(10_000_000)
But dynamically, based on:
• Which team you’re registering (Red Bull, Mercedes, etc.)
• Which class to create (from a dictionary)
• Which attribute to store it in (also from the dictionary)
Why not just use self.red_bull_team = ...?
You could — but then you'd need an if:
if team_name == "Red Bull":
self.red_bull_team = RedBullTeam(budget)
elif team_name == "Mercedes":
self.mercedes_team = MercedesTeam(budget)
With setattr, you generalize that logic — you no longer need the if.
Python has built-in functions like setattr to dynamically assign attributes to objects.
setattr(self, 'red_bull_team', RedBullTeam(budget))
is exactly the same as writing:
self.red_bull_team = RedBullTeam(budget)
But setattr lets you do it dynamically, meaning you don’t need to hard-code "red_bull_team" — you can get that name from a variable.
team_class = RedBullTeam
attr_name = 'red_bull_team'
budget = 10_000_000
setattr(self, attr_name, team_class(budget))
It’s doing:
self.red_bull_team = RedBullTeam(10_000_000)
But dynamically, based on:
• Which team you’re registering (Red Bull, Mercedes, etc.)
• Which class to create (from a dictionary)
• Which attribute to store it in (also from the dictionary)
Why not just use self.red_bull_team = ...?
You could — but then you'd need an if:
if team_name == "Red Bull":
self.red_bull_team = RedBullTeam(budget)
elif team_name == "Mercedes":
self.mercedes_team = MercedesTeam(budget)
With setattr, you generalize that logic — you no longer need the if.
×
the time library
import time
time.time()
Returns current time in seconds since epoch (Jan 1, 1970)
print(time.time())
# Output: 1746342312.123456 # seconds since Jan 1, 1970
time.sleep(seconds)
Pauses the program for given seconds
print("Start")
time.sleep(2) # pauses 2 sec
print("End")
#Output:
Start
End
time.localtime([secs])
Converts seconds to a struct_time in local time
print(time.localtime())
#Output: time.struct_time(tm_year=2025, tm_mon=8, tm_mday=31, tm_hour=15, tm_min=45, tm_sec=12, tm_wday=6, tm_yday=243, tm_isdst=0)
time.gmtime([secs])
Converts seconds to a struct_time in UTC
print(time.gmtime())
#Output: time.struct_time(tm_year=2025, tm_mon=8, tm_mday=31, tm_hour=10, tm_min=45, tm_sec=12, tm_wday=6, tm_yday=243, tm_isdst=0)
time.strftime(format, t)
Formats struct_time as a string
formatted = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(formatted)
#Output: 2025-08-31 15:45:12
time.strptime(string, format)
Converts a string to struct_time
print(time.strptime("2025-08-31", "%Y-%m-%d"))
#Output: time.struct_time(tm_year=2025, tm_mon=8, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=243, tm_isdst=-1)
time.ctime([secs])
Converts seconds to a readable string
print(time.ctime())
#Output: Sun Aug 31 15:45:12 2025
time.time()
Returns current time in seconds since epoch (Jan 1, 1970)
print(time.time())
# Output: 1746342312.123456 # seconds since Jan 1, 1970
time.sleep(seconds)
Pauses the program for given seconds
print("Start")
time.sleep(2) # pauses 2 sec
print("End")
#Output:
Start
End
time.localtime([secs])
Converts seconds to a struct_time in local time
print(time.localtime())
#Output: time.struct_time(tm_year=2025, tm_mon=8, tm_mday=31, tm_hour=15, tm_min=45, tm_sec=12, tm_wday=6, tm_yday=243, tm_isdst=0)
time.gmtime([secs])
Converts seconds to a struct_time in UTC
print(time.gmtime())
#Output: time.struct_time(tm_year=2025, tm_mon=8, tm_mday=31, tm_hour=10, tm_min=45, tm_sec=12, tm_wday=6, tm_yday=243, tm_isdst=0)
time.strftime(format, t)
Formats struct_time as a string
formatted = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(formatted)
#Output: 2025-08-31 15:45:12
time.strptime(string, format)
Converts a string to struct_time
print(time.strptime("2025-08-31", "%Y-%m-%d"))
#Output: time.struct_time(tm_year=2025, tm_mon=8, tm_mday=31, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=243, tm_isdst=-1)
time.ctime([secs])
Converts seconds to a readable string
print(time.ctime())
#Output: Sun Aug 31 15:45:12 2025
×
Typing
from typing import List, Optional
class Student:
def __init__(self, name: str, age: int) -> None:
self.name: str = name
self.age: int = age
def greet(self) -> str:
return f"Hello, my name is {self.name}."
class Classroom:
def __init__(self) -> None:
self.students: List[Student] = []
def add_student(self, student: Student) -> None:
self.students.append(student)
def find_student_by_name(self, name: str) -> Optional[Student]:
"""
Search for a student by name.
Returns the Student object if found, otherwise None.
"""
return next((s for s in self.students if s.name == name), None)
# it is really helful for lists of objects, because we can access the object's attributes (when we type s. it will show all available attributes), otherwise, we can manually type s.name but it will not show as an error if we use an attr that does not exist
In Python 3.9+, many built-in generic types like list, dict, tuple and set now support type hints directly.
This means you don’t always need to import from typing for common annotations.
class Student:
def __init__(self, name: str, age: int) -> None:
self.name: str = name
self.age: int = age
def greet(self) -> str:
return f"Hello, my name is {self.name}."
class Classroom:
def __init__(self) -> None:
self.students: List[Student] = []
def add_student(self, student: Student) -> None:
self.students.append(student)
def find_student_by_name(self, name: str) -> Optional[Student]:
"""
Search for a student by name.
Returns the Student object if found, otherwise None.
"""
return next((s for s in self.students if s.name == name), None)
# it is really helful for lists of objects, because we can access the object's attributes (when we type s. it will show all available attributes), otherwise, we can manually type s.name but it will not show as an error if we use an attr that does not exist
In Python 3.9+, many built-in generic types like list, dict, tuple and set now support type hints directly.
This means you don’t always need to import from typing for common annotations.
×
NamedTuple (typing)
from typing import NamedTuple, Any
class Pair(NamedTuple):
key: Any
value: Any
>>What is this syntax?
• Pair is a class that inherits from NamedTuple.
• NamedTuple is a special kind of tuple introduced in Python's typing module (or collections module in earlier versions).
• It allows you to create tuple-like objects with named fields, so you can access elements by name instead of position.
• The syntax key: Any and value: Any are type annotations indicating that the key and value fields can hold any type of data (Any means any type).
What does this do practically?
You can create immutable pairs with named fields:
p = Pair(key="name", value="Alice")
print(p.key)
# Output: name
print(p.value)
# Output: Alice
Why use NamedTuple?
• It creates a lightweight, immutable class.
• Gives you readable code because you access fields by name instead of by index.
• It supports type hints for better static analysis and IDE support.
When you use NamedTuple, you don’t need to write your own __init__ method because it’s automatically generated for you by the NamedTuple base class.
• NamedTuple creates an immutable data structure with fields you define.
• Behind the scenes, Python generates the __init__ method that takes parameters matching the field names (key and value in your example) and assigns them.
• So you get:
p = Pair(key="name", value="Alice")
# This works without you writing __init__
If you had to write it manually (for a normal class), it would look like:
class Pair:
def __init__(self, key, value):
self.key = key
self.value = value
But NamedTuple saves you this boilerplate, plus adds immutability and other tuple-like behaviors.
class Pair(NamedTuple):
key: Any
value: Any
>>What is this syntax?
• Pair is a class that inherits from NamedTuple.
• NamedTuple is a special kind of tuple introduced in Python's typing module (or collections module in earlier versions).
• It allows you to create tuple-like objects with named fields, so you can access elements by name instead of position.
• The syntax key: Any and value: Any are type annotations indicating that the key and value fields can hold any type of data (Any means any type).
What does this do practically?
You can create immutable pairs with named fields:
p = Pair(key="name", value="Alice")
print(p.key)
# Output: name
print(p.value)
# Output: Alice
Why use NamedTuple?
• It creates a lightweight, immutable class.
• Gives you readable code because you access fields by name instead of by index.
• It supports type hints for better static analysis and IDE support.
When you use NamedTuple, you don’t need to write your own __init__ method because it’s automatically generated for you by the NamedTuple base class.
• NamedTuple creates an immutable data structure with fields you define.
• Behind the scenes, Python generates the __init__ method that takes parameters matching the field names (key and value in your example) and assigns them.
• So you get:
p = Pair(key="name", value="Alice")
# This works without you writing __init__
If you had to write it manually (for a normal class), it would look like:
class Pair:
def __init__(self, key, value):
self.key = key
self.value = value
But NamedTuple saves you this boilerplate, plus adds immutability and other tuple-like behaviors.
×
lambda
print(list(map(lambda x: x**2, [1, 2, 3, 4, 5])))
# Output: [1, 4, 9, 16, 25]
users = [
{"name": "Alice", "age": 32},
{"name": "Bob", "age": 25},
{"name": "Charlie", "age": 37}
]
sorted_users = sorted(users, key=lambda user: user["age"])
print(sorted_users)
# Output: [1, 4, 9, 16, 25]
users = [
{"name": "Alice", "age": 32},
{"name": "Bob", "age": 25},
{"name": "Charlie", "age": 37}
]
sorted_users = sorted(users, key=lambda user: user["age"])
print(sorted_users)
×
ASCII
ord('a')
#this will get the ASCII code
----------------------
chr(100)
this will get the ASCII symbol
ASCII Table
#this will get the ASCII code
----------------------
chr(100)
this will get the ASCII symbol
ASCII Table