CLASSE TERZA • MODULO 3.1

NumPy Basics

La base per tutto: cos’è NumPy, creare array e fare operazioni semplici

Il tuo percorso NumPy

1
2
3
4
Fondamenta
(Questo modulo)
Statistiche
(Modulo 3.2)
Filtri & 2D
(Modulo 3.3)
Per l’AI
(Modulo 3.4)

🎯 Introduzione al Superpotere di Python

Hai mai provato a sommare 1000 numeri con un calcolatore normale? Ci vorrebbero ore! E se ti dicessi che con NumPy puoi fare operazioni su milioni di numeri in pochi millisecondi?

In questo modulo scoprirai NumPy, la libreria che trasforma Python in una macchina da calcolo super-veloce.

💡 Analogia: Il Supermercato

Liste Python normali sono come fare la spesa con un carrello piccolo: puoi mettere qualsiasi cosa (mele, libri, scarpe), ma è lento e disorganizzato.

Array NumPy sono come i pallet di un supermercato: tutti gli articoli sono dello stesso tipo, perfettamente organizzati, e puoi muovere 1000 scatole tutte insieme con un solo carrello elevatore! ⚡

🚀 Cos’è NumPy?

NumPy (Numerical Python) è una libreria, cioè un “pacchetto aggiuntivo” che puoi installare in Python per ottenere nuove funzionalità. In particolare, NumPy ti dà un nuovo tipo di dato chiamato array, pensato apposta per lavorare con i numeri in modo velocissimo.

⚡ 100x Più Veloce

Le operazioni su array NumPy sono fino a 100 volte più veloci delle liste Python normali

🧮 Magia Vettoriale

Puoi eseguire operazioni su migliaia di elementi contemporaneamente, senza scrivere loop!

🔢 Base Universale

Pandas, TensorFlow, Scikit-Learn... tutte le librerie AI usano NumPy come fondamenta

💡 Perché è così veloce?

NumPy è scritto in C e Fortran (linguaggi super-ottimizzati), non in Python puro. È come avere un motore di Formula 1 invece di una bicicletta! 🏎️

📦 Installazione e Primo Import

✅ Se usi Google Colab o Anaconda: NumPy è già installato! Puoi saltare l’installazione. 🎉

Se NON hai Anaconda

Apri il terminale e digita:

pip install numpy

Il Primo Import

Prima di usare NumPy, devi importarlo. Importare significa dire a Python: “Carica questa libreria, ne ho bisogno!”

import numpy as np

print("NumPy versione:", np.__version__)
print("NumPy è pronto all'uso!")

🔍 Spieghiamo pezzo per pezzo: import numpy as np

import numpy → dice a Python: “carica la libreria NumPy nel mio programma”.

as np → le assegna un soprannome breve. Invece di scrivere numpy.qualcosa() ogni volta, scriverai np.qualcosa(). Meno lettere, stesso risultato!

Tutti i programmatori del mondo usano il soprannome np per NumPy. È una convenzione universale.

Da questo momento, ogni volta che vedi np. nel codice, sappi che stiamo usando una funzione di NumPy.

🔶 Lista Python vs Array NumPy: La VERA Differenza

Con le liste Python (il vecchio modo)

Le liste Python sono flessibili ma lente per i calcoli matematici. Per fare operazioni su tutti gli elementi devi sempre scrivere cicli for:

voti = [7, 8, 6, 9, 7.5, 8.5]

# Calcolare la media con una lista
somma = sum(voti)  # sum() esiste anche per le liste
media = somma / len(voti)
print(f"Media: {media:.2f}")  # 7.67

# Ma prova a fare questo con una lista:
voti_aumentati = voti + 1  # ERRORE! Non puoi fare operazioni matematiche
voti_doppi = voti * 2      # Ripete la lista, non moltiplica! [7,8,6,9,7.5,8.5,7,8,6,9,7.5,8.5]

⚠️ Attenzione! Con le liste Python:

