Neuf erreurs courantes commises par les data scientists lorsqu'ils utilisent Python

Les meilleures pratiques s'apprennent des erreurs, nous avons donc résumé ici certaines des erreurs les plus courantes que nous rencontrons et fourni des méthodes, des idées et des ressources sur la meilleure façon de les résoudre.

1. Ne pas utiliser d'environnement virtuel

Ce n'est pas un problème de codage en soi, mais je pense quand même que c'est une très bonne pratique d'isoler l'environnement pour chaque type de projet.

Pourquoi utiliser un environnement dédié pour chaque projet ?

La première raison est le problème de la gestion des packages propre à Python. Nous voulons minimiser les conflits entre les packages et les versions.

Une autre raison est que notre code et nos dépendances peuvent être facilement déployés vers n'importe quel emplacement

L'utilisation d'un environnement virtuel peut commencer à partir d'Anaconda ou de Pipenv. Si vous souhaitez aller plus loin, Docker est le premier choix.

2. Surutilisation des notebooks Jupyter

Les notebooks sont parfaits à des fins éducatives et pour effectuer des travaux d'analyse rapides et complexes, mais ils ne constituent pas un bon IDE.

Un bon IDE est une véritable arme pour gérer les tâches de science des données et peut grandement améliorer l'efficacité de votre travail.

Les cahiers sont parfaits pour faire des expériences et permettre de montrer facilement les résultats aux autres. Mais il est sujet aux erreurs, et lorsqu'il s'agit d'exécuter des projets collaboratifs et déployables à long terme, il est préférable d'utiliser un IDE comme VScode, Pycharm, Spyder, etc.

3. Utilisez des chemins absolus plutôt que relatifs

Le plus gros problème avec les chemins absolus est qu'ils ne peuvent pas être déployés facilement. Le principal moyen de résoudre ce problème est de définir le répertoire de travail sur le répertoire racine du projet et de ne pas inclure de fichiers à l'extérieur. le répertoire du projet dans le projet et utilisez des chemins relatifs pour tous les chemins dans le code.

import pandas as pd
 import numpy as np
 import os
 #### 错误的方式 #####
 excel_path1 = "C:\Users\abdelilah\Desktop\mysheet1.xlsx"
 excel_path2 = "C:\Users\abdelilah\Desktop\mysheet2.xlsx"
 mydf1 = pd.read_excel(excel_path1)
 mydf2 = pd.read_excel(excel_path2)
 
 #### 正确的方式 ####
 DATA_DIR = "data"
 #将要读取的文件复制到data目录
 crime06_filename = "CrimeOneYearofData_2006.xlsx"
 crime07_filename = "CrimeOneYearofData_2007.xlsx"
 crime06_df = pd.read_excel(os.path.join(DATA_DIR, crime06_filename))
 crime07_df = pd.read_excel(os.path.join(DATA_DIR, crime07_filename))

4. Ne pas gérer les avertissements

Lorsque notre code s'exécute mais produit des messages d'avertissement étranges, nous sommes heureux de pouvoir enfin exécuter le code et recevoir une sortie significative. Mais devons-nous faire face à ces avertissements ?

Tout d’abord, les avertissements en eux-mêmes ne sont pas des erreurs, mais ce sont des conseils qui nous alertent d’erreurs ou de problèmes potentiels. Des avertissements apparaissent lorsque quelque chose dans votre code fonctionne correctement, mais peut-être pas comme prévu.

Les avertissements les plus courants que je rencontre sont « SettingwithCopyWarning » et « DeprecationWarning » de Pandas.

La principale raison de SettingwithCopyWarning est l'avertissement qui se produit lorsque Pandas détecte une affectation chaînée (Chained Assignment). Nous devrions éviter d'attribuer des valeurs aux résultats des index chaînés, car cette opération peut ou non signaler un avertissement.

DeprecationWarning indique généralement que Pandas a rendu obsolète certaines fonctionnalités et que votre code sera interrompu lors de l'utilisation d'une version ultérieure.

Le conseil ici n'est pas de traiter tous les avertissements, mais vous devez comprendre les raisons de tous les avertissements. Vous devez savoir quels avertissements peuvent être ignorés dans un projet spécifique. L'apparition de ces avertissements aura un impact sur vos résultats. devrait éviter.

