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!

Un'interfaccia in Java è un po' come una classe, ma con una differenza significativa: una interface può avere solo le firme dei metodi, attributi e metodi di default. A partire da Java 8, puoi anche creare metodi di default. Nel prossimo blocco di codice puoi vedere un esempio di interfaccia:

public interface Veicolo {
    public String targa = "";
    public float maxVel;
    public void accendi();
    public void spegni();
    default void suonaClacson(){
      System.out.println("Sto suonando il clacson");
   }
}

L'interfaccia qui in alto contiene due attributi, due metodi e un metodo di default. Da sola, non è molto utile, ma di solito vengono usate insieme alle Classi. In che modo? Semplice, devi assicurarti che delle classi la implementino, usando la parola chiave implements.

public class Macchina implements Veicolo {
    public void accendi() {
        System.out.println("avvio del motore...");
    }
    public void spegni() {
        System.out.println("spegnendo il motore...");
    }
}

Ora, c'è una regola di base: la classe deve implementare tutti i metodi dell'interfaccia. I metodi devono avere la stessa identica firma (nome, parametri ed eccezioni) così com'è descritta nell'interfaccia. La classe, però, non ha bisogno di dichiarare gli attributi, solo i metodi.

Istanze di un'Interfaccia

Una volta creata una classe di Java che implementa una qualsiasi Interfaccia, l'istanza dell'oggetto deve essere referenziata come istanza dell'interfaccia. Questo concetto è simile a quello dell'istanziazione ereditaria.

// facendo seguito al nostro esempio di prima

Veicolo tesla = new Macchina();

tesla.parti(); // avvio del motore ...

Un'interfaccia non può contenere un costruttore. Per questo, non puoi creare un'istanza dell'interfaccia stessa. Devi creare un'istanza di una classe implementando un'interfaccia per poterla referenziare.

Pensa alle interfacce come a moduli di contratto vuoti, o come template.

Che cosa puoi fare con questa funzionalità? Polimorfismo! Puoi usare solo le interfacce per riferirti alle istanze dell'oggetto!

class Camion implements Veicolo {
    public void avvio() {
        System.out.println("avvio del motore del camion...");
    }
    public void spegni() {
        System.out.println("spegnimento del motore del camion...");
    }
}

class Starter {
    // metodo statico, può essere invocato senza istanziare la classe
    public static void avviaMotore(Veicolo veicolo) {
        veicolo.avvio();
    }
}

Veicolo tesla = new Macchina();
Veicolo tata = new Camion();

Starter.avviaMotore(tesla); // avvio del motore ...
Starter.avviaMotore(tata); // avvio del motore del camion ...

E per quanto riguarda molteplici interfacce?

Sì, puoi implementare molteplici interfacce in una sola classe. Mentre nell'ereditarietà tra classi sei costretto ad ereditare da una sola classe, qui puoi estendere un numero qualsiasi di interfacce. Ma non dimenticare di implementare tutti i metodi di tutte le Interfacce, altrimenti la compilazione fallirà!

public interface GPS {
    public void ottieniCoordinate();
}

public interface Radio {
    public void accendiRadio();
    public void spegniRadio();
}

public class Smartphone implements GPS,Radio {
    public void ottieniCoordinate() {
        // return delle coordinate
    }
    public void accendiRadio() {
      // accendi Radio
    }
    public void spegniRadio() {
        // spegni Radio
    }
}

Alcune caratteristiche delle Interfacce

• Puoi inserire delle variabili all'interno di un'Interfaccia, anche se non sarebbe una decisione sensata poiché le Classi non sono tenute ad avere la stessa variabile. In breve, evita di inserire delle variabili!
• Tutte le variabili e i metodi in un'Interfaccia sono pubblici, anche se non metti la parola chiave public.
• Un'Interfaccia non può specificare l'implementazione di un metodo in particolare. Sta alle Classi farlo. Anche se c'è stata una recente eccezione (vedi più avanti).
• Se una Classe implementa più Interfacce, allora c'è una remota possibilità che la firma di un metodo coincida con un'altra. Poiché Java non permette di avere più metodi con la stessa firma, questo può causare problemi. Dai un'occhiata a questa domanda per maggiori informazioni.

Metodi di Default delle Interfacce

Prima di Java 8, non c'era nessun modo per far sì che un'interfaccia avesse una specifica implementazione di un metodo. Questo porta ad un sacco di confusione ed errori di codice nel caso in cui la definizione di un'interfaccia venga cambiata.

Ipotizza di aver scritto una libreria open source, che contiene un'Interfaccia. Supponiamo che i tuoi clienti, ovvero praticamente tutti gli sviluppatori del mondo, ne stiano facendo ampio uso e siano felici. Adesso hai dovuto aggiornare la libreria aggiungendo una nuova definizione di un metodo dell'Interfaccia per supportare una nuova funzionalità. Ma questo romperebbe tutti i build, poiché tutte le Classi che implementano quell'Interfaccia devono essere cambiate. Che catastrofe!

Fortunatamente, Java 8 adesso ci mette a disposizione dei metodi default per le Interfacce. Un metodo default può contenere una sua implementazione direttamente all'interno dell'Interfaccia. Dunque, se una Classe non implementa il metodo di default, il compilatore prenderà l'implementazione menzionata nell'Interfaccia. Comodo, vero? Dunque, nella tua libreria, potrai aggiungere qualsiasi numero di metodi di default nelle interfacce senza temere di rompere nulla!