lista + 1ERRORE (non puoi sommare un numero)

lista * 2Ripete la lista 2 volte, non moltiplica i valori!

lista / 2ERRORE (non esiste)

Con NumPy (il nuovo modo) ⚡

Gli array NumPy sono progettati per i calcoli matematici. Le operazioni funzionano elemento per elemento automaticamente:

import numpy as np

voti_np = np.array([7, 8, 6, 9, 7.5, 8.5])

# Tutte queste operazioni funzionano!
media = voti_np.mean()              # 7.67
voti_aumentati = voti_np + 1        # [8.  9.  7.  10.  8.5 9.5]
voti_doppi = voti_np * 2            # [14. 16. 12. 18. 15. 17.]
voti_divisi = voti_np / 2           # [3.5 4.  3.  4.5 3.75 4.25]

print(f"Media: {media:.2f}")
print(f"Aumentati di 1: {voti_aumentati}")
print(f"Doppiati: {voti_doppi}")

🔍 Perché NumPy è DIVERSO dalle liste?

Le liste Python sono pensate per contenere qualsiasi cosa (numeri, testo, altre liste...) e sono flessibili ma lente per la matematica.

Gli array NumPy contengono solo numeri dello stesso tipo e sono ottimizzati in C/Fortran per fare calcoli velocissimi.

Con NumPy puoi scrivere array + 5 invece di fare un ciclo for: NumPy applica l'operazione a tutti gli elementi in automatico!

🐢 Liste Python

✓ Flessibili (qualsiasi tipo)

✓ Hanno sum(), len()

✗ Niente lista + 1

✗ Niente .mean(), .std()

✗ Lente per calcoli

🚀 Array NumPy

✓ Solo un tipo di numero

✓ Operazioni + - * / automatiche

✓ Funzioni statistiche integrate

✓ 100x più veloci

✓ Base per AI/ML

🏗️ Creare Array: Tanti Modi

1️⃣ Da una lista Python

import numpy as np
temperature = [22, 25, 18, 30, 15, 28]
temp_array = np.array(temperature)
print("Temperature:", temp_array)
print("Tipo elementi:", temp_array.dtype)

🔍 Spieghiamo: .dtype

dtype sta per “data type” (tipo di dato). Ti dice che tipo di numeri ci sono dentro l’array.

int64 = numeri interi, float64 = numeri con la virgola.

Non ci sono le parentesi perché dtype non è una funzione ma una proprietà (un’informazione).

2️⃣ Array di zeri e uni

zeri = np.zeros(5)
print("5 zeri:", zeri)  # [0. 0. 0. 0. 0.]

uni = np.ones(5)
print("5 uni:", uni)    # [1. 1. 1. 1. 1.]

# Trucco: moltiplica per avere un array con il valore che vuoi
array_di_10 = np.ones(5) * 10
print("5 dieci:", array_di_10)  # [10. 10. 10. 10. 10.]

3️⃣ Sequenze con arange() e linspace()

# arange(inizio, fine, passo) - numeri a salti regolari
# "Parti da 0, vai fino a 10 (escluso), a salti di 2"
numeri = np.arange(0, 10, 2)
print("arange(0, 10, 2):", numeri)  # [0 2 4 6 8]

# linspace(inizio, fine, quanti) - N punti equidistanti
# "Dammi 5 punti distribuiti uniformemente tra 0 e 1"
punti = np.linspace(0, 1, 5)
print("linspace(0, 1, 5):", punti)  # [0.   0.25 0.5  0.75 1.  ]

🔍 Differenza chiave tra arange e linspace

Con arange decidi il passo (ogni quanto saltare) e NumPy calcola quanti numeri escono.

Con linspace decidi quanti numeri vuoi e NumPy calcola il passo automaticamente.

Attenzione: arange esclude il valore finale (come range()), mentre linspace lo include!

4️⃣ Numeri casuali

# 5 numeri casuali decimali tra 0 e 1
casuali = np.random.random(5)
print("Casuali:", casuali)

