Python (2)

Python (2)#

In questo capitolo, approfondiremo ulteriormente le nozioni fondamentali legate al linguaggio Python. Ci concentreremo principalmente sull’analisi delle funzioni, la gestione del flusso di esecuzione, l’utilizzo dei cicli, l’implementazione delle list comprehension e l’esplorazione delle librerie e dei moduli disponibili.

import numpy as np
import pandas as pd
from matplotlib import pyplot as plt
import arviz as az
import seaborn as sns

%config InlineBackend.figure_format = 'retina'
RANDOM_SEED = 42
rng = np.random.default_rng(RANDOM_SEED)
az.style.use("arviz-darkgrid")
sns.set_theme(palette="colorblind")

Funzioni#

Lo scopo delle funzioni è raggruppare il codice in un formato organizzato, leggibile e riutilizzabile, contribuendo così a ridurre la ridondanza del codice.

Una regola generale per le funzioni è che dovrebbero essere di piccole dimensioni e svolgere un’unica operazione.

Nella programmazione, una funzione accetta un input, esegue operazioni su di esso e può restituire un output. Python mette a disposizione un’ampia gamma di funzioni integrate, e si può anche importare funzioni da pacchetti aggiuntivi o definirne di nuove.

Per definire una nuova funzione in Python, si utilizza la parola chiave def, seguita dal nome della funzione e dai nomi simbolici dei suoi argomenti, separati da virgole e racchiusi tra parentesi. La definizione continua con i due punti (:) e il corpo della funzione, le cui istruzioni devono essere indentate. Il valore restituito dalla funzione viene specificato tramite la parola chiave return, generalmente nella riga finale del corpo della funzione.

def add_numbers(a, b):
    """
    returns the sum of the two numeric arguments
    """
    the_sum = a + b
    return the_sum

Una volta definita una funzione, è possibile eseguirla chiamandola e passando gli argomenti appropriati. Ad esempio, possiamo chiamare la funzione add_numbers per sommare due numeri, come ad esempio 20 e 10:

add_numbers(20, 10)

Consideriamo la funzione roll_die():

import random

def roll_die():
    """
    returns a random int between 1 and 6
    """
    return random.choice([1, 2, 3, 4, 5, 6])

Il corpo della funzione è composto da una singola riga di codice che utilizza la funzione choice() della libreria random, a cui viene passata una lista. Questo significa che una funzione può utilizzare altre funzioni che sono già state definite. In questo caso, la funzione si limita a specificare l’argomento da passare a choice(). La funzione choice() restituirà un numero casuale tra quelli specificati in input. Pertanto, la funzione roll_die() simula il lancio di un dado:

roll_die()

roll_die()

Si noti inoltre la docstring, cioè una stringa (in genere racchiusa tra “””…”””) che si trova come prima istruzione all’interno di una funzione. La docstring contiene informazioni sullo scopo e sulle modalità d’uso della funzione.

Introspection#

Usando un punto interrogativo (?) prima o dopo una variabile è possibile visualizzare alcune informazioni generale su quell’oggetto. Nel caso di una funzione viene stampata la doc string.

roll_die?

Metodi#

Le funzioni definite all’interno di una classe, chiamate “metodi”, rappresentano operazioni specifiche che possono essere eseguite sugli oggetti di quella classe. Una classe è una struttura concettuale che rappresenta un concetto o un oggetto nel contesto del problema che stiamo affrontando. Ad esempio, nel capitolo sull’introduzione a Pandas, lavorando con dati organizzati in una tabella, utilizziamo un oggetto chiamato DataFrame, appartenente alla classe “pandas.DataFrame”. Un DataFrame è una struttura tabellare che contiene dati disposti in righe e colonne.

I metodi specifici della classe DataFrame offrono funzionalità per manipolare e analizzare i dati in questa struttura. Per esempio, il metodo “hist()” genera istogrammi dei valori presenti in una colonna specifica del DataFrame. Per invocare un metodo su un oggetto DataFrame, come “df”, utilizziamo la sintassi “nome_oggetto.nome_metodo()” e possiamo passare eventuali parametri richiesti tra parentesi.

D’altra parte, gli attributi rappresentano le caratteristiche o le proprietà degli oggetti di una classe. Gli attributi possono essere richiamati utilizzando la sintassi “nome_oggetto.nome_attributo” e restituiscono un valore specifico associato a quell’oggetto. Per esempio, l’attributo “.shape” applicato a un DataFrame come “df.shape” restituisce il numero di righe e colonne presenti nel DataFrame.

