pandas的一些理解

pandas 简介

numpy 能够帮我们处理的是数值型数据，但是这还不够，很多时候，我们的数据除了数值之外，还有字符串，还有时间序列等，
这是就需要 pandas 帮我们处理它们了。
什么是Pandas?
Pandas的名称来自于面板数据(panel data)
Pandas是一个强大的分析结构化数据的工具集，基于NumPy构建，提供了高级数据结构和数据操作工具，它是使Python成为强大而高效的数据分析环境的重要因素之一。
。一个强大的分析和操作大型结构化数据集所需的工具集
。基础是NumPy，提供了高性能矩阵的运算
。提供了大量能够快速便捷地处理数据的函数和方法
。应用于数据挖掘，数据分析
。提供数据清洗功能

pandas 的数据结构

pandas 库有两个重要的数据结构：

Series 系列 [ˈsɪəriːz]
DataFrame Frame [freɪm] 框架

我们可以将 Series 看作显示了索引的一维数组，将 DataFrame 看作显示了纵横轴索引的二维数组，因此 numpy 的许多方法与函数可以用在 Series 与 DataFrame 上。

Series对象

我们首先来了解 Series ，因为 Pandas 是基于NumPy构建的，所以我们可以参考一维数组对象来理解 Series对象。

import numpy as np
import pandas as pd
list_1=list(range(1,6))
arr=np.array(list_1)
ser=pd.Series(list_1)
print(f'这是由 1 到 5 构成的一维数组，只有数据元素：\n{arr}')
print(f'这是由 1 到 5 构成的Series对象，由数据元素及其索引：\n{ser}')

由此我们可以更好的理解 Ndarray 对象和 Series 对象，

数据类型不同：两者都是一系列同类型数据的集合，不同之处在于 Ndarray 对象只能存储数值型数据，而一个Series 对象中可以同时包含数值型数据；字符串和python 对象等等；
两者的索引都是由 0 开始的，不同之处在于 Series 对象的索引可以重新指定，而 Ndarray 对象的索引不能变更；且 Series 对象的索引会在内容中显示出来，而Ndarray 对象的索引不会在内容中显示出来。

Series 对象的创建：

pandas. Series ( data , index , dtype , name , copy )

data：只要是数据都可以，当data的类型为字典时，键为索引，值作内容。
index：默认从零开始，当指定索引时，索引的个数要等于数据元素的个数。
dtype：元素的数据类型，默认会自己判断
name：设置索引和元素值的名称
Series . name=str 设置元素值的名称
Series . index.name=str 设置索引的名称
copy：拷贝数据，默认为 False

import numpy as np
import pandas as pd
data={'name':'张三','age':20,'class':'三班'}
ser=pd.Series(data)
print(ser)
print('利用 Series 对象的属性，index和values访问其索引值与元素值：')
print(ser.index)
print(ser.values)

DataFrame 对象

DataFrame 是一个表格型的数据结构，它含有一组有序的列，每列可以是不同的值类型（数值、字符串、布尔型值）。DataFrame 既有行索引也有列索引，它可以被看做由 Series 组成的字典（共同用一个索引）。可以参考 excel 表格

DataFrame 构造方法如下：

pandas.DataFrame( data, index, columns, dtype, copy)

参数说明：

data：一组数据(ndarray、series, map, lists, dict 等类型)。
index：索引值，或者可以称为行标签，默认为 RangeIndex (0, 1, 2, …, n) 。
columns：列标签，默认为 RangeIndex (0, 1, 2, …, n) 。
dtype：数据类型。
copy：拷贝数据，默认为 False。

Pandas DataFrame 是一个二维的数组结构，类似二维数组。
DataFrame 的构建

data 为字典类型：

键作索引，值作内容。

由数组，列表或元组构成的字典；

import numpy as np
import pandas as pd
data={'a':[1,2,3,4],'b':(4,5,6,7),'c':np.arange(9,13)}
frame=pd.DataFrame(data)
print(f'DataFrame对象：\n{frame}')
string='''通过属性 index 查看对象的行索引;columns查看对象列索引；values查看对象的值。'''
print(string)
print(f'行索引：{frame.index}')
print(f'列索引：{frame.columns}')
print(f'元素值：\n{frame.values}')
print('指定索引：')
frame=pd.DataFrame(data,index=['A','B','C','D'],columns=['a','b','c','d'])
print(frame)

