Python >> Tutoriel Python >  >> Python

12 trucs et astuces Python que tout scientifique de données devrait connaître

Vous avez déjà une connaissance de base de Python pour la science des données. Mais écrivez-vous votre code efficacement? Découvrez ces trucs et astuces pour booster vos compétences Python.

Comment écrire du code Python efficace

Dans cet article, nous allons jeter un œil à quelques astuces qui vous aideront à écrire du code Python rapide et efficace. Je vais commencer par comment optimiser le code qui implique le pandas bibliothèque. Si vous souhaitez rafraîchir vos connaissances sur les pandas, consultez notre cours Introduction à Python pour la science des données.

Ensuite, je passerai à d'autres bonnes pratiques Python générales, notamment les compréhensions de liste, les énumérateurs, la concaténation de chaînes, etc.

1. Détermination du pourcentage de données manquantes

À titre d'illustration, je vais utiliser un ensemble de données synthétiques avec les coordonnées de 500 sujets fictifs des États-Unis. Imaginons qu'il s'agit de notre clientèle. Voici à quoi ressemble l'ensemble de données :

clients.head()

Comme vous pouvez le voir, il comprend des informations sur le prénom, le nom, le nom de l'entreprise, l'adresse, la ville, le comté, l'état, le code postal, les numéros de téléphone, l'adresse e-mail et l'adresse Web de chaque personne.

Notre première tâche consiste à vérifier les données manquantes. Vous pouvez utiliser clients.info() pour obtenir un aperçu du nombre d'entrées complètes dans chacune des colonnes. Cependant, si vous voulez une image plus claire, voici comment vous pouvez obtenir le pourcentage d'entrées manquantes pour chacune des fonctionnalités par ordre décroissant :

# Getting percentange of missing data for each column
(clients.isnull().sum()/clients.isnull().count()).sort_values(ascending=False)

Comme vous vous en souvenez peut-être, isnull() renvoie un tableau de valeurs True et False qui indiquent respectivement si une entrée donnée est présente ou manquante. De plus, True est considéré comme 1 et False est considéré comme 0 lorsque nous passons cet objet booléen à des opérations mathématiques. Ainsi, clients.isnull().sum() nous donne le nombre de valeurs manquantes dans chacune des colonnes (le nombre de valeurs True), tandis que clients.isnull().count() est le nombre total de valeurs dans chaque colonne.

Après avoir divisé la première valeur par la seconde et trié nos résultats par ordre décroissant, nous obtenons le pourcentage d'entrées de données manquantes pour chaque colonne, en commençant par la colonne qui contient le plus de valeurs manquantes. Dans notre exemple, nous constatons que nous manquons le deuxième numéro de téléphone pour 51,6 % de nos clients.

2. Trouver un ensemble unique de valeurs

Il existe un moyen standard d'obtenir une liste de valeurs uniques pour une colonne particulière :clients['state'].unique() . Cependant, si vous disposez d'un ensemble de données volumineux avec des millions d'entrées, vous préférerez peut-être une option beaucoup plus rapide :

# Checking unique values efficiently
clients['state'].drop_duplicates(keep="first", inplace=False).sort_values()

De cette façon, vous supprimez tous les doublons et ne conservez que la première occurrence de chaque valeur. Nous avons également trié les résultats pour vérifier que chaque état n'est bien mentionné qu'une seule fois.

3. Joindre des colonnes

Souvent, vous devrez peut-être joindre plusieurs colonnes avec un séparateur spécifique. Voici un moyen simple de procéder :

# Joining columns with first and last name
clients['name'] = clients['first_name'] + ' ' + clients['last_name']
clients['name'].head()

Comme vous pouvez le voir, nous avons combiné le first_name et last_name colonnes dans la colonne du nom, où le prénom et le nom sont séparés par un espace.

4. Division des colonnes

Et si nous devions diviser les colonnes à la place ? Voici un moyen efficace de diviser une colonne en deux colonnes en utilisant le premier espace dans une entrée de données :

# Getting first name from the 'name' column
clients['f_name'] = clients['name'].str.split(' ', expand = True)[0]
# Getting last name from the 'name' column
clients['l_name'] = clients['name'].str.split(' ', expand = True)[1]