# 10 numeri interi casuali tra 1 e 6 (come un dado)
dadi = np.random.randint(1, 7, size=10)
print("10 lanci di dado:", dadi)

🔍 Spieghiamo: np.random.randint(1, 7, size=10)

np.random → il sotto-modulo di NumPy dedicato ai numeri casuali.

.randint(1, 7, ...) → genera numeri interi casuali. Il primo numero (1) è il minimo, il secondo (7) è il massimo escluso. Quindi i valori possibili sono: 1, 2, 3, 4, 5, 6.

size=10 → quanti numeri casuali generare.

📏 Capire Shape e Size: Le Dimensioni degli Array

Ogni array NumPy ha due proprietà fondamentali che ti dicono quanti elementi contiene e come sono organizzati:

.size - Quanti elementi in totale?

import numpy as np

voti = np.array([7, 8, 6, 9, 7.5, 8.5])
print("Quanti voti?", voti.size)  # 6

temperature = np.array([22, 25, 18, 30, 15, 28, 19, 21])
print("Quante temperature?", temperature.size)  # 8

🔍 Cosa fa .size

.size conta tutti gli elementi dell'array, dal primo all'ultimo.

È come chiedere: "Quanti numeri ci sono dentro?"

Nota: .size è una proprietà, quindi NON ha le parentesi!

.shape - Come sono organizzati?

La proprietà .shape ti dice la forma dell'array. Per ora lavoriamo solo con array unidimensionali (una sola riga di numeri):

voti = np.array([7, 8, 6, 9, 7.5, 8.5])
print("Forma dell'array:", voti.shape)  # (6,)

temperature = np.array([22, 25, 18, 30])
print("Forma:", temperature.shape)      # (4,)

🔍 Perché (6,) e non solo 6?

shape restituisce sempre una tupla (una sequenza tra parentesi).

(6,) significa: "array con 6 elementi in una dimensione" (una riga).

La virgola indica che è una tupla con un solo valore. Nei prossimi moduli vedrai array 2D come matrici, con shape tipo (3, 4) = 3 righe, 4 colonne.

Visualizziamo Shape e Size

Array: [10, 20, 30, 40, 50]

10
20
30
40
50

.size = 5 (conta tutti gli elementi)

.shape = (5,) (5 elementi in una dimensione)

Esempio pratico completo

import numpy as np

# Creiamo un array di temperature
temp = np.array([22, 25, 18, 30, 15, 28])

print(f"Array completo: {temp}")
print(f"Tipo di dato: {temp.dtype}")     # int64 o float64
print(f"Quante misure: {temp.size}")     # 6
print(f"Forma: {temp.shape}")            # (6,)
print(f"Media: {temp.mean():.2f}°C")     # 23.00°C
📝 Output del codice sopra: Array completo: [22 25 18 30 15 28] Tipo di dato: int64 Quante misure: 6 Forma: (6,) Media: 23.00°C

💡 Ricorda:

.size → Numero totale di elementi

.shape → Come sono organizzati (per ora sempre una riga: (n,))

.dtype → Che tipo di numeri (int, float...)

📃 Stampare in Modo Professionale: F-String Formattate

Quando lavori con i dati, è fondamentale stampare i risultati in modo ordinato e leggibile. Le f-string di Python ti permettono di formattare numeri, testo e tabelle con precisione millimetrica!

La sintassi base delle f-string

nome = "Mario"
età = 17
media = 7.66666

# f-string base: metti variabili dentro {}
print(f"Ciao {nome}, hai {età} anni e la tua media è {media}")
# Output: Ciao Mario, hai 17 anni e la tua media è 7.66666

Formattare i decimali: :.2f

Per limitare i decimali usa :.Nf dove N è il numero di cifre dopo la virgola:

import numpy as np

voti = np.array([7, 8, 6.5, 9, 7.5, 8.5])
media = voti.mean()