2. 由 Series对象构成的字典；

import numpy as np
import pandas as pd
data={'a':pd.Series(np.arange(3)),'b':pd.Series(np.arange(3,5))
}
frame=pd.DataFrame(data)
print(frame)

由字典构成的字典；

import numpy as np
import pandas as pd
data={'a':{'apple':3.6,'banana':5.6},'b':{'apple':3,'banana':5},'c':{'apple':3.6}
}
frame=pd.DataFrame(data)
print(frame)

data 为列表类型：

data为二维数组时；
由 Series对象构成的列表；
由字典构成的列表；

import numpy as np
import pandas as pd
arr=np.arange(12).reshape(4,3)
frame_arr=pd.DataFrame(arr)
print('data为二维数组时；')
print(frame_arr)
list_dic=[{'apple':3.6,'banana':5.6},{'apple':3,'banana':5},{'apple':3.6}]
frame_list_dic=pd.DataFrame(list_dic)
print('由字典构成的列表；')
print(frame_list_dic)
list_ser=[pd.Series(np.random.rand(3)),pd.Series(np.random.rand(2))]
frame_list_ser=pd.DataFrame(list_ser)
print(f'由字典构成的列表；\n{frame_list_ser}')

索引

与python列表一样，在 Series对象和 DataFrame 对象中我们同样可以使用索引来进行数据的增，删，改，查。

在 pandas 中索引分为以下种：

位置索引：对象默认的索引，从 0 开始。Series 对象中的index 和 DataFrame对象中的 index 和 columns 都是默认从 0 开始。
标签索引：对默认索引进行指定后的索引称为标签索引。
布尔索引：用布尔运算布尔运算充当索引，返回一个由布尔值组成的对象。
切边索引：用逗号分隔不同维度，同一维度之间通过冒号分隔切片参数 start:stop:step 来进行切片操作，位置标索引和标签索引都可以充当切片参数。

import numpy as np
import pandas as pd
ser_1=pd.Series(['张三',24,'三班','男'])
print(f'未指定索引时：\n{ser_1}')
ser_2=pd.Series(['张三',24,'三班','男'],index=('name','age','class','sex'))
print(f'重新编辑索引后：\n{ser_2}')
arr=np.random.randint(0,12,(3,4))
df_1=pd.DataFrame(arr)
print(f'未指定索引时：\n{df_1}')
df_2=pd.DataFrame(arr,index=list('abc'),columns=list('ABCD'))
print(f'重新编辑索引后：\n{df_2}')

我们可以通过两种索引来进行数据的增，删，改，查。

通过索引获取元素

因为 Pandas 是基于NumPy构建的，所以 pandas 可以使用数组的操作，可以参考数组的索引来获取元素值。

import numpy as np
import pandas as pd
data={'name':'张三','age':20,'class':'三班','sex':'男'}
ser=pd.Series(data)
print(f'Series对象：\n{ser}')
print('获取单个元素：')
print(f'方法一通过下标 ser[1]：{ser[1]}')
print(f"方法二通过标签名 ser['age']：{ser['age']}")
print('获取多个元素：')
print(f'方法一通过下标与标签名：\n下标:ser[[1,3]]=\n{ser[[1,3]]}')
print(f"标签名：ser[['name','sex']]=\n{ser[['name','sex']]}")
print(f"通过下标切片：\n{ser[0:3]}")
print(f"通过标签名切片：\n{ser['name':'sex']}")

Series对象的常用属性与方法

属性：

Series. index
Series.values

作用：访问Series对象的索引值与元素值

import numpy as np
import pandas as pd
data={'name':'张三','age':20,'class':'三班'}
ser=pd.Series(data)
print(ser)
print('利用 Series 对象的属性，index和values访问其索引值与元素值：')
print(ser.index)
print(ser.values)

方法

Series. isnull ( )
Series. notnull ( )

作用：查找缺失值，也就是 nan。