In sintesi, una classe definisce un tipo di oggetto che ha attributi che ne descrivono le caratteristiche e metodi che rappresentano le azioni eseguibili su di esso. Gli attributi forniscono informazioni specifiche sull’oggetto, mentre i metodi consentono di effettuare operazioni e manipolazioni sui dati contenuti nell’oggetto stesso.

La funzione `lambda`#

Python offre una sintassi alternativa che consente di definire funzioni “inline”, cioè in una singola linea di codice. Queste funzioni, chiamate funzioni anonime, non richiedono una definizione esplicita poiché vengono utilizzate solo nel punto in cui sono dichiarate. Per creare una funzione anonima, utilizziamo la parola chiave lambda, seguita da un elenco di argomenti separati da virgole, due punti “:” e l’espressione che definisce il comportamento della funzione basandosi sugli argomenti forniti. Questa sintassi permette di creare funzioni semplici ed espressive in modo conciso.

Nell’esempio seguente, la funzione somma 1 al valore passato come input:

(lambda x : x + 1)(2)

In questo esempio sommiamo i due numeri in entrata:

(lambda x, y: x + y)(2, 3)

È anche possibile assegnare un nome alla funzione lambda:

myadd = lambda x, y: x + y

myadd(20, 10)

La sintassi seguente è valida in quanto, per l’interprete, il carattere _ corrisponde all’ultima funzione che è stata valutata:

lambda x, y: x + y

<function __main__.<lambda>(x, y)>

_(20, 10)

Si noti abbiamo valutato la funzione lambda x, y: x + y in una cella precedente a quella che contiene _(20, 10); inserendo le due espressioni in una singola cella si ottiene un SyntaxError.

Le funzioni `map()` e `filter()`#

Per gli esercizi che svolgeremo in seguito, risultano utili le funzioni map() e filter().

La funzione map() prende come input una funzione e una lista, e restituisce il risultato dell’applicazione della funzione a ciascun elemento della lista (è anche possibile usare qualsiasi oggetto iterabile al posto della lista). La lista stessa rimane invariata. Ad esempio, la seguente linea di codice eleva al quadrato ciascuno degli elementi della lista a e salva il risultato nella lista b:

a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = list(map(lambda x: x * x, a))
b

