Image par auteur
De solides compétences en Python et SQL font partie intégrante de nombreux professionnels des données. En tant que professionnel des données, vous êtes probablement à l’aise avec la programmation Python, à tel point qu’écrire du code Python semble assez naturel. Mais suivez-vous les meilleures pratiques lorsque vous travaillez sur des projets de science des données avec Python ?
Bien qu’il soit facile d’apprendre Python et de créer des applications de science des données avec, il est peut-être plus facile d’écrire du code difficile à maintenir. Pour vous aider à écrire un meilleur code, ce didacticiel explore certaines bonnes pratiques de codage Python qui facilitent la gestion et la maintenabilité des dépendances, telles que :
- Mise en place d’environnements virtuels dédiés lorsque vous travaillez localement sur des projets de science des données
- Améliorer la maintenabilité à l’aide d’indices de type
- Modélisation et validation des données à l’aide de Pydantic
- Code de profilage
- Utiliser des opérations vectorisées lorsque cela est possible
Alors passons au codage !
1. Utilisez des environnements virtuels pour chaque projet
Les environnements virtuels garantissent que les dépendances des projets sont isolées, évitant ainsi les conflits entre les différents projets. En science des données, où les projets impliquent souvent différents ensembles de bibliothèques et de versions, les environnements virtuels sont particulièrement utiles pour maintenir la reproductibilité et gérer efficacement les dépendances.
De plus, les environnements virtuels permettent également aux collaborateurs de configurer plus facilement le même environnement de projet sans se soucier des dépendances conflictuelles.
Vous pouvez utiliser des outils comme Poetry pour créer et gérer des environnements virtuels. L’utilisation de Poetry présente de nombreux avantages, mais si tout ce dont vous avez besoin est de créer des environnements virtuels pour vos projets, vous pouvez également utiliser le module venv intégré.
Si vous êtes sur une machine Linux (ou un Mac), vous pouvez créer et activer des environnements virtuels comme ceci :
# Create a virtual environment for the project
python -m venv my_project_env
# Activate the virtual environment
source my_project_env/bin/activate
Si vous êtes un utilisateur Windows, vous pouvez vérifie la documentation sur la façon d’activer l’environnement virtuel. L’utilisation d’environnements virtuels pour chaque projet est donc utile pour maintenir les dépendances isolées et cohérentes.
2. Ajouter des indices de type pour la maintenabilité
Python étant un langage typé dynamiquement, vous n’avez pas besoin de spécifier le type de données pour les variables que vous créez. Cependant, vous pouvez ajouter des indications de type (indiquant le type de données attendu) pour rendre votre code plus maintenable.
Prenons un exemple de fonction qui calcule la moyenne d’une entité numérique dans un ensemble de données avec les annotations de type appropriées :
from typing import List
def calculate_mean(feature: List[float]) -> float:
# Calculate mean of the feature
mean_value = sum(feature) / len(feature)
return mean_value
Ici, les indications de type permettent à l’utilisateur de savoir que le calcuate_mean La fonction prend une liste de nombres à virgule flottante et renvoie une valeur à virgule flottante.
N’oubliez pas que Python n’applique pas les types au moment de l’exécution. Mais vous pouvez utiliser mypy ou similaire pour générer des erreurs pour les types non valides.
3. Modélisez vos données avec Pydantic
Précédemment, nous avons parlé de l’ajout d’indices de type pour rendre le code plus maintenable. Cela fonctionne bien pour les fonctions Python. Mais lorsque vous travaillez avec des données provenant de sources externes, il est souvent utile de modéliser les données en définissant des classes et des champs avec le type de données attendu.
Vous pouvez utiliser des classes de données intégrées dans Python, mais vous ne bénéficiez pas d’une prise en charge de la validation des données prête à l’emploi. Avec Pydantic, vous pouvez modéliser vos données et également utiliser ses capacités de validation de données intégrées. Pour utiliser Pydantic, vous pouvez l’installer avec le validateur de courrier électronique en utilisant pip :
$ pip install pydantic[email-validator]Voici un exemple de modélisation de données client avec Pydantic. Vous pouvez créer une classe modèle qui hérite de BaseModel et définir les différents champs et attributs :
from pydantic import BaseModel, EmailStr
class Customer(BaseModel):
customer_id: int
name: str
email: EmailStr
phone: str
address: str
# Sample data
customer_data = {
'customer_id': 1,
'name': 'John Doe',
'email': 'john.doe@example.com',
'phone': '123-456-7890',
'address': '123 Main St, City, Country'
}
# Create a customer object
customer = Customer(**customer_data)
print(customer)
Vous pouvez aller plus loin en ajoutant une validation pour vérifier si les champs ont tous des valeurs valides. Si vous avez besoin d’un didacticiel sur l’utilisation de Pydantic (définition de modèles et validation des données), lisez Tutoriel Pydantic : la validation des données en Python simplifiée.
4. Code de profil pour identifier les goulots d’étranglement des performances
Le code de profilage est utile si vous cherchez à optimiser les performances de votre application. Dans les projets de science des données, vous pouvez profiler l’utilisation de la mémoire et les temps d’exécution en fonction du contexte.
Supposons que vous travailliez sur un projet d’apprentissage automatique dans lequel le prétraitement d’un grand ensemble de données est une étape cruciale avant d’entraîner votre modèle. Décrivons une fonction qui applique des étapes de prétraitement courantes telles que la standardisation :
import numpy as np
import cProfile
def preprocess_data(data):
# Perform preprocessing steps: scaling and normalization
scaled_data = (data - np.mean(data)) / np.std(data)
return scaled_data
# Generate sample data
data = np.random.rand(100)
# Profile preprocessing function
cProfile.run('preprocess_data(data)')
Lorsque vous exécutez le script, vous devriez voir un résultat similaire :
Dans cet exemple, nous profilons le preprocess_data() fonction, qui prétraite les exemples de données. Le profilage, en général, permet d’identifier les goulots d’étranglement potentiels, guidant ainsi les optimisations pour améliorer les performances. Voici des tutoriels sur le profilage en Python qui pourraient vous être utiles :
5. Utilisez les opérations vectorisées de NumPy
Pour toute tâche de traitement de données, vous pouvez toujours écrire une implémentation Python à partir de zéro. Mais vous ne voudrez peut-être pas le faire lorsque vous travaillez avec de grands tableaux de nombres. Pour les opérations les plus courantes (qui peuvent être formulées comme des opérations sur des vecteurs) que vous devez effectuer, vous pouvez utiliser NumPy pour les exécuter plus efficacement.
Prenons l’exemple suivant de multiplication élément par élément :
import numpy as np
import timeit
# Set seed for reproducibility
np.random.seed(42)
# Array with 1 million random integers
array1 = np.random.randint(1, 10, size=1000000)
array2 = np.random.randint(1, 10, size=1000000)
Voici les implémentations Python uniquement et NumPy :
# NumPy vectorized implementation for element-wise multiplication
def elementwise_multiply_numpy(array1, array2):
return array1 * array2
# Sample operation using Python to perform element-wise multiplication
def elementwise_multiply_python(array1, array2):
result = []
for x, y in zip(array1, array2):
result.append(x * y)
return result
Utilisons le timeit fonction à partir du timeit module pour mesurer les temps d’exécution pour les implémentations ci-dessus :
# Measure execution time for NumPy implementation
numpy_execution_time = timeit.timeit(lambda: elementwise_multiply_numpy(array1, array2), number=10) / 10
numpy_execution_time = round(numpy_execution_time, 6)
# Measure execution time for Python implementation
python_execution_time = timeit.timeit(lambda: elementwise_multiply_python(array1, array2), number=10) / 10
python_execution_time = round(python_execution_time, 6)
# Compare execution times
print("NumPy Execution Time:", numpy_execution_time, "seconds")
print("Python Execution Time:", python_execution_time, "seconds")
Nous voyons que l’implémentation de NumPy est ~100 fois plus rapide :
Output >>>
NumPy Execution Time: 0.00251 seconds
Python Execution Time: 0.216055 seconds
Emballer
Dans ce didacticiel, nous avons exploré quelques bonnes pratiques de codage Python pour la science des données. J’espère que vous les avez trouvés utiles.
Si vous souhaitez apprendre Python pour la science des données, consultez 5 cours gratuits Master Python pour la science des données. Bon apprentissage!
Bala Priya C est un développeur et rédacteur technique indien. Elle aime travailler à l’intersection des mathématiques, de la programmation, de la science des données et de la création de contenu. Ses domaines d’intérêt et d’expertise incluent le DevOps, la science des données et le traitement du langage naturel. Elle aime lire, écrire, coder et prendre le café ! Actuellement, elle travaille à l’apprentissage et au partage de ses connaissances avec la communauté des développeurs en créant des didacticiels, des guides pratiques, des articles d’opinion, etc. Bala crée également des aperçus de ressources attrayants et des didacticiels de codage.
