Da Python Fundamentals a Generative Programming

Introduzione

La Genesi di Questo Documento

Questo documento nasce da una semplice domanda: “Quali sono tutti gli iteratori di Python?”

Una curiosità genuina che si è trasformata in un’esplorazione più ampia, attraversando:

• Le fondamenta di Python (iteratori, funzioni built-in)
• I pattern idiomatici che rendono Python unico
• La storia di come Python è diventato il linguaggio dell’AI
• Le tecniche di programmazione generativa per game development

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)

# Dizionari
d = {'a': 1, 'b': 2}
for key, value in d.items():
    print(key, value)

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

Funzioni che Restituiscono Iteratori

# map, filter, zip - Lazy evaluation
nums = [1, 2, 3]
squared = map(lambda x: x**2, nums)
print(list(squared))  # [1, 4, 9]

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

Modulo itertools

import itertools

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

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

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

Creare Iteratori Personalizzati

# Con generatori (molto più semplice)
def countdown(start):
    while start > 0:
        yield start
        start -= 1

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

Le 20 Funzioni Più Comuni

Design Patterns Python

1. List Comprehension

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

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

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

2. Unpacking

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

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

# Swap elegante
a, b = b, a

# Merge dizionari (Python 3.9+)
merged = {**d1, **d2}

3. Context Manager (with)

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

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

4. Walrus Operator := (Python 3.8+)

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

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

Come Python è Diventato il Linguaggio dell’AI

La Timeline

Perché Python Vinse

Il Paradosso Interessante

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

import numpy as np

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

    for _ in range(iterations):
        new_grid = grid.copy()
        for y in range(1, height-1):
            for x in range(1, width-1):
                neighbors = np.sum(grid[y-1:y+2, x-1:x+2]) - grid[y, x]
                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

2. Generatore di Sistemi Stellari (Space Game)

import random

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 = [
            ('G', 7.6, (255, 244, 234), 5200),  # nostro sole
            ('K', 12.1, (255, 210, 161), 3700),
            ('M', 76.45, (255, 204, 111), 2400)
        ]
        # ... logica selezione tipo stella

    def generate_planets(self):
        num_planets = random.randint(0, 10)
        # ... generazione pianeti con risorse, lune, tipo

3. Nome Generator (Markov Chains)

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)

    # Genera nomi basati sulla chain
    # ...

Conclusioni

I Takeaway Chiave

Il prossimo passo? Prendi uno di questi generatori e costruisci qualcosa. Un dungeon roguelike. Un sistema stellare procedurale. Un generatore di mappe. La teoria si solidifica solo attraverso la pratica.