Da Python Fundamentals a Generative Programming

Introduzione

Questo non è un tutorial tradizionale. È la trascrizione di un dialogo esplorativo, dove ogni risposta genera nuove domande, dove la curiosità guida l'apprendimento, e dove i concetti si stratificano naturalmente.

Iteratori: Il Cuore di Python

Gli iteratori sono oggetti che implementano il protocollo di iterazione, permettendo di attraversare sequenze di elementi uno alla volta. Sono il fondamento della filosofia «lazy evaluation» di Python.

Iteratori Built-in

Sequenze native

# Liste, tuple, stringhe, range
for item in [1, 2, 3]:
    print(item)

for char in "ciao":
    print(char)

for num in range(5):
    print(num)

Dizionari e set

d = {'a': 1, 'b': 2}

# Itera sulle chiavi
for key in d:
    print(key)

# Itera su coppie chiave-valore
for key, value in d.items():
    print(key, value)

# Solo valori
for value in d.values():
    print(value)

File

# Iterano riga per riga - memory efficient
with open('file.txt') as f:
    for line in f:
        print(line.strip())

Funzioni che restituiscono iteratori

map(), filter(), zip() — lazy evaluation

# map - applica funzione a ogni elemento
nums = [1, 2, 3]
squared = map(lambda x: x**2, nums)
print(list(squared))  # [1, 4, 9]

# filter - filtra elementi
evens = filter(lambda x: x % 2 == 0, range(10))
print(list(evens))  # [0, 2, 4, 6, 8]

# zip - combina iterabili
names = ['Alice', 'Bob']
ages = [25, 30]
for name, age in zip(names, ages):
    print(f"{name}: {age}")

enumerate() — aggiunge l'indice

for i, value in enumerate(['a', 'b', 'c'], start=1):
    print(f"{i}: {value}")
# 1: a
# 2: b
# 3: c

Modulo itertools

Fornisce iteratori specializzati per pattern comuni:

import itertools

# count - contatore infinito
for i in itertools.count(10, 2):
    if i > 20:
        break
    print(i)  # 10, 12, 14, 16, 18, 20

# cycle - cicla infinitamente
counter = 0
for item in itertools.cycle(['A', 'B', 'C']):
    print(item)
    counter += 1
    if counter >= 7:
        break

# chain - concatena iterabili
for item in itertools.chain([1, 2], [3, 4], [5, 6]):
    print(item)

# combinations e permutations
print(list(itertools.combinations([1, 2, 3], 2)))
# [(1, 2), (1, 3), (2, 3)]

# groupby - raggruppa elementi consecutivi
data = [1, 1, 2, 2, 2, 3, 1]
for key, group in itertools.groupby(data):
    print(key, list(group))

Creare iteratori personalizzati

Con classe

class Countdown:
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        self.current -= 1
        return self.current + 1

for num in Countdown(5):
    print(num)  # 5, 4, 3, 2, 1

Con generatori (molto più semplice)

def countdown(start):
    while start > 0:
        yield start
        start -= 1

for num in countdown(5):
    print(num)

Le 20 Funzioni Più Comuni

Queste funzioni built-in coprono l'80% dei casi d'uso quotidiani:

Esempi Chiave

sorted() — ordinamento versatile

sorted([3, 1, 4, 1, 5])                    # [1, 1, 3, 4, 5]
sorted(['banana', 'apple'], key=len)       # ['apple', 'banana']
sorted([3, 1, 4], reverse=True)            # [4, 3, 1]

isinstance() — type checking sicuro

isinstance(42, int)              # True
isinstance('hello', (int, str))  # True - accetta tuple di tipi

Design Patterns Python

I pattern idiomatici che rendono Python unico ed espressivo:

1. List Comprehension

Il pattern più iconico di Python — crea liste in modo conciso:

# Base
squares = [x**2 for x in range(10)]

# Con condizione
evens = [x for x in range(20) if x % 2 == 0]

# Con trasformazione condizionale
results = [x if x > 5 else 0 for x in range(10)]

