A volte può essere utile conoscere la posizione di un indirizzo IP, sia che si tratti del tuo, sia di quello di un sito web che stai utilizzando.

Un possibile caso d'uso è quando vuoi inviare informazioni di accesso agli utenti del tuo sito.

In questo articolo vedremo come puoi ottenere la posizione di un indirizzo IP utilizzando Python.

Prepara gli strumenti

Per raggiungere questo obiettivo, useremo due API:

1. ipify: questa API ci aiuterà a conoscere l'indirizzo IP da cui proviene la richiesta.
2. ipapi: questa API ci fornirà informazioni sulla posizione di un determinato indirizzo IP.

Per interagire con queste API useremo la libreria  requests di Python. Se non hai familiarità con le API, assicurati di consultare questo articolo per saperne di più.

Puoi installare questa libreria usando il comando pip in questo modo:

$ pip install requests

Una volta installata la libreria, siamo pronti a partire!

Ottenere informazioni sulla posizione

Come discusso, per prima cosa otterremo il nostro indirizzo IP tramite la prima API. Poi utilizzeremo questo indirizzo IP per ricavare informazioni geografiche tramite la seconda API. Avremo quindi due funzioni:

import requests


def get_ip():
    response = requests.get('https://api64.ipify.org?format=json').json()
    return response["ip"]


def get_location():
    ip_address = get_ip()
    response = requests.get(f'https://ipapi.co/{ip_address}/json/').json()
    location_data = {
        "ip": ip_address,
        "city": response.get("city"),
        "region": response.get("region"),
        "country": response.get("country_name")
    }
    return location_data


print(get_location())

Nel codice qui sopra, abbiamo due funzioni – get_ip() e get_location(). Vediamole separatamente.

Funzione get_ip()

Secondo la documentazione dell'API ipify, dobbiamo effettuare una richiesta GET a https://api.ipify.org?format=json per ottenere una risposta JSON simile a questa:

{
  "ip": "117.214.109.137"
}

Salviamo questa risposta in una variabile response che è un dizionario Python contenente una sola coppia chiave-valore. Quindi restituiamo il valore della chiave ip usando response["ip"].

Funzione get_location()

Secondo la documentazione di ipapi, dobbiamo effettuare una richiesta GET a https://ipapi.co/{ip}/{format}/ per ottenere le informazioni sulla posizione per un particolare indirizzo IP. {ip} viene sostituito dall'indirizzo IP e {format} può essere sostituito con uno dei seguenti formati: json, jsonp, xml, csv, yaml.

Questa funzione chiama internamente la funzione get_ip() per ottenere l'indirizzo IP e poi effettua una richiesta GET all'URL con l'indirizzo IP. Questa API restituisce una risposta JSON simile a questa:

{
    "ip": "117.214.109.137",
    "version": "IPv4",
    "city": "Gaya",
    "region": "Bihar",
    "region_code": "BR",
    "country": "IN",
    "country_name": "India",
    "country_code": "IN",
    "country_code_iso3": "IND",
    "country_capital": "New Delhi",
    "country_tld": ".in",
    "continent_code": "AS",
    "in_eu": false,
    "postal": "823002",
    "latitude": 24.7935,
    "longitude": 85.012,
    "timezone": "Asia/Kolkata",
    "utc_offset": "+0530",
    "country_calling_code": "+91",
    "currency": "INR",
    "currency_name": "Rupee",
    "languages": "en-IN,hi,bn,te,mr,ta,ur,gu,kn,ml,or,pa,as,bh,sat,ks,ne,sd,kok,doi,mni,sit,sa,fr,lus,inc",
    "country_area": 3287590,
    "country_population": 1352617328,
    "asn": "AS9829",
    "org": "National Internet Backbone"
}

La risposta contiene molte informazioni. Puoi scegliere quelle che ti servono. Per questo tutorial, utilizzeremo solo city, region e country. Per questo abbiamo creato un dizionario chiamato location_data, nel quale abbiamo raccolto questi dati e lo abbiamo restituito come risultato.

Infine, chiamiamo la funzione get_location() e stampiamo il risultato. L'output sarà simile a questo:

{
  "ip": "117.214.109.137", 
  "city": "Gaya", 
  "region": "Bihar", 
  "country": "India"
}

Conclusione

In questo articolo, abbiamo imparato come interagire con i servizi web per ottenere informazioni sulla posizione per un particolare indirizzo IP.

Grazie per aver letto questo articolo!

Di recente, il mio manager mi ha incaricato di creare un report automatico. Ho progettato il report affinché fosse semplice. Includeva un po' di numeri da un database e alcune operazioni matematiche basilari. Ero entusiasta di poter finalmente mettere in mostra in azienda le mie incredibili abilità con Python.

Ho completato e consegnato il prodotto. Tutto andava alla grande. O almeno, fino a due settimane più tardi. Il mio report ha cominciato a fallire improvvisamente a causa di un errore di divisione per zero. È il momento di far partire la risata registrata.

La mia breve storia non è particolarmente dettagliata, ma dovrebbe enfatizzare l'importanza di gestire casi limite ed errori quando si scrivono programmi. Questo report sarebbe dovuto essere un'opportunità per mettere in mostra la mia competenza in Python, invece, ne è risultata una figuraccia piuttosto imbarazzante.

Perciò, prendiamoci un momento per imparare le basi della gestione degli errori utilizzando la libreria standard di Python. Metterò in evidenza alcune delle cose di cui hai bisogno per iniziare.

Prima di iniziare a gestire eccezioni, dovresti avere una buona comprensione dei fondamenti di Python. Avrai bisogno di sapere perché le eccezioni vengono generate per poterle trattare!

Ecco cosa tratteremo:

1. Istruzioni try ed except in Python
2. Esecuzione condizionale con la clausola else
3. Eccezioni predefinite
4. Eccezioni personalizzate
5. Considerazioni sulle prestazioni

Istruzioni try ed except in Python

Le istruzioni try ed except sono i metodi principali per trattare le eccezioni. Ecco un esempio:

x = 0
try:
    print(5 / x)
except ZeroDivisionError:
    print("Qualcosa è andato storto")

# Qualcosa è andato storto

Rivediamo il codice qui sopra per essere sulla stessa lunghezza d'onda:

1. La riga 1 assegna il valore 0 alla variabile x
2. Le righe 2 e 3 aprono una clausola try e tentano di dividere 5 per la variabile x
3. Le righe 4 e 5 aprono una clausola except per qualsiasi errore di divisione per zero (ZeroDivisionError) e istruiscono il programma a stampare un messaggio qualora si tentasse di dividere per 0

Probabilmente avrai notato il problema: la variabile x ha valore 0, e sto cercando di dividere 5 per x . Neppure i migliori matematici del mondo sono in grado di dividere per 0, e nemmeno Python può farlo. Quindi, che succede?

Se non ci occupassimo dell'errore, il programma terminerebbe immediatamente, non appena cercasse di dividere 5 per x. Dato che i programmi non sanno cosa fare con le eccezioni senza istruzioni esplicite, abbiamo creato la clausola except nella riga 4 e fornito al programma i passi da seguire in caso di divisione per 0.

Questa è l'intera idea dietro la gestione delle eccezioni: occorre dire al programma cosa fare quando si verifica un errore che non può semplicemente ignorare. Vediamo come funzionano le clausole try ed except.

Analisi dell'istruzione try

Le clausole try ed except seguono un modello che ti permette di gestire in modo affidabile i problemi nel tuo codice. Vediamo come funziona.

Il primo passo è tentare l'esecuzione del codice nella clausola try.

Dopodiché, abbiamo tre possibilità:

Nessun errore nella clausola try

Se il codice nella clausola try viene eseguito senza nessun errore, il programma:

1. Esegue la clausola try
2. Salta tutte le clausole except
3. Prosegue con la sua normale esecuzione

x = 1
try:
    print(5 / x)
except ZeroDivisionError:
    print("Qualcosa è andato storto")

print("Sto eseguendo dopo la clausola try!")

# 5.0
# Sto eseguendo dopo la clausola try!

In questo esempio modificato, puoi vedere che non ci sono problemi nella clausola try (righe 3 e 4). Il codice verrà eseguito, la clausola except verrà saltata e il programma riprenderà l'esecuzione dopo la terminazione delle istruzioni try ed except.

Errori nella clausola try e l'eccezione è specificata

Se il codice nella clausola try genera un'eccezione e il tipo di eccezione viene specificato dopo qualsiasi parola chiave con except , il programma:

1. Salta il codice rimanente nella clausola try
2. Esegue il codice nella clausola except corrispondente
3. Prosegue con la sua normale esecuzione

x = 0
try:
    print(5 / x)
except ZeroDivisionError:
    print("Qualcosa è andato storto")

print("Sto eseguendo dopo la clausola try!")

# Qualcosa è andato storto
# Sto eseguendo dopo la clausola try!

Tornando al mio primo esempio, ho cambiato la nostra variabile x di nuovo al valore 0 e ho provato a dividere 5 per x. Ciò produce un  errore di divisione per zero (ZeroDivisionError). Dato che l'istruzione except specifica questo tipo di eccezione, il codice in quella clausola viene eseguito prima che il programma riprenda la sua normale esecuzione.

Errori nella clausola Try e l'Eccezione NON è Specificata

Infine, se il programma genera un'eccezione nella clausola try, ma l'eccezione non viene specificata in nessuna istruzione except, allora il programma:

1. Interrompe l'esecuzione del programma e dà errore

x = 0
try:
    print(5 / y)
except:
    print("Qualcosa è andato storto")

print("Sto eseguendo dopo la clausola try!")

# NameError: name 'y' is not defined (il nome 'y' non è definito)

Nell'esempio precedente, sto cercando di dividere 5 per la variabile y, che non esiste. Questo genera un errore di nome (NameError). Non abbiamo specificato al programma come gestire i NameError, perciò l'unica opzione è quella di terminare.

Pulizia

try ed except sono gli strumenti principali della gestione degli errori, ma esiste anche una clausola opzionale che puoi usare, chiamata finally. La clausola finally verrà sempre eseguita, che ci sia un errore o meno.

x = 0
try:
    print(5 / x)
except ZeroDivisionError:
    print("Sono la clausola except!")
finally:
    print("Sono la clausola finally!")

print("Sto eseguendo dopo la clausola try!")

# Sono la clausola except!
# Sono la clausola finally!
# Sto eseguendo dopo la clausola try!

In questo esempio, ho creato il nostro amato ZeroDivisionError. Puoi vedere che l'ordine di esecuzione è:

1. La clausola except
2. La clausola finally
3. Qualsiasi codice successivo

Una volta che correggiamo il codice nella clausola try in modo che non generi più errori, vedrai comunque un ordine di esecuzione simile. Al posto della clausola except, verrà eseguita la clausola try.

x = 1
try:
    print(5 / x)
except ZeroDivisionError:
    print("Sono la clausola except!")
finally:
    print("Sono la clausola finally!")

print("Sto eseguendo dopo la clausola try!")

# 5.0
# Sono la clausola finally!
# Sto eseguendo dopo la clausola try!

Noterai che l'unica differenza è che la clausola try viene eseguita con successo perché non vengono generate eccezioni. La clausola finally e il codice successivo vengono eseguiti come previsto.

Questo è utile in alcuni casi in cui vuoi dare una "ripulita" indipendentemente dall'esito delle clausole try e except. Azioni come chiudere connessioni, chiudere file e fare logging sono ottimi candidati per la clausola finally.

Esecuzione condizionale con la clausola else

Un'altra clausola opzionale è la clausola else. La clausola else è semplice: se il codice nella clausola try viene eseguito senza generare errori, allora anche il codice nella clausola else verrà eseguito.

x = 1
try:
    print(5 / x)
except ZeroDivisionError:
    print("Sono la clausola except!")
else:
    print("Sono la clausola else!")
finally:
    print("Sono la clausola finally!")

print("Sto eseguendo dopo la clausola try!")

# 5.0
# Sono la clausola else!
# Sono la clausola finally!
# Sto eseguendo dopo la clausola try!

L'ordine di esecuzione per questo esempio è:

1. La clausola try
2. La clausola else
3. La clausola finally
4. Qualsiasi codice dopo

Se dovessimo incontrare un'eccezione o un errore nella clausola try, la clausola else verrebbe ignorata.

x = 0
try:
    print(5 / x)
except ZeroDivisionError:
    print("Sono la clausola except!")
else:
    print("Sono la clausola else!")
finally:
    print("Sono la clausola finally!")

print("Sto eseguendo dopo la clausola try!")

# Sono la clausola except!
# Sono la clausola finally!
# Sto eseguendo dopo la clausola try!

Eccezioni predefinite

Mi hai visto scrivere a proposito di due diversi errori finora: NameError e ZeroDivisionError. Ma se avessimo bisogno di altre eccezioni?

Esiste un'intera lista di eccezioni predefinite in Python che fanno parte della libreria standard. Probabilmente coprono quasi tutte le necessità che potresti avere nella gestione di errori ed eccezioni.

Ecco solo alcune che potrebbero essere importanti:

• KeyError – Una chiave non viene trovata in un dizionario
• IndexError – L'indice è fuori dai limiti stabiliti di un oggetto iterabile
• TypeError – Una funzione o un'operazione è stata usata su un tipo di oggetto sbagliato
• OSError – Errori generali del sistema operativo

Ce ne sono molte altre, che puoi trovare nella documentazione di Python. Consiglio di darci un'occhiata. Non solo diventerai più bravo a gestire gli errori, ma esplorerai anche cosa può effettivamente andare storto nei i tuoi programmi Python.

Eccezioni personalizzate

Se hai bisogno di funzionalità estese, puoi anche definire delle eccezioni personalizzate.

class ForError(Exception):
    def __init__(self, message):
        self.message = message

    def foo(self):
        print("bar")

Nell'esempio sopra, ho creato una nuova classe e l'ho estesa dalla classe Exception. Ora posso scrivere una funzionalità personalizzata e trattare questa eccezione come qualsiasi altro oggetto.

try:
    raise FooError("Questo è un errore di test")
except FooError as e:
    e.foo()

# bar

Qui ho generato di proposito il mio nuovo FooError. Ho catturato FooError e gli assegno l'alias e. Ora posso accedere al mio metodo foo() che ho costruito nella classe che ho creato.

