Notes personnelles des opérations liées aux pandas qui peuvent être utilisées dans la pratique

0. Introduction

Récemment, j'ai étudié les pandas en résolvant Data Science 100 Knock (traitement des données structurées). Tout d'abord, j'ai cherché les parties que je ne comprenais pas sans regarder les réponses, j'ai résolu toutes les questions, puis j'ai étudié en faisant correspondre les réponses, mais à travers cette étude, j'ai résumé les processus que je pensais pouvoir utiliser dans la pratique pour moi-même. C'était.

1. Chargement-prétraitement de l'ensemble de données

Entrée / sortie de fichier

#Lire le fichier. Le code de caractère est UTF-8, délimité par des tabulations
df = pd.read_csv('data/d.csv', header=0, encoding='utf-8', sep='\t')
#Écriture de fichier. Il y a un en-tête et le code du caractère est UTF-8, séparés par des virgules
df.to_csv('data/d.csv', header=True, encoding='utf-8', sep=',')
#Écriture de fichier. Pas d'en-tête, le code de caractère est CP932, délimité par des tabulations
df.to_csv('data/d.csv', header=False, encoding='cp932', sep='\t') 

Copie du bloc de données

df2 = df.copy()

Joindre des blocs de données à l'aide de clés

pd.merge(df_receipt, df_store[['store_cd', 'store_name']], on='store_cd', how='inner')
#inner:Jointure interne, left:Jointure externe gauche, right:Jointure externe droite, outer:Jointure externe complète

Concaténation de trames de données

pd.concat([df1, df2], axis=1)
#Contrairement à la fusion, transmettez-la sous forme de liste. axe axe=Si 0, vertical, axe=S'il vaut 1, ils sont combinés dans le sens horizontal.

Nombre de trames de données (nombre de lignes)

len(df)

Numéro unique

len(df['id'].unique())

Valeur d'élément unique et son nombre d'apparences

df['id'].value_counts()

Traitement des valeurs manquantes

#Vérifiez le nombre d'éléments manquants dans chaque colonne
df.isnull().sum()
#Supprimer les enregistrements contenant au moins une valeur manquante
df.dropna()
#fillna est un type de dictionnaire et peut être spécifié à la fois
df.fillna({'price': mean(df['price']),
           'cost': median(df['cost'])}) 

Suppression des doublons

#Définir la colonne cible dans le sous-ensemble et supprimer les doublons
df.drop_duplicates(subset=['name', 'cd'], keep='first', inplace=True)

Renommer la colonne

#Changer n'importe quel nom de colonne avec renommer
df.rename(columns={'ymd':'sales_date'}, inplace=True)
#Réécrire directement dans la liste
df.columns = ['category', 'price', 'cost']

Type fonte

#Convertir en type chaîne
df['sales_date'].astype(str)
# True,Faux à 1,Convertir en 0
(df['sales']>2000).astype(int)

Remplacement de valeur

code_dict = {
    'A': 11,
    'B': 22,
    'C': 33,
    'D': 44
}
df['name'].replace(code_dict) #S'ils ne correspondent pas, laissez-les tels quels
df['name'].map(code_dict) #NAN s'ils ne correspondent pas

Accéder aux lignes qui remplissent les conditions et attribuer des valeurs

df.loc[df['age10']=='Années 60', 'age10'] = 'Années 60以上'

Définissez un indicateur 0-1 pour voir si les conditions sont remplies

(df['sales'] != 0).apply(int) #Si les ventes ne sont pas égales à 0, 1 est marqué

Convertir en appliquant une fonction à une colonne

#Compléter
df['price'].apply(lambda x: np.round(x))
# 1.Multiplier par 1 et tronquer après la virgule décimale
df['price'].apply(lambda x: np.floor(x * 1.1))
#Logarithmique commune (en bas)=dix)
df['sales'].apply(lambda x: math.log10(x))

Convertir en appliquant une fonction à plusieurs colonnes

#Faites la différence entre les mois dans les deux colonnes
df[['end_date', 'start_date']].apply(\
    lambda x: relativedelta(x[0], x[1]).years * 12 + relativedelta(x[0], x[1]).months, axis=1)
