10 errori che NON dovresti MAI fare in Python.

10 Python mistakes to NEVER make.

Quando iniziamo a imparare Python, molte volte ci imbattiamo in cattive pratiche. In questo articolo, imparerai le migliori pratiche per portare il tuo sviluppatore Python al livello successivo.

Ricordo quando ho iniziato a imparare Python, ho fatto molti errori che, se li avessi conosciuti in anticipo, mi avrebbero permesso di accelerare la curva di apprendimento.

1- Non definire variabili in una sola linea.

a = 12b = 56c = 128

Solitamente definiamo una variabile per riga; tuttavia, c’è un modo per definire più variabili in una sola linea di codice.

a,b,c = 12,56,128

In questo modo semplice possiamo definire più variabili, rendendo il codice più facile da leggere.

2- Usa * per importare moduli.

from numpy import *numbers = arange(1,10,step = 10)print(mean(numbers))

In genere usiamo * per invocare i moduli della libreria corrispondente. Tuttavia, non ha senso chiamare tutti i moduli se siamo interessati solo a funzioni specifiche della libreria.

import numpy as npnumbers = np.arange(1,10,step = 10)print(np.mean(numbers))

Importiamo la libreria di interesse, in questo caso numpy, e possiamo assegnare un alias ad essa, seguito dalla chiamata dei metodi che utilizzeremo.

from numpy import arange,meannumbers = arange(1,10,step = 10)print(mean(numbers))

Possiamo anche innovare direttamente le funzioni della libreria di interesse; entrambi questi modi sono buoni.

3- Usa “+” per concatenare.

name,year = "Amado",22print("Il mio nome è " + name + " e ho " + str(year) + " anni")

Solitamente, usiamo sempre + per concatenare le stringhe; tuttavia, ha lo svantaggio di non essere così comprensibile.

name,year = "Amado",22print(f"Il mio nome è {name} e ho {year} anni")

Usiamo le stringhe formattate, che consentono di concatenare le variabili indipendentemente dalla natura della variabile; ha inoltre il vantaggio aggiuntivo di essere più comprensibile da leggere.

Chatathon by Chatbot Conference

4- Non utilizzare la funzione lambda.

def function(x):  return x**2  print(function(12))

Generalmente, quando si crea una funzione, si crea una funzione convenzionale. Ci sono occasioni in cui il metodo che creiamo è qualcosa di semplice ma che useremo frequentemente.

function = lambda x: x**2print(function(12))

Possiamo creare una funzione lambda per lo stesso scopo, con la piacevole differenza di renderla più semplice. Se vogliamo creare funzioni che non siano così complesse, è molto meglio usare le funzioni lambda che le funzioni Python convenzionali.

5- Utilizzo di If Else da più righe di codice.

age = 22if age>=18:  print('Sei maggiorenne')else:  print('Non sei maggiorenne')

Solitamente, quando impariamo, siamo abituati a indicare l’istruzione if else in questo modo; tuttavia, può essere semplificato in una sola riga di codice.

age = 22"Sei maggiorenne" if age>=18 else "Non sei maggiorenne"

In questo modo, riduciamo l’if-else in una sola linea di codice, rendendolo più comprensibile da leggere.

6- Utilizzare più condizioni If condizionali.

kepler_third_law = lambda ua: (np.round(np.sqrt(ua**3),1))def calculate_years(planet):    planet = planet.lower()    if planet == "mercurio":        ua = 0.387        print(f'Numero di anni del pianeta Mercurio: {kepler_third_law(ua)}')            if planet == "venere":        ua = 0.723        print(f'Numero di anni del pianeta Venere: {kepler_third_law(ua)}')            if planet == "terra":        ua = 1        print(f'Numero di anni del pianeta Terra: {kepler_third_law(ua)}')            if planet == "marte":        ua = 1.524        print(f'Numero di anni del pianeta Marte: {kepler_third_law(ua)}')            if planet == "terra":        ua = 1        print(f'Numero di anni del pianeta Terra: {kepler_third_law(ua)}')            if planet == "giove":        ua = 5.208        print(f'Numero di anni del pianeta Giove: {kepler_third_law(ua)}')            if planet == "saturno":        ua = 9.539        print(f'Numero di anni del pianeta Saturno: {kepler_third_law(ua)}')            if planet == "urano":        ua = 19.182        print(f'Numero di anni del pianeta Urano: {kepler_third_law(ua)}')            if planet == "nettuno":        ua = 30.058        print(f'Numero di anni del pianeta Nettuno: {kepler_third_law(ua)}')            if planet == "plutone":        ua = 39.439        print(f'Numero di anni del pianeta Plutone: {kepler_third_law(ua)}')

Generalmente, utilizziamo più if statement in base alla condizione presente. Questo ha lo svantaggio di richiedere un eccessivo ammontare di righe di codice.

import numpy as npkepler_third_law = lambda ua: (np.round(np.sqrt(ua**3),1))def calculate_years(planet):        planet = planet.lower()        ua_dict = {'saturno':9.539,               'terra':1,               'mercurio':0.387,               'venere':0.723,              'giove':5.203,              'urano':19.182,              'plutone':39.439,              'marte':1.524}    anni = kepler_third_law(ua_dict[planet])            return f'Numero di anni del pianeta {planet}: {anni}'

Invece di utilizzare più condizioni if, creiamo un dizionario in cui memorizziamo le UA dei pianeti, per poi calcolare il numero di anni necessari per orbitare intorno al sole applicando la terza legge di Keplero; come possiamo vedere, applicando questa strategia il codice risulta più pulito e facile da capire.

7- Non utilizzare la list comprehension.

