10 erreurs que vous NE DEVRIEZ JAMAIS commettre en Python

10 Python mistakes you should NEVER make

Quand nous commençons à apprendre Python, nous rencontrons souvent de mauvaises pratiques. Dans cet article, vous apprendrez les meilleures pratiques pour amener votre niveau de développeur Python au niveau supérieur.

Je me souviens quand j’ai commencé à apprendre Python, j’ai commis beaucoup d’erreurs qui, si j’en avais eu connaissance au préalable, m’auraient permis d’accélérer la courbe d’apprentissage.

1- Ne pas définir de variables sur une seule ligne.

a = 12b = 56c = 128

Nous avons généralement une variable par ligne, cependant, il y a un moyen de définir plusieurs variables en une seule ligne de code.

• ChatGPT La perspective d’un designer web
• GitHub Topics Scraper | Scraping Web avec Python
• Comment implémenter l’IA adaptative dans votre entreprise

a,b,c = 12,56,128

De cette manière simple, nous pouvons définir plusieurs variables, ce qui rend le code plus facile à lire.

2- Utilisez * pour importer des modules.

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

Nous utilisons généralement * pour invoquer les modèles de la bibliothèque correspondante. Cependant, il n’a pas de sens d’appeler tous les modules si nous ne sommes intéressés que par des fonctions spécifiques de la bibliothèque.

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

Importez la bibliothèque qui vous intéresse, dans ce cas, numpy, et nous pouvons lui assigner un alias, suivi de l’appel des méthodes que nous allons utiliser.

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

Nous pouvons également directement innover les fonctions de la bibliothèque qui nous intéresse; l’une ou l’autre de ces deux façons est bonne.

3- Utilisez “+” pour concaténer.

name,year = "Amado",22print("My name is " + name + " and I am " + str(year) + " years old")

Habituellement, nous utilisons toujours + pour concaténer des chaînes de caractères; cependant, il a l’inconvénient de ne pas être si compréhensible.

name,year = "Amado",22print(f"My name is {name} and I'm {year} years old")

Nous utilisons des littéraux de chaîne formatés, qui permettent de concaténer des variables indépendamment de la nature de la variable; il a l’avantage supplémentaire d’être plus compréhensible à lire.

4- Ne pas utiliser la fonction lambda.

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

Généralement, lors de la création d’une fonction, nous créons une fonction conventionnelle. Il y a des occasions où la méthode que nous créons est quelque chose de simple mais que nous allons utiliser fréquemment.

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

Nous pouvons créer une fonction lambda pour le même objectif, avec la différence agréable de la rendre plus simple. Si nous voulons créer des fonctions qui ne sont pas si complexes, il est beaucoup préférable d’utiliser des fonctions lambda que des fonctions Python conventionnelles.

5- Utilisation de If Else à partir de plusieurs lignes de code.

age = 22if age>=18:  print('Vous êtes majeur')else:  print('Vous n'êtes pas majeur')

En général, lorsque nous apprenons, nous avons l’habitude d’exprimer l’instruction if else de cette manière; cependant, elle peut être simplifiée en une seule ligne de code.

age = 22"Vous êtes majeur" if age>=18 else "Vous n'êtes pas majeur"

De cette façon, réduisez le if-else en une seule ligne de code, ce qui rend la lecture plus compréhensible.

6- Utilisation de multiples instructions conditionnelles If.

kepler_third_law = lambda ua: (np.round(np.sqrt(ua**3),1))def calculate_years(planet):    planet = planet.lower()    if planet == "mercury":        ua = 0.387        print(f'Nombre d'années planétaires pour Mercure: {kepler_third_law(ua)}')            if planet == "venus":        ua = 0.723        print(f'Nombre d'années planétaires pour Vénus: {kepler_third_law(ua)}')            if planet == "earth":        ua = 1        print(f'Nombre d'années planétaires pour la Terre: {kepler_third_law(ua)}')            if planet == "mars":        ua = 1.524        print(f'Nombre d'années planétaires pour Mars: {kepler_third_law(ua)}')            if planet == "earth":        ua = 1        print(f'Nombre d'années planétaires pour la Terre: {kepler_third_law(ua)}')            if planet == "jupiter":        ua = 5.208        print(f'Nombre d'années planétaires pour Jupiter: {kepler_third_law(ua)}')            if planet == "saturn":        ua = 9.539        print(f'Nombre d'années planétaires pour Saturne: {kepler_third_law(ua)}')            if planet == "uranus":        ua = 19.182        print(f'Nombre d'années planétaires pour Uranus: {kepler_third_law(ua)}')            if planet == "neptune":        ua = 30.058        print(f'Nombre d'années planétaires pour Neptune: {kepler_third_law(ua)}')            if planet == "pluto":        ua = 39.439        print(f'Nombre d'années planétaires pour Pluton: {kepler_third_law(ua)}')

Généralement, nous utilisons plusieurs instructions conditionnelles If en fonction de la condition qui est présentée. Cela a l’inconvénient de nécessiter une quantité excessive de lignes de code.

import numpy as npkepler_third_law = lambda ua: (np.round(np.sqrt(ua**3),1))def calculate_years(planet):        planet = planet.lower()        ua_dict = {'saturne':9.539,               'terre':1,               'mercure':0.387,               'venus':0.723,              'jupiter':5.203,              'uranus':19.182,              'pluton':39.439,              'mars':1.524}    years = kepler_third_law(ua_dict[planet])            return f'Nombre d'années planétaires pour {planet}: {years}'

Au lieu d’utiliser plusieurs instructions conditionnelles If, nous créons un dictionnaire dans lequel nous stockons les UA des planètes, afin de calculer ultérieurement le nombre d’années qu’il faut pour faire le tour du soleil en appliquant la troisième loi de Kepler. Comme nous pouvons le voir, l’application de cette stratégie rend le code plus propre et plus facile à comprendre.

7- N’utilisez pas la compréhension de liste.

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)

