Grands Pandas Apprenons beaucoup

Grands Pandas Apprenons beaucoup

introduction

Pandas est une bibliothèque qui fournit des fonctions pour prendre en charge l'analyse des données dans le langage de programmation Python [^ wiki]. Je pense que «Pandas» est compliqué même dans la bibliothèque «Python» [^ atm]. Cependant, le degré de liberté est si élevé qu'il est impensable pour les analystes de données d'analyser les données sans "Pandas". Donc, je voudrais expliquer au point que "Si vous comprenez jusqu'ici, vous pouvez faire n'importe quoi (si vous regardez d'autres sites)" [^ title].

[^ wiki]: Voir https://ja.wikipedia.org/wiki/Pandas

[^ atm]: Mais il y a une atmosphère dont on ne peut pas dire qu'elle est difficile.

[^ title]: Pandas n'est pas une langue, mais le titre convient parfaitement.

Comment capturer

\ 1. Préparation

\ 2. Introduction à Pandas

Après cela, vous devriez vous mettre sur la bonne voie et atteindre un niveau où vous pouvez enquêter vous-même sur diverses choses (vous devriez être capable de comprendre «group by» et ainsi de suite).

Par exemple, «Numpy»

arr = np.arange(12) #arr est un ndarray unidimensionnel
arr = arr.reshape(3,4) #arr est un ndarrary bidimensionnel
# arr[i,j]Le premier élément est la ligne et le deuxième élément est la colonne
arr[:2] #Ndarray 2D
arr[:2, 0] #Ndarray unidimensionnel
arr[:, arr[0] > 2] #Ndarray 2D

Avec Pandas,

pop = {'Nevada' : {2001 : 2.4, 2002 : 2.9},
       'Ohio' : {2000 : 1.5, 2001 : 1.7}}
df = DataFrame(pop) # DataFrame(2D)
df[df['Nevada'] > 2] # DataFrame(2D)
df.iloc[-1:]['Nevada'] # Series(1 dimension)

Quel est le type comme ça? Si vous en êtes conscient et que vous le comprenez, il semble que la moitié soit terminée.


Alors, résumons le comportement de la référence d'index de ndarray (2D) puis passons à Pandas ~

Préparation

import

import numpy as np # ndarray
#Requis pour afficher le matplot en jupyter
%matplotlib inline
import matplotlib.pyplot as plt
from pandas import Series, DataFrame
import pandas as pd

Numpy

Prenons un ndarray bidimensionnel. Pour comprendre Pandas Il y a deux choses à comprendre ici:

Exemple

arr = np.arange(12).reshape(3,4) #arr est un ndarrary bidimensionnel(3 lignes 4 colonnes)
#array([[ 0,  1,  2,  3],
#       [ 4,  5,  6,  7],
#       [ 8,  9, 10, 11]])

Quand il n'y a qu'un seul argument + indexer, cela ressemble à ceci:

#Obtenez un ndarray unidimensionnel
arr[1] #Référence d'élément par valeur scalaire
arr[0:2] #Trancher les lignes d'extrait 0 et 1(La deuxième ligne n'est pas extraite)
##Pour chaque élément de la première ligne(>2)Renvoie la valeur booléenne de
arr[1] > 2 # array([ True,  True,  True,  True], dtype=bool) 

#Obtenez un ndarray bidimensionnel
arr>2 #Référence d'index booléen
arr[np.array([True, False, True])] #Extraire les lignes 0 et 2 avec une référence d'index booléen
# arr[[True, False, True]] # Warning
arr[[0,2,1]] #Voir l'index de fantaisie:Pour référence d'index(entier)Utiliser un tableau Extraire les 0ème, 2ème et 1ère lignes dans l'ordre

C'est fondamentalement la même chose qu'un ndarray unidimensionnel, mais ne notez que les pièges dans lesquels il est facile de tomber:

#Lorsque vous souhaitez spécifier uniquement le deuxième argument. Le premier argument ne peut pas être omis. À ce moment-là, trancher`:`Comme premier argument
arr[:, 1]

#Si vous spécifiez un index sophistiqué pour les premier et deuxième arguments, l'opération sera un peu peu intuitive.
## (Notez également que ce sera un ndarray unidimensionnel!
## np.array([arr[i,j] for i,j in zip([1,2], [0,1])])Équivalent à.# array([4, 9])
arr[[1,2], [0,1]]
## 1,2e ligne et 0,Pour obtenir un ndarray bidimensionnel qui extrait la zone de la première colonne, procédez comme suit
arr[np.iloc_([1,2], [0,1])]
array([[4, 5],
       [8, 9]])
#ligne
arr[:,1] > 2 # array([False,  True,  True], dtype=bool)

#La première ligne est(>2)Extraire les lignes qui sont
arr[arr[:,1] > 2] # arr[np.array([False,  True,  True])]Pareil que.(Je ne l'ai pas beaucoup utilisé personnellement)
# arr[arr[:, 1] > 2, :]Pareil que.


arr[1] > 5
arr[:, arr[1] > 5] # array([False, False,  True,  True], dtype=bool)
#arr[:, np.array([False, False, True, True])] #Pareil que

En résumé, le comportement du type de référence d'index de ndarray (2D) ressemble à ceci [^ summary]:

[^ summary]: C'est un peu forcé. La colonne "Aucun" du deuxième argument pointe vers ʻarr [・] `. Les parenthèses entre (1d) signifient que vous ne les utilisez pas trop. 1d signifie "ndarray" unidimensionnel et 2d signifie "indarray" bidimensionnel.

Premier argument\Deuxième argument Aucun scalaire Tranchage Index booléen Index de fantaisie
Aucun -
scalaire 1d 0d 1d 1d 1d
Tranchage 2d 2d 2d 2d 2d
Index booléen 2d 1d 2d (2d) (1d)
Index de fantaisie 2d 1d 2d (1d) (1d)
#Un piège qui peut être confondu avec autre chose. Je veux tripler l'élément d'arr
> arr = [0,1,2,3]
> arr*4
[0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]

> np.arange(4)*4
[0,4,8,12]
#Si vous souhaitez faire de même sans convertir en numpy, utilisez la notation d'inclusion.
> [i*4 for i in range(4)]
[0,4,8,12]

Introduction aux pandas

Dans Numpy, il aurait dû être traité comme le même ndarray, qu'il soit 1D ou 2D, mais dans Pandas, il est divisé en 1D => Series, 2D => DataFrame. Je suis. Ainsi, bien que les noms soient différents, le DataFrame et la Series ne peuvent pas être séparés car ils vont et viennent entre 2D <=> 1D.

Par exemple, si vous spécifiez une seule ligne / colonne à partir de «DataFrame», vous pouvez extraire la «Série» unidimensionnelle. Inversement, vous pouvez créer un DataFrame en spécifiant la listeoudict de la Series (1D) comme argument du constructeur DataFrame (2D).

Donc, comprendre si les dimensions d'une variable sont unidimensionnelles ou bidimensionnelles est important même si le nom change en Series, DataFrame.

À propos de la série

Créer une série

En gros, je mets souvent dict, list dans le constructeur. Dans le cas de «dict», ce sera «Series» avec index.

#Exemple de dictée de poussée
dic = {'word' : 470, 'camera' : 78}
Series(dic)
#Souvent, une technique de combinaison zip et dict est utilisée pour générer une série:
Series(dict(zip(words, frequency)))

Référence d'index

Pour les références d'index, il s'agit d'une extension du ndarray unidimensionnel. La différence est que le nom de l'index peut également être inclus en tant qu'argument d'index.

ser = Series(np.random.randn(5), index = list('ABCDE'))
#A    1.700973
#B    1.061330
#C    0.695804
#D   -0.435989
#E   -0.332942
#dtype: float64

