本文是基于上一篇pandas的补充,为了不影响知识整体的结构,写在一起,方便客官们查阅.后期的博客还会有pandas的高级内容
小弟的目录
1.1Pandas概述:
Pandas是一个基于Numpy的数据分析包，它是为了解决数据分析任务而创建的。Pandas中纳入了大量库和标准的数据模型，提供了高效地操作大型数据集所需的函数和方法，使用户能够快速便捷地处理数据。
Pandas特点：
- 一个快速高效的DataFrame对象，具有默认和自定义的索引
*用于在数据结构和不同文件格式中读取和写入数据，比如文本文件
*智能数据对齐和缺失数据的集成处理
*基于标签切片和花式索引获取数据集的子集
*可以删除或插入来自数据结构的列
*按数据分组进行聚合和转换
*高性能的数据合并和连接
*时间序列功能
1.2Pandas的数据结构分析
Pandas中有两个主要的数据结构：Series和DataFrame。其中Series是一维的、DataFrame是二维的。
Series
Series的介绍
Series是一个类似于一维数组的对象，它能够保存任何类型的数据，主要由一组数据和与之相关的索引两部分构成。
Series
| index | element |
|---|---|
| 0 | 1 |
| 1 | 2 |
| 2 | 3 |
| 3 | 4 |
| 4 | 5 |
索引在左，数据在右
Series对象的创建
Pandas的Series类对象可以使用以下构造方法创建：
class pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False)
构造方法中常用参数含义如下：
1.data：传入的数据，可以是ndarray、list等。
2.index：索引，必须是唯一的，且与数据的长度相同。如果没有传入索引参数，默认会自动创建一个从0~N的整数索引。
3.dtype：数据的类型
4.copy：是否复制数据，默认为False
import pandas as pd
ser_obj = pd.Series([1,2,3,4,5])
ser_obj
可以在创建的时候，为数据指定索引：
import pandas as pd
ser_obj = pd.Series([1,2,3,4,5],index=['a','b','c','d','e'])
ser_obj
使用列表构建Series外，可以使用dict进行构建，具体如下：
year_data = {2001:17.8, 2002:20.1, 2003:16.5}
ser_obj2 = pd.Series(year_data)
ser_obj2
为了方便的操作Series对象中的索引和数据，所以该对象提供两个属性index和values分别进行获取。
DataFrame
DataFrame的介绍:
DataFrame是一个类似于二维数组或表格的对象，它每列数据可以是不同的数据类型。由索引和数据组成，有行索引、还有列索引。
默认索引也是自动创建，默认是从0-N的整数类型索引。
DataFrame对象的创建:
Pandas的DataFrame类对象可以使用以下构造方法创建：
pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=None)
常用参数如下：
index：行标签。如果没有传入索引参数，默认会自动创建一个从0-N的整数类型索引
*columns：列标签，如果没有传入索引参数，默认会自动创建一个从0-N的整数类型索引
import numpy as np
import pandas as pd
demo_arr = np.array([['a','b','c'], ['d','e','f']])
df_obj = pd.DataFrame(demo_arr)
如果在创建DataFrame类对象时，指定了索引，则DataFrame的列会按照指定的索引顺序进行排列：
df_obj =pandas.DataFrame(demo_arr,)columns=['No1','No2','No3']
df_obj
为了便于获取每列数据，可以使用列索引方式，也可以通过访问属性方式来获取，返回一个结果是Series对象，该对象拥有与原DataFrame对象相同的行索引。
element = df_obj['No2']
element
注意：在获取DataFrame的一列数据时，推荐使用列索引方式
要想为DataFrame增加一列数据，则可以通过给列索引或者列名称赋值的方式实现，类似于给字典增加键值对的操作。
df_obj['No4'] = ['g','h']
df_obj
删除一列数据:
del df_obj['No3']
print(df_obj)
重置索引
Pandas中提供一个重要方法是reindex()，该方法的作用是对原有索引和新索引进行匹配，新索引含有原索引的数据，而原索引数据按照新索引排序。如果新索引中没有原索引数据，那么程序不仅不会报错，而且会添加新的索引，并将值填充为NaN或者使用fill_values填充其他值。
reindex()方法的语法格式:
- DataFrame.reindex(labels=None, index=None, columns=None, axis=None, method=None, copy=True, level=None, fill_value=nan, limit=None, tolerance=None)
reindex参数说明
- index：用作索引的新序列
- method：插值填充方式
- fill_value: 引入缺失值时使用的替代值
- limit：前向或者后向填充时的最大填充量
import pandas as pd
ser_obj = pd.Series([1,2,3,4,5], index=['c','d','a','b','e'])
print(ser_obj)
>>>[out]
c 1
d 2
a 3
b 4
e 5
import pandas as pd
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'])
ser_obj2
print(ser_obj2)
>>>[out]
c 1.0
d 2.0
a 3.0
b 4.0
e 5.0
f NaN
默认填充的是NaN,如果不想填充NaN,那么可以通过参数method来进行设置
import pandas as pd
ser_obj2 = ser_obj.reindex(['a','b','c','d','e','f'], fill_value=6)
print(ser_obj2)
>>>[out]
c 1
d 2
a 3
b 4
e 5
f 6
注意:fill_value参数会让所有的缺失数据都填充为同一个值。
如果期望使用相邻的元素值（前边或者后边元素的值）进行填充，则可以使用method参数。method参数对应的值有多个
method参数说明
| 参数 | 说明 |
|---|---|
| fifill或pad | 前向填充值 |
| 后向填充值 | |
| 从最近的索引值填充 |
import pandas as pd
ser_obj3 = pd.Series([1,3,5,7], index=[0,2,4,6])
print(ser_obj3)
>>>[out]
0 1
2 3
4 5
6 7
ser_obj3.reindex(range(6),method='ffill') #重新索引，前向填充值
>>>[out]
0 1
1 1
2 3
3 3
4 5
5 5
ser_obj3.reindex(range(6),method='bfill') #重新索引，后向填充值
>>>[out]
0 1
1 3
2 3
3 5
4 5
5 7
1.3索引操作
Series类型的索引操作
Series类对象属于一维结构，它只有行索引。而DataFrame类对象属于二维结构，它同时拥有行索引和列索引。
import pandas as pd
ser_obj = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
print(ser_obj[2])#使用索引位置
>>[out]
3
ser_obj['c'] #使用索引名称获取数据
>>[out]
3
Series也可以使用切片来获取数据。
注意：如果使用位置索引切片，与list相似，包含起始位置但不包含结束位置
**如果使用索引名称进行切片，则切片结果是包含结束位置的**
如果希望获取的是不连续的数据，则可以通过不连续索引来实现
import pandas as pd
ser_obj = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
print(ser_obj[2:4]) #使用位置索引进行切片
>>[out]
c 3
d 4
e 5
print(ser_obj[[0,2,4]])#使用不连续位置索引
>>[out]
a 1
c 3
e 5
print(ser_obj[['a','c','d']])#使用不连续名称索引
>>[out]
a 1
c 3
d 4
布尔型索引具体用法跟数组的用法一样，将布尔型的数组索引作为模板筛选数据，返回与模板中True位置对应的元素
import pandas as pd
ser_obj = pd.Series([1,2,3,4,5], index=['a','b','c','d','e'])
ser_bool = ser_obj>2
print(ser_bool)
>>[out]
a False
b False
c True
d True
e True
同时布尔索引也能作为索引值,默认只输出True的值
print(ser_obj[ser_bool])
>>[out]
c 3
d 4
e 5
DataFrame的索引操作
DataFrame结构既包含行索引，也包含列索引。其中，行索引是通过index属性进行获取的。列索引是通过columns属性进行获取的.
DataFrame中每列的数据都是一个Series对象，可以使用列索引进行获取。
import numpy as np
arr = np.arange(12).reshape(3,4)
df_obj = pd.DataFrame(arr, columns=['a','b','c','d'])
print(df_obj)
>>[out] a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
print(df_obj['b'])
>>[out]
0 1
1 5
2 9
print(type(df_obj['b']))
>>[out]
pandas.core.series.Series
pandas库中提供了操作索引的方法来访问数据
loc：基于标签索引（索引名称，如a,b），用于按标签选取数据。当执行切片操作时，既包含起始索引，也包含结束索引
iloc：基于位置索引（整数索引，从0到length-1），用于按位置选取数据。当执行切片操作时，只包含起始索引，不包含结束索引。
iloc方法主要使用整数来索引数据，而不能使用字符标签来索引数据。而loc方法恰恰相反，它只能使用字符标签来索引数据，而不能使用整数来索引数据。
arr = np.arange(16).reshape(4,4)
dataframe_obj = pd.DataFrame(arr, columns=['a','b','c','d'])
print(dataframe_obj)
>>[out] a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
3 12 13 14 15
#下面这两个分别用位置和标签索引的方式操作列(结果是一样的,我只写一个输出)
print(dataframe_obj.iloc[:,[2,0]])
print(dataframe_obj.iloc[:,['c','a']])
>>[out] c a
0 2 0
1 6 4
2 10 8
3 14 12
1.4pandas的算术运算和数据对齐
Pandas执行算术运算时，会先按照索引进行对齐，对齐以后再进行相应的运算，没有对齐的位置会用NaN进行补齐。其中，Series是按行索引对齐的，DataFrame是按行索引、列索引对齐的。
算术运算
import pandas as pd
obj_one = pd.Series(range(10,13), index=range(3))
obj_two = pd.Series(range(20,25), index=range(5))
print(obj_one)
>>[out]
0 10
1 11
2 12
print(obj_two)
>>[out]
0 20
1 21
2 22
3 23
4 24
print(obj_one+obj-two)
>>[out]
0 30.0
1 32.0
2 34.0
3 NaN
4 NaN
print(obj_one.add(obj_two, fill_value=0))#这里零填补空缺,也可以其他值,只是举一个例子
>>[out]
0 30.0
1 32.0
2 34.0
3 23.0
4 24.0
数据排序:
Pandas中存放的是索引和数据的组合，既可以按索引进行排序，又可以按数据进行排序。
按索引排序
Pandas中按索引排序使用的是sort_index()方法，该方法可以用行索引或者列索引进行排序。
语法:
- sort_index(axis=0, level=None, ascending=True, inplace=False, kind=’quicksort’, na_position=’last’, sort_remaining=True)
参数说明:
| 参数 | 说明 |
|---|---|
| axis | 轴索引(排序方向),0表示index(按行),1表示按列 |
| level | 若不为None，则对指定索引级别的值进行排序 |
| ascending | 是否升序排列，默认为True，表示升序 |
| inplace | 默认为False，表示对数据表进行排序，不创建新的实例 |
| kind | 选择排序算法 |
默认情况下，Pandas对象是按照升序排列，可以通过参数ascending=False改为降序排列,使用的是科学排序法,并列会占位,比如有两个第一名,那么下一个就直接是第三名,而不是第二名.
import pandas as pd
ser_obj = pd.Series(range(10,15), index=[5,3,1,3,2])
print(ser_obj)
>>[out]
5 10
3 11
1 12
3 13
2 14
print(ser_obj.sort_index())
>>[out]
1 12
2 14
3 11
3 13
5 10
对DataFrame的索引进行排序
import numpy as np
import pandas as pd
df_obj = pd.DataFrame(np.arange(9).reshape(3,3), index=[4,3,5])
print(df_obj)
>>[out]
0 1 2
4 0 1 2
3 3 4 5
5 6 7 8
print(df_obj.sort_index())
>>[out]
0 1 2
3 3 4 5
4 0 1 2
5 6 7 8
按值排序
Pandas中用来按值排序的方法为sort_values()
语法格式:
- sort_values(by, axis=0, ascending=True, inplace=False, kind=’quicksort’, na_position=’last’)
参数说明:
by 参数表示排序的列，na_position参数只有两个值：first和last， 若设为first，则会将NaN值放在开头；若设为False，则会将NaN值放在最后.
ser_obj = pd.Series([4, np.nan, 6, np.nan, -3, 2])
print(ser_obj)
>>[out]
0 4.0
1 NaN
2 6.0
3 NaN
4 -3.0
5 2.0
print(ser_obj.sort_values())
>>[out]
4 -3.0
5 2.0
0 4.0
2 6.0
1 NaN
3 NaN
在DataFrame中，sort_values()方法可以根据一个或多个列中的值进行排序，但是需要在排序时将一个或多个列的索引传递给by参数才行
df_obj = pd.DataFrame([[0.4, -0.1, -0.3, 0.0],
[0.2, 0.6, -0.1, -0.7],
[0.8, 0.6, -0.5, 0.1]])
print(df_obj)
>>[out]
0 1 2 3
0 0.4 -0.1 -0.3 0.0
1 0.2 0.6 -0.1 -0.7
2 0.8 0.6 -0.5 0.1
print(df_obj.sort_values(by=2))
>>[out]
0 1 2 3
2 0.8 0.6 -0.5 0.1
0 0.4 -0.1 -0.3 0.0
1 0.2 0.6 -0.1 -0.7
1.5统计计算与描述
常用的统计计算
常用描述性统计方法及说明
| 函数名称 | 说明 | 函数名称 | 说明 |
|---|---|---|---|
| sum | 计算和 | std | 样本值的标准差 |
| mean | 计算平均值 | skew | 样本值的偏度（三阶矩） |
| median | 获取中位数 | kurt | 样本值的峰度（四阶矩） |
| max、min | 获取最大值和最小值 | cumsum | 样本值的累积和 |
| idxmax、idxmin | 获取最大和最小索引值 | cummin、cummax | 样本值的累积最小值和累积最大值 |
| count | 计算非NaN值的个数 | cumprod | 样本值的累计积 |
| head | 获取前N个值 | describe | 对Series和DataFrame列计算汇总统计 |
| var | 样本值的方差 |
df_obj = pd.DataFrame(np.arange(12).reshape(3,4), columns=['a','b','c','d'])
print(df_obj)
>>[out]
a b c d
0 0 1 2 3
1 4 5 6 7
2 8 9 10 11
print(df_obj.sum())
>>[out]
a 12
b 15
c 18
d 21
统计描述
如果希望一次性输出多个统计指标，比如平均值、最大值、最小值、求和等，调用describe()方法实现，而不用再单独地逐个调用相应的统计方法。
describe()方法的语法格式
- describe(percentiles=None, include=None, exclude=None)
参数说明:
-
percentiles：输出中包含的百分数，位于[0,1]之间。如果不设置该参数，则默认为[0.25,0.5,0.75]，返回25%， 50%， 75%分位数。
-
include，exclude：指定返回结果的形式
1.6Pandas的索引对象:
索引对象的创建
-
pd.X(array-like)
index = pd.Index(np.arange(3))
索引对象的分类
| 分类 | 介绍 | 描述 |
|---|---|---|
| Index | 最泛化的对象 | 轴标签—>数组 |
| Int64Index | 用于整数的特殊对象 | |
| MultiIndex | 层次化索引对象(单个轴上的多层索引) | 可看作是元组的数组 |
| DatetimeIndex | 用于纳米级索引对象 |
索引对象的获取:
| 分类 | 获取方法 |
|---|---|
| Series | .index |
| DataFrame | ① .index ② .columns |
索引对象的特点:
索引对象是不可修改的,这样能够保证Index对象在不同的数据结构之间安全的共享
obj = Series(data,index=index)
print(obj.index is index)
结果为True
索引对象的方法和属性
方法:
| 方法表达式 | 描述 | 特征 |
|---|---|---|
| append() | 连接另一个索引对象 | 数组 |
| diff/intersection/union() | Index–>差集/交集/并集 | |
| isin() | 各值是否在参数集合中 | 布尔数组 |
| delete/insert() | 删除/插入索引出的元素 | |
| drop() | 删除传入的值 | 会生成新的Index |
| unique() | 计算唯一值数组 |
属性:
| 属性 | 返回值 | 描述 |
|---|---|---|
| is_monotonic | True | 各元素均大于前一个元素 |
| is_unique | True | 当前Index无重复值 |
索引对象的重命名(轴索引)
有两种方式:
-
直接赋值
-
obj.rename()
方法 操作 特征 直接赋值 obj.index/columbs = … 就地修改 obj.rename() index/columns = 函数/字典(传入部分轴) obj.rename() inplace=默认(保留原始数据)/True(就地修改) data.index = data.index.map(str.upper) data.rename(index={old:new},columns = {old;new}) data.rename(index=str.title,columns = str.upper)
1.7索引的整数索引:
程序:
客官们,先来看一个整数索引的示例:
import numpy as np
import pandas as pd
from pandas import Series
ser = Series(np.arange(3))
print(ser.index)
这个程序的输出结果是:
(start = 0,stop = 3,step = 1)
import numpy as np
import pandas as pd
from pandas import Series
ser = Series(np.arange(3))
print(ser[-1])
这个程序会发生错误.
解析:
第一个程序能够正确的运行,并返回.
索引器:自动递增的数字索引(RangeIndex)
而第二个程序无法正常运行时因为索引是基于标签或者位置的
这样我们得出了整数索引的规则.
整数索引的规则:
当含有索引器时:
-
根据整数进行数据选取
-
总是面向标签的--------整数->标签名 包括ix切片
非整数索引:
示例:
import numpy as np import pandas as pd from pandas import Series ser2 = Series(np.arange(3),index = ['a','b','c']) print(ser['a':'b'])#即是把str类型作为一个切片的索引是基于标签的使用任意类型的索引
还是基于标签或者位置的.
整数标签基于位置的使用方法:
| 数据结构 | 方法 | 描述 |
|---|---|---|
| Series | series.iloc[i]/.iat[i] | i为整数 |
| DataFrame | DF.iloc[*] | ①[i]第i+1行②[:j]第j+1列 |