Questo apre un mondo di possibilità quando si ha a che fare con gli errori. Log personalizzati, tracciamenti più dettagliati, o qualsiasi altra cosa di cui hai bisogno, tutto può essere codificato e creato.

Considerazioni sulle prestazioni

Ora che conosci le basi di try, except e degli oggetti eccezione, puoi cominciare a considerare di usarli nel tuo codice per gestire gli errori in modo elegante. Ma ci sono impatti significativi sulle prestazioni del codice?

La risposta breve è no. Con il rilascio di Python 3.11, non c'è praticamente nessuna riduzione di velocità nell'uso delle istruzioni try ed except quando non vengono sollevate eccezioni.

La cattura degli errori ha causato effettivamente qualche rallentamento. Ma in generale, è meglio catturare questi errori piuttosto che far crashare l'intero programma.

Nelle versioni precedenti di Python, usare le clausole try ed except causava del tempo di esecuzione aggiuntivo. Tieni presente questo dettaglio se non hai la versione aggiornata.

Ricapitolando

Grazie per aver letto fino a qui. Il futuro te e i tuoi futuri clienti ti ringrazieranno per la gestione degli errori.

Abbiamo esaminato le clausole try, except, else, e finally, il loro ordine di esecuzione e in quali circostanze vengono eseguite. Abbiamo anche visto le basi per creare eccezioni personalizzate.

La cosa più importante da ricordare è che le clausole try ed except sono i modi principali per gestire gli errori e dovresti usarle ogni volta che hai del codice rischioso e che potrebbe generare degli errori.

Inoltre, tieni a mente che la cattura degli errori renderà il tuo codice più resiliente e ti farà sembrare un programmatore decisamente migliore.

Quando stai programmando in Python, puoi utilizzare la funzione enumerate() e un ciclo for per visualizzare ciascun valore di un iterabile con una variabile contatore.

In questo articolo, ti mostrerò come usare la funzione enumerate() di Python con un ciclo for e ti spiegherò perché è una funzione migliore rispetto a creare un tuo contatore incrementale.

Prima però diamo un'occhiata a come farlo senza la funzione enumerate().

Come usare un ciclo for senza la funzione enumerate() in Python

In Python, un iterabile è un oggetto su cui è possibile iterare per restituire un valore alla volta. Tra gli esempi di iterabili sono compresi liste, tuple e stringhe.

In questo esempio, abbiamo una lista di nomi di cani ed una variabile chiamata count.

dogs = ['Harley', 'Phantom', 'Lucky', 'Dingo']
count = 1

Possiamo usare un ciclo for per attraversare la lista e stampare ciascun nome. Inoltre, incrementeremo la variabile count di 1 ogni volta per tenere traccia di quante volte abbiamo iterato sulla lista.

for name in dogs:
    print(count, name)
    count += 1

Di seguito il risultato stampato sullo schermo:

Anche se questo approccio funziona, presenta un possibile errore.

Un errore comune potrebbe essere quello di dimenticare di incrementare la variabile count.

Se modifico il codice, otteniamo:

dogs = ['Harley', 'Phantom', 'Lucky', 'Dingo']
count = 1
for name in dogs:
    print(count, name)

Ora la variabile count non tiene traccia più accuratamente del numero di iterazioni del ciclo sulla lista.

Invece di far incrementare un variabile count, possiamo usare la funzione enumerate() con il ciclo for.

Che cosa è la funzione enumerate() in Python?

La funzione integrata di Python enumerate() prende un iterabile come input e un argomento opzionale di inizio.

enumerate(iterabile, argomento opzionale di inizio)

Se ometti l'argomento opzionale di inizio, il contatore viene impostato a zero.

Il valore restituito dalla funzione enumerate() è un oggetto.

Questa funzione tiene traccia delle iterazioni eseguite così che tu non ti debba ricordare di aggiornare la variabile count .

Possiamo usare la funzione enumerate() con un ciclo for per visualizzare il valore di un iterabile con un contatore.

Come usare un ciclo for con la funzione enumerate() in Python

In questo esempio, vogliamo visualizzare la lista delle indicazioni stradali per andare da Times Square alla Juilliard School of Music a New York.

Come prima cosa dobbiamo creare la lista delle indicazioni, denominata directions:

directions = [
    'Head north on Broadway toward W 48th St',
    'Turn left onto W 58th St',
    'Turn right onto 8th Ave',
    'Turn left onto Broadway',
    'Turn left onto Lincoln Center Plaza',
    'Turn right onto Jaffe Dr',
    'Turn left onto Broadway',
    'Turn left onto W 65th St'
]

Quindi, nel ciclo for, creiamo le variabili count e direction che ci permetteranno di eseguire l'iterazione.

La funzione enumerate() prenderà come argomenti di input la lista  directions e la variabile start. Vogliamo iniziare il conteggio da 1 invece che da 0 (come impostato di default).

for count, direction in enumerate(directions, start=1):

All'interno del ciclo, stamperemo le variabili count e direction.

print(count, direction)

Ecco il codice completo:

directions = [
    'Head north on Broadway toward W 48th St',
    'Turn left onto W 58th St',
    'Turn right onto 8th Ave',
    'Turn left onto Broadway',
    'Turn left onto Lincoln Center Plaza',
    'Turn right onto Jaffe Dr',
    'Turn left onto Broadway',
    'Turn left onto W 65th St'
]

for count, direction in enumerate(directions, start=1):
    print(count, direction)

E il risultato nella console:

Come puoi vedere la variabile count  è stata automaticamente aggiornata dalla funzione enumerate().

In questo modo si rimuove la possibilità di errori se dimentichiamo di incrementare la variabile count.

Conclusioni

Puoi utilizzare la funzione enumerate() ed il ciclo for per visualizzare ciascun valore di un iterabile con un contatore.

La funzione enumerate() prende come input un iterabile e un argomento opzionale di inizio.

enumerate(iterabile, argomento opzionale di inizio)

Se l'argomento opzionale di inizio viene omesso, il conteggio viene inizializzato a zero.

L'uso della funzione enumerate() è un'alternativa migliore rispetto a creare un proprio contatore incrementale in un ciclo for.

La funzione enumerate() aggiorna automaticamente il conteggio e pertanto elimina la possibilità che si possa dimenticare di incrementare il contatore.

Spero che questo articolo ti sia piaciuto e buona fortuna per il tuo viaggio nel mondo di Python.

Ci saranno volte in cui avrai bisogno di convertire un tipo di dato in un altro.

Non temere, poiché  Python offre diversi modi per svolgere questa operazione.

In questo articolo, vedremo alcuni dei modi per convertire una stringa in una lista.

Tratteremo i seguenti argomenti:

1. Una panoramica su stringhe e liste
   1. Come verificare il tipo di dato di un oggetto
2. Convertire una stringa in una lista di singoli caratteri
3. Convertire una stringa in una lista di parole
   1. Analisi della sintassi del metodo split()
   2. Utilizzare split() con un separatore
   3. Utilizzare split() con il parametro maxsplit
4. Convertire una stringa di numeri in una lista di numeri

Cosa sono le stringhe e le liste in Python?

Una stringa è una sequenza ordinata di caratteri. È una serie di caratteri, in cui un carattere segue l'altro.

Una stringa è racchiusa tra virgolette singole o doppie:

# le seguenti sono tutte stringhe

# una stringa compresa tra virgolette singole
first_name = 'John'

# una stringa compresa tra virgolette doppie
last_name = "Doe"

Se desideri creare una stringa che si estende su più righe - una cosiddetta stringa multiriga - devi racchiuderla utilizzando le virgolette triple:

# una stringa multiriga compresa tra virgolette triple

phrase = '''Sto studiando Python
e mi piace molto imparare questo linguaggio!
'''

Le stringhe sono immutabili. Questo significa che una volta create, non possono essere modificate. I singoli caratteri che costituiscono una stringa non possono essere alterati.

Per esempio, se cercassi di cambiare la prima lettera di una parola da minuscola a maiuscola, otterresti un errore:

# prova a cambiare 'p' minuscola in 'P' maiuscola
fave_language = "python"
fave_language[0] = "P"

print(fave_language)

# il risultato sarà un messaggio di errore
#fave_language[0] = "P"
#TypeError: 'str' object does not support item assignment

Tuttavia, puoi riassegnare una stringa diversa aggiornando la variabile in questo modo:

fave_language = "python"
fave_language = "Python"

print(fave_language)

#risultato
#Python

Una lista è una collezione ordinata di dati.

Più elementi (in genere correlati) sono memorizzati insieme nella stessa variabile.

È possibile creare una lista racchiudendo zero o più elementi tra parentesi quadre, [], ognuno separato da una virgola.

Una lista può contenere qualsiasi tipo di dato integrato in Python.

# una lista di numeri
my_numbers_list = [10,20,30,40,50]

print(my_numbers_list)

# risultato
# [10, 20, 30, 40, 50]

Le liste sono mutabili.

Puoi modificare gli elementi di una lista dopo che è stata creata. Ciò significa che puoi modificare gli elementi esistenti, aggiungerne di nuovi o eliminarli in qualsiasi momento durante la vita del programma.

programming_languages = ["Javascript", "Python", "Java"]

#cambia il primo elemento della lista
programming_languages[0] = "JavaScript"

print(programming_languages)

#risultato
#['JavaScript', 'Python', 'Java']

Come determinare il tipo di dato di un oggetto in Python

Per trovare il tipo di dato di un oggetto in Python, puoi utilizzare la funzione incorporata type(), che ha la seguente sintassi:

type(object)

#object è l'oggetto di cui devi trovare il tipo di dato

La funzione type() restituisce il tipo dell'oggetto passato come argomento alla funzione.

Questa funzione è di solito utilizzata per il debug.

Vediamo come usare la funzione type() con stringhe e liste nel prossimo esempio:

my_name = "John Doe"
my_lucky_numbers = [7,14,33]

print(type(my_name))
print(type(my_lucky_numbers))

#risultato
#<class 'str'>
#<class 'list'>

Come convertire una stringa in una lista di singoli caratteri

Puoi prendere una parola e trasformarla in una lista.

Ogni singolo carattere che compone la parola diventa un elemento individuale e separato all'interno della lista.

Per esempio, prendiamo la parola "Python".

Puoi convertirla in una lista di caratteri, dove ogni elemento della lista corrisponde ad uno dei caratteri che costituisce la stringa "Python".

Ciò significa che il carattere P sarebbe un elemento della lista, il carattere  y sarebbe un altro elemento della lista, il carattere t sarebbe un ulteriore elemento e così via.

Il modo più semplice consiste nel trasformare la stringa in una lista, metodo noto come typecasting (conversione di tipo).

Il typecasting permette di convertire direttamente un tipo di dato in un altro – in questo caso dal tipo di dato denominato 'stringa' al tipo di dato chiamato 'lista'.

Puoi fare ciò utilizzando la funzione incorporata list(), passando la stringa data come argomento della funzione.

programming_language = "Python"

programming_language_list = list(programming_language)

print(programming_language_list)

#risultato
#['P', 'y', 't', 'h', 'o', 'n']

Vediamo un altro esempio:

current_routine = " Learning Python ! "

current_routine_list = list(current_routine)

print(current_routine_list)

#risultato
#[' ', 'L', 'e', 'a', 'r', 'n', 'i', 'n', 'g', ' ', 'P', 'y', 't', 'h', 'o', 'n', ' ', '!', ' ']

Il testo " Learning Python ! " ha spazi vuoti sia all'inizio che alla fine (tra le doppie virgolette e Learning, tra il punto esclamativo e le doppie virgolette), spazi vuoti tra le parole "Learning" e "Python" e spazi vuoti tra la parola "Python" e il punto esclamativo.

Quando la stringa viene convertita in una lista di caratteri, ogni spazio vuoto viene trattato come un singolo carattere ed è per questo che si vedono gli spazi vuoti tra virgolette singole ( ' ') come elementi della lista.

Per rimuovere gli spazi vuoti solo dall'inizio e dalla fine della stringa, puoi utilizzare il metodo strip() .

current_routine = " Learning Python ! "

#gli spazi vuoti all'inizio e alla fine non saranno più elementi facenti parte della lista 

current_routine_list = list(current_routine.strip())

print(current_routine_list)

#risultato
#['L', 'e', 'a', 'r', 'n', 'i', 'n', 'g', ' ', 'P', 'y', 't', 'h', 'o', 'n', ' ', '!']

Per rimuovere tutti gli spazi vuoti, e non solo quelli iniziali e finali, e fare in modo che nessun carattere di spazio vuoto sia compreso nella nuova lista, puoi utilizzare invece il metodo replace():

current_routine = " Learning Python ! "

#sostituisce ogni spazio vuoto con nessuno spazio
current_routine_list = list(current_routine.replace(" ", ""))

print(current_routine_list)

#risultato
#['L', 'e', 'a', 'r', 'n', 'i', 'n', 'g', 'P', 'y', 't', 'h', 'o', 'n', '!']

Come convertire una stringa in una lista di parole

Il metodo split() è un altro modo per convertire una stringa in una lista.

Il metodo split() divide una stringa in una lista, dove ogni elemento della lista corrisponde ad una rispettiva parola che compone la stringa.

Ogni parola sarà un singolo elemento della lista.

Analisi del metodo split() in Python

La sintassi generale del metodo split() è la seguente:

string.split(separator=None, maxsplit=-1)

Vediamo come è strutturata:

• string è la stringa che si vuole trasformare in una lista.
• Il metodo split() trasforma una stringa in una lista. Accetta due parametri opzionali.
• separator è il primo parametro opzionale e definisce il punto in cui la stringa sarà divisa. Per impostazione predefinita, il separatore è uno spazio vuoto e la stringa verrà divisa ovunque ci sia uno spazio vuoto.
• maxsplit è il secondo parametro opzionale. Specifica il numero massimo di divisioni da eseguire. Il valore predefinito, -1, significa che la stringa viene suddivisa in tutta la sua lunghezza e non ci sono limiti alla suddivisione.

Vediamo un esempio di come funziona.

phrase = "I am learning Python !"

print(type(phrase))

#risultato
#<class 'str'>