#Tranchage
ser[1] #La première ligne, c'est'A'Extraire la dimension de la ligne 0(type =type float64) 
ser['A'] # 'A'Extraire des lignes(type = float)
ser[1:3] #1,Extraire la deuxième ligne(Series(Unidimensionnel)
ser[-1:] #Extraire la dernière ligne
ser[:-1] #Extraire toutes les lignes sauf la dernière ligne
ser[[1,2]] # 1,Extraire la deuxième ligne(Index de fantaisie)
ser[['A', 'B']] # (Fantaisie)Vous pouvez également donner l'index sous forme de chaîne
ser > 0 #Le type de ser est Série(1 dimension)Chaque élément est une valeur booléenne
ser[ser > 0] #Index booléen(ser > 0)Référence d'élément avec

# Read,Puisque les deux peuvent être écrits, il est également possible d'écrire la rvalue uniquement dans la valeur correspondante, comme indiqué ci-dessous..
#La technique d'amener des conditions à lvalues est souvent utilisée dans les DataFrames.
ser[ser > 0] = 0

À propos de DataFrame

Créer un DataFrame

#Lorsque l'extérieur et l'intérieur sont dict
pop = {'Nevada' : {2001 : 2.4, 2002 : 2.9},
       'Ohio' : {2000 : 1.5, 2001 : 1.7}}
df2 = DataFrame(pop)
#      Nevada  Ohio
#2000     NaN   1.5
#2001     2.4   1.7
#2002     2.9   NaN

#L'extérieur est dict,Quand l'intérieur est en série
# df1,df2 est un type DataFrame(Donc df1['name'], df2['address']Est un type de série)
##le nom de la colonne est['typeA', 'typeB'],le nom de l'index est[0,1,2,3]
dfA = DataFrame({'typeA' : df1['name'], 'typeB' : df2['address']})
##le nom de l'index est[0,1,2,3],le nom de la colonne est['name', 'address'](l'attribut T est la translocation)
dfB = DataFrame([df1['name'], df2['address']]).T

Nous utilisons souvent la fonction + intégrée zip pour créer un DataFrame:

dict(zip([1,2,3], [4,5,6,7])) #{1: 4, 2: 5, 3: 6} =>Ne peut pas être converti en DataFrame
list(zip([1,2,3], [4,5,6,7])) #[(1, 4), (2, 5), (3, 6)] =>Peut être converti en DataFrame(à l'extérieur:Liste, à l'intérieur:Parce que c'est un taple)
pd.DataFrame(list(zip([1,2,3], [4,5,6,7]))) # => OK!
df = DataFrame(np.arange(12).reshape(3,4), columns = list('ABCD'))
print(df)
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
DataFrame(Series({'word' : 470, 'camera' : 78}), columns = ['frequency'])

La création d'un DataFrame à partir d'uneSeries sera discutée en détail dans la section Ajout de données de l'édition pour débutants.

Référence d'index DataFrame

Dans Pandas, df [・] ʻou df.loc [<spécification de ligne>] ʻou, df.loc [<spécification de ligne>, <spécification de colonne>] ʻou df.iloc [<spécification de ligne> ] ʻOudf.iloc [<spécification de ligne>, <spécification de colonne>]peut être créé. df [・] se comporte de manière assez confuse comme suit.

#J'utilise souvent
#dfA[1] # runtime error!!La première colonne ne peut pas être récupérée sous forme de valeur entière
#dfA['typeA'] #'typeA'Colonnes de série(1 dimension)Extrait comme
dfA[['typeB', 'typeA']] # typeB,DataFrame avec des colonnes de type A dans l'ordre(2D)Extrait comme
dfA['typeA'] > 3 #Série 1 dimension(Chaque élément est une valeur booléenne)


#Un peu déroutant(Je l'utilise souvent personnellement)
dfA[dfA['typeA'] > 3] #dfA'typeA'Extrayez des lignes avec 3 colonnes ou plus.
# dfA.loc[dfA['typeA'] > 3] #Si vous êtes inquiet, utilisez ceci