import numpy as np
import pandas as pd
from pandas.core.indexes.base import Index
data={'name':'张三','age':20,'class':'三班'}
string='''在使用字典作为数据时，
指定索引的个数可以超出元素值的个数，
多余的索引对应值为 nan：'''
print(string)
ser=pd.Series(data,index=['name','age','class','sex'])
print(ser)
print(f'isnull()方法判断Series对象中是否有缺失值 nan，空为True：\n{ser.isnull()}')
print(f'notnull()方法与上述类似，这个是非空为True：\n{ser.notnull()}')

Series. head ( n : int = 5)
Series. tail ( n : int = 5)

作用：在 Series 对象中从前面取 n 行；从后面取 n 行，默认 n = 5

Series. unique ( ) - - - >array

作用：去重

Series. value_counts ( ) - - - >Series

作用：检查每个元素出现的次数。

import numpy as np
import pandas as pd
ser=pd.Series([2,5,6,7,4,5,2,3,6,4])
print(ser)
print('*'*20)
print(ser.unique())
print('*'*20)
print(ser.value_counts())

DataFrame对象常见的属性与方法

属性：

DataFrame. values - - -> 返回一个二维数组
DataFrame. index - - -> 返回一个Index对象
DataFramecolumns - - -> 返回一个Index对象

方法：

apply与applymap

DataFrame. apply ( func, axis = 0) -> DataFrame
DataFrame. applymap ( func )-> DataFrame

func：函数
apply 中应用对象中于每列或每行的函数；applymap中应用于对象中每个有元素的函数。
axis : 轴：{0或’index’，1或’columns’}，默认为0
沿其应用功能的轴：
0或’index’：将函数应用于每个纵轴。
1或’columns’：将函数应用于每个横轴。

apply ( ) 方法同样适用于 Series 对象。

import numpy as np
import pandas as pd
df=pd.DataFrame(np.random.randn(4,3))
print(df)
df=df.abs()
print(f'求每个元素中的绝对值：\n{df}')
f=lambda x : x.max()
df_apply=df.apply(f)
print(f'求每一列中的最大值：\n{df_apply}')
f=lambda x:f'{x:.2f}'
df_applymap=df.applymap(f)
print(f'将每个元素保留两位小数：\n{df_applymap}')

排序方法：

索引排序

sort_index( axis , ascending)

