Python and CS sticky notes! 💜

>> Upload a folder to an empty GitHub repo:

cd path/to/your/folder
git init
git remote add origin https://github.com/your-username/your-repo-name.git
git add .
git commit -m "Initial commit"
git branch -M main
git push -u origin main


>> Clone a repo into an empty folder:

cd path/to/your/empty-folder
git clone https://github.com/your-username/your-repo.git


>> Remove folder after added by mistake (ex.: .idea):

git rm -r --cached .idea
git commit -m "Stop tracking .idea"
git push

>> Publish a page:

The main HTML file should be in root named index.html

1. Go to your repository on GitHub.
2. Click Settings → Pages (or scroll to the “GitHub Pages” section).
3. Under Source, select the branch: main (or master), and folder: /root.
4. Click Save.
5. GitHub will provide a URL, e.g., https://YOUR_USERNAME.github.io/python-cs-notes/
• Wait a few minutes for GitHub Pages to process.

# reverse
word = input()
print(word[::-1])

----------------------

#slicing with a step - skips letters
print(text[::2])

>> 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

ord('a')
#this will get the ASCII code

----------------------

chr(100)
this will get the ASCII symbol


ASCII Table

# 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:
*
**
***
****
*****
****
***
**
*

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

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

"{{" → prints "{"

"}}" → prints "}"

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)

    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(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

# 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

# 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))}")

:.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.

# 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}"

# 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.

    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 * 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')

{} → 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

>> 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()

# 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.

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']

.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']

>>> .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.

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]

>>> 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.

>>> 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)

>>> 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)"

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)]     

>>> .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.

>>> 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

    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)

    
    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

    conditions = [True, True, True]
    print(all(conditions))
    # Output: True

    conditions = [True, False, True]
    print(all(conditions))
    # Output: False

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

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.

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".

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).

==    __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

x = "global x" # Global

def outer():
x = "enclosing x" # Enclosing

def inner():
x = "local x" # Local
print(x)

inner()

outer()
print(x) # Prints the global x

local x
global x

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}"

>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.

@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

1. Single Responsibility Principle (SRP) – One class, one job
    Class: Teacher
    Responsibility: Teach students
    What it shouldn’t do: Fix the school’s computers
    Why: Only one reason to change—teaching. If you make it fix computers too, changes in IT affect teaching.
Implementation:
    Keep teaching tasks in Teacher.
    Put IT-related work in a separate ITSupport class.
    One reason to change = one class.


2. Open/Closed Principle (OCP) – Open for extension, closed for modification
    Class: RemoteControl
    Behavior: Controls TV functions (volume, channels)
    Extending: Add voice control or streaming buttons without changing existing buttons
    Why: You can add new features without touching the original design.
Implementation:
    Use extensible design: e.g., allow adding new buttons/features without modifying existing ones.
    New functionality = new class or method, not editing old ones.


3. Liskov Substitution Principle (LSP) – Subtypes must work like their base type
    Class: Car
    Subclass: SportsCar
    Behavior: Drive, stop, turn
    Why: A SportsCar can replace a Car anywhere, behaving as expected. If it breaks normal car behavior, it violates LSP.
Implementation:
    Ensure all subclasses behave like the base class.
    Don’t override methods in a way that breaks expectations.
    Anyone using Car should seamlessly use SportsCar.


4. Interface Segregation Principle (ISP) – Many small interfaces > one big interface
    Class: Smartphone
    Interfaces: Calling, Camera, MusicPlayer
    Why: A person who just wants to make calls doesn’t need to implement camera or music features.
    Idea: Split big interfaces into small, focused ones.
Implementation:
    Split big interfaces into small, focused interfaces: Calling, Camera, Music.
    Classes only implement the interfaces they need, avoiding unnecessary methods.


5. Dependency Inversion Principle (DIP) – Depend on abstractions, not concretes
    Class: TV
    Depends on: PowerSource (abstract idea of electricity)
    Why: It doesn’t care if it’s a battery, plug, or solar—high-level module depends on abstraction, not concrete implementation.
Implementation:
    Depend on abstract concepts (like PowerSource) rather than concrete types.
    You can swap battery, plug, solar panel without changing the TV class.

i and j stick together and move 1 index ahead, they swap if j is bigger
This runs multiple times until no more sorts are needed

