Seminar 1: Python Basics

# ============================================================
# ⭐ CORE — Python is strongly typed
# ============================================================

# These lines raise a TypeError — uncomment them one at a time to see.
# (To uncomment: remove the '#' and the space at the start of the line)
# "5" + 3          # → TypeError: can only concatenate str (not "int") to str
# "5" - 3          # → TypeError: unsupported operand type(s) for -: 'str' and 'int'

# What you must do instead — convert explicitly:
print("5" + str(3))        # → "53"  (int converted to str explicitly)
print(int("5") - 3)        # → 2     (str converted to int explicitly)
print(int("5") + 3)        # → 8

# Python always tracks the type of every variable:
x = 42
y = "hello"
print(f"\ntype(x) = {type(x)}")    # <class 'int'>
print(f"type(y) = {type(y)}")      # <class 'str'>

# Mixing incompatible types always fails loudly — uncomment to see:
# print(x + y)    # → TypeError: unsupported operand type(s) for +: 'int' and 'str'

# ============================================================
# ⭐ CORE — run this cell, read the output, then modify values
# ============================================================

# --- Integers ---
student_count = 42          # whole number
negative_temp = -7          # negative integer

print("=== Integers ===")
print(f"student_count = {student_count}, type = {type(student_count)}")
print(f"negative_temp = {negative_temp}")

# --- Floats ---
pi = 3.14159
scientific = 6.022e23       # Avogadro's number (scientific notation)

print("\n=== Floats ===")
print(f"pi         = {pi}")
print(f"scientific = {scientific:.3e}")     # formatted as scientific notation

# ⚠️ Classic gotcha — float arithmetic is not always exact:
print(f"\n0.1 + 0.2 = {0.1 + 0.2}")        # Not 0.3!
print(f"Round fix: {round(0.1 + 0.2, 10)}")

# --- Strings ---
name = "Alice"
city = 'Geneva'             # single or double quotes both work

print("\n=== Strings ===")
print(f"name = '{name}', length = {len(name)}")
print(f"Uppercase: {name.upper()}")
print(f"Slicing name[1:3]: {name[1:3]}")   # characters at index 1 and 2 → 'li'

# --- Booleans ---
is_enrolled = True
has_submitted = False

print("\n=== Booleans ===")
print(f"is_enrolled   = {is_enrolled}")
print(f"bool(0)       = {bool(0)}")         # 0 is falsy
print(f"bool('')      = {bool('')}")        # empty string is falsy
print(f"bool('hello') = {bool('hello')}")   # non-empty string is truthy

# --- Lists ---
grades = [85, 92, 78, 95]
names = ["Alice", "Bob", "Carol"]

print("\n=== Lists ===")
print(f"grades        = {grades}")
print(f"grades[0]     = {grades[0]}")       # first element (index starts at 0)
print(f"grades[-1]    = {grades[-1]}")      # last element
grades.append(88)
print(f"after append  = {grades}")
print(f"length        = {len(grades)}")

# --- Dicts ---
student = {"name": "Alice", "age": 21, "enrolled": True}

print("\n=== Dicts ===")
print(f"student           = {student}")
print(f"student['name']   = {student['name']}")
student["grade"] = 92
print(f"after adding key  = {student}")
print(f"keys              = {list(student.keys())}")


# ============================================================
# 💡 OPTIONAL — other integer formats and curiosities
# ============================================================

# big_number = 1_000_000   # underscores for readability (Python 3.6+)
# in_binary  = 0b1010      # binary literal  → 10
# in_hex     = 0xFF        # hexadecimal     → 255
# multiline  = """This string
# spans multiple lines."""

# Boolean quirk: True is literally the integer 1
# print(f"True + True = {True + True}")    # = 2  (legal but unusual)
# print(f"int(True)   = {int(True)}")      # = 1

# ============================================================
# ⭐ CORE — explicit type conversion
# ============================================================

age_str = "21"              # This is a string — you cannot do arithmetic on it yet
age_int = int(age_str)      # Convert to int
age_float = float(age_str)  # Convert to float

print(f"'21' as int:   {age_int + 1}")     # 22  — now we can do arithmetic
print(f"'21' as float: {age_float}")       # 21.0

# type() tells you what type a variable is
x = 42
print(f"\ntype(42):      {type(x)}")
print(f"type('hello'):  {type('hello')}")

# --- What happens with an invalid conversion? ---
try:
    int("hello")        # This raises a ValueError — "hello" is not a number
except ValueError as e:
    print(f"\nValueError: {e}")
    print("You cannot convert a non-numeric string to int!")

# isinstance() checks whether a value belongs to one or more types.
# It is preferred over type() in production code because it also handles
# subclasses (e.g. bool is a subclass of int, so isinstance(True, int) is True).
print(f"\nisinstance(42, (int, float)): {isinstance(x, (int, float))}")
# → True: 42 is an int, and int is one of the types listed

# ============================================================
# ⭐ CORE — print() and basic f-strings
# ============================================================

# --- print() basics ---
print("Hello, World!")
print("Alice", "Bob", "Carol")                  # multiple args → joined with a space by default
print("Alice", "Bob", "Carol", sep=" | ")       # sep= changes the character between each value

# '\n' is the newline character — it moves output to the next line.
# By default print() adds a '\n' at the end, so each print() starts on a fresh line.
print("Line 1", end="  ")                       # end="" replaces the default '\n' — no line break here
print("(still on the same line)")               # this continues on the same line as "Line 1"