public interface GPS {
    public void ottieniCoordinate();
    default public void ottieniCoordinateApprossimative() {
        // implementazione per restituire coordinate da fonti approssimative
        // come il wifi o il telefono
        System.out.println("Prendo coordinate approssimative...");
    }
}

public interface Radio {
    public void accendiRadio();
    public void spegniRadio();
}

public class Smartphone implements GPS,Radio {
    public void ottieniCoordinate() {
        // return delle coordinate
    }
    public void accendiRadio() {
      // accendi Radio
    }
    public void spegniRadio() {
        // spegni Radio
    }

    // nessuna implementazione per ottieniCoordinateApprossimative()
}

Smartphone motoG = new Smartphone();
motog.ottieniCoordinateApprossimative(); // Prendo coordinate approssimative...

Ma cosa succede se due interfacce hanno la stessa firma di un metodo?

Ottima domanda. In quel caso, se non fornisci un'implementazione all'interno della Classe, il povero compilatore si confonderà e, semplicemente, fallirà! Devi fornire un'implementazione di metodo di default anche all'interno della Classe. C'è anche un modo elegante di farlo usando super per chiamare l'implementazione che preferisci:

public interface Radio {
    // public void accendiRadio();
    // public void spegniRadio();

    default public void prossima() {
        System.out.println("Prossima canzone dalla Radio");
    }
}

public interface LettoreMusicale {
    // public void accendi();
    // public void pausa();
    // public void spegni();

    default public void prossima() {
        System.out.println("Prossima canzone dal lettore musicale");
    }
}

public class Smartphone implements Radio, LettoreMusicale {
    public void prossima() {
        // Supponiamo che tu voglia chiamare prossima() del LettoreMusicale
        LettoreMusicale.super.prossima();
    }
}

Smartphone motoG = new Smartphone();
motoG.prossima(); // Prossima canzone dal lettore musicale

Metodi Statici nelle Interfacce

Un'altra novità in Java 8 è la possibilità di aggiungere metodi statici alle interfacce. I metodi statici delle interfacce sono quasi identici ai metodi statici delle classi concrete. L'unica grande differenza è che i metodi static non sono ereditati nelle classi che implementano l'interfaccia. Ciò significa che quando si chiama il metodo statico viene referenziata l'interfaccia, non la classe che lo implementa.

interface LettoreMusicale {
  public static void spotPubblicitario(String sponsor) {
    System.out.println("Adesso una promozione da " + sponsor);
  }
  
  public void riproduci();
}


class Smartphone implements LettoreMusicale {
	public void riproduci() {
		System.out.println("Riproduco da smartphone");
	}
}

class Main {
  public static void main(String[] args) {
    Smartphone motoG = new Smartphone();
    MusicPlayer.spotPubblicitario("Motorola"); // Chiamato dall'interfaccia, non dalla classe che la implementa
    // motoG.spotPubblicitario("Motorola"); // Questo causerebbe un errore di compilazione
  }
}

Ereditarietà nelle interfacce

È inoltre possibile, in Java, che un'interfaccia erediti un'altra interfaccia usando, come hai già immaginato, la parola chiave extends:

public interface Lettore {
    public void accendi();
    public void pausa();
    public void spegni();
}

public interface LettoreMusicale extends Lettore {
    default public void prossima() {
        System.out.println("Prossima canzone dal lettore musicale");
    }
}

Ciò significa che la Classe che implementa l'Interfaccia LettoreMusicale deve implementare tutti i metodi di LettoreMusicale così come quelli di Lettore:

public class SmartPhone implements LettoreMusicale {
    public void accendi() {
        System.out.println("Accensione");
    }
    public void spegni() {
        System.out.println("Spegnimento");
    }
    public void pausa() {
        System.out.println("Messo in pausa");
    }
}

Adesso hai una visione più chiara delle interfacce di Java! Dai un'occhiata alle Classi Astratte per vedere un altro modo in cui Java ti permette di definire contratti.

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!

In questo articolo vedremo come convertire una stringa in un array di caratteri in Java. Ti spiegherò brevemente anche che cosa sono le stringhe, i caratteri e gli array.

Che Cos'è un Carattere in Java?

I caratteri sono tipi di dato primitivi. Un carattere è un singolo carattere racchiuso tra due apici singoli. Può essere una lettera, un numero, un segno di punteggiatura, uno spazio o qualcosa di simile. Per esempio:

char primaVocale = 'a';

Che Cos'è una Stringa in Java?

Le stringhe sono oggetti (tipo di riferimento). Una stringa è composta da una serie di caratteri. È qualsiasi cosa che si trova tra le doppie virgolette. Per esempio:

String vocali = "aeiou";

Che Cos'è un Array in Java?

Gli array sono strutture di dati fondamentali che in Java possono immagazzinare un determinato numero di elementi dello stesso tipo di dato. Per esempio, dichiariamo un array di caratteri:

char[] arrayVocali = {'a', 'e', 'i', 'o', 'u'};

Ora abbiamo una conoscenza di base di quello che sono stringhe, caratteri e array.

Convertiamo una Stringa in un Array di Caratteri

1. Usa il Metodo di Istanza toCharArray()

toCharArray() è un metodo d'istanza della classe String. Restituisce un nuovo array di caratteri basato sull'oggetto stringa corrente.

Vediamo un esempio:

// definisci una stringa
String vocali = "aeiou";

// crea un array di caratteri 
char[] arrayVocali = vocali.toCharArray();

// stampa arrayVocali
System.out.println(Arrays.toString(arrayVocali));

Output: [a, e, i, o, u]