axis ['æksɪs] : int, default 0
指定轴来直接排序。对于系列，此值只能为0。
ascending [ə’sendɪŋ] 升序：布尔值或布尔值列表，默认为True，当索引为多索引时，可以单独控制每个级别的排序方向。

import numpy as np
import pandas as pd
ser=pd.Series([2,1,4,3],index=list('cbda'))
df=pd.DataFrame(np.arange(12).reshape(3,4),index=list('cab'),columns=list('DACB'))
print(ser,df,sep='\n')
print(f'按索引排序，默认升序：\n{ser.sort_index()}')
print(f'按 纵 轴排序，默认升序：\n{df.sort_index()}')
print(f'按 横 轴排序，默认升序：\n{df.sort_index(axis=1)}')

2. 按值排序

sort_values (by , axis , ascending)

by : str or list of str。指定要排序的名称或名称列表。
作用：沿任一轴按值排序。

import numpy as np
import pandas as pd
ser=pd.Series([2,1,4,3],index=list('cbda'))
df=pd.DataFrame(np.random.randint(0,12,(4,3)),index=list('cabd'),columns=list('ACB'))
print(ser,df,sep='\n')
print(f"按值引排序，默认升序：\n{ser.sort_values()}")
print(f"按值引排序，指定单轴，默认升序：\n{df.sort_values(by='A')}")
print(f"按值引排序，指定多轴，默认升序：\n{df.sort_values(by=['A','B'])}")

成员关系判断

isin ( values )

参数
values : iterable, Series, DataFrame or dict
返回
DataFrame of booleans 布尔型数据框
Series of booleans 布尔型系列

处理缺失数据的方法

第一步：判断是否存在缺失值

isnull ( ) - - - > DataFrame of booleans

第二步：丢失缺失数据或填充缺失数据

dropna ( axis = 0)
作用：丢失缺失值所在的行或列。

fillna ( values )
作用：将值 values 填充在 nan 值所在的位置

简介介绍：

转置

print(f'转置之后，行列交换：\n{frame.T}')

通过列索引获取列数据（ Series 类型）

print(f"查看其中一列frame['a']：\n{frame['a']}")

增加列数据

frame['e']=9
frame['f']=[7,8,5,2]

删除列

del frame['e']
del frame['f']

import numpy as np
import pandas as pd
arr=np.arange(12).reshape(4,3)
frame=pd.DataFrame(arr,index=['A','B','C','D'],columns=['a','c','d'])
print(f'DataFrame对象：\n{frame}')
print(f'转置之后，行列交换：\n{frame.T}')
print(f"查看其中一列frame['a']：\n{frame['a']}")
print(f"frame['a']的类型：{type(frame['a'])}")
frame['e']=9
frame['f']=[7,8,5,2]
print(f"插入一列：\n{frame}")
del frame['e']
del frame['f']
print(f"删除一列：\n{frame}")

索引操作：

Series 和 DataFrame 中的索引都是 Index 对象。

import numpy as np
import pandas as pd
arr=np.arange(12).reshape(4,3)
ser=pd.Series(range(7))
frame=pd.DataFrame(arr,index=['A','B','C','D'],columns=['a','c','d'])
print(f'Series对象的索引类型type(ser.index)：\n{type(ser.index)}')
print(f'DataFrame对象的索引类型type(frame.index)：\n{type(frame.index)}')
print(f'type(frame.columns)： {type(frame.columns)}')

重建索引：

Series. reindex ( )
DataFrame. reindex ( )

增：
增加Series对象的索引：

Series [ new_index ] = value
在原基础上新增一个
Series. append ( other_Series )
将两个对象合并成一个新的对象，并不改变原来的对象

增加 DataFrame 对象的索引：

import numpy as np
import pandas as pd
arr=np.arange(9).reshape(3,3)
ser=pd.Series(range(5),index=['a','b','c','d','e'])
frame=pd.DataFrame(arr,index=['a','b','c'],columns=['A','B','C'])
print(frame)
print('默认增加  列 :')
frame['4']=9
frame['D']=[10,11,12]
frame.insert(0,'E',[6,66,666])
print(frame)
print('使用标签索引增加 行 ：')
frame.loc['x']=[1,11,111,111,11,1]
print(frame)

删：
改：
查：

pandas库的一些算数方法

pandas库的一些统计方法

方法	说明
count	非NA值的个数
min , max	最小值与最大值
idxmin , idxmax	最小值与最大值的索引值
sum , mean	总和与平均数
var , std	样本值的方差与标准差
cumsum	样本值的累计和
cumprod	样本值的累计积
cummin , cummax	样本值的累计最大值和最小值
describe	计算汇总统计

参数：

axis = 0 按纵轴求，默认为0；axis = 1 按横轴求。
skipna = True,跳过缺失值。

pandas库的一些算术方法

方法	描述
add , radd	加法（+）
sub , rsub	减法（-）
div , rdiv	除法（/）
floordiv , rfloordiv	整除（//）
mul , rmul	乘法（*）
pow , rpow	幂次方（**）

参数

fill_value：填充值，将na值填充掉

r：r 代表者翻转，即参数位置互换，除数变成被除数；被除数变成除数。

pandas库中数据的加载与存储

从电脑中读取CSV文件：

方法	说名
read_csv ( )	从文件对象中加载带分隔符的数据，默认逗号为分割符
read_table ( )	从文件对象中加载带分隔符的数据，默认制表符为分割符
read_excel ( )	从 excel 中读取表格数据

参数：

参数	说明
path	表示文件对象所在系统位置的字符串
sep	拆分每行字段的字符串或正则表达式
header	默认第一行为列索引，若没有索引时应设置为None
index_col	从列索引中选一个或多个组成列表，当作行索引
names	用于结果的列名称，结合 header = None使用
skipeows	跳过几行，（从 0 开始）
skip_footer	忽略几行，（从文件末尾处算起）
nrows	读取几行，（从 0 开始）
na_values	替换 NA 值
iterator	布尔类型，返回一个TextParser进行迭代读取
chunksize	整型，作用同上，两者结和文件对象方法 get_chunksize ( ) 使用。

将pandas数据写入电脑

DataFrame. to_csv ( path )

path：写入路径

数据清洗与准备

删除缺失数据

方法	说明
isnull	返回布尔值组成的对象，空为True
notnull	返回布尔值组成的对象，非空为True
dropna	删除缺失值所在的行或列
fillna	替换缺失值

dropna (axis , how , thresh , inplace )

参数：

axis 轴：{0或’index’，1或’columns’}，默认为0
删除缺少值所在的行或列
how 如何删除：{‘any’，‘all’}，默认为’any’.
“any”：只要存在一个NA值，就删除该行或列。
“all”：只有全部为NA值，才删除该行或列。
thresh： int, optional，NA值的数量是 int 的行或列才会被删除。
inplace就地；原地bool类型, default False
False：返回一个新对象，不改变原对象
True：不返回对象，直接改变原对象。

填充缺失数据

fillna ( value , axis , method , inplace , limit )

参数：

value ：替换NA值
axis ,
method 填充方法：{‘backfill’，‘bfill’，‘pad’，‘ffill’，None}，默认无。
pad/ffill：将上一个有效观察向前传播到下一个有效观察，
backfill / bfill：使用下一个有效观测值填充间隙。
inplace , 同上
limit ：int, default None
如果指定了method方法，则这是要向前/向后填充的连续NaN值的最大数目。
如果未指定method方法，则这是沿整个轴填充NAN的最大条目数。
如果不是无，则必须大于0。

替换数据

replace ( to_replace , value , method , inplace , limit )

作用：将对象内的值 to_replace 用指定值 value 进行替换

删除重复项

drop_duplicates ( subset , keep , inplace , ignore_index) - - -> DataFrame

参数：

subset ：列标签组成的列表，默认情况下使用所有列。
以选中的列为标准，进行去重
keep ：保留：{‘first’，‘last’，False}，默认值为’first’
‘first’：除去第一次出现的重复项。
‘last’：删除除最后一次出现之外的重复项。
False：删除所有重复项。
inplace ：同上
ignore_index ：忽略索引：bool，默认为False

轴索引的重命名：

区分：方法 reindex ( ) 只能调整索引的顺序，而不能改变索引的名称。

import numpy as np
import pandas as pd
df=pd.DataFrame(np.arange(12).reshape(3,4),index=['BeiJing','Tokyo','New York'],columns=['one','two','three','four'])
print(df)
print('*'*20)
print(df.reindex(['BeiJing','New York','Tokyo']))
print('*'*20)
print(df.reindex(['a','b','c']))

改变索引的名称：

利用对象属性 index , columns 进行重命名，直接更改原对象。

import numpy as np
import pandas as pd
df=pd.DataFrame(np.arange(12).reshape(3,4),index=['BeiJing','Tokyo','New York'],columns=['one','two','three','four'])
print(df)
up=lambda x:x[:4].upper()
df.index=df.index.map(up)
print('*'*20)
print(df)
df.index=['a','b','c']
print('*'*20)
print(df)

使用方法 rename 对索引进行更新与重命名

rename ( index , columns , inplace)

import numpy as np
from numpy.core.defchararray import index
import pandas as pd
df=pd.DataFrame(np.arange(12).reshape(3,4),index=['BeiJing','Tokyo','New York'],columns=['one','two','three','four'])
print(df)
print('*'*20)
print(df.rename(index=str.title,columns=str.upper))
print('*'*20)
print(df.rename(index={'Tokyo':'东京'},columns={'three':'第三年'}))

数据清洗总结：

常见问题	解决方法	检测方法	解决方法
异常数据	删除异常数据所在的行		drop ( )
NA值问题	填充或删除	isnull ( )	fillna( ) , dropna( )
重复数据	删除重复数据	duplicated ( )	drop_duplicates ( )
数据类型变更	变更数据类型,指定新类型		astype ( )
部分数据包含数值和字符串	进行字符串操作，		map ( )
不利于分析的数据	替换数据元素		replace ( )

数据规整

层次化索引

数据连接

DataFrame. merge ( left , right , how=‘inner’ , on=None , left_on=None , right_on = None )

未完待续！！！！！