Maintenant, nous enregistrons la première partie du nom sous le nom f_name colonne et la deuxième partie du nom sous la forme d'un l_name séparé colonne.

5. Vérifier si deux colonnes sont identiques

Depuis que nous nous sommes entraînés à joindre et diviser des colonnes, vous avez peut-être remarqué que nous avons maintenant deux colonnes avec le prénom (first_name et f_name ) et deux colonnes avec le nom de famille (last_name et l_name ). Vérifions rapidement si ces colonnes sont identiques.

Tout d'abord, notez que vous pouvez utiliser equals() pour vérifier l'égalité des colonnes ou même des ensembles de données entiers :

# Checking if two columns are identical with .equals()
clients['first_name'].equals(clients['f_name'])
True

Vous obtiendrez un True ou False réponse. Mais que se passe-t-il si vous obtenez False et vous voulez savoir combien d'entrées ne correspondent pas ? Voici un moyen simple d'obtenir ces informations :

# Checking how many entries in the initial column match the entries in the new column
(clients['first_name'] == clients['f_name']).sum()
500

Nous avons commencé par obtenir le nombre d'entrées que faites match. Ici, nous utilisons à nouveau le fait que True est considéré comme 1 dans nos calculs. Nous voyons que 500 entrées du first_name correspond aux entrées dans le f_name colonne. Vous vous souvenez peut-être que 500 est le nombre total de lignes dans notre ensemble de données, cela signifie donc que toutes les entrées correspondent. Cependant, vous ne vous souviendrez peut-être pas toujours (ou ne connaîtrez pas) le nombre total d'entrées dans votre jeu de données. Ainsi, pour notre deuxième exemple, nous obtenons le nombre d'entrées qui ne sont pas correspondance en soustrayant le nombre d'entrées correspondantes du nombre total d'entrées :

# Checking how many entries in the initial column DO NOT match the entries in the new column
clients['last_name'].count() - (clients['last_name'] == clients['l_name']).sum()
0

6. Regroupement de données

Pour montrer comment nous pouvons regrouper efficacement les données dans les pandas, créons d'abord une nouvelle colonne avec les fournisseurs de services de messagerie. Ici, nous pouvons utiliser l'astuce pour diviser les colonnes que vous connaissez déjà :

# Creating new columb with the email service providers
clients['email_provider'] = clients['email'].str.split('@', expand = True)[1]
clients['email_provider'].head()

Regroupons maintenant les clients par état et email_provider :

# Grouping clients by state and email provider
clients.groupby('state')['email_provider'].value_counts()

Nous avons maintenant une base de données qui utilise plusieurs niveaux d'indexation pour donner accès à chaque observation (appelée multi-indexation).

7. Désempiler

Parfois, vous préférerez transformer un niveau de l'index (comme email_provider ) dans les colonnes de votre bloc de données. C'est exactement ce que unstack() Est-ce que. Il vaut mieux expliquer cela par un exemple. Alors, désempilons notre code ci-dessus :

# Moving 'Mail providers' to the column names
clients.groupby('state')['email_provider'].value_counts().unstack().fillna(0)

Comme vous pouvez le constater, les valeurs des fournisseurs de services de messagerie sont désormais les colonnes de notre bloc de données.

Il est maintenant temps de passer à d'autres astuces Python générales au-delà de pandas .

8. Utilisation des compréhensions de liste

La compréhension de liste est l'une des fonctionnalités clés de Python, et vous connaissez peut-être déjà ce concept. Même si c'est le cas, voici un bref rappel de la façon dont les compréhensions de liste nous aident à créer des listes beaucoup plus efficacement :

# Inefficient way to create new list based on some old list
squares = []
for x in range(5):
    squares.append(x**2)
print(squares)
[0, 1, 4, 9, 16]
# Efficient way to create new list based on some old list
squares = [x**2 for x in range(5)]
print(squares)
[0, 1, 4, 9, 16]

9. Concaténer des chaînes