#Ci-dessous, c'est assez compliqué, donc je ne l'utilise pas beaucoup.
dfA[1:] #La première ligne~Trame de données(2D)Extrait comme(Notez qu'il s'agit d'une extraction de ligne)
#dfA[1:]J'écrirais ceci plutôt que moi-même.
dfA.loc[1:] #Clarifié qu'il s'agit d'une spécification de ligne. Ou dfA.loc[1:, :]

df.loc est une version dans laquelle vous pouvez spécifier le nom d'étiquette de Numpy. Donc, fondamentalement, vous devriez l'écrire avec la même colle que la référence d'index de Numpy.

Remarques sur df.loc

Cependant, il y a deux choses à garder à l'esprit lorsque vous traitez avec df.loc (assez important et facile à comprendre).

La première est que «df.loc» a la priorité sur le nom de l'étiquette, donc même lorsqu'une valeur entière est spécifiée pour «index», le numéro d'index n'est pas référencé, mais la ligne correspondant au nom de l'étiquette est extraite. est. Par exemple, lorsque vous voulez «trier» et extraire la première ligne, il est assez facile d'avoir un accident:

dic = list(zip([0,3,5,6], list('ADCB')))
dfA = DataFrame(dic, columns = ['typeA', 'typeB'])
#   typeA typeB
#0      0     A
#1      3     D
#2      5     C
#3      6     B
dfA = dfA.sort_values(by = 'typeB')
#   typeA typeB
#0      0     A
#3      6     B
#2      5     C
#1      3     D
dfA.loc[1] #1er(En d'autres termes, la deuxième place)Je veux extraire des lignes, mais lorsque j'utilise loc, la ligne avec le nom d'étiquette d'index 1 est extraite:
#typeA    3
#typeB    D
#Name: 1, dtype: object


##Pour éviter une telle tragédie, df.Utilisez iloc. Le numéro de ligne a la priorité.
##(#3      6     B)Peut être extrait
dfA.iloc[1]

ʻIloc est souvent utilisé même après l'extraction (si ʻindex n'est pas dans l'ordre numérique, il ne peut pas être référencé parloc [numéro].)

df = df[df['A'] == name]
df.iloc[0]['B'] #Il se sent un peu épuré...

L'autre est un piège dans lequel il est facile de tomber quand il s'agit d'un index entier, mais si vous voulez extraire la dernière ligne, référencer une valeur négative dans df.loc échouera. Puisque le nom d'étiquette a la priorité, on dit qu'il n'y a pas d'étiquette -1. Encore une fois, utilisez df.iloc pour souligner que l'extraction concerne les numéros de ligne.

# dfA.loc[-1] : NG
dfA.iloc[-1] # OK(La dernière ligne est Series(1 dimension)Extrait comme)
dfA.iloc[-1:] # OK(La dernière ligne est DataFrame(2D)Extrait comme)

Au contraire, df.iloc ne peut utiliser que des nombres, donc si vous voulez spécifier des lignes par numéros de ligne et des colonnes par des noms d'étiquettes, écrivez comme suit.

df.iloc[i]['A'] #C'est bien d'écrire comme ça
#iloc ne peut spécifier que des colonnes avec des nombres
# Location based indexing can only have
# [integer, integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean array] types
# res *= df.iloc[i, 'A'] #error

Pour résumer la référence d'index de DataFrame,

Si vous ne gardez que ces deux points à l'esprit, vous pouvez extraire des données aussi agréablement que la référence d'index de Numpy. C'est vraiment facile si vous ne devez vous souvenir que d'un type de df.loc, mais les index entiers sont si populaires dans la pratique que vous ne pouvez pas éviter d'utiliser df.iloc: sweat. ::

Supplément