5. Les compréhensions de listes ne sont pas utilisées (rarement utilisées)

Les compréhensions de listes sont une fonctionnalité très puissante de Python. De nombreuses boucles for peuvent être remplacées par des compréhensions de listes plus lisibles, plus pythoniques et plus rapides.

Vous pouvez voir ci-dessous un exemple de code conçu pour lire un fichier CSV dans un répertoire. Comme vous pouvez le constater, Tim est facile à gérer lors de l'utilisation de compréhensions de listes.

import pandas as pd
 import os
 
 DATA_PATH = "data"
 filename_list = os.listdir(DATA_PATH)
 
 #### 不好的方法 #####
 csv_list = []
 for fileaname in filename_list:
csv_list.append(pd.read_csv(os.path.join(DATA_PATH, filename)))
 
 #### 建议 ####
 csv_list = [pd.read_csv(os.path.join(DATA_PATH, filename)) for filename in filename_list]
 list comprehensions
 csv_list = [pd.read_csv(os.path.join(DATA_PATH,
filename)) for filename in filename_list if
filename.endswith(".csv")]

6. N'utilisez pas d'annotations de type

Les annotations de type (ou astuces de type) sont des moyens d'attribuer des types à des variables. Lorsque l'EDI invite IntelliSense, il peut nous fournir le type de variable/paramètre indicateur. Cela peut non seulement améliorer la vitesse de notre développement, mais aussi nous aider beaucoup à lire le code

def mystery_combine(a, b, times):
return (a + b) * times

Si nous l'écrivons comme ça, nous ne connaissons pas du tout les types de a, b et times

def mystery_combine(a: str, b: str, times: int) -> str:
return (a + b) * times

Mais avec les annotations de type, nous savons que a et b sont des chaînes et que les heures sont des entiers

Il convient de noter que Python a introduit les annotations de type dans la version 3.5. Python ne vérifie pas les annotations de type pendant l'exécution. Il fournit uniquement une vérification de type statique pratique pour. l'IDE. Outils pour effectuer une vérification de type statique sur les langages dynamiques afin d'éviter certaines erreurs potentielles.

7. Le code Pandas n'est pas standardisé

Le chaînage de méthodes est une fonctionnalité intéressante des pandas, mais s'il y a de nombreuses opérations incluses dans une seule ligne, le code peut devenir illisible.

Il existe une astuce pour rendre cette approche encore plus simple, en mettant l'expression entre parenthèses, vous pouvez utiliser une ligne pour chaque composant de l'expression.

var_list = ["clicks", "time_spent"]
 var_list_Q = [varname + "_Q" for varname in var_list]
 
 #不可读的方法
 df_Q = df.groupby("id").rolling(window=3, min_periods=1, on="yearmonth[var_list].mean().reset_index().rename(columns=dict(zip(var_list, var_list_Q)))
 
 #可读性强的方法
 df_Q = (
df
.groupby("id")
.rolling(window=3, min_periods=1, on="yearmonth")[var_list]
.mean()
.reset_index()
.rename(columns=dict(zip(var_list, var_list_Q))))

8. Ne pas adhérer aux conventions PEP

Quand j'ai commencé à programmer en Python, le code pouvait être grossier et illisible parce que nous n'avions pas nos propres règles de conception pour améliorer l'apparence de mon code. Il serait laborieux et laborieux de concevoir de telles règles nous-mêmes et nécessiterait beaucoup de pratique. Heureusement, Python a officiellement spécifié des règles : PEP, qui est le guide de style officiel de Python.

Bien que les règles PEP soient nombreuses et lourdes, nous pouvons ignorer certaines règles PEP, mais nous pouvons les utiliser dans 90 % du code.

9. Vous n’utilisez pas d’aides au codage

Vous souhaitez améliorer significativement votre productivité en codage ? Commencez à utiliser Coding Assist, qui facilite la saisie semi-automatique intelligente, l'ouverture de documents et la fourniture de suggestions pour améliorer votre code.

pylance, Kite, tabnine et copilot sont tous de très bons choix.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!