pandas基础这一篇足以,看完即成初级数据分析师

本文是基于上一篇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列