Quando convertiamo una stringa in un array di caratteri, la lunghezza rimane la stessa. Controlliamo la lunghezza di vocali e di arrayVocali:

System.out.println("La lunghezza di \'vocali\' è " + vocali.length());
System.out.println("La lunghezza di \'arrayVocali\' è " + arrayVocali.length);

Output:

La lunghezza di 'vocali' è 5
La lunghezza di 'arrayVocali' è 5

Possiamo usare diversi modi di stampare un array. Ho usato il metodo statico toString() dalla classe di utilità Arrays.

Puoi leggere di più riguardo il metodo d'istanza toCharArray() nella documentazione di Java.

2. Usa il Metodo di Istanza charAt()

charAt() è un metodo d'istanza della classe String. Restituisce il carattere che si trova all'indice specificato della stringa corrente.

NOTA: una stringa ha indici che partono da zero, come un array.

Vediamo come possiamo convertire una stringa in un array di caratteri usando charAt() :

// definisci una stringa
String vocali = "aeiou";

// crea un array di caratteri. La lunghezza è la lunghezza di 'vocali'
char[] arrayVocali = new char[vocali.length()];

// usa un ciclo per iterare attraverso ogni carattere nella stringa 'vocali'
for (int i = 0; i < vocali.length(); i++) {
    // aggiungi ogni carattere all'array di caratteri
    arrayVocali[i] = vocali.charAt(i);
}

// stampa l'array
System.out.println(Arrays.toString(arrayVocali));

Output: [a, e, i, o, u]

Puoi leggere di più riguardo il metodo d'istanza charAt() nella documentazione di Java.

Ti ho appena mostrato un altro modo di convertire una stringa in un array di caratteri, ma possiamo usare il metodo toCharArray() per convertirla facilmente invece di creare un loop e iterare attraverso la stringa.

Sentiti libero di farmi sapere se hai suggerimenti o domande.

Foto di Alex Alvarez su Unsplash.

Supporta freeCodeCamp nella loro Raccolta Fondi del Curriculum di Scienza dei Dati.

Mettiti in contatto con me su Medium.

Grazie 😇

Buona Programmazione ❤️

Per saperne di più sulla Programmazione in Java

1. Principi di Programmazione Orientata agli Oggetti in Java: Concetti OOP per Principianti
2. Metodi degli Array in Java - Come Stampare un Array in Java
3. Da Stringa a Int in Java - Come Convertire una Stringa in un Numero Intero
4. Generatore di Numeri Casuali in Java - Come Generare Numeri Interi con Math Random

Un array è una struttura di dati usata per immagazzinare dati dello stesso tipo. Gli array immagazzinano i propri elementi in posizioni di memoria contigue.

In Java, gli array sono oggetti. Tutti i metodi della classe object possono essere chiamati su un array. Possiamo immagazzinare un numero fisso di elementi in un array.

Dichiariamo un semplice array di tipo primitivo:

int[] intArray = {2,5,46,12,34};

Adesso proviamo a stamparlo usando il metodo System.out.println():

System.out.println(intArray);
// output: [I@74a14482

Perché Java non ha stampato il nostro array? Che cosa sta succedendo dietro le quinte?

Il metodo System.out.println() converte l'oggetto che abbiamo passato in una stringa chiamando String.valueOf(). Se diamo un'occhiata all'implementazione del metodo String.valueOf() vedremo questo:

public static String valueOf(Object obj) {
    return (obj == null) ? "null" : obj.toString();
}

Se l'oggetto passato è null ci restituisce null, altrimenti chiama il metodo obj.toString() . Alla fine, System.out.println() chiama toString() per stampare l'output.

Se la classe di quell'oggetto non sovrascrive l'implementazione di Object.toString(), chiamerà il metodo Object.toString().

Object.toString() restituisce getClass().getName()+‘@’+Integer.toHexString(hashCode()) . In parole povere, restituisce: "nome della classe @ codice hash dell'oggetto".