Généralement, si nous voulons stocker des éléments dans une liste en fonction d’une condition donnée, nous utilisons des boucles For. Par exemple, dans ce cas, nous voulons ne stocker que les valeurs paires.

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

En utilisant la compréhension de liste, nous pouvons considérablement réduire le nombre de lignes de code à une seule ligne.

8- N’utilisez pas l’énumération.

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

Supposons que nous voulons afficher le nom et le nom de famille de la personne à l’écran; pour cela, nous utilisons la fonction range() pour définir les indices et les imprimer plus tard en fonction des indices générés.

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

En utilisant la fonction d’énumération, on obtient l’indice d’objet de la liste, donc nous pouvons économiser cette étape.

9- Ne pas utiliser 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]}')

Ici, nous faisons une erreur similaire à la précédente, à la différence que nous voulons imprimer trois listes en harmonie.

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}')

L’utilisation de la méthode zip nous permet d’utiliser plusieurs listes en même temps, c’est beaucoup plus confortable que d’utiliser l’indice, et cela a également l’avantage d’être beaucoup plus facile à comprendre.

10- Keys()/Items()

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()

Parfois, nous utilisons mal les dictionnaires, plus particulièrement avec les méthodes pour y accéder. Nous utilisons keys() pour accéder à ses clés, values() se réfère à l’extraction des valeurs assignées à chaque clé, et enfin, items() nous permet d’extraire les deux éléments.

for key in consoles_dict:  print(key)

Si nous voulons accéder à la clé du dictionnaire, il suffit d’appliquer une boucle sur le dictionnaire d’intérêt.

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

Si nous voulons accéder à la valeur du dictionnaire, il suffit de lui assigner le nom de la clé sur la boucle for.

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

Il est préférable d’utiliser la méthode items() et d’ajouter les deux valeurs à itérer pour pouvoir obtenir à la fois la clé et sa valeur.

11- Ne pas compter sur les modules.

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

Certaines bibliothèques peuvent rendre la vie plus facile; par exemple, il existe une bibliothèque appelée numpy qui est utilisée pour effectuer des calculs mathématiques. Certaines bibliothèques peuvent rendre la vie plus facile au lieu de programmer à partir de zéro. Par exemple, il existe une bibliothèque très célèbre en science des données qui est utilisée pour effectuer des calculs complexes.

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

La bibliothèque numpy nous facilite grandement la tâche lors de la réalisation de certains calculs mathématiques, de quelque chose d’aussi simple qu’une somme à quelque chose de plus complexe comme les transformations de Fourier.

12- Ne pas utiliser IN

car_model = "Maxima"if car_model == "Altima" or car_model == "Maxima" or car_model == "Q50" or car_model == "Q60":    print('Modèle disponible')

Au lieu d’utiliser une longue déclaration conditionnelle, nous pouvons utiliser la condition IN.

car_models = ['Altima','Maxima','Q50','Q60']car_model = "Maxima"'Modèle disponible' if car_model in car_models else 'Modèle non disponible'

Nous créons une liste Python conventionnelle, et l’opérateur IN comparera si la voiture que nous sélectionnons est à l’intérieur de la liste. Nous nous appuyons également sur la déclaration if-else d’une seule ligne de code.

Ça pourrait vous intéresser.

10 erreurs de Pandas que vous ne devriez JAMAIS commettre

Cet article examinera les 10 erreurs les plus courantes dans Pandas que les débutants commettent lorsqu’ils commencent à apprendre Pandas dans…

IPGirl.com

Créez une belle application en utilisant Streamlit

Si vous voulez amener vos projets de ML à un autre niveau, où différents utilisateurs peuvent utiliser votre algorithme de ML sur le web…

IPGirl.com

Éliminez l’underfitting et l’overfitting avec ces astuces

L’underfitting et l’overfitting sont des problèmes auxquels nous sommes confrontés dans notre quotidien, dans cet article, vous apprendrez les plus puissants…

IPGirl.com

Merci beaucoup d’avoir lu cet petit article. J’espère que vous avez beaucoup appris et que vous le mettez en pratique dans vos projets, que ce soit la Science des Données, la Sécurité Informatique ou le développement web. Vous pouvez accéder au dépôt sur GitHub .

We will continue to update IPGirl; if you have any questions or suggestions, please contact us!