Index i starts at 0
j starts at 1
j compares to i and swaps if smaller, it does not scan the whole arr like in selection
i moves ahead until len - 1

Index i stays at the start
Index j scans the whole array and finds the smallest
If it is smaller than i, swap
i is moved 1 ahead until it reaches len - 1

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

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())

A determinant is a scalar (a single number) that can be computed from a square matrix (a matrix with the same number of rows and columns). It is a numeric representation of how the area of a matirx changes (space between i-hat, j-hat, k-hat). It looks like an area for 2D space and volume for 3D space. Negative det means it gor inverted, and 0 a line or a dot in 2D (no area) or a 2D shape, line, or a dot in 3D (no volume).

Vectors represent movement, it is like walking on the first and then the second (starting from the point of the first), not in terms of distance, but in terms of result, the destination reached

The num by which we multiply a vector is called a scaler.

Scaling then adding is called linear combination.

3 and -2 are the scalers of i-hat and j-hat. Their combination creates a new vector.

Big-O Notation (O-notation)
    Read as: "Big O of f(n)"
    Meaning: Describes the worst-case complexity (upper bound).
    Example: If an algorithm is O(n²), it means in the worst case, the runtime grows no faster than n².

Omega Notation (Ω-notation)
    Read as: "Omega of f(n)"
    Meaning: Describes the best-case complexity (lower bound).
    Example: If an algorithm is Ω(n), it means it takes at least linear time in the best case.

Theta Notation (Θ-notation)
    Read as: "Theta of f(n)"
    Meaning: Describes the average or tight bound (both upper and lower).
    Example: If an algorithm is Θ(n log n), it means its runtime grows like n log n on average and tightly bounded there.

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()

# 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.

>>> 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.

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

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.

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.

A binary tree is a data structure where each node has at most two children:
Left child
Right child
The top node is called the root.
Nodes with no children are called leaves.

10 → root
5 → left child of 10
20 → right child of 10
Each node can have 0, 1, or 2 children.


>>> Binary Search Tree (BST)
A BST is a binary tree where for every node:
Left child ≤ parent
Right child ≥ parent
This property makes searching efficient.

Search: To find 15 → compare with root 10 → go right → 20 → go left → 15.
Time complexity: O(log n) in a balanced tree


>>> Min-Heap
A Min-Heap is a binary tree (usually implemented as an array) where:
A complete binary tree where:
Parent ≤ children
Minimum element at root
Used in priority queues.

• The smallest element is always at the root.
• Every parent node is less than or equal to its children.
• It's a complete binary tree (all levels filled except possibly the last, which is filled left to right).

In array form:
[1, 3, 5, 4, 8, 6]

"Min-Heap of size k" — What does that mean?
It means:
• You're using a Min-Heap that stores at most k elements at any time.
• This is common in algorithms where you want to track the smallest (or largest) k elements from a larger set.


>>> Max-Heap
A complete binary tree where:
Parent ≥ children
Maximum element at root
Used when you want largest element quickly.

>>><<<
BST → Organized phonebook (searchable by value)
Min-Heap → Queue where the smallest task is always on top
Max-Heap → Queue where the largest task is always on top
>>><<<

1. INTEGER (INT)
Stores whole numbers (no decimals).
Typical range: -2,147,483,648 to 2,147,483,647 (4 bytes).
Good for things like IDs, counts, ages.
Variants: SMALLINT (2 bytes), BIGINT (8 bytes).

2. SMALLINT
Smaller range than INT.
Typical range: -32,768 to 32,767 (2 bytes).
Saves storage if you know values are small (e.g., number of items in stock, months of the year).

3. BIGINT
Larger range than INT.
Typical range: -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 (8 bytes).
Use for very large counts (e.g., social media user IDs, transaction logs).

4. DECIMAL(p, s) / NUMERIC(p, s)
Stores exact fixed-point numbers.
p = precision (total number of digits).
s = scale (digits after the decimal point).
Example: DECIMAL(10,2) can store up to 99999999.99.
Great for money, prices, financial data (no rounding errors).

