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.
\ 1. Préparation
Activer l'utilisation de références d'index numpy (unidimensionnelles), de découpage, de références d'index booléen et de références d'index fantaisie
Activer l'utilisation de références d'index numpy (bidimensionnelles), de découpage et de références d'index booléen. Comprenez le comportement de la fonction numpy.iloc_. (La référence d'index fantaisie est difficile à utiliser dans ndarray en 2D, donc je l'utilise rarement personnellement)
\ 2. Introduction à Pandas
Créez Series, DataFrame et utilisez la référence d'index ( Series est fondamentalement une extension de numpy (1D) . DataFrame est fondamentalement df.loc (priorité du nom d'étiquette) ) Ou dx.iloc (priorité au nombre) est essentiellement une extension de numpy (en deux dimensions).)
Vous permet d'ajouter, d'extraire, de supprimer, de modifier, etc. des données pour Series, DataFrame
(Si l'élément ou le nom de l'index dans Series, DataFrame est une chaîne de caractères, une opération d'extraction et de modification par lots est possible. C'est pratique, alors comprenez le traitement de la chaîne de caractères par l'accesseur str de 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 ~
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:
Avoir une bonne compréhension des références d'index Numpy, du découpage, des références d'index booléen et des références d'index fantaisie
Le Numpy bidimensionnel est ʻarr [<spécification de ligne>], ʻarr [<spécification de ligne>, <spécification de colonne>] (je le comprends sans aucune confusion).
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
Numpy (ʻarr [･ (premier argument), ･ (deuxième argument)]` pour 2D). Le premier argument est la ligne et le deuxième argument est la colonne.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]])
Numpy lui-même sont extrêmement faibles, mais comme l'idée devient importante lors de l'utilisation de Pandas, je la décrirai ci-dessous (sautez-la pour le moment):#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]
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.
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)))
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
list ou dict, peu importe ce que l'intérieur est ( list, Series, dict, tuple Oui)#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!
DataFrame en insérant un ndarray 2D.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 en le combinant avec la Series.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.
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.
df.locCependant, 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 n'êtes pas sûr, utilisez df.loc [<spécification de ligne>] ʻou, df.loc [<spécification de ligne>, <spécification de colonne>] plutôt que df [･]`.
Cependant, si vous voulez mettre l'accent sur l'extraction des numéros de ligne, utilisez df.iloc [<spécification de ligne>] ou df.iloc [<spécification de ligne>, <spécification de colonne>].
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. ::
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
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.
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 (2 * 3)DataFrame([s1, s2]) #Utilisation du constructeur
DataFrame (3 * 2)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é
DataFrame (6 * 1)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
DataFrame (1 * 6)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
DataFrame ((n + 1) * 3)# 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)
...
(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
#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
#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')
df1.merge (df2), veuillez vous référer à [1].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.
#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.
# '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'
sort_index (pour trier autour de l'index), sort_values (spécifié par by) peut être trié par ordre croissant ou décroissant (dans le cas de l'ordre décroissant, spécifiez ʻascending = False`) )df [・].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)]
df [･] est dans plusieurs candidats#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)]
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']]
Voir http://nekoyukimmm.hatenablog.com/entry/2015/02/25/222414.
how = 'all'.#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)
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
df.reindex contient un paramètre d'index qui n'est pas inclus dans l'index de df.Exemple omis
locdf.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).
Ajout de trames de données (NAN est l'élément non pris en charge de ʻindex ou column`)
Quand how = 'outside' est spécifié pour merge, join
ʻAppend, concat` (si l'index ne prend pas en charge)
df.dropna (le paramètre est le comment ou l'axe),df.fillna (0)(définir la valeur NA à 0 uniformément
Spécifiez le paramètre fill_value ou le paramètre method dans df.reindex
combine_first: Seule la valeur NA de ʻold_df` est complétée par le premier argument. (Notez que la partie où l'élément est 0 dans old_df n'est pas sujette à des correctifs!)
# 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
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
[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