loc, ʻiloc` ne peuvent pas être copiés dans la valeur l lorsque l'indexeur est utilisé deux fois comme indiqué ci-dessous (la valeur à modifier dans le DataFrame d'origine n'est pas modifiée).

#A value is trying to be set on a copy of a slice from a DataFrame
df.loc[5]['colA'] #Ne peut pas être une lvalue

#aucun problème!(Parce que c'est une référence)
df.loc[k, 'non_view_rate'] *= mult

Édition débutant Pandas

Jusqu'à présent, nous avons examiné la référence de l'index «Pandas». C'est peut-être au-dessus de la montagne, mais il y a encore des parties compliquées telles que l'ajout et la modification de DataFrame. Pour l'utilisation de base de chaque fonction, [Introduction à l'analyse de données par Python --- Traitement des données à l'aide de NumPy, pandas](https://www.amazon.co.jp/ Introduction à l'analyse de données par Python --- NumPy, pandas Traitement des données en utilisant-Wes-McKinney / dp / 4873116554), et je voudrais ici le résumer de manière inverse.

Comment le façonner à l'aide de Pandas

Ajouter (consolider)

ser = Series([1,2,3], index = list('ABC'))
#A    1
#B    2
#C    3
#dtype: int64

Sera exprimé comme «Série (3 * 1)». Les noms d'index sont tous les mêmes. (['A', 'B', 'C']) Voyons comment concaténer divers modèles de données.

(Series(31) <- Series(31)) -> DataFrame

DataFrame([s1, s2]) #Utilisation du constructeur
df = DataFrame([s1, s2], index = list('AB')).T
pd.concat([s1, s2], axis = 1) #Si vous voulez empiler vers le bas, concattez(.., axis = 1)Devrait être utilisé
serA.append(serB)
#Ou
pd.concat([serA, serB])
#Si vous souhaitez que le nom de l'index soit un numéro de série de 0..
s1.append(s2).reset_index(drop = True) #Re-trier l'index
df1 = DataFrame(serA)
df2 = DataFrame(serB)
ndf = df1.join(df2, how = 'outer', lsuffix = 'A', rsuffix = 'B') #je me demande
#Seuls deux peuvent être connectés ici.
ndf = pd.merge(df1, df2, left_index=True, right_index=True, how='outer') 
   0A  1A  2A  0B  1B  2B
0   1   2   3   4   5   6

(DataFrame(n3) <- Series(31)) => DataFrame

# Can only append a Series if ignore_index=True or if the Series has a index name
df.append(serA, ignore_index = True)

cols = ['colA', 'colB', 'colC']
res_df = DataFrame(columns = cols)
res_df = res_df.append(Series([1,2,3], cols).T, ignore_index = True)
...

Je veux empiler plusieurs séries

(Series(3*1) + Series(3*1)) + Series(3*1) + Series(3*1)-> DataFrame(4*3)

df = DataFrame([serA, serB, serC, serD])
# DataFrame(3*4)Si tu veux.Ajoutez simplement T
df = DataFrame([serA, serB, serC, serD]).T

Je veux ajouter la dernière ligne (Series) vers le bas à un DataFrame existant (ou ajouter un DataFrame vers le bas)

#Ajouter une ligne
df.loc['newrow'] = 0
df.append(serA, ignore_index = True)
#Ajouter plusieurs lignes
df1.append(df2)
#Ajouter plusieurs DataFrames(Piquer la liste)
df1.append([df2, df3, df4])
#Ou
pd.concat([df1, df2, df3, df4])

#1 colonne ajoutée
df['newcol'] = 0

Les index sont presque les mêmes, et je veux connecter df à droite

#L'index non applicable est une jointure externe(outer)À.(NAN値À.)
df1.join(df2, how = 'outer')
df1.join([df2, df3], how = 'outer')
#La fusion peut être plus détaillée, mais limitée à la fusion de deux DataFrames:
df1.merge(df1, how = 'outer')

Autres ajouts

Pour d'autres détails, voir la page officielle http://pandas.pydata.org/pandas-docs/version/0.19.1/generated/pandas.DataFrame.merge.html ou http://sinhrks.hatenablog.com/entry / 2015/01/28/073 Je pense que 327 est bon.

Pour le dernier,

+Concaténation verticale simple DataFrame.append
+Concaténation flexible pd.concat
+Rejoindre par valeur de colonne pd.merge
+Rejoindre par index DataFrame.join (faire une version facile de la fusion)

Il est facile à comprendre car il est écrit avec des chiffres et des exemples.


Modifier le contenu du DataFrame

Je veux renommer tous les index et colonnes

#Renommer l'index
df.index = ['one', 'two', 'three']
#réaffectation du numéro d'index
df.reset_index(drop = True) #Re-trier l'index(À partir du numéro 0~)

#Renommer les colonnes
##création de table=>Après modification, la colonne peut ne pas être dans l'ordre prévu, donc
##Il est plus sûr de spécifier explicitement l'ordre des colonnes.
df = df[['old_a', 'old_b', 'old_c']] 
df.columns = ['new_a', 'new_b', 'new_c']

#Ou df.Utiliser renommer
df = df[['old_a', 'old_b', 'old_c']] #Quoi qu'il en soit, si vous ne vous souciez pas de l'ordre des colonnes.
#Puisque renommer n'est pas une méthode destructive, elle doit être affectée à une lvalue. Pour le paramètre, spécifiez les colonnes.(Notez qu'il ne s'agit pas d'un paramètre d'axe)
df = df.rename(columns = {'old_a' : 'new_a', 'old_b' : 'new_b', 'old_c' : 'new_c'})

Note1) Vous pouvez également utiliser df.rename lorsque vous souhaitez modifier certains noms d'index et de colonnes. (Spécifiez le type dict (comme table de correspondance avant le changement) dans le paramètre ʻindex ou columns. Notez qu'il n'y a pas de paramètre ʻaxis. Le reste est au lieu de colonne`. colonnes »(avec« s »))

