c = [0, 20, 100]  # Celcius values 

c0 = c[0]
f0 = (c0 * 9/5) + 32
print(c0, "°C =", f0, "°F")

c1 = 20
f1 = (c1 * 9/5) + 32
print(c1, "°C =", f1, "°F")

c2 = 100
f2 = (c2 * 9/5) + 32
print(c2, "°C =", f2, "°F")

def say_hello(name):
	print(f"Hello {name}.")

result = say_hello("Susie")

print(type(result))

def square_cube(n):
	return n**2, n**3
  
result = square_cube(2)

print(result)

def square_cube(n):
	return n**2, n**3
  
squared, cubed = square_cube(3)

print(squared)
print(cubed)

numbers = [1, 1, 2, 3, 5, 8, 13]

def scream(word, times):
    saying = word * times
    return saying.upper() + "!"

# Try these two examples
scream('ha', 4)

scream(4, 3)  # raises error!

def scream(word: str, times: int) -> str:
    saying = word * times
    return saying.upper() + "!"

def scale_numbers(numbers: list[int], factor: int | float) -> list[float]:
    result = []
    for n in numbers:
        result.append(n * factor)
    return result

def area(width, height):
	return width * height

def greet(name: str, greeting: str = "hello", exclaim: bool = True):
    """
    Create a greeting message.

    Parameters
    ----------
    name : str
        The name of the person to greet (required).
    greeting : str, default="hello"
        The punctuation mark to end the greeting with.
    exclaim : bool, default=True
        Whether to use an exclaimation mark instead of a period.
    """
    
    punctuation = "!"
    
    if not exclaim:
        punctuation = "."
    
    print(f"{greeting.capitalize()}, {name}{punctuation}")

greet("Alice", "good evening")

greet(name="Alice", greeting="good evening")

# does not work!
greet("Alice", False)

# because arguments are no longer in order
# you need to explicitly write the keyword
greet("Alice", exclaim=False)

def greet_everyone(greeting: str, *args, exclaim: bool = False):
  
	print(args)
    
    punctuation = "."
    if exclaim:
        punctuation = "!"
    
    for name in args:
        print(f"{greeting}, {name}{punctuation}")

# extra args get expanded into a tuple

greet_everyone("Hello", "Alice", "Bob", "Charlie", exclaim=True)

# ('Alice', 'Bob', 'Charlie')
# Hello, Alice.
# Hello, Bob.
# Hello, Charlie.

def contact_card(name, student_id: int, **kwargs):
    
    print(kwargs)
    
    
    print("Contact Card")
    print(f"Name: {name}")
    print(f"Student ID: {student_id}")
    
    for key, value in kwargs.items():
        print(f"{key.capitalize()}: {value}")

contact_card(
	"Alice", 
    student_id=123456, 
    email="alice@tum.net", 
    phone="0123456789"
)

# {'email': 'alice@tum.net', 'phone': '0123456789'}

# Contact Card
# Name: Alice
# Student ID: 123456
# Email: alice@tum.net
# Phone: 0123456789

def roll_n_dice(n: int) -> int:
	# etc

n = [1, 2, 3, 4]

squared = []
for number in n:
    squared.append(number ** 2)
    
print(squared)

squared = [number ** 2 for number in n]
print(squared)

def square(number: int | float):
	return number ** 2

squared = [squared(number) for number in n]
print(squared)

Input: "Data science is tough sometimes."
Output: ['DATA', 'SCIENCE', 'IS', 'TOUGH', 'SOMETIMES.']

# Normal function
def square(x: int) -> int:
    return x ** 2

# Same thing but with a lambda
square = lambda x: x ** 2
print(square(4))   # 16

class Character:
    """A character in our video game."""
    
    def __init__(self, name: str, health: int):
        # ...
        
	def take_damage(self, amount: int):
		"""
        Reduce health when taking damage
        
        Parameters
        ----------
            amount : int
            	Amount of health lost
        """
        self.health -= amount

warrior = Character("Jacob", 100)

print(warrior.health)

warrior.take_damage(20)

print(warrior.health)

class Character:
    """A character in our video game."""
    
    def __init__(self, name: str, base_health: int):
        """
        Args:
            name (str): Name of the character
            base_health (int): Base health points
        """
        self.name = name
        self.base_health = base_health

warrior = Character("Lisa", 100)

print(warrior)

print(warrior.name)