[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Un’altra funzione molto utile per manipolare gli oggetti iterabili è la funzione filter(). Questa funzione filtra un oggetto iterabile selezionando solo gli elementi che rispondono ad un determinato predicato. (Il predicato è una funzione che restituisce un booleano). Per esempio

c = list(filter(lambda x: x > 50, b))
c

[64, 81, 100]

Sia map() che filter() restituiscono risultati che non sono ancora stati calcolati.

filter(lambda x: x > 50, b)

<filter at 0x169ad3160>

Possiamo visualizzare il risultato convertendolo in una lista:

list(filter(lambda x: x > 50, b))

[64, 81, 100]

La funzione `zip()`#

La funzione zip() crea una lista di tuple dagli elementi di due contenitori. Come nel caso delle operazioni precedenti, gli elementi vengono calcolati solo quando viene richiesto. Per esempio:

a = list(range(4))
a

[0, 1, 2, 3]

b = list(range(4, 8))
b

[4, 5, 6, 7]

b = zip(a, b)
b

<zip at 0x169b903c0>

list(b)

[(0, 4), (1, 5), (2, 6), (3, 7)]

Il flusso di esecuzione#

In Python il codice viene eseguito sequenzialmente, partendo dalla prima riga fino a quando non c’è più nulla da eseguire. L’ordine di esecuzione delle varie istruzioni è detto flusso di esecuzione.

Per esempio la cella seguente prima memorizza la lista names, poi la lista born e infine la lista dead.

names = ["Sigmund Freud", "Jean Piaget", "Burrhus Frederic Skinner", "Albert Bandura"]
born = [1856, 1896, 1904, 1925]
dead = [1939, 1980, 1990, None]

Ho usato il valore speciale None in quanto non risulta disponibile l’anno. In queste situazioni si parla di valori mancanti (missing values) che, di norma, vengono indicati con la sigla NA (not available).

La cella seguente include le istruzioni condizionali che specificano se e quando devono essere eseguiti determinati blocchi di codice. La più semplice istruzione di controllo è l’istruzione if. Per esempio:

name = "Maria"
grade = 29

if name == "Maria" and grade > 28:
    print("Maria, hai ottenuto un ottimo voto all'esame!")

if name == "Giovanna" or grade > 28:
    print(
        "Tu potresti essere Giovanna oppure potresti avere ottenuto un ottimo voto all'esame."
    )

if name != "Giovanna" and grade > 28:
    print("Tu non sei Giovanna ma hai ottenuto un ottimo voto all'esame.")

Maria, hai ottenuto un ottimo voto all'esame!
Tu potresti essere Giovanna oppure potresti avere ottenuto un ottimo voto all'esame.
Tu non sei Giovanna ma hai ottenuto un ottimo voto all'esame.

Tutte e tre le condizioni precedenti ritornano True, quindi vengono stampati tutti e tre i messaggi.

Si noti che == e != confrontano valori, mentre is e not confrontano oggetti. Per esempio,

name_list = ["Maria", "Giovanna"]
name_list_two = ["Marco", "Francesco"]

# Compare values
print(name_list == name_list_two)

# Compare objects
print(name_list is name_list_two)

False
False

Una delle parole chiave condizionali più utili è in. Un esempio è il seguente:

name_list = ["Maria", "Giovanna", "Marco", "Francesco"]

print("Giovanna" in name_list)
print("Luca" in name_list)

True
False

La condizione opposta è not in.

print("Luca" not in name_list)

True

Facciamo un altro esempio.

age = 26
if age >= 18:
    print("Sei maggiorenne")

Sei maggiorenne

Python dispone di un’espressione ternaria che introduce la potenza dell’istruzione ‘else’ in una sintassi concisa:

age = 26
b = "Sei maggiorenne" if age >=18 else "Sei minorenne"
print(b)

Sei maggiorenne

age = 16
b = "Sei maggiorenne" if age >=18 else "Sei minorenne"
print(b)

Sei minorenne

Una struttura di selezione leggermente più complessa è “if-else”. La sintassi di questa struttura è la seguente:

if <condizione>:
    <istruzione_se_condizione_vera>
else:
    <istruzione_se_condizione_falsa>

La semantica di “if-else” è quella che ci si aspetta: la condizione tra la parola chiave if e il carattere di due punti viene valutata: se risulta vera viene eseguita l’istruzione alla linea seguente, altrimenti viene eseguita l’istruzione dopo la parola chiave else. Anche in questo caso l’indentazione permette di identificare quali istruzioni devono essere eseguite nei due rami della selezione. Per esempio:

age = 16
if age >= 18:
    print("Sei maggiorenne")
else:
    print("Sei minorenne")

Sei minorenne

In presenza di più di due possibilità mutuamente esclusive ed esaustive possiamo usare l’istruzione elif. Per esempio:

cfu = 36
thesis_defense = False

if cfu >= 180 and thesis_defense == True:
    print("Puoi andare a festeggiare!")
elif cfu >= 180 and thesis_defense == False:
    print("Devi ancora superare la prova finale!")
else:
    print("Ripassa tra qualche anno!")

Ripassa tra qualche anno!

Commenti#

In Python è possibile usare il carattere # per aggiungere commenti al codice. Ogni riga di commento deve essere preceduta da un #. I commenti non devono spiegare il metodo (cosa fa il codice: quello si vede), ma bensì lo scopo: quello che noi intendiamo ottenere. I primi destinatari dei commenti siamo noi stessi tra un po’ di tempo, ovvero quando ci saremo dimenticati cosa avevamo in mente quando abbiamo scritto il codice.

# This is a comment and will not be executed.

Cicli#

Un ciclo è un modo per eseguire una porzione di codice più di una volta. I cicli sono fondamentali nei linguaggi di programmazione. Come molti altri linguaggi di programmazione, Python ha due tipi di cicli per gestire tutte le proprie necessità di iterazione: il ciclo “while” e il ciclo “for”.

Il ciclo `while`#

il ciclo while permette l’esecuzione di un blocco di codice finché una determinata condizione è True. Per esempio:

counter = 0

while counter <= 10:
    print(counter)
    counter += 1

Il codice counter += 1 è equivalente a counter = counter + 1 e, ogni qualvolta viene eseguito il ciclo, riassegna alla variabile counter il valore che aveva in precedenza + 1.

L’istruzione while controlla se alla variabile counter è associato un valore minore o uguale a 10. Nel primo passo del ciclo la condizione è soddisfatta, avendo noi definito counter = 0, pertanto il programma entra nel loop, stampa il valore della variabile counter e incrementa counter di un’unità.

Questo comportamento si ripete finché la condizione counter <= 10 risulta True. Quando il contatore counter assume il valore 11 il ciclo while si interrompe e il blocco di codice del ciclo non viene più eseguito.

Il ciclo `for`#

Il ciclo for è un costrutto di controllo di flusso che viene utilizzato per iterare su una sequenza di valori, come ad esempio una lista, una tupla, una stringa o un dizionario.

La sintassi generale di un ciclo for in Python è la seguente:

for element in sequence:
    # codice da eseguire

Dove element è una variabile temporanea che assume il valore di ciascun elemento della sequenza ad ogni iterazione del ciclo, e sequence è la sequenza di valori su cui iterare.

Durante l’esecuzione del ciclo, il blocco di codice indentato sotto la linea for viene eseguito una volta per ogni elemento della sequenza. Ad ogni iterazione, la variabile elemento assume il valore dell’elemento corrente della sequenza e il codice all’interno del blocco viene eseguito con questo valore.

Il ciclo for è spesso utilizzato per eseguire operazioni su ciascun elemento di una sequenza, come ad esempio la somma degli elementi di una lista o la stampa di ciascun carattere di una stringa. Per esempio

numbers = [0, 1, 2, 3, 4, 5]
for number in numbers: # number is temporary name to refer to the list's items, valid only inside this loop
    print(number)

language = "Python"
for letter in language:
    print(letter)

P
y
t
h
o
n

La funzione range() è spesso usata nei cicli for e permette di impostare un intervallo di esecuzione tanto ampio quanto il numero che le passiamo come parametro meno uno.

La funzione range() prende tre parametri: start (default 0), stop e step (default 1), ovvero un punto di inizio dell’intervallo, un punto di fine e un passo di avanzamento. L’indicizzazione Python parte da 0; quindi range(0, 11, 1) una lista di 11 elementi, da 0 a 10 inclusi.

print(list(range(0, 11, 1)))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Ad esempio, impostiamo un punto di inizio a 3, il punto di fine a 11 e un passo di 2:

print(list(range(3, 12, 2)))

[3, 5, 7, 9, 11]

In un ciclo for, l’intervallo di range() corrisponde al numero di iterazioni che verranno eseguite, ovvero al numero di volte che il ciclo verrà processato. Nel caso seguente, l’indice del ciclo (qui chiamato number) assume il valore 0 la prima volta che il ciclo viene eseguito e il valore 10 nell’ultima esecuzione del ciclo.

for number in range(11):
    print(number)

for number in range(3, 12, 2):
    print(number)

Cicli `for` annidati#

Sono possibili i cicli for annidati, vale a dire un ciclo posto all’interno del corpo di un altro (chiamato ciclo esterno). Al suo primo passo, il ciclo esterno mette in esecuzione quello interno che esegue il proprio blocco di codice fino alla conclusione. Quindi, al secondo passo, il ciclo esterno rimette in esecuzione quello interno. Questo si ripete finché il ciclo esterno non termina. Per esempio:

for i in range(4):
    for j in range(4):
        print((i, j))

(0, 0)
(0, 1)
(0, 2)
(0, 3)
(1, 0)
(1, 1)
(1, 2)
(1, 3)
(2, 0)
(2, 1)
(2, 2)
(2, 3)
(3, 0)
(3, 1)
(3, 2)
(3, 3)

Modificare gli elementi di una lista#

Il ciclo for è il modo più comune per scorrere gli elementi di una lista, come abbiamo visto in precedenza.

for name in name_list:
    print(name)

Maria
Giovanna
Marco
Francesco

Questo approccio può essere usato se abbiamo solo bisogno di leggere gli elementi della lista. Nel ciclo seguente, ad esempio, leggiamo gli elementi d una lista per incrementare una variabile così da calcolare una somma.

numbers = [2, -4, 1, 6, 3]

total = 0
for num in numbers:
    total += num

print(total)

Ma se vogliamo cambiare gli elementi di una lista l’approccio precedente non funziona e dobbiamo usare gli indici. Nell’esempio seguente, questo risultato viene ottenuto utilizzando le funzioni range e len:

numbers = [2, -4, 1, 6, 3]

for i in range(len(numbers)):
    numbers[i] = numbers[i] * 2

print(numbers)

[4, -8, 2, 12, 6]

Nel codice seguente, la funzione len() ritorna 5.

numbers = [2, -4, 1, 6, 3]
len(numbers)

Quindi, range(5) produce la seguente sequenza iterabile:

list(range(5))

[0, 1, 2, 3, 4]

Questi sono gli indici che verranno usati nelle iterazioni del ciclo for.

La prima volta che il ciclo viene eseguito, l’indice i vale 0 e numbers[i] si riferisce al primo elemento della lista;
la seconda volta che il ciclo viene eseguito, i vale 1 e numbers[i] si riferisce al secondo elemento della lista;
e così via.

L’istruzione di assegnazione nel corpo del ciclo for usa i per leggere il valore i-esimo della lista originale (a destra dell’uguale) e per assegnargli un nuovo valore (a sinistra dell’uguale).

List comprehension#

Una list comprehension è un modo conciso di creare una lista. È un modo compatto per creare una nuova lista. Accade speso di dover creare una lista dove ciascun elemento è il risultato di un’operazione condotta sugli elementi di un’altra lista o di un iterabile; oppure, di dover estrarre gli elementi che soddisfano una certa condizione. Per esempio, supponiamo di volere sommare una costante ad una lista di numeri. Usando un ciclo for possiamo procedere nel modo seguente (si noti l’uso della funzione append):

new_list = []
k = 10
for x in range(10):
    new_list.append(x + k)

new_list

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Oppure, in maniera più semplice, possiamo usare una list comprehension:

new_list = [x + k for x in range(10)]
new_list

[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]

Una list comprehension è racchiusa tra parentesi quadre; contiene un’espressione, seguita da una clausola for, seguita da zero o più clausole for o if. La sintassi è la seguente:

[ <expression> for item in iterable <if optional_condition> ]

Il risultato è una nuova lista costruita valutando l’espressione nel contesto delle clausole for e if che la seguono. Una list comprehension combina dunque un ciclo for e (se necessario) una o più condizioni logiche in una singola riga di codice. Esaminiamo una variante dell’esempio precedente.

list1 = [1, 2, 3, 4, 5, 6]
print("list1:", list1)

list1: [1, 2, 3, 4, 5, 6]

list2 = [item + 1 for item in list1]
print("list2:", list2)

list2: [2, 3, 4, 5, 6, 7]

Si noti che la parola item avrebbe potuto essere quasi qualsiasi stringa (in precedenza abbiamo usato x). La possiamo immaginare con la seguente definizione: ...per ogni elemento in .... Nel seguente esempio, sommiamo 1 agli elementi di list1 solo se sono pari:

list3 = [item + 1 for item in list1 if item % 2 == 0] 
print('list3:', list3)

list3: [3, 5, 7]

Facciamo un altro esempio usando range():

num_list = range(50, 60)
[1 + num for num in num_list]

[51, 52, 53, 54, 55, 56, 57, 58, 59, 60]

Qui selezioniamo solo i numeri pari (oltre allo zero):

[i for i in range(11) if i % 2 == 0]

[0, 2, 4, 6, 8, 10]

Specificando una condizione, possiamo cambiare il segno solo dei numeri dispari nella lista:

[-i if i % 2 else i for i in range(11)]

[0, -1, 2, -3, 4, -5, 6, -7, 8, -9, 10]

Possiamo anche eseguire più iterazioni simultaneamente:

[(i, j) for i in range(3) for j in range(4)]

[(0, 0),
 (0, 1),
 (0, 2),
 (0, 3),
 (1, 0),
 (1, 1),
 (1, 2),
 (1, 3),
 (2, 0),
 (2, 1),
 (2, 2),
 (2, 3)]

In questo esempio vengono selezionati solo i nomi inclusi nella lista female_names:

first_names = ["Maria", "Marco", "Francesco", "Giovanna"]
female_names = ["Alice", "Maria", "Giovanna", "Lisa"]
female_list = [name for name in first_names if name in female_names]
print(female_list)

['Maria', 'Giovanna']

Nel seguente esempio vengono estratte le prime tre lettere di ciascuno dei nomi che compongono una lista:

letters = [name[0:3] for name in first_names] 
letters

['Mar', 'Mar', 'Fra', 'Gio']

Per estrarre l’ultimo carattere di una stringa usiamo [-1]:

my_string = "barbablù"
my_string[-1]

'ù'

Possiamo dunque usare seguente list comprehension estrae gli ultimi tre caratteri di ciascun elemento della lista first_names.

letters = [name[-3:] for name in first_names] 
letters

['ria', 'rco', 'sco', 'nna']

È possibile impiegare un’espressione ternaria all’interno di una list comprehension per sfruttare la versatilità dell’istruzione ‘else’ in modo sintatticamente efficace. Ad esempio, possiamo sostituire tutti i numeri dispari di una lista (un un NumPy array) con il valore 99.

num = np.array([4, 7, 2, 6, 3, 9])  # può anche essere una lista Python
[e if e % 2 == 0 else 99 for e in num]

[4, 99, 2, 6, 99, 99]

Librerie e moduli#

Importare moduli#

I moduli (anche conosciuti come librerie in altri linguaggi) sono dei file usati per raggruppare funzioni e altri oggetti. Python include una lista estensiva di moduli standard (anche conosciuti come Standard Library), ma è anche possibile scaricarne o definirne di nuovi. Prima di potere utilizzare le funzioni non presenti nella Standard Library all’interno dei nostri programmi dobbiamo importare dei moduli aggiuntivi, e per fare ciò usiamo il comando import.

L’importazione può riguardare un intero modulo oppure solo uno (o più) dei suoi elementi. Consideriamo per esempio la funzione mean. Essa è disponibile nel modulo numpy. L’istruzione import numpy importa tutto il modulo numpy. Dopo che un modulo è stato importato, è possibile accedere a un suo generico elemento usando il nome del modulo, seguito da un punto e dal nome dell’elemento in questione. Ad esempio, numpy.mean().

Indicare il nome di un modulo per poter accedere ai suoi elementi ha spesso l’effetto di allungare il codice, diminuendone al contempo la leggibilità. È per questo motivo che è possibile importare un modulo specificando un nome alternativo, più corto. È quello che succede quando scriviamo l’istruzione import numpy as np. In questo caso, l’istruzione precedente diventa np.mean().

I moduli più complessi sono organizzati in strutture gerarchiche chiamate package. La seguente cella importa il modulo pyplot che è contenuto nel package matplotlib (matplotlib è la libreria di riferimento in Python per la creazione di grafici).

import matplotlib.pyplot as plt

Qui di seguito sono descritte tutte le possibilità:

# import everything from library
import random
# call function by
random.random()

0.8276798945954928

#import everything, but change name
import random as rnd
# call function by
rnd.random()

0.44867236987906334

# select what to import from library
from random import random
#call function by
random()

0.8841713742867969

# import everything from library
from random import *
# call function by
random()

0.1387220122450915

Nella cella seguente importiamo seaborn con il nome sns e usiamo le sue funzionalità per impostare uno stile e una palette di colori per la visualizzazione dei grafici.

import seaborn as sns
sns.set_theme()
sns.set_palette("colorblind")

Nell’esempio seguente calcoliamo la somma degli elementi della lista numerica primes usando funzione sum() contenuta nella libreria NumPy che abbiamo importato con il nome di np:

import numpy as np

primes = [1, 2, 3, 5, 7, 11, 13]
np.sum(primes)

Calcolo la media di primes:

np.mean(primes)

6.0

Scriviamo una nuova funzione per la media, \(\bar{x} = n^{-1}\sum_{i=1}^n x_i\):

def my_mean(x):
    res = np.sum(x) / len(x)
    return res

my_mean(primes)

6.0

Si noti che, nel corpo di una funzione, è possibile usare altre funzioni: qui, np.sum() e len().

È sempre possibile usare la funzione di help su una funzione:

help(sum)

Help on built-in function sum in module builtins:

sum(iterable, /, start=0)
    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
    
    When the iterable is empty, return the start value.
    This function is intended specifically for use with numeric values and may
    reject non-numeric types.

In Visual Studio Code è sufficiente posizionare il cursore sul nome della funzione.

Formattazione del codice#

%load_ext watermark
%watermark -n -u -v -iv -w -m

Last updated: Mon Jan 29 2024

Python implementation: CPython
Python version       : 3.11.7
IPython version      : 8.19.0

Compiler    : Clang 16.0.6 
OS          : Darwin
Release     : 23.3.0
Machine     : x86_64
Processor   : i386
CPU cores   : 8
Architecture: 64bit

pandas    : 2.1.4
matplotlib: 3.8.2
numpy     : 1.26.2
arviz     : 0.17.0
seaborn   : 0.13.0

Watermark: 2.4.3