print(f"Media: {media:.2f}")    # 7.75 (2 decimali)
print(f"Media: {media:.3f}")    # 7.750 (3 decimali)
print(f"Media: {media:.1f}")    # 7.8 (1 decimale, arrotondato)

🔍 Decodifichiamo {media:.2f}

media → la variabile da stampare

: → "inizia la formattazione"

.2 → "usa 2 cifre decimali"

f → "formato numero con virgola" (float)

Allineamento del testo: :<15, :>15, :^15

Puoi riservare uno spazio fisso per ogni campo, così le colonne si allineano perfettamente:

# :<15 = allinea a SINISTRA, occupa 15 caratteri
# :>15 = allinea a DESTRA, occupa 15 caratteri
# :^15 = allinea al CENTRO, occupa 15 caratteri

print(f"{'Nome':<15} {'Cognome':<15} {'Età':>5}")
print(f"{'Mario':<15} {'Rossi':<15} {17:>5}")
print(f"{'Anna':<15} {'Verdi':<15} {18:>5}")
print(f"{'Giuseppe':<15} {'Bianchi':<15} {16:>5}")
📝 Output (nota gli spazi perfettamente allineati): Nome Cognome Età Mario Rossi 17 Anna Verdi 18 Giuseppe Bianchi 16

Combinare allineamento E decimali: :<15.2f

Per i numeri con la virgola, puoi combinare allineamento e precisione decimale:

import numpy as np

nomi = ["Mario", "Anna", "Giuseppe"]
voti_scritto = np.array([7.5, 8.25, 6.75])
voti_orale = np.array([8.0, 7.5, 7.0])
medie = (voti_scritto + voti_orale) / 2

# Tabella formattata con allineamento E decimali
print(f"{'Nome':<15} {'Scritto':>10} {'Orale':>10} {'Media':>10}")
print("-" * 50)  # Linea separatrice

for i in range(len(nomi)):
    print(f"{nomi[i]:<15} {voti_scritto[i]:>10.2f} {voti_orale[i]:>10.2f} {medie[i]:>10.2f}")
📝 Output: Nome Scritto Orale Media -------------------------------------------------- Mario 7.50 8.00 7.75 Anna 8.25 7.50 7.88 Giuseppe 6.75 7.00 6.88

🔍 Decodifichiamo {voti_scritto[i]:>10.2f}

voti_scritto[i] → il valore da stampare

: → inizia la formattazione

> → allinea a DESTRA

10 → occupa 10 caratteri di spazio

.2f → mostra 2 decimali, formato float

Esempio pratico: Stampare più valori formattati

Quando hai molti valori decimali da stampare, ogni variabile dentro le graffe ha bisogno del suo :.2f:

import numpy as np

temp_mattina = 18.66666
temp_pomeriggio = 25.33333
temp_sera = 21.77777
media_giorno = np.mean([temp_mattina, temp_pomeriggio, temp_sera])

# Ogni variabile ha il suo :.2f
print(f"Mattina: {temp_mattina:.2f}°C | Pomeriggio: {temp_pomeriggio:.2f}°C | Sera: {temp_sera:.2f}°C")
print(f"Media del giorno: {media_giorno:.2f}°C")

# Output: 
# Mattina: 18.67°C | Pomeriggio: 25.33°C | Sera: 21.78°C
# Media del giorno: 21.93°C

⚠️ Errore comune: mettere :.2f FUORI dalle graffe

La formattazione va dentro le graffe {}, non fuori!

# ✗ SBAGLIATO - :.2f fuori dalle graffe
print(f"Media: {media}:.2f")  # ERRORE! Python non capisce

# ✓ CORRETTO - :.2f dentro le graffe
print(f"Media: {media:.2f}")  # Funziona!

# ✗ SBAGLIATO - pensare che basta una volta
print(f"{temp1} e {temp2:.2f}")  # ERRORE! Formatta solo temp2

# ✓ CORRETTO - ogni variabile ha il suo formato
print(f"{temp1:.2f} e {temp2:.2f}")  # Funziona!

