Tutto è un oggetto

1.1 Oggetti e classi

Oggi imparerai come è strutturato un tipico programma in Python. E la notizia principale: ogni programma in Python è composto da classi e oggetti. Python è un linguaggio orientato agli oggetti, e tutto in esso è un oggetto: numeri, stringhe, funzioni e persino classi sono oggetti.

Ma cosa sono le classi?

Inizio con un'analogia. Immagina di voler costruire una piccola nave. Prima bisogna fare un disegno, poi portarlo in fabbrica, dove da quel disegno verrà assemblata la nave. O una decina. Beh, quanti ne vuoi. Con un solo disegno si costruiscono decine di navi identiche, ecco cosa è importante.

Nella programmazione in Python è esattamente così.

Disegni

Un programmatore è come un progettista. Solo che il progettista disegna disegni, mentre il programmatore Python scrive classi. Poi, basandosi sui disegni, si creano i componenti, e basandosi sulle classi — gli oggetti.

Prima scriviamo le classi (facciamo i disegni), poi, durante l'esecuzione del programma, Python crea oggetti basati su queste classi. Esattamente come le navi sono create basandosi sui disegni.

Un disegno solo, ma tante navi. Le navi sono diverse, hanno nomi diversi, trasportano carichi diversi. Ma sono molto simili: sono tutte navi con una struttura identica e possono svolgere compiti analoghi.

O un'altra analogia...

Formicaio

Il formicaio è un buon esempio di interazione tra oggetti. In un semplice formicaio ci sono tre classi di formiche: regina, soldati e operaie.

Il numero di formiche di ciascuna classe è diverso. La regina è una per tutto il formicaio, i soldati sono decine, e le operaie sono centinaia. Tre classi e centinaia di oggetti. Le formiche interagiscono tra loro, con formiche della stessa classe e con formiche di altre classi secondo regole rigidamente fissate.

È semplicemente un esempio perfetto. In un tipico programma è esattamente così. C'è un oggetto principale, che crea oggetti di tutte le altre classi. Gli oggetti iniziano a interagire tra loro e con il "mondo esterno" del programma. All'interno di questi oggetti è rigidamente programmato il loro comportamento.

Queste due spiegazioni sono le due facce della stessa medaglia. La verità sta nel mezzo. Il primo esempio (sui disegni e le navi) mostra la connessione tra una classe e gli oggetti di quella classe. L'analogia è molto forte. Il secondo esempio (sul formicaio) mostra la connessione tra gli oggetti che esistono durante l'esecuzione del programma e le classi scritte.

Prima devi scrivere le classi per tutti gli oggetti presenti nel programma, e poi descrivere anche le loro interazioni. Sembra complicato, ma è più facile di quanto sembri.

In Python tutte le entità durante l'esecuzione del programma sono oggetti, e la scrittura del programma consiste nel descrivere i vari modi di interazione tra gli oggetti. Gli oggetti semplicemente richiamano i metodi l'uno dell'altro e passano i dati necessari.

Documentazione

E come fare per sapere quali dati passare ai metodi? Beh, qui è già tutto stato pensato prima di te.

Di solito ogni classe ha una descrizione che ne spiega lo scopo. Inoltre, di solito ogni metodo pubblico ha una descrizione: cosa fa e quali dati devono essere passati.

Per utilizzare una classe, devi avere un'idea generale di cosa faccia. E devi sapere esattamente cosa fa ogni suo metodo. E non è affatto necessario sapere come lo fa. Una specie di bacchetta magica.

Diamo un'occhiata al codice — copia di un file:

src = open('source.txt', 'r')
dst = open('destination.txt', 'w')
            
for line in src:
    dst.write(line)
            
src.close()
dst.close()
        

Se leggi questo codice riga per riga, puoi intuire cosa fa in generale. Anche se serve esperienza e pratica. Quindi, dopo un po', questo codice ti sembrerà familiare e comprensibile.

1.2. Progettare un programma

Progettare un programma è un'arte. È sia semplice che difficile allo stesso tempo. Semplice, perché non ci sono leggi rigide: tutto ciò che non è vietato è permesso. E difficile anche per questo motivo: ci sono tanti modi per fare qualcosa ed è difficile trovare il migliore.

Progettare un programma è come scrivere un libro. Da un lato, stai solo scrivendo lettere, parole, frasi. Dall'altro — è importante la trama, i caratteri dei protagonisti, le contraddizioni interne, i conflitti, lo stile del racconto, l'intrigo, ecc.

La cosa principale è capire per chi stai scrivendo il codice. Ricorda che il tuo codice è destinato ad altri programmatori.

Lo sviluppo di qualsiasi prodotto è un processo di modifiche: aggiungi qui, togli lì, rifai qua. E così, con piccole iterazioni, nascono grandi, enormi e giganteschi progetti.

Il requisito principale per il codice è che deve essere comprensibile agli altri programmatori. Un codice sbagliato ma comprensibile può essere corretto. Un codice corretto e incomprensibile non può essere migliorato. Rimane solo da buttarlo via.

Quindi come scrivere un buon codice comprensibile?

Per questo devi fare tre cose:

• Scrivere un buon codice comprensibile all'interno dei metodi — il più semplice.
• Decidere quali entità devono essere nel programma.
• Dividere correttamente il programma in parti logiche.