#X pour les valeurs manquantes[1](Mesian). Sinon comme c'est
df[['price', 'median_price']].apply(\
    lambda x: np.round(x[1]) if np.isnan(x[0]) else x[0], axis=1)

Standardiser les valeurs (moyenne 0, écart type 1)

#Lorsque vous écrivez sur une seule ligne
df['sales_ss'] = preprocessing.scale(df['sales'])
from sklearn import preprocessing
scaler = preprocessing.StandardScaler()
scaler.fit(customer[['sales']])
customer['sales_ss'] = scaler.transform(customer[['sales']])

Normaliser la valeur (valeur minimale 0, valeur maximale 1)

from sklearn import preprocessing
scaler = preprocessing.MinMaxScaler()
scaler.fit(customer[['sales']])
customer['sales_mm'] = scaler.transform(customer[['sales']])

Créer une variable factice

pd.get_dummies(df, columns=['cd'])
#Si des colonnes sont spécifiées, seules des colonnes spécifiques peuvent être appliquées et elles peuvent être factices même s'il ne s'agit pas d'un type d'objet.

Manipulation des cordes

#Extraction des 3 premiers caractères
df['name'].str[0:3]
#Concaténation de chaînes
df['gender'].str.cat((df['age10']).astype(str)) #Combinez les chaînes gender et age10

Extraction de lignes par condition numérique

#Extraction de données par méthode de requête. Peut être écrit simplement en spécifiant plusieurs conditions
df[['sales_date', 'id', 'cd', 'quantity', 'amount']]\
    .query('id == "XXXX" & (amount >= 1000 | quantity >=5)')
#(Référence) Si la méthode de requête n'est pas utilisée, ce sera compliqué si les conditions sont compliquées.
target = (df['id']=="XXXX") & ((df['amount']>=1000) | (df['quantity']>=5))
df[target][['sales_date', 'id', 'cd', 'quantity', 'amount']]

Extraction de lignes par condition de chaîne

# "SASS"Extraire les lignes commençant par
df['store'].str.startswith('SASS')
#Extraire les lignes se terminant par 1
df['id'].str.endswith('1')
#Extraire des lignes dont Sapporo
df['address'].str.contains('Sapporo')
#Jugement à l'aide d'expressions régulières
df['cd'].str.contains('^[A-D]', regex=True) #Commencez par l'un de A à D
df['cd'].str.contains('[1-9]$', regex=True) #Se termine par l'un des 1-9
df['cd'].str.contains('^[A-D].*[1-9]$', regex=True) #Commence par A à D et se termine par l'un des 1-9
df['tel'].str.contains('^[0-9]{3}-[0-9]{3}-[0-9]{4}', regex=True) #Numéro de téléphone à 3 chiffres-3 chiffres-4 chiffres

2. Agrégation

Trier

#Trier par ordre décroissant en fonction de la colonne des ventes
df.sort_values('sales', ascending=True).head(10) #Si défini sur False, ordre croissant
#Trier en fonction de plusieurs colonnes. Vous pouvez également spécifier un ordre décroissant ou croissant pour chaque colonne.
df.sort_values(['sales', 'id'], ascending=[False, True])
#Par ordre décroissant des ventes (croissant=Faux) dans le rang. méthode='min'Ensuite, lorsque les valeurs sont les mêmes, les mêmes numéros sont attribués.
df['sales'].rank(method='min', ascending=False)

Agrégation par groupe par

#Sélectionnez la fonction d'agrégation à appliquer pour chaque colonne à agréger
df.groupby('id', as_index=False).agg({'amount':'sum', 'quantity':'sum'}) 
#Appliquer plusieurs agrégats à une colonne
df.groupby('id', as_index=False).agg({'ymd':['max', 'min']})
#Fonction arbitraire (ici pd.Series.mode) est spécifié
df.groupby('id', as_index=False).agg({'cd': pd.Series.mode})
#Spécifier la fonction anonyme lambda
df.groupby('id', as_index=False).agg({'amount': lambda x: np.var(x)})
#Il est également possible d'écrire sans utiliser la fonction agg
df.groupby('id', as_index=False).max()[['id', 'ymd']]
df.groupby('id', as_index=False).sum()[['id', 'amount', 'quantity']]
#(Référence) Utilisez la fonction agg lors de l'agrégation des valeurs (modes) les plus fréquentes par groupe par
df.groupby('id', as_index=False).mode() #J'obtiens une erreur