# --- f-strings: the essential pattern ---
name = "Alice"
score = 95.666

print(f"\nStudent: {name}")           # \n at the start adds a blank line before the output
print(f"Score:   {score:.2f}%")       # :.2f = show exactly 2 decimal places

# Any Python expression works inside { }
a, b = 7, 3
print(f"\n{a} + {b} = {a + b}")
print(f"Name uppercase: {name.upper()}")

# Debug trick (Python 3.8+): add = after the variable name inside { }
# to print both the variable name and its value — very handy when debugging!
x = 42
print(f"{x=}")   # prints: x=42


# ============================================================
# 💡 OPTIONAL — alignment and padding (useful for Exercise 4)
# ============================================================

rank = 1
population = 8_100_000_000

print(f"\nRank:    {rank:03d}")                   # 03d: pad integer with zeros to width 3 → 001
print(f"World population: {population:,}")        # , adds thousands separators → 8,100,000,000
print(f"Right-aligned: {'hello':>15}")            # >15: right-align in a field of 15 characters
print(f"Left-aligned:  {'hello':<15}|")           # <15: left-align  (the | shows where the field ends)
print(f"Centered:      {'hello':^15}|")           # ^15: center
print(f"Pi approx: {3.14159265:.4f}")

# --- input() example ---
# Run this cell — a text field will appear below it in Jupyter.
# Type your name, press Enter, then type your age and press Enter again.

name = input("Enter your name: ")
age_str = input("Enter your age: ")
age = int(age_str)   # input() always returns a string — convert to int for arithmetic
print(f"Hello, {name}! You are {age} years old.")
print(f"In 10 years you will be {age + 10}.")

# ============================================================
# PEP-8 VIOLATIONS vs. CORRECT CODE — side-by-side comparison
# ============================================================

# --- BAD: poor naming, no spaces, mixed style ---
# (This is commented out because it's intentionally bad style)
# def CalcArea(r):
#   PI=3.14159
#   return PI*r*r
# myResult=CalcArea(5)
# print(myResult)

# --- GOOD: PEP-8 compliant ---
import math  # standard library imports at the top


def calculate_circle_area(radius: float) -> float:
    """Return the area of a circle given its radius."""
    # Use math.pi for the most accurate value
    return math.pi * radius ** 2


# Constants in UPPER_SNAKE_CASE
MAX_RADIUS = 1000

# Variable names in snake_case
test_radius = 5.0
area_result = calculate_circle_area(test_radius)

print(f"Area of circle with radius {test_radius}: {area_result:.4f}")
print(f"Maximum allowed radius: {MAX_RADIUS}")

# --- Spaces around operators ---
x = 10
y = 20
total = x + y          # good: spaces around +
product = x * y        # good

# Exception: no space around = in keyword arguments
print(f"Total: {total}", end="\n")  # 'end' has no spaces around =

# --- Boolean comparisons ---
items = []
# BAD:  if items == []:  or  if len(items) == 0:
# GOOD:
if not items:
    print("The list is empty (Pythonic check)")

value = None
# BAD:  if value == None:
# GOOD:
if value is None:
    print("Value is None (use 'is', not '==', for None)")

# Exercise 1 — Your solution here
# Hint: use input(), int(), and f-strings.

# ================================================
# BROKEN CODE — do NOT run this cell as-is
# (it will run, but the style is terrible)
# ================================================

import math,os  # violation 1: multiple imports on one line

def CalcRectArea(W,H):   # violation 2: PascalCase for function; violation 3: no spaces after commas
  area=W*H               # violation 4: 2-space indent; violation 5: no spaces around =
  return area

MyWidth=10    # violation 6: PascalCase for variable
MyHeight=5    # violation 7: same
Result=CalcRectArea(MyWidth,MyHeight)  # violation 8: PascalCase; violation 9: no space after comma

if Result == None:   # violation 10: use 'is None' not '== None'
    print( "No result")  # violation 11: extra space inside print()
else:
    print("Area =",Result)

# Exercise 2 — Fixed PEP-8-compliant version
# Write your corrected code here.

# Exercise 3 — Type Conversions

# ── Part A: explore conversions (fill in the expected results) ──
print(int("42"))          # → ?
print(int(3.99))          # → ?  (truncates, does not round)
print(float("3.14"))      # → ?
print(str(100))           # → ?
print(bool(0))            # → ?
print(bool(""))           # → ?
print(bool("hello"))      # → ?
print(bool([]))           # → ?
print(bool([0]))          # → ?  (non-empty list — truthy even if it holds 0)

# ── Part B: YOUR CODE HERE ──────────────────────────────────────
# 1. Read a number from the user
# 2. Convert to float
# 3. Print square and square root
# 4. Print positive / negative / zero

# Exercise 4 — f-string Formatting

students = [
    ("Alice",  21, 87.0),
    ("Bob",    19, 73.5),
    ("Chiara", 22, 95.0),
    ("Dmitri", 20, 61.3),
]

# Step 1: print the header line and the separator
# YOUR CODE HERE


# Step 2: the loop unpacks each row into (name, age, grade) for you.
# Replace the 'pass' with a single print() using f-string specifiers.
for name, age, grade in students:
    pass  # ← replace with: print(f"...")