Nella stringa sopra, ogni parola che la compone è separata da uno spazio vuoto.

Puoi utilizzare il metodo split() per trasformare questa stringa in una lista di parole.

Non è necessario che specifichi un separatore o un parametro maxsplit, poiché vogliamo separare tutte le parole ovunque ci siano spazi vuoti tra di esse.

phrase = "I am learning Python !"

phrase_to_list = phrase.split()

print(phrase_to_list)
print(type(phrase_to_list))


#risultato
#['I', 'am', 'learning', 'Python', '!']
#<class 'list'>

La stringa è stata suddivisa in base a dove c'erano spazi vuoti e ogni parola che la costituiva è stata trasformata in un singolo elemento della lista.

Come utilizzare il metodo split() con un separatore

Puoi anche convertire una stringa in una lista utilizzando un separatore con il metodo split(). Il separatore può essere un qualsiasi carattere da te scelto.

La stringa verrà divisa in base al separatore da te dato.

Ad esempio, puoi usare una virgola, ,, come separatore.

La stringa si trasformerà in una lista ogni volta che c'è una virgola, partendo da sinistra.

Gli elementi separati da una virgola saranno i singoli elementi della lista.

Prendiamo la stringa seguente:

phrase = "Hello world,I am learning Python!"

Una virgola separa Hello world da I am learning Python!.

Se desideriamo usare la virgola come separatore per creare due singoli elementi della lista, procederemo come segue:

phrase = "Hello world,I am learning Python!"

phrase_to_list = phrase.split(",")

print(phrase_to_list)

#risultato
#['Hello world', 'I am learning Python!']

Due elementi separati sono stati creati come elementi della lista e la divisione è avvenuta dove c'era la virgola.

Un altro esempio potrebbe essere quello di separare un nome di dominio, ogni volta che c'è un punto, ..

domain_name = "www.freecodecamp.org"

domain_name_list = domain_name.split(".")

print(domain_name_list)

#risultato
#['www', 'freecodecamp', 'org']

Ogni volta che c'è un punto, un nuovo elemento sarà aggiunto alla lista.

Come usare il metodo split() con il parametro maxsplit

Come menzionato in precedenza, maxsplit è un parametro opzionale del metodo split().

Definisce quanti elementi della lista verranno divisi e trasformati in singoli elementi della lista. Di default, il parametro maxsplit è impostato a -1. Ciò significa che tutti gli elementi che compongono la stringa saranno divisi.

Ma possiamo cambiare il valore con un numero specifico.

Per dividere la stringa soltanto due volte, modifichiamo maxsplit a 2:

current_routine = "I enjoy learning Python everyday"

current_routine_list = current_routine.split(maxsplit=2)

print(current_routine_list)

#risultato
#['I', 'enjoy', 'learning Python everyday']

maxsplit è impostato a 2, il che significa che massimo due parole saranno divise da uno spazio e costituiranno due singoli elementi della lista. Il terzo elemento della lista sarà costituito dal resto delle parole che compongono la stringa iniziale.

Utilizzando un altro esempio della sezione precedente, puoi combinare un separatore con maxsplit per eseguire una conversione mirata di una stringa in un elenco:

domain_name = "www.freecodecamp.org"

domain_name_list = domain_name.split(".", maxsplit=1)

print(domain_name_list)

#risultato
#['www', 'freecodecamp.org']

In questo esempio, il separatore era un punto e solo il primo elemento è stato separato.

Come convertire una stringa di numeri interi in una lista di numeri interi

I numeri sono considerati stringhe quando sono racchiusi tra virgolette singole o doppie.

Supponiamo che la tua data di nascita sia memorizzata come una stringa, come di seguito:

birthdate = "19/10/1993"

print(type(birthdate))

#risultato
#<class 'str'>

Per rimuovere le barre e memorizzare i numeri associati alla data, al mese e all'anno di nascita come elementi separati della lista, puoi procedere così:

birthdate = "19/10/1993"

birthdate_list = birthdate.split("/")

print(birthdate_list)
print(type(birthdate_list))

#risultato
#['19', '10', '1993']
#<class 'list'>

Nell'esempio qui sopra il separatore era la barra, /, e un nuovo elemento della lista è stato creato in ogni punto in cui c'era una barra.

Se osservi attentamente il risultato, vedrai che gli elementi della lista sono ancora stringhe: sono racchiusi da virgolette singole e non è stata effettuata alcuna conversione di tipo.

Per convertire ogni elemento della lista da una stringa a un numero intero, puoi usare la funzione map.

La funzione map prende due argomenti:

• Una funzione. In questo caso la funzione sarà la funzione int.
• Un iterabile, ovvero una sequenza o una collezione di elementi. In questo caso, l'iterabile è la lista da noi creata.

birthdate = "19/10/1993"

birthdate_list = birthdate.split("/")

str_to_int = (map(int, birthdate_list))

print(str_to_int)

#risultato
#<map object at 0x10e289960>

Questo non è esattamente il risultato che volevamo. Quando controlliamo il tipo di dato, vediamo che non abbiamo più una lista:

print(type(str_to_int))

#risultato
#<class 'map'>

Per correggere questo problema, dobbiamo tornare indietro e aggiungere la funzione list() prima della conversione:

birthdate = "19/10/1993"

birthdate_list = birthdate.split("/")

str_to_int = list(map(int, birthdate_list))

print(type(str_to_int))
print(str_to_int)

#risultato
#<class 'list'>
#[19, 10, 1993]

Conclusioni

Ed ecco fatto! Ora conosci alcuni dei modi per trasformare una stringa in una lista in Python.

Per saperne di più sul linguaggio di programmazione Python, dai un'occhiata alla certificazione di freeCodeCamp Scientific Computing with Python Certification.

È un corso adatto anche ai principianti, ti permetterà di partire dalle basi ed imparare in modo facile ed interattivo. Inoltre, avrai modo di realizzare cinque progetti per mettere in pratica e rafforzare quanto imparato.

Grazie per il tempo dedicato alla lettura e buona programmazione!

Alcuni mesi fa, ho deciso di rilasciare Caer, un pacchetto (package) per la visione artificiale (computer vision) disponibile in Python. Ho trovato l'intero processo estremamente complicato e frustrante. Probabilmente puoi immaginarne il motivo: documentazione scarsa (e confusa), mancanza di buoni tutorial, e così via.

Ho così deciso di scrivere questo articolo nella speranza di aiutare chi sta affrontando le stesse difficoltà nel creare un package in Python. Realizzeremo un modulo molto semplice e lo renderemo disponibile a chiunque in tutto il mondo.  

Il contenuto di questo modulo segue una struttura molto basilare. In totale sono riportati quattro file Python, ciascuno dei quali contiene un singolo metodo. Per questo tutorial adottiamo appositamente uno schema molto semplice.

base-verysimplemodule  --> Cartella base
└── verysimplemodule   --> Modulo effettivo
    ├── extras
    │   ├── multiply.py
    │   ├── divide.py
    ├── add.py
    ├── subtract.py

Puoi notare che abbiamo una cartella chiamata  verysimplemodule, la quale, a sua volta, contiene i due file Python add.py e subtract.py. C'è anche una sottocartella chiamata extras (che contiene i file multiply.py e divide.py). La cartella verysimplemodule costituirà la base del nostro modulo Python.

Creare i file __ init __.py

Una cosa che si trova sempre in qualsiasi package di Python è un file  __init__.py. Questo file comunica a Python di considerare le cartelle come moduli (o sotto-moduli).

Molto semplicemente, questo file conserva i nomi di tutti i metodi contenuti in tutti i file Python che si trovano nella sua stessa cartella.

Un tipico file __init__.py ha il seguente formato:

from file import method 

# 'method' è un funzione presente nel file denominato 'file.py'

Per creare un package in Python, occorre aggiungere un file __init__.py  in ogni sottocartella del tuo package. Queste sottocartelle diventano i sottomoduli del tuo package.

Nel nostro caso, aggiungiamo i nostri file __init__.py alla cartella del modulo effettivo, denominata verysimplemodule, in questo modo:

from add import add
from subtract import subtract

e facciamo lo stesso per la sottocartella extras, in questo modo:

from multiply import multiply
from divide import divide

Una volta fatto questo, siamo praticamente a metà dell'opera!

Come impostare il file setup.py

All'interno della cartella base-verysimplemodule (e nella stessa cartella del nostro modulo verysimplemodule), dobbiamo aggiungere il file setup.py. Questo file è essenziale se si intende effettuare il build del modulo in questione.

Nota: si può nominare il file setup.py a piacimento. Questo file non deve avere un nome specifico, a differenza del file __init__.py.

Alcune possibili scelte per il nome possono essere setup_my_very_awesome_python_package.py e python_package_setup.py, ma di solito è buona pratica utilizzare setup.py.

Il file setup.py conterrà informazioni sul tuo package, specificamente il nome del package, la sua versione, le dipendenze dalle diverse piattaforme e molto altro.

Per i nostri scopi, non sono richieste meta-informazioni avanzate, così il seguente codice dovrebbe andare bene per la maggior parte dei pacchetti che creerai:

from setuptools import setup, find_packages

VERSION = '0.0.1' 
DESCRIPTION = 'Il mio primo package in Pyhton'
LONG_DESCRIPTION = 'Il mio primo package in Python con una descrizione un po più lunga'

# Impostazioni
setup(
       # il nome deve essere uguale a quello della cartella 'verysimplemodule'
        name="verysimplemodule", 
        version=VERSION,
        author="Jason Dsouza",
        author_email="<youremail@email.com>",
        description=DESCRIPTION,
        long_description=LONG_DESCRIPTION,
        packages=find_packages(),
        install_requires=[], # aggiungi qualsiasi package addizionale che 
        # deve essere installato insieme al tuo package. Ad Es. 'caer'
        
        keywords=['python', 'first package'],
        classifiers= [
            "Development Status :: 3 - Alpha",
            "Intended Audience :: Education",
            "Programming Language :: Python :: 2",
            "Programming Language :: Python :: 3",
            "Operating System :: MacOS :: MacOS X",
            "Operating System :: Microsoft :: Windows",
        ]
)

Una volta fatto questo, possiamo lanciare il seguente comando nella stessa cartella di base-verysimplemodule:

python setup.py sdist bdist_wheel

Questo comando permetterà di effettuare il build di tutti i pacchetti necessari richiesti da Python. Il comandi sdist e bdist_wheel permettono di creare una distribuzione sorgente (source distribution) e una distribuzione binaria in formato wheel (.whl) che potrai successivamente caricare su PyPi.

PyPi — eccoci arrivati!

PyPi è l'archivio ufficiale di Python dove sono conservati tutti i package Python. Si può considerarlo un pò come il Github per i Package di Python.

Per rendere il tuo package disponibile agli utenti in tutto il mondo, devi attivare un account PyPi.

Fatto ciò, saremo pronti per caricare il nostro package su PyPi. Ricordi la distribuzione sorgente e la distribuzione binaria Wheel che sono state costruite quando è stato lanciato il comando python setup.py? Bene, è proprio ciò che verrà effettivamente caricato su PyPi.

Ma prima di fare tutto questo, devi installare twine se non lo hai già installato. L'operazione è molto semplice e si esegue lanciando il comando pip install twine.

Come caricare il tuo package su PyPi

Assumendo di avere installato twine , procediamo lanciando il seguente comando:

