1.pandas优势

便捷的数据处理能力

读取文件方便

封装了Matplotlib、Numpy的画图和计算

2.pandas主要的两种数据结构

1.Series

表示一维数据，会自动为这一维数据创建行索引。

创建series：index默认值为整数序列,也可自定义。

se = pd.Series([0.25,0.5,0.75,1.0])

se

0   0.25

1    0.50

2    0.75

3    1.00

dtype: float64

Series本身的属性有两种，index，values

se.index

RangeIndex(start=0, stop=4, step=1)

se.values

array([0.25, 0.5 , 0.75, 1. ])

排序：

使用series.sort_values(ascending=True)对内容进行排序

series排序时，只有一列，不需要参数

se.sort_values()

使用series.sort_index()对索引进行排序

se.sort_index()

2.Dataframe

既有行索引，又有列索引,类似于二维数组

行索引，表明不同行，横向索引，叫index

列索引，表名不同列，纵向索引，叫columns

创建Dataframe

pd.DataFrame(data)

pd.DataFrame.from_dict(data)

在已有的DataFrame中，增加N列

df.insert() 下标，字段名，添加数据

allow_duplicates=True:允许添加重复的列

df.insert(2,"C",[333,44,55])  

常用属性：

df.shape  得到dataframe是几行几列的元组

(3, 2)

df.index   DataFrame的行索引列表

RangeIndex(start=0, stop=3, step=1)

df.columns DataFrame的列索引列表

Index(['a', 'b'], dtype='object')

df.values  直接获取其中array的值,通过type函数，可得到

numpy.ndarray

df.values

array([[0, 0],

      [1, 2],

      [2, 4]], dtype=int64)

转置 T

df.T

    0 1 2

a  0 1 2

b  0 2 4

常用方法：

df.head()  如果不补充参数，默认前5行。填入参数N则显示前N行

df.tail()       如果不补充参数，默认后5行。填入参数N则显示后N行

DataFrame索引的设置

修改行列索引值，必须整体全部修改

li = ["A","B"]

df.columns=li

重设索引值

设置新的下标索引

reset_index(drop=False)

drop:默认为False，不删除原来索引，如果为True,删除原来的索引值

 index A B

0  0  0  0

1  1  1   2

2  2  2  4

以某列值设置为新的索引

set_index(keys, drop=True)

keys : 列索引名称或者列索引名称的列表

drop : boolean, default True.当做新的索引，删除原来的列

索引操作

直接使用行列索引(先列后行) 列是列名，如果是数字，按照行索引取值。

df['A'][2]

结合loc或者iloc使用索引

使用loc:只能指定行列索引的名字 先行后列

df.loc[0,'A':'B']

A     0

B    0

Name: 0, dtype: int64

使用iloc可以通过索引的下标去获取  先行后列

df.columns.get_indexer(["A","B"]) 获取列中指定字段的下标

df.index.get_indexer([1])   获取行中指定字段的下标

df.index[下标] 根据下标得行中指定字段

df.columns[下标]   根据下标得列中指定字段

df.iloc[1,0:2]

A    1

B    2

Name: 1, dtype: int64

使用ix组合索引

ix下标和名称组合索引

df.ix[1:3,"B"]

赋值操作

df.A = 1

df["A"] = 1

排序

对内容排序

使用df.sort_values(key=, ascending=)对内容进行排序

单个键或者多个键(放入列表中)进行排序,默认升序

ascending=False:降序

ascending=True:升序

df.sort_values(by="B",ascending=False)

对索引排序

使用df.sort_index对索引进行排序

DataFrame运算

算术运算

add()  进行数学运算加上具体的一个数字

df.A.add(1)

sub()   进行数学运算减上具体的一个数字

df.A.sub(1)

逻辑运算

逻辑运算符： <、 >、|、 &

df[(df.A>0)&(df.B<3)]

逻辑运算函数:

query(expr)

expr:查询字符串

df.query('A>0 & B<3')

isin(values1) 指定值是否在values1列表中

df.A.isin([1,2,3])

df.isin([1])

统计运算

 describe() 得到总计数，平均值，标准差，最小值，25%分位数值

50%分位数值（中位数），75%分位数值，最大值

df.describe()

统计函数

min(), max() , mean(), median(), var(), std()

idxmax()、idxmin() 求出最大值/最小值的位置

0 代表列求结果， 1 代表行求统计结果

df

    A B

0  1   0

1   1  2

2   1  4

df.max(1)

0 1

1    2

2    4

dtype: int64

df.idxmax(1)

0   A

1    B

2    B

dtype: object

df.idxmax(0)

A    0

B    2

dtype: int64

累计统计函数

cumsum计算前1/2/3/…/n个数的和

df["A"].cumsum()

0    1

1    2

2    3

cummax计算前1/2/3/…/n个数的最大值

cummin计算前1/2/3/…/n个数的最小值

cumprod计算前1/2/3/…/n个数的积

自定义运算

apply(func, axis=0)  按行或列进行计算

func:自定义函数

axis=0:默认是列,跨行，axis=1为行， 跨列进行运算

df.apply(lambda x: x.max() - x.min(),axis=0)

A    0

B    4

dtype: int64

applymap（func）不分行列，所有元素进行计算

df.applymap(lambda x: x+2)

pandas画图

DataFrame.plot(x=None, y=None, kind='line')  

x : label or position, default None 指x轴的标签或位置参数，

y : label, position or list of label, positions, default None