import numpy as npnumbers = np.arange(1,20+1,step = 1)par_numbers = []for number in numbers:    if number %2==0:        par_numbers.append(number)

In generale, se vogliamo memorizzare gli elementi in una lista in base ad una determinata condizione, utilizziamo i cicli for; ad esempio, in questo caso, vogliamo memorizzare solo i valori pari.

import numpy as npnumbers = np.arange(1,20+1,step = 1)[n for n in numbers if n % 2 == 0]

Utilizzando la list comprehension, possiamo ridurre notevolmente le righe di codice ad una sola linea.

8- Non utilizzare l’enumerate.

names = ['Amado','John','Artemio']last_name = ['Vazquez','Jobs','Lara']for i in range(len(names)):    print(f'{names[i]} {last_name[i]}')

Supponiamo di voler stampare il nome e il cognome della persona sullo schermo; per questo, utilizziamo la funzione range() per definire gli indici e successivamente stamparli in base agli indici generati.

names = ['Amado','John','Artemio']last_name = ['Vazquez','Jobs','Lara']for i,name in enumerate(names):    print(f'{name} {last_name[i]}')

Utilizzando la funzione enumerate, restituiamo l’indice dell’oggetto nella lista, quindi possiamo risparmiare questo passaggio.

9- D o non usare zip

manufacturer = ['Infiniti','Mazda','Nissan','BMW']model = ['Q50','Mazda 6','Altima','3 Series']engine = [3.0,2.5,2.0,2.0]for i in range(len(manufacturer)):    print(f'{manufacturer[i]} {model[i]} {engine[i]}')

Qui commettiamo un errore simile al precedente, con la differenza che qui vogliamo stampare tre liste in armonia.

manufacturers = ['Infiniti','Mazda','Nissan','BMW']models = ['Q50','Mazda 6','Altima','3 Series']engines = [3.0,2.5,2.0,2.0]for (manufacturer,model,engine) in zip(manufacturers,models,engines):    print(f'{manufacturer} {model} {engine}')

Utilizzando il metodo zip ci consente di utilizzare più liste contemporaneamente, è molto più comodo che usare l’indice, ed ha anche il vantaggio che è molto più facile da capire.

10- Chiavi()/Elementi()

consoles_dict = {'PS5':499,                 'PS5 Digital':399,                 'Xbox Series S':299,                 'Xbox Series X':499}consoles_dict.keys() #'PS5','PS5 Digital','Xbox Series S','Xbox Series X'consoles_dict.values() # 499,399,299,499consoles_dict.items()

A volte facciamo un uso improprio dei dizionari, più precisamente dei metodi per accedervi. Usiamo la funzione keys() per accedere alle chiavi, values() si riferisce all’estrazione dei valori assegnati ad ogni chiave e, infine, items() ci consente di estrarre entrambi gli elementi.

for key in consoles_dict:  print(key)

Se vogliamo accedere alla chiave del dizionario, è sufficiente applicare un ciclo al dizionario di interesse.

for key in consoles_dict:  print(consoles_dict[key])

Se vogliamo accedere al valore del dizionario, è sufficiente assegnare il nome della chiave sul ciclo for.

for key,value in consoles_dict.items():  print(key,value)

È meglio utilizzare il metodo items() e aggiungere i due valori da iterare in modo da poter ottenere sia la chiave che il suo valore.

11- Non fare affidamento sui moduli.

sum_ = 0for number in range(1,10+1):  sum_ += number  print(sum_/10)

Alcune librerie possono rendere la vita più facile; ad esempio, esiste una libreria chiamata numpy che viene utilizzata per effettuare calcoli matematici. Alcune librerie possono rendere la vita più facile invece di programmare da zero. Ad esempio, c’è una libreria molto famosa nella scienza dei dati che viene utilizzata per effettuare calcoli complessi.

import numpy as npnumbers = np.arange(1,10+1,1)print(np.mean(numbers))

La libreria numpy ci facilita enormemente quando si eseguono alcuni calcoli matematici, da qualcosa di semplice come una somma a qualcosa di più complesso come le trasformate di Fourier.

12- Non usare IN

car_model = "Maxima"if car_model == "Altima" or car_model == "Maxima" or car_model == "Q50" or car_model == "Q60":    print('mMdel disponibile')

Invece di utilizzare una lunga istruzione condizionale, possiamo supportare la condizione IN.

car_models = ['Altima','Maxima','Q50','Q60']car_model = "Maxima"'Modello disponibile' if car_model in car_models else 'Modello non disponibile'

Creiamo una lista convenzionale di Python e l’operatore IN confronta se l’auto che selezioniamo è presente nella lista. Ci affidiamo anche alla dichiarazione if-else di una singola riga di codice.

Potrebbe interessarti.

10 Errori di Pandas che NON dovresti mai commettere

Questo articolo rivedrà i 10 errori più comuni in Pandas che i principianti commettono quando iniziano ad imparare Pandas in…

Nisoo.com

Crea una Bellissima App Utilizzando Streamlit

Se vuoi portare i tuoi progetti di ML a un altro livello, dove differenti utenti possono usare il tuo algoritmo di ML in un sito web…

Nisoo.com

Elimina l’Underfitting e l’Overfitting con questi Trucchi

L’Underfitting e l’Overfitting sono problemi che affrontiamo nella nostra giornata, in questo articolo imparerai il più potente…

Nisoo.com

Grazie mille per aver letto questo piccolo articolo. Spero tu abbia imparato molto e che lo metta in pratica nei tuoi progetti, sia esso Data Science, Computer Security o sviluppo web. Puoi accedere al repository su GitHub .

Ottieni la Certificazione in ChatGPT + Conversational UX + Dialogflow