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.
#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')
df2 = df.copy()
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
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.
len(df)
len(df['id'].unique())
df['id'].value_counts()
#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'])})
#Définir la colonne cible dans le sous-ensemble et supprimer les doublons
df.drop_duplicates(subset=['name', 'cd'], keep='first', inplace=True)
#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']
#Convertir en type chaîne
df['sales_date'].astype(str)
# True,Faux à 1,Convertir en 0
(df['sales']>2000).astype(int)
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
df.loc[df['age10']=='Années 60', 'age10'] = 'Années 60以上'
(df['sales'] != 0).apply(int) #Si les ventes ne sont pas égales à 0, 1 est marqué
#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))
#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)
#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']])
from sklearn import preprocessing
scaler = preprocessing.MinMaxScaler()
scaler.fit(customer[['sales']])
customer['sales_mm'] = scaler.transform(customer[['sales']])
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.
#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 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']]
# "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
#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)
#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
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
df.quantile([0, 0.25, 0.5, 0.75, 1.0])[['amount']]
#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 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')
#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
#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()))
#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)
#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'])
En étudiant, j'ai évoqué ce qui suit. Merci beaucoup.
Recommended Posts