twine upload dist/*

Questo comando caricherà i contenuti della cartella dist, che è stata generata automaticamente quando abbiamo lanciato il comando python setup.py. Verrà visualizzato un prompt che chiederà lo username e la password dell'account PyPi, quindi procediamo ed inseriamoli come richiesto.

A questo punto, se hai seguito questo tutorial alla lettera, potresti ottenere un errore del tipo il repository è già esistente.

Questo accade di solito perché c'è un conflitto tra i nomi del tuo package e di un package già esistente. In altre parole, cambia il nome del tuo package - quel nome è già stato utilizzato.

Ed è tutto!

Per installare orgogliosamente il tuo modulo tramite pip, avvia un terminale e lancia il comando:

pip install <nome_package> 

# nel nostro caso:
pip install verysimplemodule

Osserva come Python installa accuratamente il tuo package dai file binari che sono stati generati prima.

Apri una shell interattiva di Python e prova ad importare il tuo package:

>> import verysimplemodule as vsm

>> vsm.add(2,5)
7
>> vsm.subtract(5,4)
1

Per accedere ai metodi per divisione emoltiplicazione ( ricordi che erano in una sottocartella chiamata extras?), lancia il comandi:

>> import verysimplemodule as vsm

>> vsm.extras.divide(4,2)
2
>> vsm.extras.multiple(5,3)
15

È proprio così semplice.

Congratulazioni! Hai appena creato il tuo primo package in Python. Anche se molto semplice, il tuo package è adesso disponibile per il download da chiunque in tutto il mondo (premesso che abbia Python, ovviamente).

Qual è il prossimo passo?

Test PyPi

Il package che abbiamo usato in questo tutorial era un modulo estremamente semplice - le operazioni matematiche basilari di addizione, sottrazione, moltiplicazione e divisione. Non ha senso caricarlo direttamente in PyPi specialmente se lo stai provando per la prima volta.

Fortunatamente per noi, esiste Test PyPi, una istanza separata di PyPi dove puoi testare e sperimentare il tuo pacchetto (è necessario iscriverti ad un account separato sulla piattaforma).

Il processo da seguire per caricare su Test PyPi è praticamente lo stesso, con qualche piccola modifica.

# Il seguente comando caricherà il package su Test PyPi
# Ti verrà chiesto di fornire le tue credenziali di accesso a Test PyPi

twine upload --repository testpypi dist/*

Per scaricare progetti da Test PyPi:

pip install --index-url "https://test.pypi.org/simple/<nome_package>"

Meta-informazioni avanzate

Le meta-informazioni che abbiamo usato nel file setup.py erano molto basilari. Puoi aggiungere ulteriori informazioni come manutentori multipli (se ci sono), email dell'autore, informazioni sulla licenza ed un gran numero di altri dati.

Questo articolo si rivelerà particolarmente utile se intendi farlo.

Dai un'occhiata ad altri repository

Vedere come gli altri repository hanno costruito i loro pacchetti si può rivelare molto utile.

Mentre realizzavo Caer, osservavo costantemente come Numpy e Sonnet impostavano il loro pacchetti. Raccomanderei di dare un'occhiata ai repository di Caer, Numpy e Tensorflow se stai pianificando di realizzare pacchetti leggermente più avanzati.

Quando lavori con le stringhe in Python, potresti dover suddividere una stringa in sottostringhe. O potresti aver bisogno di unire pezzi più piccoli per formare una stringa. I metodi delle stringhe di Python split() e join() ti aiutano ad eseguire queste operazioni facilmente.

In questo tutorial, imparerai i metodi delle stringhe split() e join() con molti esempi di codice.

Poiché le stringhe in Python sono immutabili, puoi chiamare questi metodi su di loro senza modificare le stringhe originali. Iniziamo!

Sintassi del Metodo split() di Python

Quando hai bisogno di dividere una stringa in sottostringhe, puoi usare il metodo split().

Il metodo split() opera su una stringa e restituisce una lista di sottostringhe. La sintassi è:

<string>.split(sep,maxsplit)

Nella sintassi qui in alto:

• <string> è una qualsiasi stringa valida in Python,
• sep è il separatore in corrispondenza del quale vuoi dividere la stringa. Deve essere specificato come stringa.

<string>  sep = ","

• sep è un argomento opzionale. Di default, il metodo divide le stringhe sugli spazi.
• maxsplit è un argomento opzionale che indica quante volte vuoi dividere <string>.
• maxsplit ha come valore di default -1, che divide la stringa su tutte le occorrenze di sep.

<string>  first  maxsplit = 1

E impostare maxsplit = 1 ti lascerà con due porzioni - una con la sezione di <string> prima della prima virgola, e un'altra con la sezione di <string> dopo la prima virgola.

Quando dividi una stringa una volta sola, ottieni 2 porzioni. Quando la dividi due volte, ottieni 3 porzioni. Quando dividi una stringa k volte, ottieni k+1 porzioni.

▶ Prendiamo alcuni esempi per vedere il metodo split() in azione.

Esempi del Metodo split() in Python

Iniziamo con my_string, mostrata qui sotto.

my_string = "I code for 2 hours everyday"

Ora, chiamiamo il metodo split() su my_string, senza gli argomenti sep e maxsplit.

my_string.split()

Puoi notare che my_string è stata divisa in corrispondenza di tutti gli spazi e che viene restituita una lista di sottostringhe, come mostrato in alto.

▶ Prendiamo ora in considerazione il seguente esempio. Qui, my_string contiene nomi di frutti separati da virgole.

my_string = "Apples,Oranges,Pears,Bananas,Berries"

Dividiamo ora my_string in corrispondenza delle virgole – imposta sep = "," o specifica solo "," nella chiamata del metodo.

my_string.split(",")

Come previsto, il metodo split() restituisce una lista di frutti, dove ogni frutto in my_string è ora un elemento della lista.

▶ Usiamo ora anche l'argomento opzionale maxsplit impostandolo su 2.

my_string.split(",",2)

Proviamo ad analizzare la lista restituita.

Ricorda che my_string è "Apples,Oranges,Pears,Bananas,Berries", e abbiamo deciso di dividerla in corrispondenza delle virgole (",").

• La prima virgola si trova dopo Apples, e dopo la prima divisione avrai due elementi, Apples e Oranges,Pears,Bananas,Berries.
• La seconda virgola si trova dopo Oranges. E avrai 3 elementi, Apples, Oranges, e Pears,Bananas,Berries dopo la seconda divisione.
• A questo punto, maxsplit ha raggiunto il valore 2, e non si può fare nessun'altra divisione.
• Ecco perché la porzione di stringa dopo la seconda virgola è ammassata insieme in un solo elemento nella lista restituita.

Spero che tu abbia capito come funzionano il metodo split() e gli argomenti sep e maxsplit.

Sintassi del Metodo join() di Python

Ora che sai come dividere una stringa in sottostringhe, è il momento di imparare come usare il metodo join() per formare una stringa a partire dalle sottostringhe.

La sintassi del metodo di Python join() è:

<sep>.join(<iterable>)

Qui,

• <iterable> è un qualsiasi elemento iterabile di Python che contenga delle sottostringhe, ad esempio, una lista o una tupla, e
• <sep> è il separatore che vorresti usare per unire le stringhe.

join()  <iterable>  <sep>

▶ Ed è il momento per gli esempi.

Esempi del Metodo join() di Python

Nella sezione precedente sul metodo split(), hai diviso my_string in una lista sulle occorrenze delle virgole. Chiamiamo la lista my_list.

Ora formerai una stringa usando il metodo join() per mettere insieme gli elementi nella lista restituita. Gli elementi in my_list sono tutti nomi di frutti.

my_list = my_string.split(",")

# dopo che my_string è stata divisa my_list è:
['Apples', 'Oranges', 'Pears', 'Bananas', 'Berries']

📑 Nota che il separatore per unire deve essere specificato come stringa. Incorrerai in errori di sintassi se non lo fai, come mostrato in basso.

,.join(my_list)

▶ Per unire gli elementi in my_list usando una virgola come separatore, usa "," non ,. Questo viene mostrato nella porzione di codice qui in basso.

", ".join(my_list)

La riga di codice in alto unisce gli elementi in my_list usando una virgola seguita da uno spazio come separatore.

Puoi specificare un qualunque separatore a tua scelta. Questa volta, userai 3 trattini bassi (___) per unire gli elementi in my_list.

"___".join(my_list)

Gli elementi in my_list adesso sono stati uniti in una sola stringa, e sono separati l'uno dall'altro da ___.

E adesso sai come formare una stringa di Python mettendo insieme delle sottostringhe usando il metodo join().

Conclusione

In questo tutorial, hai imparato che:

• <string>.split(sep, maxsplit) divide <string> sulle occorrenze di sep, un numero di volte uguale a maxsplit,
• <sep>.join(<iterable>) unisce le sottostringhe in <iterable> usando <sep> come separatore.

Spero che tu abbia trovato utile questo tutorial. Buona programmazione!

Google Colaboratory ("Colab") è un blocco note (come Jupyter Notebook) da cui puoi eseguire del codice Python nel tuo Google Drive.

Puoi scrivere del testo, scrivere codice, eseguire del codice e vederne l'output - tutto all'interno dello stesso blocco note.

Benefici di Google Colab

Condividere blocchi note è facile tanto quanto condividere un qualsiasi documento Google. Puoi anche scaricare l'app ed eseguire il codice dal tuo telefono.

Puoi usare il potente e popolare linguaggio Python all'interno del tuo Google Drive, e l'installazione richiederà meno di cinque minuti.

Poiché Python viene eseguito su un server (e non sul tuo browser locale o sul tuo computer locale) puoi usarlo facilmente per interagire con un database online e analizzare i dati in situazioni in cui hai bisogno di mantenere il codice privato.

Come Aggiungere Colab al Tuo Google Drive

1. Sul tuo computer, nel tuo Google Drive, clicca il bottone "+ Nuovo".

2.  Clicca “Altro”, poi clicca "Collega altre applicazioni" in fondo al nuovo menu.

3.  Nel Google Workspace Marketplace, digita "colab" nella barra di ricerca.

4.  Clicca per aggiungere Google Colaboratory.

5.  Ora hai Colab nella  lista di applicazioni disponibili.

Come Usare Google Colab

Ora quando clicchi sul bottone "+ Nuovo" e clicchi "Altro" (in fondo alla prima lista) vedrai "Google Colaboratory" nella lista seguente.

Cliccaci per aprire un nuovo blocco note Colab. Dai un nome al tuo blocco note, come faresti con qualsiasi documento o foglio Google. Questo blocco note è in modalità scura:

Digita un semplice comando come test. Per eseguire il codice in qualsiasi cella, puoi cliccare il bottone "esegui" a sinistra della cella di codice (somiglia ad un bottone "play" con un triangolo all'interno di un cerchio) o puoi cliccare [shift] + [invio]. L'output apparirà appena sotto la cella di codice.

Puoi importare molte librerie popolari senza bisogno di installarle prima.

Se importi una libreria o definisci una funzione in una cella, essa sarà ancora disponibile nelle altre celle per almeno qualche minuto. Il runtime si disconnetterà se stai 30 minuti senza eseguire nessuna cella o se tieni il blocco note aperto per 12 ore.

Esplora Colab

Se stavi seguendo passo passo e adesso hai Google Colaboratory installato, sei pronto per sviluppare i tuoi progetti.

Se clicchi sul simbolo “< >” in basso a sinistra del blocco note, troverai degli esempi di codice che puoi usare. Inoltre, Google possiede molte risorse per te, alcune delle quali si trovano su https://colab.research.google.com/ (chiudi semplicemente la finestra pop-up che appare).

A freeCodeCamp stiamo mettendo su un curriculum per mostrarti come usare Python per risolvere problemi matematici. Adesso hai gli strumenti a portata di mano. Buona programmazione!

Quando hai bisogno di saltare una parte del loop in corso o di uscire completamente dal loop, puoi utilizzare le istruzioni break e continue.

In questo articolo ti spiegherò come utilizzare le istruzioni break e continue nel tuo codice Python.

Come utilizzare l'istruzione break in Python

È possibile utilizzare l’istruzione break per uscire da un loop for o while e passare alla sezione di codice successiva.

Questo primo esempio mostra un loop for che percorre ogni lettera della parola freeCodeCamp e la visualizza nella console.

for letter in 'freeCodeCamp':
    print('letter :', letter)

Ecco cosa viene visualizzato nella console:

Se vogliamo interrompere il loop alla lettera "o", possiamo utilizzare un'istruzione if seguita da un’istruzione break.

for letter in 'freeCodeCamp':
    if letter == "o":
        break
    print('letter :', letter)

Ecco cosa viene visualizzato nella console:

Nel prossimo esempio utilizziamo un loop while per incrementare num fintanto che num è inferiore a 20.

num = 5
while num < 20:
    print('Current number :', num)
    num = num + 1

Ecco cosa viene visualizzato nella console:

Possiamo poi aggiungere una condizione all’interno del loop while che ordina di uscire dal loop se num è uguale a 9.

num = 5
while num < 20:
    print('Current number :', num)
    num = num + 1
    if num == 9:
        break

Ecco cosa viene visualizzato nella console:

Come utilizzare l'istruzione continue in Python

È possibile utilizzare l’istruzione continue per saltare l’iterazione in corso di un loop for o while e passare all’iterazione successiva.

In questo esempio stiamo eseguendo un loop su una stringa che contiene il mio nome.

for letter in "Jessica":

Dentro al loop for, inseriamo una condizione che ordina di saltare l’iterazione in corso e passare alla successiva se la lettera presa in considerazione è uguale a "i".

  if letter == "i":
        continue

Ecco come appare il codice completo:

for letter in "Jessica":
    if letter == "i":
        continue
    print(letter)

Ed ecco cosa viene visualizzato nella console:

Nota che la lettera "i" non è stata visualizzata nella console poiché l’istruzione continue ha fatto saltare quell’iterazione.

Nel prossimo esempio visualizzeremo numeri con incrementi di 10 utilizzando un loop while. Aggiungeremo poi una condizione nel loop che ordini di saltare l’iterazione e passare alla successiva se num è uguale a 50.

num = 10
while num < 100:
    num = num + 10
    if num == 50:
        continue
    print("Current num: ", num)

Ecco cosa viene visualizzato nella console:

Come si può vedere, il numero 50 non viene visualizzato nella console a causa dell’istruzione continue contenuta all’interno dell’istruzione if.

Conclusione

Le istruzione break e continue in Python sono utilizzate per saltare parti del loop in corso o per uscire completamente dal loop.

È possibile utilizzare l’istruzione break quando si vuole uscire completamente da un loop for o while e passare alla sezione di codice successiva.

È possibile utilizzare l’istruzione continue per saltare l’iterazione in corso del loop for o while e passare all’iterazione successiva dello stesso loop.

Spero che questo articolo ti sia piaciuto e ti auguro buona fortuna per il tuo viaggio con Python.

Prima di provare ad eseguire qualsiasi programma in Python sul tuo sistema operativo Windows, dovrai controllare di avere Python installato e aggiunto correttamente alla variabile di ambiente path.

In questo articolo, ti mostrerò come puoi controllare di avere Python installato sul tuo sistema operativo. Se non lo hai, allora ti mostrerò anche come puoi installarlo correttamente su Windows.

In questo articolo, userò Windows 11 poiché è l'ultima versione di Microsoft Windows. Ma lo stesso metodo è applicabile ad altre versioni di Windows. Dunque, senza indugiare oltre, cominciamo.

Come Controllare se Hai Python Installato sul Tuo Sistema Operativo Windows

Apri il CMD o la Powershell e controlla la versione di Python usando questo comando:

python --version

Se ottieni la versione di Python nell'output come vedi in alto, allora il tuo computer è perfettamente in grado di eseguire qualsiasi programma di Python. Nel tuo caso, la versione di Python potrebbe essere diversa.

Ma se ottieni il tipo di output che vedi in alto, potrebbe significare una di queste cose:

1. Non avevi Python installato sul tuo computer, oppure
2. La cartella di Python non è stata aggiunta al percorso delle Variabili di Ambiente.

Per ora fammi dare per scontato che tu non abbia Python installato sul tuo computer. Più avanti in questo articolo ti spiegherò anche come puoi aggiungere la cartella di Python al percorso delle Variabili d'Ambiente.

Come Installare Python su Windows

Prima di tutto, dobbiamo andare sul sito ufficiale di Python.

Clicca sulla sezione Downloads.

Qui otterrai l'ultima versione. Clicca semplicemente su Download Python 3.10.2. Nel momento in cui stai leggendo questo articolo, Python potrebbe essere stato aggiornato, nel qual caso la versione sarebbe diversa. Semplicemente scarica la versione che ti mostra.

Tieni a mente che qui ti mostrerà sempre l'ultima versione di Python in alto.

Dopo aver scaricato il file, otterremo un file eseguibile come questo. Fai semplicemente doppio click su quel file e il wizard di installazione si aprirà.

Clicca su Customize installation.

Assicurati di spuntare tutte le caselle, come in alto. Poi clicca su Next.

Poi vedrai lo screen in basso. Se vuoi, puoi spuntare tutte le caselle. Non ho bisogno del debugging dei simboli e del debug dei binari. Per questo motivo, non spunterò le ultime due caselle.

Ti consiglierei inoltre di non cambiare la posizione per l'installazione. Ricorda dove lo hai installato perché potrebbe servirti in seguito. Stiamo aggiungendo Python alle variabili d'ambiente direttamente qui.

Poi clicca Install.

Lascia che termini il processo di installazione...

Se ottieni questo tipo di suggerimento per disabilitare il limite di lunghezza del percorso, clicca semplicemente su quella casella. Disabiliterà il limite di lunghezza del percorso rimuovendo la limitazione sulla variabile MAX_PATH.

Questo cambiamento non romperà nulla, né apporterà modifiche negative. Permetterà solamente a Python di usare nomi di percorso lunghi. È consigliato disabilitare il limite di lunghezza del percorso.

L'installazione è terminata con successo.

Come Controllare la Versione di Python

Adesso dobbiamo controllare di nuovo se Python sia stato installato e aggiunto con successo al percorso delle variabili di ambiente oppure no.

Per controllarlo, dobbiamo aprire il CMD o la Powershell. Poi dobbiamo usare il seguente comando:

python --version

Python è stato installato con successo e anche il percorso è stato aggiunto tra le variabili d'ambiente!

Come Controllare il Percorso delle Variabili d'Ambiente

Se vuoi controllare il percorso delle variabili manualmente allora devi aprire le Impostazioni di sistema avanzate. Puoi cercare Impostazioni di sistema avanzate, oppure puoi aprirle dal Pannello di Controllo.

Se le cerchi usando le parole chiave Impostazioni di sistema avanzate, lo otterrai direttamente in questo modo.

Se vuoi aprirle dal Pannello di Controllo allora, prima di tutto, devi aprire il pannello di controllo.

Vai su Sistema e Sicurezza.

Clicca su Sistema.

Da qui, clicca su Impostazioni di sistema avanzate.

Clicca su Variabili d'ambiente.

Clicca su Path e poi clicca Modifica.

Vedrai che la cartella radice di Python310 e le cartelle degli script di Python310 sono state già aggiunte durante il processo di installazione, poiché abbiamo spuntato la casella per farlo durante l'installazione.

Se avessi voluto farlo manualmente allora avresti dovuto copiare e incollare le due cartelle qui cliccando su Nuovo e incollando le due cartelle nelle due caselle bianche (una nuova casella si apre ogni volta che clicchi su Nuovo). Poi clicca semplicemente su OK su tutte le caselle aperte e chiudi tutte le finestre aperte.

Ho fatto anche un video dove mostro tutti i processi menzionati in alto. Se vuoi, puoi darci un'occhiata qui.

Conclusione

Grazie per aver letto l'intero articolo. Se ti può essere di aiuto puoi anche dare un'occhiata ai miei altri articoli su freeCodeCamp.

Se vuoi metterti in contatto con me, puoi farlo usando Twitter, LinkedIn, e GitHub.

Puoi anche ISCRIVERTI al mio canale di YouTube (Code With FahimFBA) se vuoi imparare diversi tipi di linguaggi di programmazione con molti esempi pratici pubblicati regolarmente.

Se vuoi dare un'occhiata ai miei highlights, puoi farlo sulla mia timeline Polywork.

Puoi anche visitare il mio sito per saperne di più su di me e sulle cose su cui sto lavorando.

Grazie mille!

Ci sono molti e diversi tipi di database in uso oggi. Abbiamo database centralizzati, database commerciali, database cloud, database distribuiti, database end-user, database NoSQL, database relazionali, e molti altri.

Questo articolo si concentrerà su un esempio di database relazionale (PostgreSQL) e su come richiedere dati da esso. Altri esempi di database relazionali includono MySQL, MariaDB e SQLite.

In questo tutorial, imparerai come installare, connettere e infine eseguire query su un database PostgreSQL con Python.

Per iniziare, partiamo con calma imparando qualcosina in più su PostgreSQL.

Che Cos'è PostgreSQL?

PostgreSQL è uno dei più conosciuti database relazionali open-source. È usato da sviluppatori e aziende di qualsiasi dimensione in tutto il mondo.

Per quanto riguarda la sua popolarità globale, PostgreSQL è stato classificato quarto da DB-Engines, e la sua popolarità è in crescita. Ciò non deve sorprendere, considerando quante applicazioni web e mobile, così come strumenti analitici, usano i database PostgreSQL.

PostgreSQL possiede anche un robusto ecosistema con una grandissima varietà di add-on ed estensioni che funzionano bene con il database principale. Per queste ragioni, PostgreSQL è un'opzione fantastica sia che tu voglia creare una tua soluzione di database personalizzata, sia che tu abbia bisogno di un database commerciale o analitico.

Adesso che sai che c0s'è PostgreSQL, parliamo di come connettersi al database usando Python.

Per Iniziare

Dobbiamo usare una libreria connettore per database per connetterci all'istanza di un database PostgreSQL dal nostro script di Python. Possiamo scegliere da una gamma di alternative in Python, ma Psycopg2 è la più conosciuta e più usata.

Ci sono librerie alternative scritte interamente in Python, come pg8000 e py-postgresql, ma qui useremo Psycopg2.

Che cos'è Psycopg2?

La libreria Psycopg2 usa il linguaggio di programmazione C come wrapper della libreria di PostgreSQL libpq per supportare gli standard di Python DB API 2.0. L'implementazione in C di Psycopg2 la rende incredibilmente veloce ed efficiente.

Usando una query SQL, possiamo utilizzare Psycopg2 per ottenere una o più righe dal database. Con questa libreria, possiamo anche inserire dati all'interno del database usando una varietà di metodi di inserimento, singoli o di gruppo.

La libreria è come SQL (Structured Query Language) e compie tutti i lavori e le operazioni che un linguaggio di query può fare. Gestisce sia Unicode che Python3, e include la thread safety (la stessa connessione è condivisa da molteplici thread).

È fatta per eseguire programmi altamente multi-thread, che producono e cancellano frequentemente molti cursori e compiono molti INSERT and UPDATE simultaneamente. Le funzionalità di Psycopg2 includono cursori dal lato client e dal lato server, comunicazione asincrona, e notifiche.

Come Installare Psycopg2

Dobbiamo prima installare Pyscopg2 per poterlo usare. Possiamo installarlo dal terminale o dal prompt dei comandi usando pip.

#installazione

pip install psycopg2
pip3 install psycopg2

Se decidi di installare anche la libreria connettore in un ambiente virtuale, puoi farlo usando questo codice:

virtualenv env && source env/bin/activate
pip install psycopg2-binary

La libreria Psycopg2 e tutte le sue dipendenze verranno installate nel nostro ambiente virtuale di Python con queste righe di codice.

Abbiamo installato il nostro connettore, quindi iniziamo a scrivere alcune query.

Come Interrogare PostgreSQL usando Python

Prima di tutto, dovrai creare un nuovo file e chiamarlo come preferisci. Poi aprilo nel tuo IDE e inizia a scrivere il codice.

La prima cosa da fare è importare la libreria (questo è molto importante). Useremo due oggetti di Pyscogp2:

• Oggetto connessione: la connessione a un'istanza di un database PostgreSQL è gestita da un oggetto connessione. Incapsula la sessione di un database, creata usando la funzione connect().
• Oggetto cursore: l'oggetto cursore rende possibile l'esecuzione dei comandi PostgreSQL per gli script di Python durante la sessione di un database. La connessione genera dei cursori, dopodiché il metodo cursor() li lega permanentemente alla connessione. Tutti i comandi sono effettuati all'interno della struttura della sessione del database racchiusa nella connessione.

import psycopg2

conn = psycopg2.connect(database="db_name",
                        host="db_host",
                        user="db_user",
                        password="db_pass",
                        port="db_port")

Dobbiamo specificare questi argomenti per poterci connettere al database. Diamo una veloce occhiata a questi argomenti.

• database: il nome del database a cui vogliamo avere accesso o connetterci. Nota che possiamo connetterci a un solo database con un oggetto connessione.
• host: molto probabilmente questo fa riferimento all'indirizzo IP o all'URL del server del database.
• user: come suggerisce il nome, si riferisce al nome dell'utente PostgreSQL.
• password: questa è la password associata all'utente PostgreSQL.
• port: il numero della porta del server PostgreSQL sul localhost - di solito è 5432.

Se le credenziali del nostro database sono state inserite correttamente, riceveremo un oggetto connessione al database in tempo reale che possiamo usare per costruire un oggetto cursore. Possiamo proseguire ed eseguire qualsiasi query sul database e recuperare dati con l'aiuto del nostro oggetto cursore.

cursor = conn.cursor()

Scriviamo una semplice query:

cursor.execute("SELECT * FROM DB_table WHERE id = 1")

Usiamo la funzione execute() e forniamo come parametro una stringa di query. Poi il database sarà interrogato usando la query che abbiamo inserito.

Una volta che avremo compiuto questa azione con successo, per poter recuperare dati dal database usando Pyscopg2, dobbiamo usare una di queste funzioni: fetchone(), fetchall() o fetchmany().

Come usare fetchone():

Dopo aver eseguito la query SQL, questa funzione restituirà soltanto la prima riga. È il metodo più semplice per prendere dati da un database.

#code
print(cursor.fetchone())

#output
(1, 'A-CLASS', '2018', 'Subcompact executive hatchback')

La funzione fetchone() restituisce una singola riga in forma di tupla, con le informazioni organizzate nell'ordine specificato dalle colonne fornite nella query.

Quando strutturiamo la stringa di query, è cruciale fornire l'ordine delle colonne in modo preciso per poter distinguere quali dati nella tupla corrispondono a quali colonne.

Come usare fetchall():

La funzione fetchall() funziona allo stesso modo di fetchone() ad eccezione del fatto che non restituisce una riga sola ma tutte le righe. Quindi, in caso volessimo 20-200 righe o più, possiamo fare uso di fetchall().

#code
print(cursor.fetchall())

#output
[(1, 'A-CLASS', '2018', 'Subcompact executive hatchback'),
 (2, 'C-CLASS', '2021', 'D-segment/compact executive sedan'),
 (3, 'CLA', '2019', 'Subcompact executive fastback sedan'),
 (4, 'CLS', '2018', 'E-segment/executive fastback sedan'),
 (5, 'E-CLASS', '2017', 'E-segment/executive sedan'),
 (6, 'EQE', '2022', 'All-electric E-segment fastback'),
 (7, 'EQS', '2021', 'All-electric full-size luxury liftback'),
 (8, 'S-CLASS', '2020', 'F-segment/full-size luxury sedan.'),
 (9, 'G-CLASS', '2018', 'Mid-size luxury SUV, known as the G-Wagen'),
 (10, 'GLE', '2019', 'Mid-size luxury crossover SUV')]
[...]

Come usare fetchmany():

La funzione fetchmany() ci permette di ottenere un certo numero di voci dal database e ci dà maggiore controllo sul numero preciso di righe che otteniamo.

#code
print(cursor.fetchmany(size=3))

#output
[(1, 'A-CLASS', '2018', 'Subcompact executive hatchback'),
 (2, 'C-CLASS', '2021', 'D-segment/compact executive sedan'),
 (3, 'CLA', '2019', 'Subcompact executive fastback sedan')]

Poiché abbiamo impostato 3 come argomento, riceviamo solamente tre righe.

Quando abbiamo finito di interrogare il nostro database dobbiamo chiudere la connessione con conn.close().

Conclusione

È stato piuttosto semplice, vero? Siamo stati in grado di eseguire tutte queste operazioni da un singolo script Python e ha funzionato molto bene.

Spero che questo articolo ti sia stato utile, adesso puoi lavorare con PostgreSQL usando Python,

Per maggiori informazioni, dai un'occhiata alla documentazione di Psycopg2.

Puoi usare i set in Python per immagazzinare una collezione di dati in una singola variabile.

Tutte le strutture di dati integrate in Python, come le liste, i dizionari e le tuple, hanno delle caratteristiche distinte.

Ecco alcune caratteristiche dei set in Python:

• Non sono ammessi elementi duplicati. Se un elemento compare più volte, solo uno verrà riconosciuto nel set.
• Gli elementi di un set sono in ordine casuale. L'ordine del set cambia ogni volta che viene usato.
• Il valore degli elementi di un set non può essere modificato/cambiato una volta che il set è stato creato.

In questo articolo, imparerai come creare i set. Imparerai anche come accedere, aggiungere e rimuovere elementi da un set in Python.

Concluderemo parlando di alcuni casi d'uso dei set nella programmazione e nella matematica con Python.

Come Creare Set in Python

Usiamo le parentesi graffe per immagazzinare degli elementi in un set. Ecco come appare un set:

nomeSet = {"John", "Jane", "Doe"}

print(nomeSet)
# {'Jane', 'Doe', 'John'}

Nel codice in alto, abbiamo creato un set chiamato nomeSet.

Noterai che quando il set viene stampato, i valori appaiono in un ordine diverso. Questa è una delle caratteristiche dei set di Python che ho menzionato prima.

Ecco un altro esempio con un elemento duplicato:

nomeSet = {"John", "Jane", "Doe", "Jane"}

print(nomeSet)
# {'Jane', 'Doe', 'John'}

Il duplicato di "Jane" è stato ignorato nell'esempio qui sopra. Questo perché gli elementi duplicati non sono ammessi.

Come Accedere agli Elementi di un Set in Python

Puoi usare un loop per accedere agli elementi di un set e stamparli. Non puoi usare l'indice degli elementi per avere accesso ad essi, poiché l'ordine cambia costantemente– nessun elemento mantiene il suo indice.

Ecco un esempio:

nomeSet = {"John", "Jane", "Doe"}

for nomi in nomeSet:
    print(nomi)
    # John
    # Doe
    # Jane

Usiamo un loop for per stampare gli elementi in nomeSet.

Nella prossima sezione, vedrai come aggiungere gli elementi a un set.

Come Aggiungere Elementi a un Set in Python

Puoi aggiungere un elemento a un set in Python usando il metodo add() con il nuovo elemento da aggiungere passato come parametro.

Ecco un esempio:

nomeSet = {"John", "Jane", "Doe"}

nomeSet.add("Ihechikara")

print(nomeSet)
# {'John', 'Ihechikara', 'Doe', 'Jane'}

Abbiamo aggiunto un nuovo elemento – "Ihechikara" – al set: nomeSet.add("Ihechikara").

Puoi anche aggiungere un elemento da un altro set o da altre strutture di dati (liste, dizionari, e tuple) a un set usando il metodo update().

Ecco un esempio:

nomeSet = {"John", "Jane", "Doe"}

nomeSet2 = {"Jade", "Jay"}

nomeSet.update(nomeSet2)

print(nomeSet)
# {'Doe', 'Jay', 'Jane', 'Jade', 'John'}

Per aggiungere i nomi da nomeSet2 a nomeSet, abbiamo passato nomeSet2 come parametro al metodo update(): nomeSet.update(nomeSet2).

Come Rimuovere Elementi da un Set in Python

Ci sono diversi metodi che puoi usare per rimuovere elementi da un set. Diamoci un'occhiata.

Come Rimuovere Elementi da un Set in Python Usando il Metodo discard()

Puoi usare il metodo discard() per rimuovere un elemento specifico. Ecco un esempio:

nomeSet = {"John", "Jane", "Doe"}

nomeSet.discard("John")

print(nomeSet)
# {'Doe', 'Jane'}

Nell'esempio in alto, "John" è stato passato come parametro al metodo discard() ed è stato dunque rimosso dal set.

Come Rimuovere Elementi da un Set in Python Usando il Metodo remove()

Il metodo remove() funziona allo stesso modo del metodo discard().

nomeSet = {"John", "Jane", "Doe"}

nomeSet.remove("Jane")

print(nomeSet)
# {'John', 'Doe'}

Come Svuotare un Set in Python Usando il Metodo clear()

Per eliminare tutti gli elementi in un set, usiamo il metodo clear().

Ecco un esempio:

nomeSet = {"John", "Jane", "Doe"}

nomeSet.clear()

print(nomeSet)
# set()

Quando Usare i Set in Python

In questa sezione, parleremo di due importanti casi d'uso dei set in Python.

Possiamo usare i set per rimuovere elementi duplicati in altre strutture di dati.

Possiamo anche compiere delle fantastiche operazioni matematiche come ottenere l'unione, l'intersezione, la differenza e la differenza simmetrica di due o più set.

Come Usare i Set per Rimuovere Elementi Duplicati in Altre Strutture di Dati

Possiamo usare i set per liberarci di elementi duplicati in altre strutture di dati come liste e tuple.

Ciò è utile quando hai a che fare con insiemi di dati molto grandi che richiedono solo le unità individuali degli elementi e non il numero di occorrenze degli elementi.

Ecco un esempio:

listaNumeri = [2, 2, 4, 8, 9, 10, 8, 2, 5, 7, 3, 4, 7, 9]

setNumeri = set(listaNumeri)

print(setNumeri)
# {2, 3, 4, 5, 7, 8, 9, 10}

Nel codice qui sopra, abbiamo creato una lista di numeri chiamata listaNumeri che ha molteplici occorrenze di alcuni numeri: [2, 2, 4, 8, 9, 10, 8, 2, 5, 7, 3, 4, 7, 9].

Usando il metodo set(), abbiamo convertito la lista listaNumeri in un set: setNumeri = set(listaNumeri).

Quando il nuovo set è stato stampato, tutti i duplicati dei numeri sono stati rimossi - ci viene restituita solo un'occorrenza di ogni numero: {2, 3, 4, 5, 7, 8, 9, 10}.

Come Compiere Operazioni Matematiche Usando i Set in Python

I set in Python sono simili agli insiemi in matematica, e possiamo ottenere vari risultati a seconda della relazione che esiste tra gli insiemi.

In questa sezione, vedrai come ottenere l'unione, l'intersezione, la differenza e la differenza simmetrica tra set in Python.

Puoi compiere tutte le operazioni in questa sezione usando più di due set. Per mantenere la cosa il più semplice possibile, useremo solo due set per ogni esempio.

Come Ottenere l'Unione di Set in Python

L'unione di due set è un set con tutti gli elementi individuali che esistono in entrambi i set. Nell'unione, i duplicati vengono ignorati.

Ecco un esempio:

primoSet = {2, 3, 4, 5}

secondoSet = {1, 3, 5, 7}

print(primoSet | secondoSet)
# {1, 2, 3, 4, 5, 7}

Nell'esempio in alto, abbiamo due set – primoSet = {2, 3, 4, 5} e secondoSet = {1, 3, 5, 7}.

Usando l'operatore barra verticale (|), siamo in grado di ottenere l'unione dei due set: primoSet | secondoSet.

L'unione dei set è la seguente: {1, 2, 3, 4, 5, 7}. Come puoi vedere, i due set sono stati uniti per formare un solo set senza alcun duplicato.

Come Ottenere l'Intersezione di Set in Python

L'intersezione di due set è un set di elementi che sono comuni a entrambi i set. Nel nostro caso, è il set di elementi che compare sia in primoSet che in secondoSet.

Ecco un esempio:

primoSet = {2, 3, 4, 5}

secondoSet = {1, 3, 5, 7}

print(primoSet & secondoSet)
# {3, 5}

In questo esempio, stiamo usando l'operatore & per ottenere l'intersezione tra primoSet e secondoSet: primoSet & secondoSet.

Ci viene restituito {3, 5} perché 3 e 5 compaiono in entrambi i set.

Come Ottenere la Differenza tra Set in Python

La differenza tra due set è un set di tutti gli elementi che esistono in un set ma non nell'altro.

Ecco un esempio:

primoSet = {2, 3, 4, 5}

secondoSet = {1, 3, 5, 7}

print(primoSet - secondoSet)
# {2, 4}

Nell'esempio in alto, stiamo ottenendo un set di elementi che esiste in primoSet ma non in secondoSet.

Abbiamo usato l'operatore - per ottenere questo risultato: primoSet - secondoSet.

Il risultato dell'operazione è 2 e 4.

Come Ottenere la Differenza Simmetrica tra Set in Python

La differenza simmetrica di due set è un set di elementi che esistono in uno dei due set ma non in entrambi.

Nell'ultima sezione, abbiamo avuto come risultato elementi che esistono in un set ma non nell'altro. La differenza simmetrica ha come risultato gli elementi che esistono in ciascun set ma non in entrambi.

primoSet = {2, 3, 4, 5}

secondoSet = {1, 3, 5, 7}

print(primoSet ^ secondoSet)
# {1, 2, 4, 7}

Abbiamo usato l'operatore ^ per ottenere la differenza simmetrica dei due set: primoSet ^ secondoSet.

Il risultato è stato 1, 2, 4, 7.  Nessuno di questi elementi compare in entrambi i set.

Riepilogo

In questo articolo, abbiamo parlato dei set e di come crearli in Python.

I set non ammettono elementi duplicati, hanno un ordine casuale e gli elementi in essi contenuti non possono essere modificati.

Abbiamo anche visto come accedere, aggiungere e rimuovere elementi dai set usando metodi diversi.

Infine, abbiamo parlato di quando usare i set in Python. Abbiamo visto alcune applicazioni dei set in Python e il loro utilizzo nelle operazioni matematiche.

Buona programmazione!

In questo tutorial, imparerai come aprire un file, scrivere nel file e chiuderlo. Imparerai anche come leggere un file usando Python.

Alla fine di questo tutorial, dovresti sapere le basi di come usare i file in Python.

Gestione dei File in Python

La gestione dei file è un'importante attività di ogni app web. Le tipologie di attività che puoi eseguire su di un file aperto sono controllate dalle modalità di accesso. Esse descrivono come un file verrà usato dopo essere stato aperto.

Queste modalità specificano, inoltre, dove deve trovarsi l'handle del file al suo interno. Simile a un puntatore, l'handle di un file indica dove vanno letti o inseriti i dati in un file.

In Python, ci sono sei metodi o modalità di accesso, che sono:

1. Read Only (r – sola lettura): questa modalità apre il file di testo per la sola lettura. L'handle si trova all'inizio del file. Si verifica l'errore di I/O se il file non esiste. Questa è anche la modalità predefinita per aprire i file.
2. Read and Write (r+ – lettura e scrittura): questo metodo apre il file sia per la lettura che per la scrittura. L'handle si trova all'inizio del file. Se il file non esiste, si verifica un errore di I/O.
3. Write Only (w – sola scrittura): questa modalità apre il file per la sola scrittura. I dati in file già esistenti vengono modificati e sovrascritti. L'handle si trova all'inizio del file. Se il file non esiste già nella cartella, ne viene creato uno nuovo.
4. Write and Read (w+ – scrittura e lettura): questa modalità apre il file sia per la lettura che per la scrittura. Il testo è sovrascritto e cancellato da un file esistente. L'handle si trova all'inizio del file.
5. Append Only (a – sola aggiunta): questa modalità permette di aprire il file per la scrittura. Se il file non esiste, ne viene creato uno nuovo. L'handle si trova alla fine del file. I nuovi dati scritti vengono aggiunti alla fine, dopo i dati già esistenti.
6. Append and Read (a+ – aggiunta e lettura): usando questo metodo, puoi leggere e scrivere nel file. Se il file non esiste, ne viene creato uno. L'handle si trova alla fine del file. Il nuovo testo scritto viene aggiunto alla fine, dopo i dati già esistenti.

Di seguito c'è il codice necessario per creare, scrivere e leggere file di testo usando i metodi di gestione dei file o le modalità di accesso di Python.

Come Creare File in Python

In Python, puoi usare la funzione open() con una delle seguenti opzioni - "x" o "w" - per creare un nuovo file:

• "x" – Creare: questo comando creerà un nuovo file se e solo se non c'è già un file esistente con lo stesso nome, altrimenti si verificherà un errore.

Esempio della creazione di un file in Python usando il comando "x":

# creazione di un file di testo con la funzione di comando "x"

f = open("myfile.txt", "x")

Adesso abbiamo creato un nuovo file vuoto! Ma se riprovi ad eseguire il codice qui sopra - per esempio, se provi a creare un nuovo file con lo stesso nome che hai usato qui sopra (se vuoi riusare il nome del file in alto), otterrai un errore che ti notifica che il file esiste già. Come nell'immagine in basso:

• "w" – Scrivere: questo comando creerà un nuovo file di testo a prescindere dal fatto che ci sia o meno già un file in memoria con il nuovo nome specificato. Non restituirà un errore se trova un file esistente con lo stesso nome - invece, sovrascriverà il file esistente.

Esempio di come creare un file con il comando "w":

# creazione di un file di testo con la funzione di comando "w"

f = open("myfile.txt", "w")

#Questo comando "w" può anche essere usato per creare un nuovo file, ma a differenza del comando "x", il comando "w" sovrascriverà qualsiasi file esistente con lo stesso nome.

Con il codice qui sopra, sia che il file esista o che il file non esista in memoria, puoi procedere e usare il codice. Tieni a mente che sovrascriverà il file se ne trova uno già esistente con lo stesso nome.

Come Scrivere un File in Python

Ci sono due metodi per scrivere un file in Python, che sono:

Il metodo write():

Questa funzione inserisce la stringa all'interno del file di testo su una singola riga.

Prendendo come esempio il file che abbiamo creato prima, la riga di codice in basso inserirà la stringa nel nuovo file di testo creato, che è "myfile.txt".

file.write("Ciao a tutti\n")

Il metodo writelines():

Questa funzione inserisce più stringhe allo stesso tempo. Viene creata una lista di stringhe, e ogni stringa viene aggiunta al file di testo.

Usando il file creato in precedenza, la riga di codice in basso inserirà la stringa nel file di testo creato, che è "myfile.txt".

f.writelines(["Hello World ", "Benvenuti su FCC\n"])

Esempio:

#Questo programma mostra come scrivere dati in un file di testo.

file = open("myfile.txt","w")
L = ["Questa è Lagos \n","Questo è Python \n","Questo è Fcc \n"]

# ho assegnato ["Questa è Lagos \n","Questo è Python \n","Questo è Fcc \n"]
# alla variabile L, puoi usare qualsiasi lettera o parola a tua scelta.
# Le variabili sono contenitori in cui i valori possono essere immagazzinati.
# Il \n è inserito per indicare la fine di una riga

file.write("Ciao a tutti \n")
file.writelines(L)
file.close()

# Usa close() per cambiare la modalità di accesso del file

Come Leggere un File di Testo in Python

Ci sono tre metodi per leggere dati da un file di testo in Python. Ecco quali:

Il metodo read():

Questa funzione restituisce i byte letti come una stringa. Se non viene specificato nessun valore n, leggerà l'intero il file.

Esempio:

f = open("myfiles.txt", "r")
#('r’) apre il file di testo per la sola lettura
print(f.read())
#"f.read" stampa i dati nel file di testo sulla shell quando viene eseguito.

Il metodo readline():

Questa funzione legge una riga da un file e la restituisce come stringa. Legge un massimo di n bytes a seconda del valore n specificato. Ma se anche n è più grande della lunghezza della riga, non leggerà più di una riga.

f = open("myfiles.txt", "r")
print(f.readline())

Il metodo readlines():

Questa funzione legge tutte le righe e le restituisce come stringhe in una lista, una per ogni riga.

Puoi leggere le prime due righe di un file chiamando readline() due volte:

f = open("myfiles.txt", "r")
print(f.readline())
print(f.readline())

Come Chiudere un File di Testo in Python

È buona prassi chiudere sempre il file quando hai finito di lavorarci.

Esempio di chiusura di un file di testo:

Questa funzione chiude il file di testo quando hai finito di modificarlo:

f = open("myfiles.txt", "r")
print(f.readline())
f.close()

La funzione close() alla fine del codice dice a Python che ok, ho finito con questa sezione di creazione o lettura - è la stessa cosa di dire Fine.

Esempio:

Il programma qui in basso mostra più esempi di modi di leggere e scrivere dati in un file di testo. Ogni riga di codice ha dei commenti per aiutare a capire che cosa sta succedendo:

# Programma che mostra vari modi di leggere e
# scrivere dati in un file di testo.

file = open("myfile.txt","w")
L = ["Questa è Lagos \n","Questo è Python \n","Questo è Fcc \n"]

#ho assegnato ["Questa è Lagos \n","Questo è Python \n","Questo è Fcc \n"]
#alla variabile L
  
# \n è inserito per indicare la fine di una riga

file.write("Ciao a tutti \n")
file.writelines(L)
file.close()
# usa close() per cambiare la modalità di accesso del file



file = open("myfile.txt","r+") 
print("L'output della funzione Read è ")
print(file.read())
print()
  
# seek(n) prende il file handle fino all'n-esimo
# byte dall'inizio.
file.seek(0) 
  
print( "L'output della funzione Readline è ")
print(file.readline()) 
print()
  
file.seek(0)
  
# Per mostrare la differenza tra read e readline

print("L'output della funzione read(12) è ") 
print(file.read(12))
print()

file.seek(0)
  
print("L'output della funzione readline(8) è ") 
print(file.readline(8))
  
file.seek(0)
# funzione readlines
print("L'output della funzione readlines è ") 
print(file.readlines()) 
print()
file.close()

Questo è l'output del codice in alto quando viene eseguito nella shell. Ho assegnato "Questa è Lagos", "Questo è Python" e "Questo è FCC" a "L" e poi ho chiesto di stamparlo usando la funzione "file.read()".

Il codice in alto mostra che la funzione "readline()" restituisce la lettera basandosi sul numero che le viene specificato, mentre la funzione "readlines()" restituisce ogni stringa assegnata a "L", incluso il \n. Dunque, la funzione "readlines()" stamperà tutti i dati all'interno del file.

Conclusione

Spero che, dopo aver letto questo tutorial, tu abbia capito che cos'è la gestione di un file in Python. Abbiamo anche imparato le modalità/i metodi necessari per creare, scrivere, leggere e chiudere un file di testo usando alcuni esempi base da Python.

Grazie per aver letto!

L'errore di Python "TypeError: 'int' object is not subscriptable" (TypeError: l'oggetto 'int' non è sottoscrivibile) si verifica quando provi a trattare un numero intero come un oggetto "sottoscrivibile".

In Python, un oggetto "sottoscrivibile" è un oggetto su cui puoi usare l'operatore parentesi quadre [], o su cui puoi iterare.

Perché si Verifica l'Errore "TypeError: 'int' object is not subscriptable Error"

Puoi iterare su una stringa, una lista, una tupla o anche un dizionario. Ma non è possibile iterare su un numero intero o un insieme di numeri.

Quindi, se ottieni questo errore, significa che stai cercando di iterare su un numero intero oppure che stai trattando un numero intero come un array.

Nell'esempio in basso, ho scritto la data di nascita (variabile dob) nel formato ddmmyy. Ho provato a ottenere il mese di nascita ma non ha funzionato. Ha restituito l'errore "TypeError: 'int' object is not subscriptable":

dob = 21031999
mob = dob[2:4]

print(mob)

# Output: Traceback (most recent call last):
#   File "int_not_subable..py", line 2, in <module>
#     mob = dob[2:4]
# TypeError: 'int' object is not subscriptable

Come Risolvere l'Errore "TypeError: 'int' object is not subscriptable"

Per risolvere questo errore, devi convertire il numero intero in un altro tipo di dato che sia iterabile, per esempio, una stringa.

E se stai ottenendo questo errore perché hai convertito qualcosa in un numero intero, allora devi riconvertirlo in ciò che era prima. Per esempio, una stringa, una tupla, una lista, e così via.

Per quanto riguarda il codice che ci ha restituito l'errore in alto, sono stato in grado di farlo funzionare convertendo la variabile dob in una stringa:

dob = "21031999"
mob = dob[2:4]

print(mob)

# Output: 03

Se stai ottenendo l'errore dopo aver convertito qualcosa in un numero intero, significa che devi riconvertirlo in una stringa e lasciarlo così com'è.

Nell'esempio in basso, ho scritto un programma di Python che stampa la data di nascita nel formato ddmmyy. Ma restituisce un errore:

name = input("Come ti chiami? ")
dob = int(input("Qual è la tua data di nascita nel formato ddmmyy? "))
dd = dob[0:2]
mm = dob[2:4]
yy = dob[4:]
print(f"Ciao, {name}, \nIl tuo giorno di nascita è {dd} \nIl mese di nascita è {mm} \nE l'anno di nascita è {yy}.")

#Output: Come ti chiami? John Doe
# Qual è la tua data di nascita nel formato ddmmyy? 01011970
# Traceback (most recent call last):
#   File "int_not_subable.py", line 12, in <module>
#     dd = dob[0:2]
# TypeError: 'int' object is not subscriptable

Scorrendo il codice, ho ricordato che l'input restituisce una stringa, quindi non devo convertire la data di nascita inserita dall'utente in un numero intero. Questo risolve l'errore:

name = input("Come ti chiami? ")
dob = input("Qual è la tua data di nascita nel formato ddmmyy? ")
dd = dob[0:2]
mm = dob[2:4]
yy = dob[4:]
print(f"Ciao, {name}, \nIl tuo giorno di nascita è {dd} \nIl mese di nascita è {mm} \nE l'anno di nascita è {yy}.")

#Output: Come ti chiami? John Doe
# Qual è la tua data di nascita nel formato ddmmyy? 01011970
# Ciao, John Doe,
# Il tuo giorno di nascita è 01
# Il mese di nascita è 01
# E l'anno di nascita è 1970.

Conclusione

In questo articolo, hai imparato che cosa causa l'errore "TypeError: 'int' object is not subscriptable" in Python e come risolverlo.

Se stai ottenendo questo errore, significa che stai trattando un numero intero come un tipo di dato iterabile. I numeri interi non sono iterabili, quindi devi usare un tipo di dato differente o convertire il numero intero in un tipo di dato iterabile.

E se questo errore si verifica perché hai convertito qualcosa in un numero intero, allora devi riconvertirlo in un tipo di dato iterabile.

Grazie per aver letto.

Siamo tutti diversi, ma penso che quasi tutti amiamo ascoltare la musica.

Se vuoi tenere una versione locale degli stream audio che ascolti spesso, dovrai scaricare questi file. A volte potresti anche voler tagliare una porzione di questo file audio invece di avere solo il file intero disponibile.

Puoi sviluppare uno script di Python per fare esattamente queste cose. Puoi anche ampliarlo con delle funzionalità aggiuntive se preferisci. E ti mostrerò come farlo in questo tutorial.

Una Nota sul Copyright

Se hai mai usato internet prima d'ora, probabilmente sei consapevole del fatto che i problemi di copyright possono dare fastidio a molte persone - qualsiasi sia la loro posizione su come dovrebbero essere i contenuti gratuiti.

Anche la stessa libreria che andremo ad usare ha avuto la sua buona parte di problemi di copyright.

Fortunatamente, c'è del materiale non protetto da copyright disponibile con cui possiamo sia divertirci che giocare nei nostri programmi. Per questo motivo, in questo tutorial useremo il brano non protetto da diritti d'autore del quarto movimento della nona sinfonia di Beethoven.

Questa guida dà per scontato che userai i seguenti metodi per scaricare del materiale non protetto da copyright. Non usare queste informazioni per infrangere alcun copyright!

Cosa Faremo in Questo Tutorial

Per prima cosa installeremo la dipendenza di base, FFMPEG. Poi installeremo la libreria youtube-dl (che funziona anche con Vimeo ed altre piattaforme) per scaricare audio da un URL di YouTube e usarlo nel nostro codice di Python.

Poi scaricheremo la libreria pydub per ritagliare i file audio e implementare questa funzionalità nel nostro codice.

Infine, creeremo alcune amichevoli interfacce utente così da poter riutilizzare questo script in un secondo momento senza dover modificare il codice.

Questo è tutto ciò che verrà eseguito nella funzione main() così possiamo separare funzionalità, implementazione ed uso.

Come Installare il Pacchetto FFMPEG

Questo pacchetto è la parte essenziale di molti programmi multimediali (e di tutti quelli open-source che ho usato finora). Ne avremo bisogno per entrambe le librerie di Python che presto installeremo.

Come Installare su Linux

Se sei su un sistema basato su Debian (come Ubuntu o Kali), ecco il comando per installare FFMPEG:

sudo apt-get install ffmpeg

Se stai usando altre tipologie di distribuzioni, le istruzioni per installare sono qui.

Come Installare su Windows

Per prima cosa, installa il Chocolatey Package Manager. Le istruzioni per installarlo sono qui, ti aspetto.

Una volta che avrai correttamente installato chocolatey (se non lo avevi già), scarica il pacchetto eseguendo questo comando come amministratore su Powershell:

choco install ffmpeg

Come Installare su Mac

Se già non lo hai, installa homebrew. Poi, in un terminale:

brew install ffmpeg

Come Scaricare Audio da URL di YouTube Programmaticamente

Prima di tutto, scarica il pacchetto youtube-dl da pip. È uno tra quelli con più stelle su GitHub.

pip install youtube-dl

Importeremo questo modulo per poi dichiarare una funzione che scarica l'audio in un formato mp3 di qualità accettabile da un URL di YouTube.

import youtube_dl # client per molti portali multimediali

# scarica yt_url nella stessa cartella da cui viene eseguito lo script
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)

main()

Il metodo .download() scaricherà gradualmente lo stream audio come file .webm. Una volta che avrà determinato che l'intero file è disponibile, userà ffmpeg per convertirlo in un file MP3. Ciò significa che se succedesse qualcosa, ad esempio se ci fosse un calo di connessione quando solo il 90% del file è stato scaricato, il download riprenderà dal 90% invece che dall'inizio - molto conveniente.

Nota che se hai già il file mp3 scaricato, il download ricomincerà e sovrascriverà il file.

Esegui il tuo script di Python. Il download dell'audio di questa interpretazione del Quarto movimento della Nona sinfonia di Beethoven dovrebbe scaricare un file MP3 di ~33MB con il titolo del video disponibile localmente. Probabilmente sarà un po' lento, quindi vai pure a farti una tazza di tè.

Come puoi vedere, è possibile passare parametri opzionali a youtube-dl (che sarà disponibile anche come programma CLI autonomo al di fuori dello script). Una delle sue capacità è quella di scaricare una serie di video dall'URL di una playlist. Se sei interessato, puoi leggere la loro documentazione. In questo tutorial continuerò a farne un uso più superficiale.

Come Tagliare il File Scaricato

Una volta scaricato il file, andremo a tagliarlo arbitrariamente in locale (potresti esserti chiesto se fosse o meno possibile scaricare semplicemente una clip da YouTube. Tutti i metodi affidabili che ho trovato portano sempre a scaricare l'intero file e poi a modificarlo localmente). Per quello useremo la libreria pydub. Puoi installarla così:

pip install pydub

Questa è una libreria molto buona che ti permette di manipolare completamente l'audio, riducendo o aumentando il volume a determinati intervalli, ripetendo delle clip, e così via. Per ora, ci interessa solo tagliarlo.

Per tagliare il nostro file scaricato, dovremo prendere il nome del nostro nuovo file MP3, convertire il punto di inizio e il punto di fine dell'intervallo audio che desideriamo da 'ore:minuti:secondi' a millisecondi, e finalmente usare pydub per tagliare il nostro file audio.

Come prendere il nome del file

Sfortunatamente, il metodo .download() non restituisce il nome del file generato, a cui non avremmo comunque accesso avendo passato l'URL come parametro. Ma abbiamo Python che è uno strumento fantastico.

Sappiamo che stiamo cercando un file .mp3 che è stato generato giusto poco prima della nostra ricerca del nome del file (Python è un linguaggio a thread singolo e eseguirà il codice in modo sincrono di default). Prenderemo il nome del nostro file MP3 più recente nella cartella dello script, e quello sarà il nostro file.

Possiamo eseguire questa operazione elencando tutti i file .mp3 nella cartella locale, prendendo le loro marche temporali come numeri interi (dunque il tempo in millisecondi contato da una data del passato. Ciò significa che più alto sarà il valore, più lontano nel tempo il file sarà stato creato.) e scegliendo il file con il valore più alto.

Per questo avremo bisogno dei moduli glob per navigare nella cartella e os per prendere le informazioni delle marche temporali, entrambi già disponibili.

import glob
import os

def newest_mp3_filename():
    # elenca tutti gli mp3 nella cartella locale
    list_of_mp3s = glob.glob('./*.mp3')
    # restituisce l'mp3 con il valore di marca temporale più alto
    return max(list_of_mp3s, key = os.path.getctime)

Come ottenere HH:MM:SS in millisecondi

Una volta tagliato il nostro file, pydub si aspetta degli intervalli di tempo in millisecondi. Ma per noi esseri umani, calcolare il momento esatto in millisecondi ogni volta che tagliamo un video potrebbe risultare abbastanza fastidioso, quindi chiederemo gentilmente al computer di farlo per noi.

Il nostro input sarà una stringa nel formato HH:MM:SS. Questa cosa funziona bene se vogliamo tagliare un video più lungo di un'ora, ma la maggior parte delle volte vogliamo solo ottenere l'intervallo di tempo da un intervallo minuto:secondo ad un altro. Quindi dobbiamo tenere in considerazione anche questo.

Un millisecondo è un 1/1000 di un secondo, un minuto è formato da 60 secondi e un'ora è formata da 60 minuti. Dunque dobbiamo prima ottenere il valore per le ore, poi per i minuti, poi per i secondi, eseguire la conversione in millisecondi per ognuno e poi sommare le parti per ottenere il risultato.

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # se in formato HH:MM:SS
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # formato MM:SS
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # tempo in millisecondi
    return hours + minutes + seconds

Come Ottenere l'Audio Tagliato

Adesso leggeremo il nostro MP3 come oggetto pydub e taglieremo l'intervallo che desideriamo. La sintassi è la stessa dell'operazione di taglio per stringhe e array, ma invece di un indice per ogni elemento useremo i millisecondi per istanti specifici all'interno dell'audio.

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # restituisci un errore per fermare immediatamente l'esecuzione del programma
        raise Exception("Nessun MP3 nella cartella locale.")
    # legge l'mp3 come oggetto PyDub
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Inizio del processo di taglio del file ", mp3_filename, ".\n")
    print("Inizia da ", initial, "...")
    if (len(final) > 0):
        print("...fino a ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # da t0 fino a t1
    return sound[t0:] # t0 fino alla fine

Come Mettere Tutto Insieme

Alle Menschen werden Brüder,
Wo dein sanfter Flügel weilt.
-- Friedrich Schiller

Nel caso te lo stessi chiedendo, la traduzione del frammento qui sopra è "Tutti gli uomini diventano fratelli, dove la tua ala soave freme." È un frammento dell'Inno alla Gioia, un poema di Friedrich Schiller, che fa da testo alla maggior parte delle parti corali del Quarto movimento.

Questo è il frammento più famoso del movimento più famoso della sinfonia più famosa di Beethoven. Chiunque tu sia, dovunque e comunque tu sia stato cresciuto, quasi sicuramente riconoscerai questo brano.

Adesso metteremo insieme tutto ciò che abbiamo fatto. Scaricheremo l'audio da YouTube, taglieremo la parte corale dell'Inno alla Gioia (da 9:51 a 14:04), e lo salveremo come <filename> - TRIM.mp3.

Se hai seguito correttamente il tutorial, aggiorna la tua funzione main() per eseguire ogni fase in modo da avere sia l'MP3 intero che la versione tagliata nella cartella da cui eseguirai lo script. Non dimenticarti di eseguire la funzione main() alla fine dello script.

def main():
    yt_url = "https://www.youtube.com/watch?v=8OAPLk20epo"
    download_audio(yt_url)
    initial = "9:51"
    final = "14:04"
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Processo concluso con successo. Salvataggio del file tagliato con il nome ", trimmed_filename)
    # salva il file con il nuovo nome
    trimmed_file.export(trimmed_filename, format="mp3")

Come Aggiungere l'Interazione dell'Utente Direttamente da CLI

Per questa parte avremo bisogno del modulo sys di Python, che legge l'input passato dalla linea di comando (tra le altre cose). Aggiorneremo semplicemente le variabili della funzione main() per leggere l'input dalla CLI invece dei dati che sono scritti nel codice.

ARGV legge l'input in modo sequenziale come un array, iniziando dall'indice 1 (0 rappresenta il nome dello script di Python in esecuzione). Lo imposteremo in modo da fargli leggere un URL come primo argomento, poi (questo è opzionale) gli istanti iniziali e finali per tagliarlo.

import sys

def main():
    if (not len(sys.argv) > 1):
        print("Per favore, inserisci l'URL di una piattaforma multimediale supportata da youtube-dl come primo argomento.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # esci se non vengono inseriti istanti come argomenti
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Processo concluso con successo. Salvataggio del file tagliato con il nome ", trimmed_filename)
    # salva il file con il nuovo nome
    trimmed_file.export(trimmed_filename, format="mp3")

Esegui il file per collaudarlo. Ricordati di usare il nome dello script che si trova sul tuo dispositivo.

python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04

Script Finale

Ecco la versione finale di tutto quanto messo insieme. Nota che i commenti sui moduli sono solo relativi a quello per cui dobbiamo usarli e che la funzione main() viene chiamata nell'ultima riga.

import youtube_dl # client per scaricare da molti portali multimediali
import glob # operazioni nelle cartelle
import os # interfaccia per prendere le informazioni sui file fornite dal sistema operativo
import sys # interfaccia per la linea di comando
from pydub import AudioSegment # solo operazioni audio

def newest_mp3_filename():
    # elenca tutti gli mp3 nella cartella locale
    list_of_mp3s = glob.glob('./*.mp3')
    # restituisce l'mp3 con il valore di marca temporale più alto
    return max(list_of_mp3s, key = os.path.getctime)

def get_video_time_in_ms(video_timestamp):
    vt_split = video_timestamp.split(":")
    if (len(vt_split) == 3): # se in formato HH:MM:SS
        hours = int(vt_split[0]) * 60 * 60 * 1000
        minutes = int(vt_split[1]) * 60 * 1000
        seconds = int(vt_split[2]) * 1000
    else: # formato MM:SS
        hours = 0
        minutes = int(vt_split[0]) * 60 * 1000
        seconds = int(vt_split[1]) * 1000
    # tempo in millisecondi
    return hours + minutes + seconds

def get_trimmed(mp3_filename, initial, final = ""):
    if (not mp3_filename):
        # restituisci un errore per fermare immediatamente l'esecuzione del programma
        raise Exception("Nessun MP3 nella cartella locale.")
    # legge l'mp3 come oggetto PyDub
    sound = AudioSegment.from_mp3(mp3_filename)
    t0 = get_video_time_in_ms(initial)
    print("Inizio del processo di taglio del file ", mp3_filename, ".\n")
    print("Inizia da ", initial, "...")
    if (len(final) > 0):
        print("...fino a ", final, ".\n")
        t1 = get_video_time_in_ms(final)
        return sound[t0:t1] # da t0 fino a t1
    return sound[t0:] # t0 fino alla fine



# scarica yt_url nella stessa cartella da cui viene eseguito lo script
def download_audio(yt_url):
    ydl_opts = {
        'format': 'bestaudio/best',
        'postprocessors': [{
            'key': 'FFmpegExtractAudio',
            'preferredcodec': 'mp3',
            'preferredquality': '192',
        }],
    }
    with youtube_dl.YoutubeDL(ydl_opts) as ydl:
        ydl.download([yt_url])

def main():
    if (not len(sys.argv) > 1):
        print("Per favore, inserisci l'URL di una piattaforma multimediale supportata da youtube-dl come primo argomento.")
        return
    yt_url = sys.argv[1]
    download_audio(yt_url)
    if (not len(sys.argv > 2)): # esci se non vengono inseriti istanti come argomenti
        return
    initial = sys.argv[2]
    final = ""
    if (sys.argv[3]):
        final = sys.argv[3]
    filename = newest_mp3_filename()
    trimmed_file = get_trimmed(filename, initial, final)
    trimmed_filename = "".join([filename.split(".mp3")[0], "- TRIM.mp3"])
    print("Processo concluso con successo. Salvataggio del file tagliato con il nome ", trimmed_filename)
    # salva il file con il nuovo nome
    trimmed_file.export(trimmed_filename, format="mp3")

# esempio d'uso:
# python ytauddown.py https://www.youtube.com/watch?v=8OAPLk20epo 9:51 14:04
main()

Esercizi Consigliati

1. Individua se il primo input è un URL valido oppure no. Dai un'occhiata alle RegEx di Python se non sai da dove partire.
2. Individua se il secondo e il terzo input sono in un formato valido (ore:minuti:secondi OPPURE minuti:secondi).
3. Aggiungi un'opzione per rinominare il file MP3 direttamente dalla CLI. Ricorda che gli argomenti di ARGV vengono eseguiti in ordine.
4. Riscrivi lo script per interagire con le sue funzionalità usando una GUI. Può essere sia un'app locale che un'app web, come preferisci.

Considerazioni Finali

Spero che ti divertirai con questo progetto e che ne farai buon uso.

Ricorda che guadagnarsi da vivere come artista è molto difficile, specialmente per la maggior parte di coloro che non hanno il supporto di un'azienda. Ricorda di supportare gli artisti che ti piacciono ogni volta che puoi e ricordati inoltre di supportare i software open-source.

MacOS ha già Python pre-installato. Ma è la versione 2.7, che adesso è superata (abbandonata dalla comunità di sviluppatori di Python).

L'intera comunità di Python adesso usa Python 3.x (la versione più recente al momento in cui viene scritto questo articolo è la 3.9). E presto verrà rilasciato Python 4.x, ma sarà totalmente retrocompatibile.

Se provi ad avviare Python dal tuo terminale di MacOS, vedrai questo avviso:

Fino a quando Apple non deciderà di impostare Python 3.x come versione predefinita, dovrai installarlo per conto tuo.

Un Singolo Comando per Eseguire Python 3

Per alcune delle persone che stanno leggendo questo articolo, questo comando potrebbe essere sufficiente. Puoi eseguire Python 3 usando questo comando (con il 3 alla fine).

python3

Se questo è tutto ciò per cui siete qui, non preoccupatevi. Buona giornata e buona programmazione.

Ma se vuoi un vero e proprio sistema di controllo di versione di Python per tenere traccia delle varie versioni - e avere un maggiore controllo su quale versione usi - questo tutorial ti mostrerà esattamente come ottenerlo.

Come Installare Homebrew su Mac

Per prima cosa hai bisogno di installare Homebrew, un potente sistema di gestione dei pacchetti per Mac.

Apri il tuo terminale. Puoi farlo usando MacOS spotlight (command + spazio) e scrivendo "terminal".

Ora che sei su una linea di comando, puoi installare l'ultima versione di Homebrew eseguendo questo comando:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Il tuo terminale chiederà i permessi di accesso di livello Super User. Avrai bisogno di inserire la tua password per eseguire questo comando. È la stessa password che inserisci quando fai log in sul tuo Mac. Inseriscila e premi invio.

Homebrew ti chiederà di confermare di voler installare i seguenti elementi. Devi premere invio per continuare (o premere qualsiasi altro tasto se ci hai ripensato.)

Come Installare pyenv per Gestire le Tue Versioni di Python

Adesso prendiamoci un momento per installare PyEnv. Questa libreria ti aiuterà a passare da una versione di Python all'altra (in caso avessi bisogno di eseguire Python 2.x per qualche motivo, e in vista dell'arrivo di Python 4.0).

Esegui questo comando:

brew install pyenv

Adesso puoi installare l'ultima versione di Python.

Come Usare pyenv per Installare Python o Aggiornare la Tua Versione di Python

Adesso devi solamente eseguire il seguente comando:

pyenv install 3.9.2 

Nota che puoi sostituire 3.9.2 con qualunque sia l'ultima versione di Python. Per esempio, quando uscirà Python 4.0.0, potrai eseguire questo:

pyenv install 4.0.0

Risoluzione Problemi dell'Installazione di pyenv

Se incorri in un errore che dice "C compiler cannot create executables" (Il compilatore C non può creare file eseguibili), il modo più semplice di risolverlo è installare da capo Xcode di Apple.

Xcode è uno strumento creato da Apple che include tutte le librerie di C e altri strumenti che Python usa quando viene eseguito su MacOS. Xcode occupa la bellezza di 11 gigabyte, ma vorrai avere la versione più aggiornata. Potresti voler eseguire l'installazione mentre stai dormendo.

Puoi ottenere l'ultima versione di Xcode di Apple qui. Ho dovuto farlo dopo aver aggiornato MacOS Big Sur, ma una volta fatto tutti i comandi hanno funzionato senza problemi. Semplicemente esegui di nuovo il comando pyenv install 3.9.2 e adesso dovrebbe funzionare.

Come Configurare il tuo PATH di MacOS per pyenv (Bash o ZSH)

Per prima cosa hai bisogno di aggiornare il tuo path Unix per fare in modo che PyEnv possa interagire con il tuo sistema.

Ecco una lunga spiegazione di come funziona il PATH su MacOS (e Unix), direttamente dal repository di GitHub di pyenv.

Quando esegui un comando come python o pip, il tuo sistema operativo cerca in una lista di cartelle un file eseguibile con quel nome. Questa lista di cartelle si trova in una variabile d'ambiente chiamata PATH, con ogni cartella della lista separata da due punti:

/usr/local/bin:/usr/bin:/bin

Le cartelle all'interno di PATH vengono cercare da sinistra a destra, quindi il file eseguibile corrispondente che si trova in una cartella all'inizio della lista ha la precedenza su un altro che si trova alla fine. In questo esempio, la cartella  /usr/local/bin verrà ispezionata prima, poi /usr/bin, poi /bin.

Ed ecco la spiegazione di cosa è uno Shim. Sto citando di nuovo il documento per esteso perché non riesco davvero a spiegarlo meglio di così.

pyenv funziona inserendo una cartella di shim all'inizio del tuo PATH:

$(pyenv root)/shims:/usr/local/bin:/usr/bin:/bin

Attraverso un processo chiamato rehashing, pyenv mantiene gli shim in quella cartella così che trovi le corrispondenze per ogni comando di Python attraverso tutte le versioni di Python installate —python, pip, e così via.

Gli shim sono file eseguibili leggeri che passano semplicemente il tuo comando a pyenv.

Ecco come aggiornare il tuo .bash_profile su Bash (che è già installato su MacOS):

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.bash_profile

Poi esegui:

echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.bash_profile

Nota: se non hai una cartella /bin nella tua cartella pyenv_root (puoi avere solo una cartella /shims) potresti aver bisogno di eseguire questa versione del comando:

`echo 'export PATH="$PYENV_ROOT/shims:$PATH"' >> ~/.bash_profile`

Dopodiché vorrai aggiungere PyEnv Init al tuo terminale. Esegui questo comando se stai usando Bash (che, ripeto, è già installato su MacOS):

echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init -)"\nfi' >> ~/.bash_profile

Adesso resetta il tuo terminale eseguendo questo comando:

reset

Come Configurare il tuo PATH su MacOS per pyenv su ZSH o OhMyZSH

Se invece di Bash, già installato su Mac, stai usando ZSH (o OhMyZSH) come me, potresti voler modificare il file .zshrc:

echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc

Poi esegui questo:

echo -e 'if command -v pyenv 1>/dev/null 2>&1; then\n  eval "$(pyenv init --path)"\n  eval "$(pyenv init -)"\nfi' >> ~/.zshrc

Come Impostare una Versione Globale Predefinita di Python (Bash o ZSH)

Puoi impostare la versione più recente di Python come globale, il che significa che sarà la versione predefinita di Python che MacOS usa quando esegui delle applicazioni di Python.

Esegui questo comando:

pyenv global 3.9.2

Di nuovo, puoi sostituire 3.9.2 con qualunque sia l'ultima versione.

Adesso puoi verificare che abbia funzionato controllando la versione globale di Python:

pyenv versions

Dovresti visualizzare questo output:

Ultima Fase: Chiudi il Tuo Terminale e Riavvialo

Dopo aver riavviato il tuo terminale, esegui il comando python e avvierai la nuova versione di Python invece di quella vecchia.

Congratulazioni. Grazie per aver letto, e buona programmazione.