💡 Riassunto Formattazione F-String

{variabile} → stampa così com'è

{variabile:.2f} → 2 decimali

{variabile:<15} → allineato a sinistra, 15 caratteri

{variabile:>15} → allineato a destra, 15 caratteri

{variabile:^15} → centrato, 15 caratteri

{variabile:>10.2f} → destra, 10 caratteri, 2 decimali

Esercizio guidato: Crea la tua tabella

import numpy as np

# Dati di esempio
prodotti = ["Penna", "Quaderno", "Zaino", "Astuccio"]
prezzi = np.array([1.50, 3.75, 25.99, 8.50])
sconti = np.array([0.10, 0.15, 0.20, 0.05])  # 10%, 15%, 20%, 5%
prezzi_finali = prezzi * (1 - sconti)

# Stampa tabella formattata
print(f"{'Prodotto':<15} {'Prezzo':>10} {'Sconto':>10} {'Finale':>10}")
print("=" * 50)

for i in range(len(prodotti)):
    print(f"{prodotti[i]:<15} {prezzi[i]:>10.2f}€ {sconti[i]*100:>9.0f}% {prezzi_finali[i]:>10.2f}€")
📝 Output: Prodotto Prezzo Sconto Finale ================================================== Penna 1.50€ 10% 1.35€ Quaderno 3.75€ 15% 3.19€ Zaino 25.99€ 20% 20.79€ Astuccio 8.50€ 5% 8.07€

✨ La MAGIA di NumPy: Operazioni su TUTTI i numeri

Operazioni tra un array e un numero (Broadcasting)

Puoi usare un singolo numero con un intero array. NumPy applica quel numero a ogni elemento automaticamente. Questo meccanismo si chiama broadcasting:

prezzi = np.array([10, 20, 30, 40, 50])

prezzi_doppi = prezzi * 2
prezzi_scontati = prezzi - 5
prezzi_aumentati = prezzi * 1.2  # +20%

print(f"Originali:       {prezzi}")
print(f"Doppi:           {prezzi_doppi}")
print(f"Scontati 5€:     {prezzi_scontati}")
print(f"+20%:            {prezzi_aumentati}")
📝 Cosa succede dentro prezzi * 1.2: NumPy "espande" il numero 1.2 e lo applica a ogni elemento: 10 * 1.2 = 12.0 20 * 1.2 = 24.0 30 * 1.2 = 36.0 40 * 1.2 = 48.0 50 * 1.2 = 60.0 Risultato: [12.0, 24.0, 36.0, 48.0, 60.0]

Operazioni tra due array

Quando usi +, -, * o / tra due array della stessa lunghezza, NumPy applica l’operazione posizione per posizione:

scritto = np.array([7, 8, 6, 9, 7.5])
orale   = np.array([8, 7.5, 7, 8.5, 8])

# Media ponderata: scritto vale 60%, orale vale 40%
voto_finale = scritto * 0.6 + orale * 0.4

print(f"Scritto: {scritto}")
print(f"Orale:   {orale}")
print(f"Finale:  {voto_finale}")
📝 Come viene calcolato scritto * 0.6 + orale * 0.4: Prima: scritto * 0.6 7*0.6=4.2 8*0.6=4.8 6*0.6=3.6 9*0.6=5.4 7.5*0.6=4.5 Poi: orale * 0.4 8*0.4=3.2 7.5*0.4=3.0 7*0.4=2.8 8.5*0.4=3.4 8*0.4=3.2 Infine: somma posizione per posizione 4.2+3.2=7.4 4.8+3.0=7.8 3.6+2.8=6.4 5.4+3.4=8.8 4.5+3.2=7.7 Risultato: [7.4, 7.8, 6.4, 8.8, 7.7]

💡 Perché si chiama “Broadcasting”?

Immagina una radio che trasmette (broadcast) un messaggio a tutti. Quando scrivi prezzi * 2, NumPy “trasmette” il numero 2 a tutti gli elementi dell’array, come una radio che invia lo stesso segnale a tutti i ricevitori!