Nel nostro precedente output [I@74a14482 , [ esprime che si tratta di un array, e I sta per int (il tipo dell'array). 74a14482 è la rappresentazione esadecimale senza segno del codice hash dell'array.

Ogni volta che creiamo le nostre classi personalizzate, è buona prassi sovrascrivere il metodo Object.toString().

Non possiamo stampare gli array in Java usando il banale metodo System.out.println(). Invece, questi sono i modi in cui possiamo stampare un array:

1. Loop: loop for e loop for-each
2. Il metodo Arrays.toString()
3. Il metodo Arrays.deepToString()
4. Il metodo Arrays.asList()
5. L'interfaccia Java Iterator
6. Java Stream API

Vediamoli uno ad uno.

1. Loop: loop for e loop for-each

Ecco un esempio di un loop for:

int[] intArray = {2,5,46,12,34};

for(int i=0; i<intArray.length; i++){
    System.out.print(intArray[i]);
    // output: 25461234
}

Tutte le classi wrapper sovrascrivono Object.toString() e restituiscono una rappresentazione del loro valore in formato di stringa.

Ed ecco un loop for-each:

int[] intArray = {2,5,46,12,34};

for(int i: intArray){
    System.out.print(i);
    // output: 25461234
}

2. Il metodo Arrays.toString()

Arrays.toString() è un metodo statico della classe array che appartiene al package java.util. Restituisce una rappresentazione dei contenuti dell'array specificato in formato di stringa. Possiamo stampare array unidimensionali usando questo metodo.

Gli elementi dell'array sono convertiti in stringhe usando il metodo String.valueOf(), in questo modo:

int[] intArray = {2,5,46,12,34};
System.out.println(Arrays.toString(intArray));
// output: [2, 5, 46, 12, 34]

Per un array di riferimenti, dobbiamo assicurarci che la classe del tipo di riferimento sovrascriva il metodo Object.toString().

Per esempio:

public class Test {
    public static void main(String[] args) {
        Studente[] studenti = {new Studente("John"), new Studente("Doe")};
        
        System.out.println(Arrays.toString(studenti));
        // output: [Studente{nome='John'}, Studente{nome='Doe'}]
    }
}

class Studente {
    private String nome;

    public Student(String nome){
        this.nome = nome;
    }

    public String getNome() {
        return nome;
    }

    public void setNome(String nome) {
        this.nome = nome;
    }

    @Override
    public String toString() {
        return "Studente{" + "nome='" + nome + '\'' + '}';
    }
}

Questo metodo non è appropriato per array multidimensionali. Converte gli array multidimensionali in stringhe usando Object.toString() che descrive i loro id al posto dei loro contenuti.

Per esempio:

// creo un array multidimensionale
int[][] multiDimensionalArr = { {2,3}, {5,9} };

System.out.println(Arrays.toString(multiDimensionalArr));
// output: [[I@74a14482, [I@1540e19d]

Con l'aiuto di Arrays.deepToString(), possiamo stampare array multidimensionali.

3. Il metodo Arrays.deepToString()

Arrays.deepToString() restituisce una rappresentazione dei "contenuti profondi" dell'array specificato in formato di stringa.

Se l'elemento è un array di tipo primitivo, viene convertito in una stringa chiamando il sovraccarico appropriato di Arrays.toString() .

Ecco un esempio di un array multidimensionale di tipo primitivo:

// creo un array multidimensionale
int[][] multiDimensionalArr = { {2,3}, {5,9} };

System.out.println(Arrays.deepToString(multiDimensionalArr));
// output: [[2, 3], [5, 9]]

Se l'elemento è un array di riferimenti, viene convertito in una stringa chiamando ricorsivamente Arrays.deepToString().

Insegnante[][] insegnanti = 
{{ new Insegnante("John"), new Insegnante("David") }, {new Insegnante("Mary")} };

System.out.println(Arrays.deepToString(insegnanti));
// output: 
[[Insegnante{nome='John'}, Insegnante{nome='David'}],[Insegnante{nome='Mary'}]]

Dobbiamo sovrascrivere Object.toString() nella nostra classe Insegnante.

Se ti incuriosisce il modo in cui viene eseguita la ricorsione, ecco il codice sorgente del metodo Arrays.deepToString().

NOTA: anche gli array unidimensionali di riferimenti possono essere stampati usando questo metodo. Per esempio:

Integer[] oneDimensionalArr = {1,4,7};

System.out.println(Arrays.deepToString(oneDimensionalArr));
// output: [1, 4, 7]

4. Il metodo Arrays.asList()

Questo metodo restituisce una lista di dimensioni fisse costruita sull'array specificato.

Integer[] intArray = {2,5,46,12,34};

System.out.println(Arrays.asList(intArray));
// output: [2, 5, 46, 12, 34]

Abbiamo cambiato il tipo da int a Integer, perché List è un insieme che contiene una lista di oggetti. Quando convertiamo un array in una lista dovrebbe essere un array di riferimenti.

Java chiama Arrays.asList(intArray).toString() . Questa tecnica usa internamente il metodo toString() del tipo degli elementi all'interno della lista.

Un altro esempio con la nostra classe personalizzata Insegnante:

Insegnante[] insegnante = { new Insegnante("John"), new Insegnante("Mary") };

System.out.println(Arrays.asList(insegnante));
// output: [Insegnante{nome='John'}, Insegnante{nome='Mary'}]

NOTA: non possiamo stampare array multidimensionali usando questo metodo. Per esempio:

Insegnante[][] insegnanti = 
{{ new Insegnante("John"), new Insegnante("David") }, { new Insegnante("Mary") }};
        
System.out.println(Arrays.asList(insegnanti));

// output: [[Lcom.thano.article.printarray.Insegnante;@1540e19d, [Lcom.thano.article.printarray.Insegnante;@677327b6]

5. L'interfaccia Java Iterator

In modo simile a un loop for-each, possiamo usare l'interfaccia Iterator per iterare attraverso gli elementi dell'array e stamparli.

L'oggetto Iterator può essere creato chiamando il metodo iterator() su una Collection. Quell'oggetto verrà usato per iterare attraverso gli elementi della Collection.

Ecco un esempio di come possiamo stampare un array usando l'interfaccia Iterator:

Integer[] intArray = {2,5,46,12,34};

// creo una List di Integer
List<Integer> list = Arrays.asList(intArray);

// creo un iteratore della Integer List
Iterator<Integer> it = list.iterator();

// se la List ha elementi da iterare
while(it.hasNext()) {
    System.out.print(it.next());
    // output: 25461234
}

6. Java Stream API

La Stream API è usata per lavorare con insiemi di oggetti. Uno stream è una sequenza di oggetti. Gli stream non cambiano la struttura dei dati originaria, forniscono soltanto il risultato delle operazioni richieste.

Con l'aiuto dell'operazione terminale forEach() possiamo iterare attraverso ogni elemento dello stream.

Per esempio:

Integer[] intArray = {2,5,46,12,34};

Arrays.stream(intArray).forEach(System.out::print);
// output: 25461234

Adesso sappiamo come stampare un array in Java.

Grazie per aver letto.

Immagine di copertina di Aziz Acharki su Unsplash.

Puoi leggere gli altri miei articoli su Medium.

Buona Programmazione!

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.

Se lavori con Java, probabilmente hai usato uno dei più famosi editor di testo come Sublime Text, VS Code, Brackets, Atom, e Notepad++, o anche IDE come Apache NetBeans e IntelliJ IDEA.

Eseguire il codice nel tuo IDE è immediato, ma spesso non riesci a vedere in che modo viene eseguito il codice (anche se ovviamente puoi controllare il comando nel terminale).

Tuttavia, è buona prassi sapere come viene eseguito effettivamente il codice e come viene prodotto l'output che ti restituisce.

Molti di voi potrebbero aver sentito che gli sviluppatori professionisti esperti usano anche il terminale per eseguire i programmi. Questo dà loro una visione più chiara e li aiuta a capire in che modo sta funzionando il codice, dove sta restituendo il valore desiderato, dove potrebbe trovarsi un bug, e così via.

Qualsiasi sia l'obiettivo, eseguire il codice Java direttamente dal terminale è un lavoro molto semplice.

In questo articolo ti mostrerò come puoi eseguire il codice Java direttamente dalla tua finestra del terminale preferita. Non temere! La procedura è abbastanza semplice, e dopo aver letto l'intero articolo dovresti essere in grado di eseguire il tuo codice Java dal terminale.

Come Eseguire il Codice Java nel Terminale

Il processo che sto per mostrarti in questo articolo si applica a qualsiasi sistema operativo, che sia Windows, MacOS o Linux.

Userò il seguente codice Java nel prossimo passaggio.

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

📦 Step 1 – Vai nella cartella dove si trova il codice sorgente

Se hai già scritto il tuo codice Java in un editor, allora vai semplicemente in quella cartella. Puoi andare direttamente nella cartella usando il gestore dei file se vuoi.

Come andare nella cartella dove si trova il codice sorgente: per Windows 🪟

Supponiamo di avere il codice sorgente (Main.java) dentro la cartella This PC > Documents. Posso andare lì semplicemente usando Esplora File.

Oppure, volendo, posso anche andarci usando il mio terminale. Devo usare cd (da "change directory" in inglese) per indicare che voglio cambiare cartella .

In questo caso, posso usare cd "C:\Users\Md. Fahim Bin Amin\Documents". Poiché il mio nome utente contiene degli spazi, ho usato " " per racchiuderli.

Poi se controllo tutti i file all'interno di quella cartella, vedrò anche il file Main.java.

Ho messo il file Main.java nel mio drive D questa volta. Quindi sono andato in quella cartella usando il comando cd.

Vedo il mio file Java anche nel terminale.

Come andare nella cartella dove si trova il codice sorgente: per Linux 🐧

Puoi andare nella cartella dove si trova il tuo codice sorgente sia attraverso la GUI o dal terminale usando il comando cd anche qui.

🧑‍💻Come Compilare il Codice Java

Prima di eseguire il nostro codice Java, dobbiamo compilarlo. Per compilare un codice/programma in Java, otteniamo il file class che in seguito dovremo eseguire.

Come compilare il codice Java usando il terminale

Dobbiamo usare il comando javac nome_file_con_estensione. Per esempio, dato che voglio compilare il mio Main.java, userò il comando javac Main.java. La c in javac sta per compila.

Se il processo di compilazione avviene con successo, non otterremo nessun errore.

Questo creerà il file class di cui abbiamo bisogno nella stessa cartella.

Tieni a mente che eseguiamo il file class, non il file .java.

Lo stesso processo è applicabile per tutti i sistemi operativi disponibili.

🖥️ Come Eseguire il Codice Java

Eseguiamo il file .class per lanciare i programmi Java. Per questo, usiamo il comando java nome_file_class_senza_estensione. Per esempio, poiché il nostro file .class per questo programma è Main.class, il nostro comando sarà java Main.

Il programma Java è stato eseguito con successo!

La stessa identica procedura è applicabile anche ad altri sistemi operativi.

🏅Bonus: Come Eseguire un Programma Java con i Package

Un package sta praticamente ad indicare una cartella. Prima ti ho mostrato come usare un qualsiasi normale codice Java ricorrendo al terminale. Lì non ho usato alcun package all'interno del codice Java.

Adesso ti mostrerò come puoi eseguire qualsiasi codice Java che ha dei package dichiarati al suo interno. Questa volta, userò il seguente codice Java.

package myJavaProgram.Source;
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, World!"); 
    }
}

Nella prima riga ho scritto il package come package myJavaProgram.Source. Questo indica che voglio creare una cartella chiamata myJavaProgram. Poi, voglio creare un'altra cartella al suo interno chiamata Source. Infine, voglio creare un file class del mio codice Java all'interno della cartella Source.

La struttura ad albero delle cartelle sarà la seguente: myJavaProgram > Source.

Per compilare questo tipo di codice Java con i package, usiamo il comando javac -d . nome_file_con_estensione.

Al momento sto usando il file Main.java, quindi userò il comando javac -d . Main.java. Questo creerà una cartella chiamata myJavaProgram, poi creerà un'altra cartella chiamata Source dentro la cartella myJavaProgram dentro la cartella dove si trova il mio file sorgente.

• La_Cartella_Dove_Ho_Il_Mio_Codice_Sorgente
• cartella myJavaProgram
• cartella Source

Crea istantaneamente la cartella myJavaProgram.

All'interno della cartella, crea la cartella Source.

Dentro la cartella Source, crea il nostro file .class. Abbiamo bisogno di questo file per eseguire il programma Java.

Adesso, se vogliamo eseguire il file .class, abbiamo bisogno di cambiare un po' il comando, poiché dobbiamo fornire la cartella del file .class nella finestra del terminale.

Usiamo il comando per eseguire il programma Java con i package, java cartella_del_file_class.il_nome_del_file_class_senza_estensione.

Poiché sto usando Main.java e ho bisogno di eseguire il file Main.class, il mio comando sarà java myJavaProgram.Source.Main. Eseguirà il codice Java come qui di seguito.

Se ti stai chiedendo perché stiamo cambiando il comando adesso, è perché prima non abbiamo dichiarato nessun package. Quindi il compilatore Java ha creato il file .class all'interno della cartella dove si trovava il nostro codice sorgente. Quindi, potremmo prendere il file .class direttamente da lì e potremmo anche eseguire il file class.

Ma se dichiariamo i package all'interno del codice sorgente in questo modo, allora stiamo dicendo al compilatore di creare il file .class in un altro posto (non all'interno della cartella dove si trova il nostro codice sorgente). Ciò significa che non prendiamo il file class direttamente da lì.