5. FLOAT / REAL / DOUBLE PRECISION
Stores approximate values with floating-point representation.
FLOAT → database decides precision (often 4 bytes, ~7 digits).
DOUBLE PRECISION → higher precision (8 bytes, ~15 digits).
Faster than DECIMAL, but not always exact (can have rounding errors).
Use for scientific data, measurements, percentages, but avoid for money.

These are all floating-point numeric types, meaning they store approximate numbers (not exact). The main difference is in precision (how many digits they can represent reliably) and storage size.
REAL = small, fast, less precise.
DOUBLE PRECISION = bigger, slower, much more precise.
FLOAT(p) = SQL standard that maps to REAL or DOUBLE depending on p.

6. SERIAL / BIGSERIAL (PostgreSQL only)
Auto-incrementing integer.
SERIAL = INTEGER + auto-increment.
BIGSERIAL = BIGINT + auto-increment.
Perfect for primary keys.

1. CHAR(n)
Fixed-length string.
Always stores exactly n characters → pads with spaces if shorter.
Example: CHAR(5)
'hi' is stored as 'hi ' (3 spaces added).
Efficient for codes of fixed length (e.g., country codes like USA, postal codes).

2. VARCHAR(n)
Variable-length string.
Stores up to n characters, without extra padding.
Example: VARCHAR(50) → can store between 0 and 50 characters.
More flexible than CHAR.
VARCHAR (without n) → unlimited length (same as TEXT).
Common for names, emails, descriptions.

3. TEXT
Stores unlimited-length text (well, very large).
Example: in PostgreSQL, up to 1 GB per value.
No need to define a max length.
Good for long text (comments, articles, logs).
But often lacks some indexing/constraint options compared to VARCHAR.

4. NVARCHAR / NCHAR (Unicode types, mainly SQL Server / Oracle)
Like VARCHAR/CHAR, but stores Unicode characters.
Needed when working with multilingual data (Chinese, Arabic, emojis, etc.).
Each character can take more bytes (UTF-16 encoding).

5. Other Useful String Types (DB-specific)
UUID (PostgreSQL, MySQL 8.0) → special string for universally unique identifiers.
JSON / JSONB (PostgreSQL, MySQL, SQL Server) → structured text data.
ENUM (MySQL, PostgreSQL) → predefined list of string values (like "pending", "approved", "rejected").

1. DATE
Stores a calendar date (year, month, day).
Format: YYYY-MM-DD.
'2025-09-09'
No time of day is stored.

2. TIME [WITHOUT TIME ZONE]
Stores only the time of day (hours, minutes, seconds, fractions).
Format: HH:MI:SS[.ffff].
'14:35:20'

3. TIMESTAMP [WITHOUT TIME ZONE]
Stores both date and time together.
Format: YYYY-MM-DD HH:MI:SS[.ffff].
'2025-09-09 14:35:20'

4. TIMESTAMP WITH TIME ZONE (timestamptz in PostgreSQL)
Same as TIMESTAMP, but also stores a time zone offset.
'2025-09-09 14:35:20+02'
Useful when working across multiple time zones.

5. INTERVAL (PostgreSQL, some others)
Stores a time duration (years, months, days, hours, minutes, seconds).
'2 days 5 hours 30 minutes'

6. DATETIME (MySQL, SQL Server)
Equivalent to TIMESTAMP in many systems.
Stores both date and time (without timezone).
Copy code
'2025-09-09 14:35:20'

>>> General SQL Rules for Dates & Intervals

Type awareness

You can only add/subtract intervals to/from DATE or TIMESTAMP types.
Example: DATE '2025-01-01' + INTERVAL '10 days' → 2025-01-11.

Valid units for INTERVAL
Standard SQL supports: YEAR, MONTH, DAY, HOUR, MINUTE, SECOND.

Some databases add extras like WEEK, MICROSECOND, etc.

Addition vs. subtraction

date + interval → moves forward.
date - interval → moves backward.
date1 - date2 → returns an interval (the difference).

Overflow handling (months/years)

Adding months is tricky because months have different lengths.
Example in PostgreSQL:
DATE '2025-01-31' + INTERVAL '1 month' → 2025-02-28 (it clamps to the last valid day).

MySQL might behave differently.

CREATE TYPE type_mood AS ENUM ('happy', 'relaxed', 'stressed', 'sad');
ALTER TABLE minions_info ADD COLUMN mood type_mood;