# Nested (appiattire liste)
matrix = [[1, 2], [3, 4], [5, 6]]
flat = [num for row in matrix for num in row]
# [1, 2, 3, 4, 5, 6]

# Con enumerate
indexed = [f"{i}: {val}" for i, val in enumerate(['a', 'b', 'c'])]

2. Dict & Set Comprehension

# Dict comprehension
squares_dict = {x: x**2 for x in range(5)}
# {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Invertire dizionario
inverted = {v: k for k, v in {'a': 1, 'b': 2}.items()}

# Set comprehension
unique_evens = {x for x in [1, 2, 2, 3, 4, 4] if x % 2 == 0}
# {2, 4}

3. Unpacking

Destrutturazione elegante di sequenze:

# Base
a, b, c = [1, 2, 3]

# Con *rest
first, *rest = [1, 2, 3, 4, 5]
# first = 1, rest = [2, 3, 4, 5]

first, *middle, last = [1, 2, 3, 4, 5]
# first = 1, middle = [2, 3, 4], last = 5

# Swap elegante
a, b = b, a

# Unpacking in funzioni
def func(x, y, z):
    return x + y + z

args = [1, 2, 3]
func(*args)  # 6

# Merge dizionari (Python 3.9+)
d1 = {'a': 1, 'b': 2}
d2 = {'c': 3, 'd': 4}
merged = {**d1, **d2}

4. Context Manager (with)

# File
with open('file.txt', 'r') as f:
    content = f.read()
# File chiuso automaticamente

# Multipli
with open('in.txt') as fin, open('out.txt', 'w') as fout:
    fout.write(fin.read())

# Custom context manager
from contextlib import contextmanager

@contextmanager
def timer():
    import time
    start = time.time()
    yield
    print(f"Elapsed: {time.time() - start}s")

with timer():
    sum(range(1000000))

5. Generator Expression

# Come list comprehension ma lazy
squares = (x**2 for x in range(1000000))  # parentesi invece di []

# Utile con sum, max, any, all
total = sum(x**2 for x in range(1000))
has_even = any(x % 2 == 0 for x in range(10))

6. Walrus Operator := (Python 3.8+)

# Assignment expression
if (data := get_data()):
    process(data)

# In list comprehension
results = [y for x in range(10) if (y := x**2) > 20]

# In while loop
while (line := file.readline()):
    process(line)

Come Python è Diventato il Linguaggio dell'AI

Python non è nato per l'AI. È stata una convergenza di fattori storici e pratici.

La Timeline

from sklearn.ensemble import RandomForestClassifier
model = RandomForestClassifier()
model.fit(X_train, y_train)
predictions = model.predict(X_test)

Perché Python Vinse

Contro C++ — velocissimo ma boilerplate infernale, debugging complicato, cicli di sviluppo lentissimi. Python: prototipa in ore, non settimane.

Contro Java — troppo verboso, ecosistema scientifico debole, JVM overhead. Python: conciso e scientifico.

Contro R — ottimo per la statistica, ma design inconsistente e performance problematiche. Python: più versatile.

Contro MATLAB — proprietario, costoso, non adatto alla produzione. Python + NumPy: MATLAB gratis con più features.

Il Circolo Virtuoso

1. I ricercatori pubblicano paper con codice Python
2. Altri ricercatori usano quel codice (PyTorch/TensorFlow)
3. Le startup assumono quei ricercatori
4. Il codice di produzione è in Python (già scritto)
5. Più aziende → più librerie → più adozione

# Questo loop Python è lento
for i in range(1000000):
    result += i * 2

# Ma questo è velocissimo (NumPy in C)
result = np.sum(np.arange(1000000) * 2)

Programmazione Generativa per Game Development

1. Dungeon/Cave Generator (Cellular Automata)

Ideale per roguelike o giochi esplorativi:

import random
import numpy as np