Poiché vogliamo eseguire il file class, abbiamo bisogno di dire al compilatore esplicitamente dove si trova il file class al momento, così che possa prendere il file class ed eseguirlo.

Se pensi di poter fare confusione durante questo passaggio, allora puoi copiare la cartella direttamente dal tuo codice Java.

Nella riga 1, abbiamo dichiarato la cartella del package (dove vogliamo che sia generato il file class). Dunque, se copiamo semplicemente la cartella e aggiungiamo il nome del file .class senza l'estensione (.class), preceduto da un punto (.), allora soddisfiamo la condizione per eseguire qualsiasi codice Java che ha dei package dichiarati nel codice sorgente.

Lo stesso processo è applicabile agli altri sistema operativi. Ecco qui degli screenshot da un sistema Linux:

Ottimo lavoro! 👏 Adesso puoi eseguire qualsiasi codice/programma Java direttamente usando un terminale. 🥳

Ho creato anche un video dove ho mostrato tutti i procedimenti menzionati in alto. Puoi darci un'occhiata qui. 😁

💁‍♂️ Conclusione

Spero che questo articolo ti aiuti ad eseguire i tuoi programmi Java usando solo il terminale.

➡️ Se vuoi sapere come installare un compilatore Java per il tuo sistema operativo Windows, allora puoi dare un'occhiata a questo articolo.