Lorsque vous avez besoin de concaténer une liste de chaînes, vous pouvez le faire en utilisant une boucle for et ajouter chaque élément un par un. Cependant, cela serait très inefficace, surtout si la liste est longue. En Python, les chaînes sont immuables, et donc les chaînes gauche et droite devraient être copiées dans la nouvelle chaîne pour chaque paire de concaténation.

Une meilleure approche consiste à utiliser le join() fonctionner comme indiqué ci-dessous :

# Naive way to concatenate strings
sep = ['a', 'b', 'c', 'd', 'e']
joined = ""
for x in sep:
    joined += x
print(joined)
abcde
# Joining strings
sep = ['a', 'b', 'c', 'd', 'e']
joined = "".join(sep)
print(joined)
abcde

10. Utilisation des énumérateurs

Comment imprimeriez-vous une liste numérotée des personnes les plus riches du monde ? Peut-être pourriez-vous envisager quelque chose comme ceci :

# Inefficient way to get numbered list
the_richest = ['Jeff Bezos', 'Bill Gates', 'Warren Buffett', 'Bernard Arnault & family', 'Mark Zuckerberg']
i = 0
for person in the_richest:
    print(i, person)
    i+=1

Cependant, vous pouvez faire la même chose avec moins de code en utilisant le enumerate() fonction :

# Efficient way to get numbered list
the_richest = ['Jeff Bezos', 'Bill Gates', 'Warren Buffett', 'Bernard Arnault & family', 'Mark Zuckerberg']
for i, person in enumerate(the_richest):
    print(i, person)

Les énumérateurs peuvent être très utiles lorsque vous devez parcourir une liste tout en gardant une trace des index des éléments de la liste.

11. Utilisation de ZIP lors de l'utilisation de listes

Maintenant, comment procéderiez-vous si vous aviez besoin de combiner plusieurs listes de même longueur et d'imprimer le résultat ? Encore une fois, voici une manière plus générique et "Pythonic" d'obtenir le résultat souhaité en utilisant zip() :

# Inefficient way to combine two lists
the_richest = ['Jeff Bezos', 'Bill Gates', 'Warren Buffett', 'Bernard Arnault & family', 'Mark Zuckerberg']
fortune = ['$112 billion', '$90 billion', '$84 billion', '$72 billion', '$71 billion']
for i in range(len(the_richest)):
    person = the_richest[i]
    amount = fortune[i]
    print(person, amount)
# Efficient way to combine two lists
the_richest = ['Jeff Bezos', 'Bill Gates', 'Warren Buffett', 'Bernard Arnault & family', 'Mark Zuckerberg']
fortune = ['$112 billion', '$90 billion', '$84 billion', '$72 billion', '$71 billion']
for person, amount in zip(the_richest,fortune):
    print(person, amount)

Applications possibles du zip() La fonction inclut tous les scénarios qui nécessitent une cartographie des groupes (par exemple, les employés et leurs informations sur le salaire et le département, les étudiants et leurs notes, etc.).

Si vous avez besoin de récapituler le travail avec des listes et des dictionnaires, vous pouvez le faire ici en ligne.

12. Échange de variables

Lorsque vous avez besoin d'échanger deux variables, la méthode la plus courante consiste à utiliser une troisième variable temporaire. Cependant, Python vous permet d'échanger des variables dans une seule ligne de code en utilisant des tuples et en compressant/décompressant :

# Swapping variables)
a = "January"
b = "2019"
print(a, b)
a, b = b, a
print(b, a)
January 2019
January 2019

Récapitulatif

Impressionnant! Vous connaissez maintenant quelques trucs et astuces Python utiles que les data scientists utilisent dans leur travail quotidien. Ces conseils devraient vous aider à rendre votre code plus efficace et même à impressionner vos employeurs potentiels.

Cependant, en plus d'utiliser différentes astuces, il est également crucial pour un data scientist d'avoir une base solide en Python. N'oubliez pas de consulter notre cours d'introduction à Python pour la science des données si vous avez besoin d'un rappel ; il couvre les bases des pandas et matplotlib — les principales bibliothèques Python pour la science des données — ainsi que d'autres concepts de base dont vous avez besoin pour travailler avec des données en Python.