# This is a code cell. Run it with Shift+Enter.
print("Welcome to Python for Economists.")

Welcome to Python for Economists.

# Economic variables — all four basic types
year = 2024                  # int
gdp_growth = 2.1             # float  (annual % change)
country = "Italy"            # str
is_eurozone = True           # bool

# Check the type of any variable with type()
print(type(year))
print(type(gdp_growth))
print(type(country))
print(type(is_eurozone))

<class 'int'>
<class 'float'>
<class 'str'>
<class 'bool'>

# You can reassign a variable at any time
gdp_growth = 0.3    # 2023 estimate
print(gdp_growth)

# And convert between types
year_as_string = str(year)
print(year_as_string, type(year_as_string))

0.3
2024 <class 'str'>

# Arithmetic operators
gdp_2022 = 1909.0   # Italy GDP in billion EUR
gdp_2023 = 1948.0

growth_rate = (gdp_2023 - gdp_2022) / gdp_2022 * 100
print("Growth rate:", growth_rate, "%")

# Integer division and modulo
print(7 // 2)   # integer division → 3
print(7 % 2)    # remainder → 1

# Exponentiation
print(2 ** 10)  # 2 to the power of 10

Growth rate: 2.0429544264012574 %
3
1
1024

# Comparison operators — always return a bool
inflation = 5.8
ecb_target = 2.0

print(inflation > ecb_target)     # True
print(inflation == ecb_target)    # False  (note: == not =)
print(inflation != ecb_target)    # True

# Logical operators
recession = False
high_debt = True

print(recession and high_debt)    # False
print(recession or high_debt)     # True
print(not recession)              # True

True
False
True
False
True
True

country = "Italy"
gdp_growth = 0.73
year = 2023

# f-string: prefix the string with f, put variables in {}
print(f"{country} GDP growth in {year}: {gdp_growth}%")

# Format numbers: control decimal places with :.2f
print(f"{country} GDP growth in {year}: {gdp_growth:.2f}%")

# Alignment formatting in f-strings: {value:align width}
# < aligns left, > aligns right, ^ centers. The number sets the minimum field width in characters.
# Keeping widths consistent across rows and header produces neatly aligned columns.
# Example: {country:<12} reserves 12 characters, left-aligned; {growth:>8.2f} reserves 8, right-aligned, 2 decimal places.

# Useful for tables
print(f"{'Country':<12} {'Growth':>8} {'Year':>6}")
print(f"{'Italy':<12} {0.73:>8.2f} {2023:>6}")
print(f"{'Germany':<12} {-0.30:>8.2f} {2023:>6}")
print(f"{'France':<12} {0.90:>8.2f} {2023:>6}")

Italy GDP growth in 2023: 0.73%
Italy GDP growth in 2023: 0.73%
Country        Growth   Year
Italy            0.73   2023
Germany         -0.30   2023
France           0.90   2023

gdp_growth = -0.5   # annual % change

if gdp_growth < 0:
    label = "contraction"
elif gdp_growth == 0:
    label = "stagnation"
elif gdp_growth < 2:
    label = "slow growth"
else:
    label = "strong growth"

print(f"GDP growth of {gdp_growth}% → {label}")

GDP growth of -0.5% → contraction

# A common pattern: validate inputs before computing
gdp_base = 0   # this would cause a division by zero

if gdp_base == 0:
    print("Error: base period GDP cannot be zero.")
else:
    growth = (1950 - gdp_base) / gdp_base * 100
    print(f"Growth: {growth:.2f}%")

Error: base period GDP cannot be zero.

# for loop over a list
countries = ["Italy", "Germany", "France", "Spain"]

for country in countries:
    print(f"Processing data for {country}...")
    # write some commands here...

Processing data for Italy...
Processing data for Germany...
Processing data for France...
Processing data for Spain...

# range() generates a sequence of integers
# Useful for iterating over years
for random_name in range(2018, 2024):   # 2018, 2019, ..., 2023
    print(random_name)

# enumerate() gives you both the index and the value
growth_rates = [1.2, 0.3, -0.5, 1.8]
years = [2020, 2021, 2022, 2023]

for i, rate in enumerate(growth_rates):
    print(f"{years[i]}: {rate:+.1f}%")   # +.1f forces the sign to appear

2020: +1.2%
2021: +0.3%
2022: -0.5%
2023: +1.8%

# Accumulate results in a list
gdp_levels = [100]   # index = 100 in year 0
growth_rates = [0.012, 0.003, -0.005, 0.018, 0.007]

for g in growth_rates:
    new_level = gdp_levels[-1] * (1 + g)
    gdp_levels.append(new_level)

print("GDP index:", [round(x, 3) for x in gdp_levels])

GDP index: [100, 101.2, 101.504, 100.996, 102.814, 103.534]

# while loop — useful when you don't know in advance how many iterations
# Example: how many years to double GDP at 3% annual growth?
gdp = 1.0
years_elapsed = 0

while gdp < 2.0:
    gdp *= 1.03   # gdp = gdp * 1.03
    years_elapsed += 1 

print(f"GDP doubles in {years_elapsed} years at 3% growth.")

# Rule of 72: a quick mental-math approximation for doubling time under compound growth.
# Divide 72 by the annual growth rate (in %) to get the approximate number of years to double.
# Example: at 3% growth, GDP doubles in roughly 72/3 = 24 years (exact value: ~23.4 years).
print(f"(Rule of 72 approximation: {72 // 3} years)")

GDP doubles in 24 years at 3% growth.
(Rule of 72 approximation: 24 years)

# Basic function: one input, one output
def annualize_rate(quarterly_rate):
    """Convert a quarterly growth rate to an annualized rate."""
    return (1 + quarterly_rate) ** 4 - 1

q_rate = 0.005   # 0.5% per quarter
ann_rate = annualize_rate(q_rate)
print(f"Quarterly {q_rate:.1%} → annualized {ann_rate:.2%}")
q_rate = 0.03   # 0.5% per quarter
ann_rate = annualize_rate(q_rate)
print(f"Quarterly {q_rate:.1%} → annualized {ann_rate:.2%}")

Quarterly 0.5% → annualized 2.02%
Quarterly 3.0% → annualized 12.55%

# Multiple arguments and a default argument
def gdp_growth_rate(gdp_current, gdp_previous, as_percent=True):
    """
    Compute GDP growth rate between two periods.

    Parameters
    ----------
    gdp_current : float
        GDP in the current period.
    gdp_previous : float
        GDP in the previous period.
    as_percent : bool, optional
        If True (default), return the rate in percentage points.

    Returns
    -------
    float
        Growth rate.
    """
    if gdp_previous <= 0:
        raise ValueError("Base period GDP must be strictly positive.")
    rate = (gdp_current - gdp_previous) / gdp_previous
    return rate * 100 if as_percent else rate

print(gdp_growth_rate(1948, 1909))           # returns percent
print(gdp_growth_rate(1948, 1909, as_percent=False))   # returns decimal

2.0429544264012574
0.020429544264012573

# Functions can return multiple values (as a tuple)
def describe_series(values):
    """Return mean, min and max of a numeric list."""
    mean = sum(values) / len(values)
    return mean, min(values), max(values)

growth_rates = [1.2, 0.3, -0.5, 1.8, 0.7, -1.1]
avg, low, high = describe_series(growth_rates)
print(f"Mean: {avg:.2f}  |  Min: {low:.2f}  |  Max: {high:.2f}")

Mean: 0.40  |  Min: -1.10  |  Max: 1.80

# Calling a function inside a loop — a very common pattern
data = [
    ("Italy",   1948, 1909),
    ("Germany", 4072, 4082),
    ("France",  2794, 2782),
]

print(f"{'Country':<12} {'Growth':>8}")
print("-" * 22)
for country, gdp_now, gdp_prev in data:
    g = gdp_growth_rate(gdp_now, gdp_prev)
    print(f"{country:<12} {g:>+8.2f}%")

Country        Growth
----------------------
Italy           +2.04%
Germany         -0.24%
France          +0.43%

# Task 1 — write your function here

def gdp_growth(gdp_t1, gdp_t0):
    # YOUR CODE HERE
    pass

# Tasks 2 & 3 — loop and formatted output

data = [
    ("Italy",   2010.0, 1789.0),
    ("Germany", 4082.0, 3449.0),
    ("Spain",   1419.0, 1245.0),
]

# YOUR CODE HERE

# Task 4 (optional) — CAGR function

def compound_growth(gdp_start, gdp_end, n_years):
    # YOUR CODE HERE
    pass

# ── SOLUTION ──────────────────────────────────────────────────────────────────

# Task 1
def gdp_growth(gdp_t1, gdp_t0):
    """Compute percentage GDP growth rate from t0 to t1."""
    if not isinstance(gdp_t1, (int, float)) or not isinstance(gdp_t0, (int, float)):
        raise ValueError("Both arguments must be numeric.")
    if gdp_t0 <= 0:
        raise ValueError(f"Base period GDP must be strictly positive (got {gdp_t0}).")
    return (gdp_t1 - gdp_t0) / gdp_t0 * 100

# Tasks 2 & 3
data = [
    ("Italy",   2010.0, 1789.0),
    ("Germany", 4082.0, 3449.0),
    ("Spain",   1419.0, 1245.0),
]

print(f"{'Country':<12} {'Growth':>8}  {'Label'}")
print("-" * 42)

for country, gdp_t1, gdp_t0 in data:
    g = gdp_growth(gdp_t1, gdp_t0)

    if g < 0:
        label = "contraction"
    elif g < 1:
        label = "stagnation"
    elif g < 3:
        label = "moderate growth"
    else:
        label = "strong growth"

    print(f"{country:<12} {g:>+7.2f}%  {label}")

# Task 4
def compound_growth(gdp_start, gdp_end, n_years):
    """Compute CAGR over n_years."""
    if gdp_start <= 0:
        raise ValueError("Starting GDP must be strictly positive.")
    if n_years <= 0:
        raise ValueError("Number of years must be positive.")
    return ((gdp_end / gdp_start) ** (1 / n_years) - 1) * 100

print("\nCAGR (5 years):")
for country, gdp_t1, gdp_t0 in data:
    cagr = compound_growth(gdp_t0, gdp_t1, 5)
    print(f"  {country:<12} {cagr:.2f}% per year")

Country        Growth  Label
------------------------------------------
Italy         +12.35%  strong growth
Germany       +18.35%  strong growth
Spain         +13.98%  strong growth

CAGR (5 years):
  Italy        2.36% per year
  Germany      3.43% per year
  Spain        2.65% per year

Type	Example	Used for
`int`	`2024`	integers, counts, years
`float`	`2.1`	continuous values, rates, prices
`str`	`"Italy"`	text, country names, labels
`bool`	`True`	binary indicators, flags

Concept	Key takeaway
Variables & types	Python infers types; use descriptive snake_case names
Operators	Arithmetic, comparison, logical — all return values
f-strings	Cleanest way to mix text and numbers in output
Conditionals	`if / elif / else` — indentation defines the block
Loops	`for` iterates over sequences; `while` iterates until a condition fails
Functions	`def` + `return`; add docstrings; validate inputs

Lecture 1 — Setup & Python Syntax¶

Python for Economists · University of Bologna · 2025/2026¶

What we cover today¶

1. Setting up your environment¶

1.1 Anaconda¶

1.2 Create a New Environment¶

1.3 Launching Jupyter Notebook¶

1.4 Installing additional packages¶

1.5 A note on notebooks¶

2. Variables and data types¶

2.1 Naming conventions¶

3. Operators and expressions¶

4. String formatting¶

5. Conditional statements¶

6. Loops¶

7. Functions¶

8. Exercise¶

Tasks¶

Solution¶

What we covered today¶

Next lecture¶