➡️ Se vuoi sapere come installare dei compilatori per C e C++ sul tuo sistema operativo Windows, allora puoi dare un'occhiata a questo articolo.

➡️ Se vuoi sapere come installare Python sul tuo sistema operativo Windows, allora puoi dare un'occhiata a questo articolo.

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ù di me e delle cose su cui sto lavorando.

Grazie mille!

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.

Quando usi Python, potresti aver bisogno di installare ed usare determinati pacchetti. E c'è un comando disponibile per questo, conosciuto come 'pip'.

Con pip puoi installare, aggiornare e disinstallare vari pacchetti di Python. In questo articolo imparerai come usarlo e come gestire gli errori di pip.

Come usare pip

Pip è un comando che puoi usare sulla linea di comando di Linux o Mac. Puoi selezionare un pacchetto da qui.

In basso vediamo un esempio di come puoi installare il pacchetto mock-open con pip.

pip3 install mock-open

Output:

Poiché questo pacchetto era già stato installato, ci viene mostrato un messaggio che dice che il requisito è già stato soddisfatto.

Nota che ho usato pip3 perché sto usando Python3. Discuteremo di questo nel dettaglio più avanti.

Che cos'è l'errore pip: command not found?

A volte, quando stai installando dei pacchetti, potresti ritrovarti con l'errore: pip: command not found (pip: comando non trovato). Questo errore potrebbe essere dovuto alle seguenti ragioni:

1. Pip non è installato.
2. Pip è installato, ma non è compatibile con l'ambiente attuale.

Su Linux, devi installare il gestore di pacchetti di pip separatamente, poiché si tratta di un pacchetto indipendente. Ma su Mac non hai bisogno di installare pip manualmente, a patto che tu stia lavorando con Python 3.x.

Risolvere l'errore pip: command not found

1. Controlla che pip sia installato.

Su Mac e Linux, puoi usare il comando seguente per controllare se pip è installato.

 python3 -m pip --version 

Se pip non è installato, puoi seguire i passaggi per installarlo qui per il sistema operativo corrispondente.

2. Aggiorna pip all'ultima versione

Se pip non funziona ancora, prova ad aggiornarlo all'ultima versione:

python -m pip install --upgrade pip

3. Risolvi problemi relativi all'ambiente di sviluppo

È possibile che tu stia provando ad usare la versione sbagliata di pip. Per esempio, pip3 funziona per Python3, mentre pip funziona solo per Python2.

Puoi controllare la tua versione di Python su Linux e Mac in questo modo:

Se il tuo codice è in Python 2 e vuoi comunque usare una vecchia versione di pip, puoi seguire i passaggi qui in basso.

Nota che Python 2 ha ormai fatto il suo corso. È meglio aggiornare il tuo codice sorgente a Python 3 e usare la versione più aggiornata di pip.

Segui i passaggi qui in basso solo se stai usando Python2:

1. Installa pip (una vecchia versione)

sudo easy_install pip

Questo comando installa il comando pip sul tuo sistema.

Adesso prova ad usare il comando pip - dovrebbe funzionare senza errori.

Ricapitolando