def generate_cave(width, height, fill_prob=0.45, iterations=4):
    """Genera una caverna usando cellular automata"""
    # Inizializza con rumore casuale
    grid = np.random.choice([0, 1], size=(height, width),
                           p=[1-fill_prob, fill_prob])

    # Applica regole cellular automata
    for _ in range(iterations):
        new_grid = grid.copy()
        for y in range(1, height-1):
            for x in range(1, width-1):
                # Conta vicini (muri)
                neighbors = np.sum(grid[y-1:y+2, x-1:x+2]) - grid[y, x]

                # Regole: se troppi vicini -> diventa muro
                if neighbors > 4:
                    new_grid[y, x] = 1
                elif neighbors < 4:
                    new_grid[y, x] = 0

        grid = new_grid

    return grid  # 0 = vuoto, 1 = muro

# Uso
cave = generate_cave(50, 50)
print(cave)

2. Perlin Noise per Terreni

Per generare heightmap, texture, terreni organici:

import noise  # pip install noise
import numpy as np

def generate_terrain(width, height, scale=50.0, octaves=6):
    """Genera heightmap usando Perlin noise"""
    terrain = np.zeros((height, width))

    for y in range(height):
        for x in range(width):
            value = noise.pnoise2(x/scale,
                                  y/scale,
                                  octaves=octaves,
                                  persistence=0.5,
                                  lacunarity=2.0,
                                  repeatx=width,
                                  repeaty=height,
                                  base=random.randint(0, 1000))

            terrain[y][x] = value

    # Normalizza 0-1
    terrain = (terrain - terrain.min()) / (terrain.max() - terrain.min())
    return terrain

# Uso per biomi
terrain = generate_terrain(100, 100)
# < 0.3 = acqua, 0.3-0.6 = pianura, > 0.6 = montagna

3. Wave Function Collapse (WFC)

Pattern potente per generare livelli coerenti:

import random

def simple_wfc(tiles, rules, width, height):
    """Simplified Wave Function Collapse"""
    grid = [[None for _ in range(width)] for _ in range(height)]

    def get_valid_tiles(x, y):
        valid = set(tiles)

        # Controlla ogni direzione
        for dx, dy in [(-1,0), (1,0), (0,-1), (0,1)]:
            nx, ny = x + dx, y + dy
            if 0 <= nx < width and 0 <= ny < height:
                neighbor = grid[ny][nx]
                if neighbor:
                    valid &= set(rules[neighbor])

        return list(valid)

    # Collapse iterativo
    while None in [cell for row in grid for cell in row]:
        # Trova cella con minima entropia
        min_entropy = float('inf')
        candidates = []

        for y in range(height):
            for x in range(width):
                if grid[y][x] is None:
                    valid = get_valid_tiles(x, y)
                    entropy = len(valid)
                    if entropy < min_entropy:
                        min_entropy = entropy
                        candidates = [(x, y, valid)]
                    elif entropy == min_entropy:
                        candidates.append((x, y, valid))

        if candidates:
            x, y, valid = random.choice(candidates)
            if valid:
                grid[y][x] = random.choice(valid)

    return grid

# Uso
tiles = ['grass', 'water', 'sand', 'forest']
rules = {
    'grass': ['grass', 'sand', 'forest'],
    'water': ['water', 'sand'],
    'sand': ['grass', 'water', 'sand'],
    'forest': ['grass', 'forest']
}
world = simple_wfc(tiles, rules, 20, 20)

4. Generatore di Sistemi Stellari (Space Game)

import random
import math