Tableau croisé

pd.pivot_table(df, index='age10', columns='gender', values='amount', aggfunc='sum')
#index:Face avant, columns:De face, values:Valeur cible, aggfunc:Méthode d'agrégation)
pd.pivot_table(sales, index='id', columns='year', values='amount', aggfunc='sum', margins=True) 
#margins=Si True, vous pouvez obtenir des totaux et des sous-totaux

Calcul du quadrant

df.quantile([0, 0.25, 0.5, 0.75, 1.0])[['amount']]

3. Traitement lié à la date et à l'heure

Conversion de variable de temps

#Chaîne de caractères → type datetime
pd.to_datetime(df['str_date'])
#Epoch secondes → type datetime
pd.to_datetime(df['epoch'], unit='s')
#type datetime → epoch secondes
df['date'].astype(np.int64) // 10**9
#type datetime → chaîne de caractères%Y:4 chiffres par an, %m:2 chiffres par mois, %d:Deux chiffres par jour. *%Notez que la signification est différente entre les majuscules et les minuscules. Par exemple%M signifie minutes
df['date'].dt.strftime('%Y%m%d')

Extraire les informations année / mois / jour de la variable datitime

#Extraire les informations sur l'année. Vous pouvez récupérer le mois par mois et la date par jour
t.dt.year
#Utilisez strftime pour obtenir une chaîne à 2 chiffres complétée par 0
t.dt.strftime('%d')

Différence de variable de temps

#Soustrayez simplement le type datetime pour obtenir la différence en jours
df['end_date'] - df['start_date']
#Utilisez le delta relatif pour obtenir la différence entre les mois
relativedelta(x0, x1).years * 12 + relativedelta(x0, x1).months

Traitement de jour

#Sortie du jour sous forme de nombre (le nombre de jours à partir du lundi) avec la fonction jour de la semaine
df['Jours écoulés à partir du lundi'] = df['ymd'].apply(lambda x: x.weekday())
#Obtenez la date du lundi de la semaine
df['Lundi de la semaine'] = df['ymd'].apply(lambda x: x - relativedelta(days=x.weekday()))

Traitement des séries chronologiques

#Différence par rapport à il y a 1 fois
df['sales'].diff(1)
#Taux de changement d'il y a une fois
df['sales'].pct_change(1)
#Valeur il y a une fois
df['sales'].shift(1)
#Valeur avant 2 points
df['sales'].shift(2)

4. Échantillonnage

Échantillonnage aléatoire

#Au hasard 10%Échantillonnage des données de
df.sample(frac=0.1, random_state=5) 
#Au hasard 10 en fonction du pourcentage de sexe%Extraction stratifiée des données
_, test = train_test_split(df, test_size=0.1, stratify=df['gender'], random_state=5)
#8 pour les données d'entraînement et les données de test:Divisez par un rapport de 2
df_train, df_test = train_test_split(df, test_size=0.2, random_state=5) 
# 1:Sous-échantillonnage à 1
r = RandomUnderSampler(random_state=5)
df_sample, _ = r.fit_sample(df, df['flag'])

référence

En étudiant, j'ai évoqué ce qui suit. Merci beaucoup.

Recommended Posts