Cosa significano questi concetti?

Scrivere buon codice all'interno dei metodi

Se hai almeno un livello base di inglese, forse avrai notato quanto a volte il codice sia facile da leggere: come frasi in inglese:

• class Cat(Pet) – la classe Gatto estende la classe AnimaleDomestico.
• while stream: – finché il flusso non è vuoto ...
• a if a < b else b – se a è minore di b, ritorna a, altrimenti ritorna b.

È fatto apposta. Python è uno dei pochi linguaggi in cui è facile scrivere codice auto-documentato: codice che è comprensibile senza commenti. In un buon codice in Python molti metodi si leggono semplicemente come frasi in inglese.

Il tuo compito quando scrivi codice è fare lo stesso, renderlo il più semplice e conciso possibile. Basta pensare a quanto sarà facile leggere il tuo codice, e inizierai a muoverti nella giusta direzione.

In Python è consuetudine scrivere codice facilmente leggibile. È preferibile che ogni metodo si adatti completamente allo schermo (la lunghezza del metodo è di 20-30 righe). Questa è la norma per tutta la community Python. Se il codice può essere migliorato, deve essere migliorato.

Il miglior modo per imparare a scrivere buon codice è la pratica costante. Scrivi molto codice, studia il codice degli altri, chiedi ai colleghi più esperti di fare una revisione del tuo codice. E ricorda che nel momento in cui ti dirai "va bene così", il tuo miglioramento si fermerà.

Decidere quali entità devono essere nel programma

Devi scrivere codice comprensibile ad altri programmatori. Se 9 su 10 programmatori durante la progettazione di un programma creano le classi A, B e C, anche tu devi creare nella tua programma le classi A, B e C. Devi scrivere codice comprensibile agli altri.

Un codice eccellente, funzionante, veloce, non convenzionale è un codice scadente.

Devi studiare i progetti degli altri: è il miglior, più veloce e più facile modo per apprendere tutta la saggezza che si è accumulata per decenni nell'industria IT.

E, tra l'altro, hai già a portata di mano un progetto eccellente, popolare, ben documentato — Python SDK. Inizia da lì.

Analizza le classi e le strutture delle classi. Pensa a perché alcuni metodi sono statici e altri no. Perché i metodi hanno quei parametri e non altri. Perché quei particolari metodi, perché le classi hanno quei nomi e si trovano in quei pacchetti.

Quando inizierai a capire le risposte a tutte queste domande, sarai in grado di scrivere codice comprensibile agli altri.

Tuttavia voglio metterti in guardia dall'analizzare il codice nei metodi del Python SDK. Il codice di molti metodi è stato riscritto con l'obiettivo di massimizzare la velocità di esecuzione — la sua leggibilità è molto discutibile.

Dividere correttamente il programma in parti logiche

Ogni programma viene solitamente suddiviso in parti o moduli. Ogni parte è responsabile di un aspetto del programma.

Ecco, il computer ha un'unità di sistema, un monitor, una tastiera, e sono tutte parti separate e indipendenti. Inoltre, la loro interazione è standardizzata: USB, HDMI ecc. E se versi del caffè sulla tastiera, puoi semplicemente lavarla sotto il rubinetto, asciugarla e usarla ancora.

Un portatile, invece, è un esempio di architettura monolitica: le parti logiche sembrano esserci, ma sono integrate molto più strettamente. Su un Macbook Pro, per pulire la tastiera, bisogna smontare metà del portatile. E versare del caffè sul portatile — è un motivo per ordinarne uno nuovo. Tranne il caffè.

1.3 Creare le proprie classi

Quando inizi a programmare, è importante iniziare con poco — imparare a creare le tue classi.

Le hai sicuramente già create, ma devi imparare a capire quali classi dovrebbero essere nel programma, come dovrebbero chiamarsi, quali metodi dovrebbero avere. E come dovrebbero interagire tra di loro.

Elenco delle entità

Se non sai da dove iniziare, inizia dall'inizio.

All'inizio della progettazione del programma, puoi semplicemente scrivere su un foglio un elenco di entità (oggetti) che dovrebbero essere nel programma. E poi programmarle secondo questo principio: ogni entità — una classe separata.

Esempio

Supponiamo di voler scrivere un gioco di scacchi. Ti serviranno queste entità: la scacchiera e 6 tipi di pezzi. I pezzi si muovono in modo diverso, hanno valori diversi — è logico che siano classi separate. E in generale, all'inizio, più classi ci sono — meglio è.

Incontrare un programmatore principiante che invece di due classi ne scriva dieci — è una grande rarità. Invece di dieci scriverne due, o addirittura una — questo i principianti lo amano. Quindi più classi, signori programmatori. E il vostro codice sarà più comprensibile a tutti, tranne forse voi 😛

Scacchi

Supponiamo di aver deciso di scrivere classi per gli scacchi: come apparirebbero queste classi?

La scacchiera è solo un array 8x8? Meglio farne una classe separata, che all'interno conserva un riferimento all'array. Così nella classe "scacchiera" potrai aggiungere molti metodi utili, che, per esempio, verificano se una casella è vuota o occupata.

Insomma, all'inizio puoi sempre seguire il principio: Il programma ha diverse Entità e ogni Entità ha un tipo. Questo tipo è la classe.