Note 2) reindex est un remplacement de la position d'index existante, pas un changement de nom d'index. set_index crée un nouvel objet en utilisant une ou plusieurs colonnes spécifiques comme index, comme df.set_index (['c1', 'c0']). Notez que ce n'est pas une méthode pour renommer l'index. reset_index convertit un index hiérarchique en colonne. Juste la relation de set_index <=> reset_index.

Substitution

# 'A'Focus sur les colonnes'wrong'Sélectionnez les lignes qui sont et de ces lignes'B'Colonne'sth'Changer pour
df.loc[df['A'] == 'wrong', 'B'] = 'sth'

Extraction

http://naotoogawa.hatenablog.jp/entry/2015/09/12/PandasのDataFrameの嵌りどころ

#Mettez chaque index booléen entre parenthèses
df = df[(df['A'] > 0) | (df['B'] > 0)]
#apply est une fonction qui prend Series comme argument(Style Lambda)Dans le premier argument
#map est une fonction qui prend un élément comme argument(Style Lambda)Dans le premier argument
df = df[df['A'].map(lambda d : d in listA)]

Effacer

Supprimez les lignes et les colonnes avec df.drop (non destructif). Si vous spécifiez un axe, vous pouvez supprimer à la fois des lignes et des colonnes.

df = df.drop("A", axis=1)
#la colonne est'A', 'B', .. 'F'alors'C'De la colonne'F'列まalors削除したいときとかは、以下のようにする方が多い
df = df[['A', 'B']]

se débarrasser de na

Voir http://nekoyukimmm.hatenablog.com/entry/2015/02/25/222414.

Référence d'index booléen