class Character:
    """A character in our video game."""
    
    def __init__(self, name: str, base_health: int):
        # ...
        self.name = name
        self.base_health = base_health
        self.items: list[str] = []
        
    def pickup_item(self, item: str):
        """
        Add an item to the character's inventory.
        
        Parameters
        ----------
            item : str
                The item to pick up
        """
        self.items.append(item)

warrior = Character(name="Hodor", health=100)

print(warrior.items)

warrior.pickup_item("sword")

print(warrior.items)

class ShoutingString(str):
    
    def shout(self):
        return self.upper() + "!!!"
    

class Dragon(Character):
    
    def take_damage(self, amount: int):
        """
        Dragons take half damage from attacks.
        
        Parameters
        ----------
            amount : int
                Amount of health lost
        """
        reduced_amount = int(amount * 0.5)
        print(f"{self.name} takes 1/2 damage because it is a dragon!")
        self.health -= reduced_amount

__init__
__repr__
__len__
__eq__
...

warrior = Character("Warrior", 100)
dragon = Dragon("Smaug", 100)

print(warrior)
print(dragon)

warrior = Character("Warrior", 100)
dragon = Dragon("Smaug", 100)
dragon.pickup_item("fire")

print(len(dragon))
print(len(warrior))

Starting value: 0
Comparing 1 to 0
Updating max_value to 1
Comparing -3 to 1
Comparing 2 to 1
Updating max_value to 2
Comparing 8 to 2
Updating max_value to 8
Comparing 4 to 8
Comparing -5 to 8
8

=====
Starting value: 0
Comparing -3 to 0
Comparing -2 to 0
Comparing -8 to 0
Comparing -4 to 0
Comparing -5 to 0
0

def find_max(nums: list[int]) -> int:
    
    max_value = 0
    
    print(f"Starting value: {max_value}")
    for n in nums:
        print(f"Comparing {n} to {max_value}")
        
        if n > max_value:
            print(f"Updating max_value to {n}")
            max_value = n
            
    return max_value

# run our test cases with the print statements
print(find_max([1, -3, 2, 8, 4, -5]))

print("=====")

print(find_max([-3, -2, -8, -4, -5]))

"""
Buggy checkout example for VS Code Run and Debug.
"""

def add_tax(subtotal: float, tax_percent: float):
    return subtotal * tax_percent

def checkout(items: list[dict[str, float]], tax_percent: float):
    
    # add the price of each item to get subtotal
    subtotal = sum(item["price"] for item in items)
    
    # calculate tax amount
    tax_amount = add_tax(subtotal, tax_percent)
    
    # calculate total
    total = subtotal + tax_amount
    
    # print receipt
    print(f"Subtotal: ${subtotal:.2f}")
    print(f"Tax ({tax_percent}%): ${tax_amount:.2f}")
    print(f"Total: ${total:.2f}")

# example usage
cart = [
    {"name": "Notebook", "price": 4.50},
    {"name": "Pen", "price": 1.25},
    {"name": "Sticker", "price": 0.75},
]
vat_percent = 8.5
checkout(items=cart, tax_percent=vat_percent)

import logging


logging.basicConfig(
	level=logging.INFO,
	format="%(asctime)s %(levelname)s %(name)s:%(lineno)d — %(message)s",
  	datefmt="%Y-%m-%d %H:%M:%S",
	filename="test.log",
)

logger = logging.getLogger(__name__)

# cont. from above

logger = logging.getLogger(__name__)

logger.debug("This is a debug message")
logger.warn("Be careful!")

import logging


logging.basicConfig(
	level=logging.DEBUG,  # also save debug logs
	format="%(asctime)s %(levelname)s %(name)s:%(lineno)d — %(message)s",
	datefmt="%Y-%m-%d %H:%M:%S",
	filename="sqrt.log",
)

logger = logging.getLogger(__name__)

def safe_sqrt(x: float) -> float:
    try:
      	logger.debug(f"Got {x}")
        return math.sqrt(x)
    except ValueError:
        logger.warning(f"{x} is negative, flipping sign.")
        return math.sqrt(-x)

print(safe_sqrt(16))
print(safe_sqrt(-16))

### sqrt.log
# 2025-09-02 19:37:13 DEBUG __main__:16 — Got 16
# 2025-09-02 19:37:13 DEBUG __main__:16 — Got -16
# 2025-09-02 19:37:13 WARNING __main__:19 — -16 is negative, flipping sign.