Pip è un comando utile per installare pacchetti di Python. Abbiamo parlato di alcuni metodi per risolvere l'errore pip: command not found.

Spero che tu abbia trovato utile questo tutorial.

Connettiamoci su Twitter!

Puoi leggere gli altri miei post qui.

In qualsiasi linguaggio di programmazione, le funzioni facilitano la riutilizzabilità del codice. In poche parole, quando vuoi fare qualcosa ripetutamente puoi definire qualcosa come una funzione e chiamare quella funzione ogni volta che ne hai bisogno.

In questo tutorial, impareremo di più sulle funzioni definite dall'utente in Python.

Quando hai iniziato a programmare in Python, avrai dovuto usare la funzione integrata print() nel tuo programma Hello World! 😀 e la funzione input() per leggere gli input forniti dall'utente.

Fintanto che sai come usare queste funzioni, non devi preoccuparti di come sono state implementate.

Nell'ambito della programmazione, ciò viene chiamato astrazione. Ti permette di usare delle funzioni chiamandole con gli argomenti richiesti, senza doverti preoccupare di come funzionino effettivamente.

Ci sono moltissime funzioni integrate in Python. In questo articolo, vedremo come definire e usare delle funzioni scritte da noi. Iniziamo!

Sintassi delle Funzioni di Python

Il seguente blocco di codice mostra la sintassi generale che serve a definire una funzione in Python:

def nome_funzione(parametri):
    # Quello che fa la funzione va qui
    return risultato 

• Devi usare la parola chiave def , dare un nome alla funzione seguito da un paio di parentesi, e chiudere la riga con i due punti (:).
• Se la tua funzione prende degli argomenti, i nomi degli argomenti (parametri) vengono menzionati all'interno delle parentesi.
• Nota bene che nella definizione di funzione, gli argomenti che la tua funzione utilizza vengono chiamati parametri.
• Quando chiami la funzione specificando dei valori per questi parametri, essi vengono chiamati argomenti o parametri effettivi. Questo perché, nella chiamata della funzione, gli argomenti sono i valori dei parametri della funzione.
• Dopodiché, inizi un blocco rientrato. Esso sarà il corpo della funzione che descrive che cosa fa la tua funzione.
• C'è una dichiarazione return che restituisce il risultato dell'operazione eseguita sugli argomenti. La dichiarazione return restituisce il comando al punto in cui la funzione è stata originariamente chiamata.

Nota che gli argomenti e la dichiarazione return sono opzionali. Ciò significa che potresti avere una funzione che non prende nessun argomento, e non restituisce niente. 😀

Proviamo ora a capire ciò che è stato detto sopra usando dei semplici esempi.

Come Creare una Semplice Funzione in Python

Creiamo ora una semplice funzione di Python che saluta l'utente, come mostrato di seguito:

def my_func():
  print("Ciao! Spero che tu stia bene")

Come puoi vedere, la funzione my_func():

• non prende argomenti,
• non restituisce nulla, e
• stampa "Ciao! Spero che tu stia bene" ogni volta che viene chiamata.

Nota che la definizione di funzione in alto è inerte finché la funzione non viene attivata o chiamata. Facciamo una prova e chiamiamo la funzione my_func() e controlliamo il suo output.

my_func()

# Output
Ciao! Spero che tu stia bene

Come Creare una Funzione con Argomenti in Python

Adesso modificheremo la funzione my_func() così che includa il nome e la città dell'utente.

def my_func(nome, città):
  print(f"Ciao {nome}! Vieni da {città}?")

Possiamo chiamare my_func() passando due stringhe per il nome e la città dell'utente, come mostrato in basso.

my_func("Jane","Parigi")

# Output
Ciao Jane! Vieni da Parigi?

Cosa succede se inserisci prima la città e poi il nome? Scopriamolo.

my_func("Roma","Robert")

# Output
Ciao Roma! Vieni da Robert?

Otteniamo Ciao Roma! Vieni da Robert? – e non ha senso! 🙂Che cosa causa questo problema?

Gli argomenti passati nella chiamata della funzione sono argomenti posizionali. Ciò significa che il primo argomento nella chiamata di funzione è usato come valore del primo parametro (nome) e il secondo argomento nella chiamata di funzione è usato come valore del secondo parametro (città).

Osserva il blocco di codice in basso. Invece di specificare solo gli argomenti, abbiamo menzionato i parametri e il valore che prendono.

my_func(città="Roma",nome="Robert")

# Output
Ciao Robert! Vieni da Roma?

Questi sono chiamati argomenti a parola chiave. L'ordine degli argomenti nella chiamata della funzione non è importante a patto che i nomi dei parametri siano corretti.

Come Creare una Funzione con Argomenti Predefiniti in Python

E se avessimo determinati parametri che assumono uno specifico valore la maggior parte delle volte in cui viene chiamata la funzione?

Non esiste un modo migliore di chiamare la funzione specificando sempre lo stesso valore per un parametro in particolare?

Certo che esiste, ed è a questo che servono i default arguments (argomenti predefiniti)! 😀

Creiamo una funzione total_calc() che ci aiuta a calcolare e visualizzare il totale da pagare al ristorante. Dati un conto e la percentuale del conto che scegli di lasciare come mancia (perc_mancia), questa funzione calcola il totale da pagare.

Nota che la definizione della funzione include il valore predefinito del parametro perc_mancia da usare quando l'utente non specifica una percentuale di mancia.

Esegui il blocco di codice in basso.👇🏽 Ora la tua funzione è pronta!