#Renvoie le type DataFrame
df.apply(lambda ser: ser % 2 == 0)
df.applymap(lambda x: x % 2 == 0)
df['goal'] == 0
df.isin([1,2])
df = df[~df.index.duplicated()] #Supprimer l'index en double(Supprimer les données qui apparaissent après la deuxième fois)
#Type de série de retours
df.apply(lambda ser : (ser > 0).any())
df['A'].map(lambda x : x > -1)
serA > serB #type de série
-bool_ser #Retourne l'index d'un élément de l'index booléen
#Le deuxième argument est uniquement l'élément qui devient False dans le premier argument
df['A'].where(df['A'] > 0, -df['A']) #Version de série d'ABS(Si le premier argument ne s'applique pas, ajoutez un signe négatif(En d'autres termes, il devient positif parce qu'il est négatif.)
(df['goal'] == 0).all() #Vrai si vous êtes accro à toutes les conditions
df.apply(lambda ser: ser % 2 == 0)
(df['cdf(%)'] < 90).sum() #Comptez le nombre qui remplit les conditions
df.where(df % 3 == 0, -df)

Style d'écriture auquel la valeur NA peut être attribuée

Il est assez courant de rester coincé autour de NA, alors notez où la valeur NA peut être générée.

dic = dict(zip(list('ABCD'), [3,4,6,2])) #Générer un dict
ser = Series(dic, index = list('ABCDE'))
#La colonne E pas en dic est NAN
#A    3.0
#B    4.0
#C    6.0
#D    2.0
#E    NaN
#dtype: float64

(Exemple)

pop = {'Nevada' : {2001 : 2.4, 2002 : 2.9},
       'Ohio' : {2000 : 1.5, 2001 : 1.7}}
df = DataFrame(pop)

      Nevada  Ohio
2000     NaN   1.5
2001     2.4   1.7
2002     2.9   NaN

Exemple omis

df.loc[[2002, 2001, 1999], ['Alaska', 'Nevada']]

      Alaska  Nevada
2002     NaN     2.9
2001     NaN     2.4
1999     NaN     NaN

Note) Erreur avec df ['non_exists'], df.loc [:, 'non_exists'] (en spécifiant un nom qui n'est pas dans la colonne).

Comment se débarrasser de la valeur NA

# df ..sauts d'index(index.name : B_idx, columns = ['A'] =>index numéro de série(0~89)Je souhaite définir la valeur d'interpolation sur 0
old_df = DataFrame(index = range(90), columns = 'A')
new_df = old_df.combine_first(df).fillna(0) # index.le nom disparaît

Manipuler des chaînes

Surtout parce que l'opération de chaîne de caractères de «Series» est souvent utilisée sobrement. Il peut être utilisé non seulement pour les éléments mais aussi pour les noms d'index et les noms de colonnes!

Voir http://pandas.pydata.org/pandas-docs/stable/text.html (en particulier en bas) pour plus d'informations. Si vous souhaitez utiliser une chaîne de caractères dans un DataFrame, vous pouvez généralement le résoudre ici.

Par exemple, lorsque vous souhaitez extraire uniquement les lignes qui correspondent à une certaine expression régulière.

#df'A'Mettez à jour df en extrayant uniquement les lignes commençant par des lettres minuscules dans la colonne
r = '^[a-z]'
df = df[df['A'].str.match(r)] # df['A'].str.match(r)Est un index booléen

Les références

[1] [Introduction à l'analyse de données à l'aide de Python --- Traitement de données à l'aide de NumPy et pandas](https://www.amazon.co.jp/ Introduction à l'analyse de données à l'aide de Python --- Traitement de données à l'aide de NumPy et pandas-Wes -McKinney / dp / 4873116554)

[2] http://sinhrks.hatenablog.com/entry/2015/01/28/073327

[3] Documentation http://pandas.pydata.org/pandas-docs/stable/api.html

Recommended Posts

Grands Pandas Apprenons beaucoup
Apprenez les pandas en 10 minutes
Pandas apprenant avec la chimioinfomatique
[Blender x Python] Organisons une grande quantité de Susanne proprement !!
Faisons un robot Discord.
Apprenez librosa avec un tutoriel 1
Essayons un script shell
Essayez de dessiner une fonction logistique