Pandas est un package d'analyse de données basé sur Numpy qui contient des structures de données et des outils plus avancés
Semblable à Numpy, dont le cœur est ndarray, pandas s'articule également autour des deux structures de données principales de Series et DataFrame. . Series et DataFrame correspondent respectivement à une séquence unidimensionnelle et à une structure de table bidimensionnelle. La méthode d'importation conventionnelle des pandas est la suivante :
from pandas import Series,DataFrame import pandas as pd
Les séries peuvent être considérées comme un dictionnaire ordonné de longueur fixe. Fondamentalement, n'importe quelle donnée unidimensionnelle peut être utilisée pour construire des objets Series :
>>> s = Series([1,2,3.0,'abc']) >>> s 0 1 1 2 2 3 3 abc dtype: object
Bien que dtype:object puisse contenir une variété de types de données de base, cela semble toujours affecter les performances, il est donc préférable de le conserver type simple.
L'objet Series contient deux attributs principaux : l'index et les valeurs, qui sont les colonnes de gauche et de droite dans l'exemple ci-dessus. Étant donné que ce qui est transmis au constructeur est une liste, la valeur de l'index est un entier qui augmente à partir de 0. Si une structure de paire clé-valeur de type dictionnaire est transmise, une série correspondant à la valeur de l'index sera générée ou dans ; l'initialisation Lors de l'utilisation de paramètres mot-clés pour spécifier explicitement un objet index :
>>> s = Series(data=[1,3,5,7],index = ['a','b','x','y']) >>> s a 1 b 3 x 5 y 7 dtype: int64 >>> s.index Index(['a', 'b', 'x', 'y'], dtype='object') >>> s.values array([1, 3, 5, 7], dtype=int64)
Les éléments de l'objet Series seront construits strictement selon l'index donné, ce qui signifie : si le paramètre data a une valeur-clé paire, alors seule la clé contenue dans l'index sera utilisée et si la clé correspondante est manquante dans les données, la clé sera ajoutée même si une valeur NaN est donnée.
Notez que bien qu'il existe une correspondance entre l'index de la série et les éléments de valeurs, celle-ci est différente du mappage du dictionnaire. L'index et les valeurs sont en fait toujours des tableaux ndarray indépendants, donc les performances des objets Series sont tout à fait correctes. Le plus grand avantage des
Series, une structure de données qui utilise des paires clé-valeur, est que lorsque des opérations arithmétiques sont effectuées entre les séries, les index seront automatiquement alignés.
De plus, l'objet Series et son index contiennent tous deux un attribut name :
>>> s.name = 'a_series' >>> s.index.name = 'the_index' >>> s the_index a 1 b 3 x 5 y 7 Name: a_series, dtype: int64
DataFrame est a Une structure de données tabulaire qui contient un ensemble de colonnes ordonnées (similaire à un index), et chaque colonne peut être d'un type de valeur différent (contrairement à ndarray, qui ne peut avoir qu'un seul type). Fondamentalement, vous pouvez considérer un DataFrame comme une collection de séries partageant le même index.
La méthode de construction de DataFrame est similaire à Series, sauf qu'elle peut accepter plusieurs sources de données unidimensionnelles en même temps, dont chacune deviendra une colonne distincte :
>>> data = {'state':['Ohino','Ohino','Ohino','Nevada','Nevada'],
'year':[2000,2001,2002,2001,2002],
'pop':[1.5,1.7,3.6,2.4,2.9]}
>>> df = DataFrame(data)
>>> df
pop state year
0 1.5 Ohino 2000
1 1.7 Ohino 2001
2 3.6 Ohino 2002
3 2.4 Nevada 2001
4 2.9 Nevada 2002
[5 rows x 3 columns]Bien que le paramètre data ressemble à un dictionnaire, la clé du dictionnaire ne joue pas le rôle d'index du DataFrame, mais d'attribut "name" de la série. L'index généré ici est toujours "01234".
Les paramètres du constructeur DataFrame les plus complets sont : DataFrame(data=None,index=None,coloumns=None), les colonnes sont "nom" :
>>> df = DataFrame(data,index=['one','two','three','four','five'],
columns=['year','state','pop','debt'])
>>> df
year state pop debt
one 2000 Ohino 1.5 NaN
two 2001 Ohino 1.7 NaN
three 2002 Ohino 3.6 NaN
four 2001 Nevada 2.4 NaN
five 2002 Nevada 2.9 NaN
[5 rows x 4 columns]De même, les valeurs manquantes sont remplies avec NaN. Jetez un œil aux index, aux colonnes et aux types d'index :
>>> df.index Index(['one', 'two', 'three', 'four', 'five'], dtype='object') >>> df.columns Index(['year', 'state', 'pop', 'debt'], dtype='object') >>> type(df['debt']) <class 'pandas.core.series.Series'>
Les opérations DataFrame orientées ligne et colonne sont fondamentalement équilibrées et toute colonne extraite est une série.
La réindexation des objets Series est implémentée via sa méthode .reindex(index=None,**kwargs). Il y a deux paramètres couramment utilisés dans **kwargs : method=None,fill_value=np.NaN :
ser = Series([4.5,7.2,-5.3,3.6],index=['d','b','a','c']) >>> a = ['a','b','c','d','e'] >>> ser.reindex(a) a -5.3 b 7.2 c 3.6 d 4.5 e NaN dtype: float64 >>> ser.reindex(a,fill_value=0) a -5.3 b 7.2 c 3.6 d 4.5 e 0.0 dtype: float64 >>> ser.reindex(a,method='ffill') a -5.3 b 7.2 c 3.6 d 4.5 e 4.5 dtype: float64 >>> ser.reindex(a,fill_value=0,method='ffill') a -5.3 b 7.2 c 3.6 d 4.5 e 4.5 dtype: float64
.reindex() La méthode renverra un nouvel objet dont l'index suit strictement les paramètres donnés. Le paramètre method:{'backfill', 'bfill', 'pad', 'ffill', None} est utilisé pour. spécifiez le mode d'interpolation (Fill), lorsqu'il n'est pas indiqué, se remplit automatiquement avec fill_value, la valeur par défaut est NaN (ffill = pad, bfill = back fill, fait respectivement référence à la valeur avant ou arrière pendant l'interpolation)
DataFrame La méthode de réindexation d'un objet est : .reindex(index=None,columns=None,**kwargs). Il n'y a qu'un seul paramètre de colonnes facultatif de plus que Series, qui est utilisé pour indexer les colonnes. L'utilisation est similaire à l'exemple ci-dessus, sauf que le paramètre de méthode d'interpolation method ne peut être appliqué qu'aux lignes, c'est-à-dire à l'axe 0.
>>> state = ['Texas','Utha','California']
>>> df.reindex(columns=state,method='ffill')
Texas Utha California
a 1 NaN 2
c 4 NaN 5
d 7 NaN 8
[3 rows x 3 columns]
>>> df.reindex(index=['a','b','c','d'],columns=state,method='ffill')
Texas Utha California
a 1 NaN 2
b 1 NaN 2
c 4 NaN 5
d 7 NaN 8
[4 rows x 3 columns]Cependant fill_value est toujours valable. Les amis intelligents se sont peut-être déjà demandé si l'interpolation sur les colonnes pouvait être réalisée via df.T.reindex(index,method='**').T. Notez également que lors de l'utilisation de reindex(index,method='**'), l'index doit être monotone, sinon il déclenchera un ValueError: Must be monotonic for forward fill. Par exemple, le dernier appel de l'exemple ci-dessus ne fonctionnera pas si index=['a','b','d','c'] est utilisé.
signifie supprimer un élément d'une Series ou une ligne (colonne) d'un DataFrame, via la méthode .drop(labels, axis=0) de l'objet :
>>> ser d 4.5 b 7.2 a -5.3 c 3.6 dtype: float64 >>> df Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> ser.drop('c') d 4.5 b 7.2 a -5.3 dtype: float64 >>> df.drop('a') Ohio Texas California c 3 4 5 d 6 7 8 [2 rows x 3 columns] >>> df.drop(['Ohio','Texas'],axis=1) California a 2 c 5 d 8 [3 rows x 1 columns]
.drop() Ce qui est renvoyé est un nouvel objet, et le méta-objet ne sera pas modifié.
Tout comme Numpy, pandas prend également en charge l'indexation et le découpage obj[::] et le filtrage via des tableaux booléens.
Cependant, il convient de noter que, comme l'index d'un objet pandas n'est pas limité aux entiers, lors de l'utilisation d'un nombre non entier comme index de tranche, il est inclus en terminal.
>>> foo a 4.5 b 7.2 c -5.3 d 3.6 dtype: float64 >>> bar 0 4.5 1 7.2 2 -5.3 3 3.6 dtype: float64 >>> foo[:2] a 4.5 b 7.2 dtype: float64 >>> bar[:2] 0 4.5 1 7.2 dtype: float64 >>> foo[:'c'] a 4.5 b 7.2 c -5.3 dtype: float64
这里 foo 和 bar 只有 index 不同——bar 的 index 是整数序列。可见当使用整数索引切片时，结果与 Python 列表或 Numpy 的默认状况相同；换成 'c' 这样的字符串索引时，结果就包含了这个边界元素。
另外一个特别之处在于 DataFrame 对象的索引方式，因为他有两个轴向（双重索引）。
可以这么理解：DataFrame 对象的标准切片语法为：.ix[::,::]。ix 对象可以接受两套切片，分别为行（axis=0）和列（axis=1）的方向：
>>> df Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.ix[:2,:2] Ohio Texas a 0 1 c 3 4 [2 rows x 2 columns] >>> df.ix['a','Ohio'] 0
而不使用 ix ，直接切的情况就特殊了：
索引时，选取的是列
切片时，选取的是行
这看起来有点不合逻辑，但作者解释说 “这种语法设定来源于实践”，我们信他。
>>> df['Ohio'] a 0 c 3 d 6 Name: Ohio, dtype: int32 >>> df[:'c'] Ohio Texas California a 0 1 2 c 3 4 5 [2 rows x 3 columns] >>> df[:2] Ohio Texas California a 0 1 2 c 3 4 5 [2 rows x 3 columns]
使用布尔型数组的情况，注意行与列的不同切法（列切法的 : 不能省）：
>>> df['Texas']>=4 a False c True d True Name: Texas, dtype: bool >>> df[df['Texas']>=4] Ohio Texas California c 3 4 5 d 6 7 8 [2 rows x 3 columns] >>> df.ix[:,df.ix['c']>=4] Texas California a 1 2 c 4 5 d 7 8 [3 rows x 2 columns]
pandas 最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，结果的索引取索引对的并集。自动的数据对齐在不重叠的索引处引入空值，默认为 NaN。
>>> foo = Series({'a':1,'b':2})
>>> foo
a 1
b 2
dtype: int64
>>> bar = Series({'b':3,'d':4})
>>> bar
b 3
d 4
dtype: int64
>>> foo + bar
a NaN
b 5
d NaN
dtype: float64DataFrame 的对齐操作会同时发生在行和列上。
当不希望在运算结果中出现 NA 值时，可以使用前面 reindex 中提到过 fill_value 参数，不过为了传递这个参数，就需要使用对象的方法，而不是操作符：df1.add(df2,fill_value=0)。其他算术方法还有：sub(), div(), mul()。
Series 和 DataFrame 之间的算术运算涉及广播，暂时先不讲。
Numpy 的 ufuncs（元素级数组方法）也可用于操作 pandas 对象。
当希望将函数应用到 DataFrame 对象的某一行或列时，可以使用 .apply(func, axis=0, args=(), **kwds) 方法。
f = lambda x:x.max()-x.min() >>> df Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.apply(f) Ohio 6 Texas 6 California 6 dtype: int64 >>> df.apply(f,axis=1) a 2 c 2 d 2 dtype: int64
Series 的 sort_index(ascending=True) 方法可以对 index 进行排序操作，ascending 参数用于控制升序或降序，默认为升序。
若要按值对 Series 进行排序，当使用 .order() 方法，任何缺失值默认都会被放到 Series 的末尾。
在 DataFrame 上，.sort_index(axis=0, by=None, ascending=True) 方法多了一个轴向的选择参数与一个 by 参数，by 参数的作用是针对某一（些）列进行排序（不能对行使用 by 参数）：
>>> df.sort_index(by='Ohio') Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.sort_index(by=['California','Texas']) Ohio Texas California a 0 1 2 c 3 4 5 d 6 7 8 [3 rows x 3 columns] >>> df.sort_index(axis=1) California Ohio Texas a 2 0 1 c 5 3 4 d 8 6 7 [3 rows x 3 columns]
排名（Series.rank(method='average', ascending=True)）的作用与排序的不同之处在于，他会把对象的 values 替换成名次（从 1 到 n）。这时唯一的问题在于如何处理平级项，方法里的 method 参数就是起这个作用的，他有四个值可选：average, min, max, first。
>>> ser=Series([3,2,0,3],index=list('abcd')) >>> ser a 3 b 2 c 0 d 3 dtype: int64 >>> ser.rank() a 3.5 b 2.0 c 1.0 d 3.5 dtype: float64 >>> ser.rank(method='min') a 3 b 2 c 1 d 3 dtype: float64 >>> ser.rank(method='max') a 4 b 2 c 1 d 4 dtype: float64 >>> ser.rank(method='first') a 3 b 2 c 1 d 4 dtype: float64
注意在 ser[0]=ser[3] 这对平级项上，不同 method 参数表现出的不同名次。
DataFrame 的 .rank(axis=0, method='average', ascending=True) 方法多了个 axis 参数，可选择按行或列分别进行排名，暂时好像没有针对全部元素的排名方法。
pandas 对象有一些统计方法。它们大部分都属于约简和汇总统计，用于从 Series 中提取单个值，或从 DataFrame 的行或列中提取一个 Series。
比如 DataFrame.mean(axis=0,skipna=True) 方法，当数据集中存在 NA 值时，这些值会被简单跳过，除非整个切片（行或列）全是 NA，如果不想这样，则可以通过 skipna=False 来禁用此功能：
>>> df
one two
a 1.40 NaN
b 7.10 -4.5
c NaN NaN
d 0.75 -1.3
[4 rows x 2 columns]
>>> df.mean()
one 3.083333
two -2.900000
dtype: float64
>>> df.mean(axis=1)
a 1.400
b 1.300
c NaN
d -0.275
dtype: float64
>>> df.mean(axis=1,skipna=False)
a NaN
b 1.300
c NaN
d -0.275
dtype: float64其他常用的统计方法有：
| ######################## | ****************************************** |
| count | 非 NA 值的数量 |
| describe | 针对 Series 或 DF 的列计算汇总统计 |
| min , max | 最小值和最大值 |
| argmin , argmax | 最小值和最大值的索引位置（整数） |
| idxmin , idxmax | 最小值和最大值的索引值 |
| quantile | 样本分位数（0 到 1） |
| sum | 求和 |
| mean | 均值 |
| median | 中位数 |
| mad | 根据均值计算平均绝对离差 |
| var | 方差 |
| std | 标准差 |
| skew | 样本值的偏度（三阶矩） |
| kurt | 样本值的峰度（四阶矩） |
| cumsum | 样本值的累计和 |
| cummin , cummax | 样本值的累计最大值和累计最小值 |
| cumprod | 样本值的累计积 |
| diff | 计算一阶差分（对时间序列很有用） |
| pct_change | 计算百分数变化 |
L'expression principale de NA dans les pandas est np.nan De plus, None intégré à Python sera également traité comme NA. .
Il existe quatre façons de gérer NA : dropna , fillna , isnull , notnull .
Cette paire de méthodes effectue des applications au niveau des éléments sur l'objet, puis renvoie un tableau booléen, qui peut généralement être utilisé pour l'indexation booléenne.
Pour une série, dropna renvoie une série contenant uniquement des données non vides et des valeurs d'index.
Le problème réside dans la façon dont DataFrame est traité, car une fois supprimé, au moins une ligne (colonne) doit être perdue. La solution ici est similaire à la précédente, mais elle passe toujours un paramètre supplémentaire : dropna(axis=0, how='any', thresh=None) La valeur facultative du paramètre how est any ou all. all supprime la ligne (colonne) uniquement si tous les éléments de tranche sont NA. Un autre paramètre intéressant est le seuil, qui est de type entier. Sa fonction est que, par exemple, seuil=3, il sera conservé lorsqu'il y aura au moins 3 valeurs non NA d'affilée. En plus du type de base, le paramètre value dans
fillna(value=None, method=None, axis=0) peut également utiliser un dictionnaire, afin que différentes colonnes puissent être remplies avec différentes valeurs. L’utilisation de la méthode est la même que celle de la méthode .reindex() précédente, je n’entrerai donc pas dans les détails ici.
Il y a un point que je n'ai pas mentionné auparavant, mais après avoir écrit l'exemple complet, j'ai trouvé que c'est assez important. Parmi les méthodes des objets Series et DataFrame, celles qui modifient le tableau et renvoient un nouveau tableau ont souvent un paramètre facultatif de replace=False. S'il est défini manuellement sur True, le tableau d'origine peut être remplacé.
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