📊 Statistiche BASE (le 5 fondamentali)

voti = np.array([5, 7, 8, 4, 6, 9, 5.5, 7, 8.5, 6])

print(f"Voti: {voti}")
print(f"Media:        {voti.mean():.2f}")
print(f"Minimo:       {voti.min():.2f}")
print(f"Massimo:      {voti.max():.2f}")
print(f"Somma:        {voti.sum():.2f}")
print(f"Quanti voti:  {voti.size}")
📝 Output formattato: Voti: [5. 7. 8. 4. 6. 9. 5.5 7. 8.5 6. ] Media: 6.60 Minimo: 4.00 Massimo: 9.00 Somma: 66.00 Quanti voti: 10

💡 Funzione vs Proprietà: quando mettere le parentesi?

.mean(), .min(), .max(), .sum()con parentesi perché sono funzioni (eseguono un calcolo).

.size, .dtype, .shapesenza parentesi perché sono proprietà (informazioni già pronte).

⚠️ ATTENZIONE: Errori comuni dei principianti

❌ ERRORE 1: Confondere lista e array

lista = [1, 2, 3]
array = np.array([1, 2, 3])

# print(lista.mean())  # ERRORE! Le liste non hanno .mean()
print(array.mean())     # CORRETTO: 2.0

# lista + 1            # ERRORE! Non puoi fare operazioni matematiche
print(array + 1)        # CORRETTO: [2 3 4]

❌ ERRORE 2: Dimenticare di importare NumPy

# array([1, 2, 3])      # ERRORE: NumPy non è importato
import numpy as np
np.array([1, 2, 3])     # CORRETTO

❌ ERRORE 3: Tipi di dati misti

strano = np.array([1, 2, "tre"])
print(strano)  # ['1' '2' 'tre']  Tutti diventano testo!

buono = np.array([1, 2, 3])        # Tutti numeri interi OK
buono2 = np.array([1.5, 2.0, 3.7]) # Tutti decimali OK

❌ ERRORE 4: Moltiplicare una lista (non è come NumPy!)

# Con le LISTE, * ripete la lista:
lista = [1, 2, 3]
print(lista * 2)  # [1, 2, 3, 1, 2, 3]  Ripetuta!

# Con NUMPY, * moltiplica ogni elemento:
array = np.array([1, 2, 3])
print(array * 2)  # [2 4 6]  Moltiplicato!

❌ ERRORE 5: Formattazione f-string fuori posto

media = 7.66666

# ✗ SBAGLIATO: :.2f fuori dalle graffe
# print(f"Media: {media}:.2f")  # ERRORE!

# ✓ CORRETTO: :.2f dentro le graffe
print(f"Media: {media:.2f}")    # Media: 7.67

✅ Checklist: Cosa sai fare ora?

💪 ESERCIZI: Metti in pratica

Esercizio 1: La Palestra 💪 Facile

Hai registrato i tuoi pesi sollevati in panca piana per 6 allenamenti: [50, 52.5, 55, 52.5, 57.5, 60] kg

  • Crea un array NumPy con questi pesi
  • Stampa .size, .shape e .dtype
  • Calcola di quanto è aumentato il peso dall'inizio alla fine (max - min)
  • Qual è il peso medio che hai sollevato?
  • Aggiungi 5kg a tutti gli allenamenti (simulando un miglioramento) e calcola la nuova media
  • Stampa tutto usando f-string formattate con 1 decimale

Esercizio 2: Il Budget Mensile 💰 Facile

Le tue spese settimanali di gennaio: [120, 85, 150, 95] euro

  • Crea un array con le spese
  • Calcola il totale speso nel mese (.sum())
  • Calcola la spesa media settimanale
  • Se vuoi risparmiare il 15% su ogni settimana, quanto spenderesti? (moltiplica per 0.85)
  • Quanto risparmieresti in totale in un mese?
  • Stampa una tabella: Settimana | Spesa Attuale | Spesa Risparmiosa