Allows plotting of one column versus another

kind : str  选择需要的图形，默认折线图

‘line’ : line plot (default) 折线图

‘bar’ : vertical bar plot 条形图

‘barh’ : horizontal bar plot横向条形图

‘hist’ : histogram 柱状图

‘pie’ : pie plot 饼图

‘scatter’ : scatter plot 散点图  需要传入columns方向的索引

df.plot.bar(x='A',y='B')

文件读取与存储

csv

读取：pandas.read_csv()

filepath_or_buffer:文件路径

sep：字符串，分割符，默认值为‘，’

delimiter ： str,default None 定界符，备选分隔符（如果指定该参数，则sep参数失效）

usecols:指定读取的列名，列表形式

names:添加表头，列表形式

encoding:编码格式，默认utf8

data = pd.read_csv("D:\\BaiduNetdiskDownload\\company_sql.csv",sep=",",encoding='gbk')

存储：pandas.to_csv()

filepath_or_buffer:文件路径

sep ：字符串，分隔符

colums=[],想存储的列

index= ,false,存储不需要行索引

header=false,存储不需要列索引

mode= a：追加 w：重写

data.head().to_csv("D:\\BaiduNetdiskDownload\\company.csv",columns=["companyId","companyFullName"],mode="a",index=False)

sql

读取pandas.read_sql(sql, con, index_col=None, coerce_float=True, params=None, parse_dates=None, columns=None, chunksize=None)

sql：执行的sql语句

con：连接数据库操作，使用SQLAlchemy可以使用该库支持的任何数据库

index_col：要设置为索引的列

coerce_float：尝试将非字符串，非数字对象（如decimal.Decimal）的值转换为浮点，这对SQL结果集很有用

columns：从SQL表中选择的列名列表（仅在读取表时使用）

import pymysql

con = pymysql.connect(host="127.0.0.1",user="root",password="wuxin",db="test",charset="utf8")

data_sql = pd.read_sql(sql="select * from student",con=con)

存储：pandas.to_sql()

name: 输出的表名

con: 与read_sql中相同，数据库链接

if_exits： 三个模式：fail，若表存在，则不输出；replace：若表存在，覆盖原来表里的数据；append：若表存在，将数据写到原表的后面。默认为fail

index：是否将df的index单独写到一列中

index_label:指定列作为df的index输出，此时index为True

dtype: 指定列的输出到数据库中的数据类型。字典形式储存：{column_name: sql_dtype}。常见的数据类型有sqlalchemy.types.INTEGER(), sqlalchemy.types.NVARCHAR(),sqlalchemy.Datetime()等,如果不提供dtype,to_sql会自动根据df列的dtype选择默认的数据类型输出.

sqlalchemy 连接数据库模式：

'数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名?charset=utf8'

from sqlalchemy import create_engine

engine = create_engine(

    "mysql+pymysql://root:root@localhost:3306/test?charset=utf8")

data_sql.to_sql(name="student",con=engine,index=False,if_exists="append")

缺失值处理

先判断是否有缺失值NaN

pd.isnull(df) /pd.notnull(df)/df.isnull()/df.notnull()

存在缺失值nan, 并且是np.nan:

 1.直接删除 dropna(axis=0/1)

 2.替换缺失值 fillna(value, inplace=True)

    value：替换成的值

    inplace：

    True：会修改原数据

    False：不替换修改原数据，生成新的对象

若是特殊的符号值，如?等，

1 先替换'?'为np.nan

df.replace(to_replace=, value=)

to_replace:替换前的值

value:替换后的值

2.再进行缺失值的处理

数据离散化

离散化：把连续型数据切分为若干“段”，即把无限空间中有限的个体映射到有限的空间中去，以此提高算法的时空效率。

优势：①算法需要。②离散化可以有效地克服数据中隐藏的缺陷：使模型结果更加稳定。③降低时间、空间复杂度

流程：

对数据进行分组

自动分组：pd.qcut(data, bins)

自定义分组：pd.cut(data, bins)

对数据进行分组将数据分组 一般会与value_counts搭配使用，统计每组的个数

series.value_counts()：统计分组次数

对分好组的数据求哑变量

pandas.get_dummies(data, prefix=None)

data:array-like, Series, or DataFrame

prefix:分组名字

合并

concat 索引合并

pd.concat([data1,data2],axis=1)

data数据类型为Dataframe类型

按照行或列进行合并,axis=0为列索引，axis=1为行索引

merge进行按照键合并

pd.merge(left, right, how='inner', on=[左右共同字段], left_on=None, suffixes=('_x', '_y'))

可以指定按照两组数据的共同键值对合并或者左右各自

left: A DataFrame object

right: Another DataFrame object

how: inner，outer，left，right

left_on=None, right_on=None：指定左右键

suffixes：如果和表合并的过程中遇到有一列两个表都同名，但是值不同，合并的时候又都想保留下来，就可以用suffixes给每个表的重复列名增加后缀。

交叉表与透视表：

交叉表：交叉表用于计算一列数据对于另外一列数据的分组个数(寻找两个列之间的关系)

pd.crosstab(value1, value2)

透视表：

DataFrame.pivot_table([], index=[])

分组与聚合

分组与聚合通常是分析数据的一种方式，通常与一些统计函数一起使用，查看数据的分组情况

分组：

data.groupby(by，)

key：按key分组，多个key，用列表

as_index:true，false保存行索引

聚合：就是将分组后的数据，count/sum等。