Notes personnelles des opérations liées aux pandas qui peuvent être utilisées dans la pratique
Un minuteur (ticker) qui peut être utilisé sur le terrain (peut être utilisé n'importe où)
Fonctions pouvant être utilisées dans l'instruction for
Collection de conseils Numpy, Pandas souvent utilisés sur le terrain
Algorithmes de base utilisables par les pros de la compétition
Une collection de code souvent utilisée dans Python personnel
Enregistrement d'image ANT qui peut être utilisé en 5 minutes
Résumé des méthodes d'analyse de données statistiques utilisant Python qui peuvent être utilisées en entreprise
Goroutine (contrôle parallèle) utilisable sur le terrain
Goroutine utilisable sur le terrain (édition errgroup.Group)
Scripts pouvant être utilisés lors de l'utilisation de Bottle en Python
Index d'évaluation pouvant être spécifié pour GridSearchCV de sklearn
Peut être utilisé avec AtCoder! Une collection de techniques pour dessiner du code court en Python!
[Python] Mémo des phrases fréquemment utilisées dans les scripts Python
Créez une Spinbox qui peut être affichée en binaire avec Tkinter
Résumé de l'entrée standard de Python pouvant être utilisée dans Competition Pro
Créez une Spinbox pouvant être affichée dans HEX avec Tkinter
J'ai écrit un tri-arbre qui peut être utilisé pour l'implémentation de dictionnaire à grande vitesse en langage D et Python
J'ai créé un modèle de projet Python générique
Résumé des méthodes fréquemment utilisées chez les pandas
[Linux] Liste des commandes Linux utilisées dans la pratique
Nombre maximum de paramètres de fonction pouvant être définis dans chaque langue
Résumé des processus souvent effectués par Pandas 1 (CSV, opérations liées aux fichiers Excel)
Une histoire que heroku, qui peut se faire en 5 minutes, a en fait duré 3 jours
[Python3] Code qui peut être utilisé lorsque vous souhaitez découper une image dans une taille spécifique
Notes pour créer des figures pouvant être publiées dans des revues avec matplotlib
Je souhaite créer une file d'attente prioritaire pouvant être mise à jour avec Python (2.7)
Si "ne peut pas être utilisé lors de la création d'un objet PIE" apparaît dans make
Programme d'installation facile et programme de mise à jour automatique pouvant être utilisé dans n'importe quelle langue
Résumé des sources de données scikit-learn pouvant être utilisées lors de la rédaction d'articles d'analyse
Comment installer la bibliothèque Python qui peut être utilisée par les sociétés pharmaceutiques
Module de grattage "Gaspacho" qui peut être utilisé plus facilement que Beautiful Soup
Construire un Sphinx qui peut être écrit avec Markdown
Résumé de ce qui a été utilisé dans 100 coups de Pandas (# 1 ~ # 32)
Liste des outils qui peuvent être utilisés pour essayer facilement l'analyse des émotions des phrases japonaises avec Python (essayez avec google colab)
[Python] J'ai examiné une pratique qui peut être exécutée en parallèle avec le thread principal par traitement asynchrone (multiprocessing, asyncio)
Présentation et fonctionnalités utiles de scikit-learn qui peuvent également être utilisées pour l'apprentissage en profondeur
Convertir des images du SDK FlyCapture en un formulaire pouvant être utilisé avec openCV
Introduction du package de collecte automatique d'images "icrawler" (0.6.3) qui peut être utilisé pendant l'apprentissage automatique
Une note qui implémente une tâche en Python qui charge un fichier GCS dans BigQuery
Visualisation des informations géographiques de R et Python qui peuvent être exprimées par Power BI
[Python] Introduction au scraping WEB | Résumé des méthodes pouvant être utilisées avec webdriver
J'ai essayé de faire une application mémo qui peut être pomodoro, mais un enregistrement de réflexion
Comment créer une propriété de relations qui peuvent être prefetch_related par des conditions spécifiques
Un mécanisme pour appeler des méthodes Ruby à partir de Python qui peut être fait en 200 lignes
Statistiques simples qui peuvent être utilisées pour analyser l'effet des mesures sur les sites EC et les codes qui peuvent être utilisés dans le notebook jupyter
Notes sur les connaissances Python utilisables avec AtCoder
Une collection de commandes fréquemment utilisées dans la gestion des serveurs
Programme Shell qui devient aho par multiples de 3
Peut être utilisé chez les pros de la compétition! Bibliothèque standard Python
[Django] À propos des utilisateurs pouvant être utilisés sur un modèle
Comment configurer un serveur SMTP simple qui peut être testé localement en Python
[Django] Noms de champs pouvant être utilisés pour le modèle utilisateur, l'enregistrement des utilisateurs et les méthodes de connexion
[Python3] Code qui peut être utilisé lorsque vous souhaitez redimensionner des images dossier par dossier
[Atcoder] [C ++] J'ai fait un outil d'automatisation de test qui peut être utilisé pendant le concours
[Python] Un programme pour trouver le nombre de pommes et d'oranges qui peuvent être récoltées
Récapitulatif du format des formats qui peuvent être sérialisés avec gensim
Votre dll est-elle une dll qui peut tirer parti du multi-core?
Connaissance de base du DNS qui ne peut pas être entendue maintenant