Esercizio 3: Il Percorso Fitness 🏃 Medio

Hai corso per 7 giorni e registrato i km: [3.2, 4.5, 0, 5.1, 3.8, 6.0, 4.2] (lo 0 è il giorno di riposo)

  • Crea un array con i km percorsi
  • Calcola il totale dei km corsi nella settimana
  • Calcola la media dei km (includendo il giorno di riposo)
  • Converti i km in metri (moltiplica per 1000)
  • Qual è il giorno in cui hai corso di più? (usa .max())
  • Stampa una tabella formattata: Giorno | KM | Metri usando {'Lunedì':<12} per i nomi

Esercizio 4: Il Dado Statistico 🎲 Medio

Simula un esperimento con i dadi!

  • Crea un array di 100 lanci di dado con np.random.randint(1, 7, size=100)
  • Stampa size e shape dell'array
  • Calcola la media dei lanci (teoricamente dovrebbe essere circa 3.5)
  • Qual è il valore minimo e massimo uscito? (dovrebbero essere 1 e 6)
  • Calcola la somma totale di tutti i lanci
  • Crea un secondo array di 100 lanci e somma i due array elemento per elemento. Qual è la nuova media?
  • Bonus: Moltiplica tutti i valori del primo array per 10. I dadi diventano "dadi da 10 a 60"!

Esercizio 5: Il Negozio di Elettronica ⚡ Medio

Gestisci un negozio con 5 prodotti:

  • Prodotti: ["Smartphone", "Tablet", "Cuffie", "Smartwatch", "Speaker"]
  • Prezzi di listino: [699, 449, 89, 299, 149] euro
  • Prezzi di acquisto (quello che tu hai pagato): [500, 320, 60, 200, 100] euro
  • Calcola il margine di guadagno per ogni prodotto (listino - acquisto)
  • Calcola la percentuale di guadagno: (margine / acquisto) * 100
  • Qual è il prodotto con il guadagno percentuale maggiore?
  • Stampa una tabella formattata con: Prodotto, Listino, Acquisto, Margine, %Guadagno

Esercizio 6: La Sfida dei Range 🎯 Medio

Esplora le funzioni di creazione array:

  • Crea i multipli di 5 da 0 a 100 con np.arange()
  • Crea 20 punti equidistanti tra -10 e 10 con np.linspace()
  • Crea un array di 15 numeri casuali decimali tra 0 e 1 con np.random.random()
  • Per ogni array creato, stampa: size, shape, min, max, mean
  • Moltiplica l'array di linspace per 3 e sottrai 5. Qual è il nuovo min e max?

Esercizio 7: Il Confronto PRO 🏆 Difficile

Sfida avanzata che combina tutto!

  • Crea due array: vendite_2023 = [1200, 1350, 1180, 1420, 1500] e vendite_2024 = [1450, 1520, 1380, 1680, 1750]
  • Calcola la crescita assoluta mese per mese: vendite_2024 - vendite_2023
  • Calcola la crescita percentuale mese per mese: ((2024 - 2023) / 2023) * 100
  • Qual è la crescita percentuale media?
  • Qual è la crescita assoluta massima in euro? (usa .max() sull'array delle differenze)
  • Calcola il totale vendite per ogni anno (usa .sum())
  • Stampa una tabella formattata con tutte le colonne:
# La tabella dovrebbe essere simile a questa:
# Mese      2023     2024     Diff€    Crescita%
# Gennaio   1200     1450      250      20.83%
# Febbraio  1350     1520      170      12.59%
# ...
# TOTALE    6650     7780     1130      17.00%
# 
# Usa: {mese:<12} {v2023:>8.0f} {v2024:>8.0f} {diff:>8.0f} {crescita:>10.2f}%

🚀 Pronto per il prossimo livello?

Nel Modulo 3.2 imparerai le statistiche avanzate:

Vai al Modulo 3.2: Statistiche con NumPy →