def total_calc(conto, perc_mancia=10):
  totale = conto * (1 + 0.01*perc_mancia)
  totale = round(totale, 2)
  print(f"Si prega di pagare ${totale}")

Ora chiamiamo la funzione in modi diversi. Il blocco di codice in basso mostra le seguenti situazioni:

• Quando chiami la funzione total_calc specificando solo il conto, in automatico viene usata la percentuale di mancia del 10%.
• Quando specifichi esplicitamente la percentuale di mancia, viene usata la percentuale specificata nella chiamata di funzione.

# specifica solo il conto
# viene usato solo il valore predefinito della percentuale di mancia

 total_calc(150)
 # Output
 Si prega di pagare $165.0
 
 # specifica sia il conto che una percentuale di mancia a scelta
 # viene usata la percentuale di mancia specificata nella chiamata di funzione
 
 total_calc(200,15)
 # Output
 Si prega di pagare $230.0
 
 total_calc(167,7.5)
 # Output
 Si prega di pagare $179.53
 

Come Creare una Funzione che Restituisce un Valore in Python

Fino ad ora abbiamo creato solo funzioni che possono prendere o non prendere argomenti e non restituiscono nulla. Adesso, creiamo una semplice funzione che restituisce il volume di un cuboide dati la lunghezza, la larghezza e l'altezza.

def volume_di_cuboide(lunghezza,larghezza,altezza):
  return lunghezza*larghezza*altezza
  
  

Ricorda che la parola chiave return restituisce il comando al punto in cui la funzione è stata chiamata. La chiamata di funzione viene restituita dal return value (valore restituito) dalla funzione.

Chiamiamo la funzione volume_di_cuboide() con gli argomenti di dimensione necessari, come mostrato nel blocco di codice in basso. Fai caso al modo in cui usiamo la variabile volume per immagazzinare il valore restituito dalla funzione.

volume = volume_di_cuboide(5.5,20,6)
print(f"Il volume del cuboide è di {volume} unità cubiche")

# Output
Il volume del cuboide è di 660.0 unità cubiche

Come Creare una Funzione che Restituisce Molteplici Valori in Python

Negli esempi che abbiamo fatto prima, la funzione volume_di_cuboide() restituiva un solo valore, ossia il volume del cuboide date le sue dimensioni. Vediamo come possiamo far restituire molteplici valori a una funzione.

• Per far restituire molteplici valori a una funzione, dobbiamo semplicemente specificare i valori da restituire, separati da una virgola.
• In automatico, la funzione restituisce i valori come tupla. Se ci sono N valori di ritorno, otterremo una tupla di dimensione N.

Creiamo una semplice funzione cubo() che restituisce il volume e l'area di superficie totale di un cubo, data la lunghezza del suo spigolo.

def cubo(spigolo):
  volume = spigolo **3
  area_superficie = 6 * (spigolo**2)
  return volume, area_superficie

Per verificare che sia stata restituita una tupla, immagazziniamola in una variabile valori_restituiti, come mostrato in basso:

valori_restituiti = cubo(8)
print(valori_restituiti)

# Output
(512, 384)

Adesso, possiamo spacchettare la tupla e inserire i valori in due variabili diverse.

volume, area = cubo(6.5)
print(f"Il volume del cubo è di {volume} unità cubiche e l'area di superficie totale è di {area} unità quadrate.")

# Outputs
Il volume del cubo 274.625 è di unità cubiche e l'area di superficie totale è di 253.5 unità quadrate

Come Creare una Funzione che Prende un Numero Variabile di Argomenti in Python

Cominciamo ponendoci alcune domande:

• E se non sapessimo in anticipo il numero esatto di argomenti che ci servono?
• Possiamo creare funzioni che lavorano con un numero variabile di argomenti?

La risposta è sì! E creeremo una funzione del genere proprio adesso.

Creiamo una semplice funzione my_var_sum() che restituisce la somma di tutti i numeri passati come argomento. Tuttavia, il numero di argomenti potrebbe essere diverso ogni volta che chiamiamo la funzione.

Nota come la definizione di funzione adesso ha *args invece di avere semplicemente il nome del parametro. Nel corpo della funzione, iteriamo attraverso args finché non abbiamo usato tutti gli argomenti. La funzione my_var_sum restituisce la somma di tutti i numeri passati come argomento.

def my_var_sum(*args):
  somma = 0
  for arg in args:
    somma += arg
  return somma

Adesso chiamiamo la funzione my_var_sum() con un numero diverso di argomenti ogni volta e controlliamo velocemente che le risposte restituite siano corrette! 🙂

# Esempio 1 con 4 numeri
somma = my_var_sum(99,10,54,23)
print(f"La somma dei tuoi numeri è {somma}")
# Output
La somma dei tuoi numeri è 186

# Esempio 2 con 3 numeri
somma = my_var_sum(9,87,45)
print(f"La somma dei tuoi numeri è {somma}")
# Output
La somma dei tuoi numeri è 141

# Esempio 3 con 6 numeri
somma = my_var_sum(5,21,36,79,45,65)
print(f"La somma dei tuoi numeri è {somma}")
# Output
La somma dei tuoi numeri è 251

⌛ Un Veloce Riepilogo

Riassumiamo velocemente ciò di cui abbiamo parlato. In questo tutorial abbiamo imparato:

• come definire delle funzioni,
• come passare argomenti ad una funzione,
• come creare funzioni con argomenti predefiniti e con un numero variabile di argomenti, e
• come creare una funzione che restituisca dei valori.

Spero che ti sia piaciuto leggere questo articolo. Grazie per aver letto. Come sempre, alla prossima! 😀