class StarSystem:
    def __init__(self, seed=None):
        if seed:
            random.seed(seed)

        self.star = self.generate_star()
        self.planets = self.generate_planets()

    def generate_star(self):
        star_types = [
            ('O', 0.00003, (200, 255, 255), 30000),
            ('B', 0.13, (170, 191, 255), 10000),
            ('A', 0.6, (202, 215, 255), 7500),
            ('F', 3.0, (248, 247, 255), 6000),
            ('G', 7.6, (255, 244, 234), 5200),  # nostro sole
            ('K', 12.1, (255, 210, 161), 3700),
            ('M', 76.45, (255, 204, 111), 2400)
        ]

        roll = random.uniform(0, 100)
        cumulative = 0
        for star_type, probability, color, temp in star_types:
            cumulative += probability
            if roll <= cumulative:
                return {
                    'type': star_type,
                    'color': color,
                    'temperature': temp,
                    'mass': random.uniform(0.5, 2.0),
                    'radius': random.uniform(0.7, 1.5)
                }

    def generate_planets(self):
        num_planets = random.randint(0, 10)
        planets = []

        for i in range(num_planets):
            distance = 0.4 + (0.3 * (2 ** i))

            planet = {
                'name': f"Planet {i+1}",
                'distance_au': distance,
                'radius_km': random.uniform(2000, 70000),
                'type': self.determine_planet_type(distance),
                'moons': random.randint(0, 5),
                'resources': {
                    'metals': random.randint(0, 100),
                    'water': random.randint(0, 100),
                    'rare_minerals': random.randint(0, 50)
                }
            }
            planets.append(planet)

        return planets

    def determine_planet_type(self, distance):
        if distance < 0.5:
            return random.choice(['rocky', 'lava'])
        elif 0.5 <= distance < 2.0:
            return random.choice(['rocky', 'terran', 'desert'])
        elif 2.0 <= distance < 5.0:
            return random.choice(['gas_giant', 'ice_giant'])
        else:
            return random.choice(['ice', 'dwarf'])

# Uso
system = StarSystem(seed=12345)
print(f"Star: {system.star['type']}, Temp: {system.star['temperature']}K")
for planet in system.planets:
    print(f"  {planet['name']}: {planet['type']}, "
          f"{planet['distance_au']:.2f} AU")

5. L-Systems per Vegetazione

def l_system(axiom, rules, iterations):
    """Lindenmayer system per pattern frattali"""
    current = axiom

    for _ in range(iterations):
        next_gen = ""
        for char in current:
            next_gen += rules.get(char, char)
        current = next_gen

    return current

# Albero
tree_rules = {
    'F': 'FF+[+F-F-F]-[-F+F+F]',
    '+': '+',
    '-': '-',
    '[': '[',
    ']': ']'
}
tree = l_system('F', tree_rules, 3)

6. Nome Generator (Markov Chains)

import random

def markov_name_generator(sample_names, order=2, count=10):
    """Genera nomi usando Markov chains"""
    chain = {}
    for name in sample_names:
        name = '^' * order + name.lower() + '$'
        for i in range(len(name) - order):
            key = name[i:i+order]
            next_char = name[i+order]
            if key not in chain:
                chain[key] = []
            chain[key].append(next_char)

    generated = []
    for _ in range(count):
        name = '^' * order
        while True:
            key = name[-order:]
            if key not in chain or name[-1] == '$':
                break
            name += random.choice(chain[key])

        generated.append(name[order:-1].capitalize())

    return generated

# Uso
planet_samples = ['terra', 'venus', 'mars', 'jupiter']
new_planets = markov_name_generator(planet_samples, order=2, count=5)
print(new_planets)

Conclusioni

I Takeaway Chiave

1. Python è un linguaggio di orchestrazione — è «lento» ma non importa: il lavoro pesante è in C/CUDA sotto. Python orchestra, non computa.

2. I pattern sono essenziali — list comprehension, unpacking, context manager: non sono solo «sintassi carina», sono il modo Pythonic di risolvere problemi.

3. Lazy evaluation = efficienza — iteratori e generator expression: Python è lazy per default, il che permette di lavorare con dataset enormi.

4. Il network effect vince — Python vinse nell'AI non perché «migliore» tecnicamente, ma perché al momento giusto con l'ecosistema giusto. Poi il loop si autoalimentò.

5. Generativo = creatività procedurale — Python eccelle nella generazione procedurale: cellular automata, noise functions, L-systems. Perfetto per il game dev.

Per il Tuo Percorso Software Engineer 3.0

Questo documento rappresenta un approccio diverso all'apprendimento:

• Curiosity-driven — segui le domande, non il syllabus
• Connessioni trasversali — dagli iteratori alla storia dell'AI al game dev
• Pratico ma contestuale — codice funzionante + perché esiste
• Build, don't just learn — ogni esempio è usabile