Python pandas学习总结
Python pandas学习总结
pandas是做数据分析非常重要的一个模块，它使得数据分析的工作变得更快更简单。由于现实世界中数据源的格式非常多，但是pandas也支持了不同数据格式的导入方法，所以学习pandas非常有必要。
要是想看所有的方法详解可以去官网，要想学习Pandas建议先看下面2个网站。
官网地址如下：https://pandas.pydata.org/
官网教程如下（十分钟搞定pandas）：https://pandas.pydata.org/pandas-docs/stable/10min.html
两种特殊数值：NAN （数值数据类型的一类数），全称Not a Number ，表示未定义或者不可表示的值，inf表示无穷，可能无穷大也可能无穷小。
常用方法
| 常用方法 | 程序 | 备注 |
|---|---|---|
| 创建pandas数据 | df=pd.DataFrame({“列1”:[1,2,3],“列2”:[4,5,6]}） | #DataFrame类 |
| 读取excel数据到python中 | pd.read_excel(“路径”,header=n，index_col=“列1”,skiprows=3,usecols=“C:F”，dtype={“old”:str,“name”:str},sheet_name=‘sheet2’) | #read_excel方法,header默认为0，即将第0行作为索引列，如果需要设置第n行为索引列，则headers=n,若读取的数据中只有数据，没有有列索引，则需要添加header=None来表示，同时可以通过df.columns=[“name”,“old”,“sexuality”]来为数据新增列索引，index_col表示在导入数据的时候就指定行索引,siprows=3表示跳过前3行，从第4行开始读取，usecols="C:F"表示使用C:F列数据，一般用于数据前几行前几列为空白,dtype为设置某列的数据类型,sheet_name表示读取excel中的某个sheet页 |
| 创建excel并将数据输出到excel中 | df.to_excel(“路径”) | #to_excel方法 |
| 设置excel的行索引并更新(替换原本数据) | df=df.set_index(“列1”) | #列1为想要设置的行索引，set_index方法 |
| 返回数据的行和列 | print(df.shape) | #主要为shape属性 |
| 返回数据的列名，即属性 | print(df.columns) df.columns=[“name”,“old”,“sexuality”] | #主要为colums属性，df.columns=[“name”,“old”,“sexuality”]来为数据新增列索引 |
| 返回数据的前几行 | print(df.head(n)) | #head()默认返回前5行，若返回n行则head(n) |
| 返回数据的后几行 | print(df.tail()) | #tail()默认返回前5行，若返回n行则tail(n) |
Series
| 常用方法 | 程序 | 备注 |
|---|---|---|
| 创建Series | 1、d={‘x’:100,‘y’:200,‘z’:300} pd.Series(d) 2、 L1=[100,200,300] L2=[‘x’,‘y’,‘z’ ]pd.Series(L1,index=L2) 3、 pd.Series([100,200,300],index=[‘x’,‘y’,‘z’]) | 3种方法创建Series,方法1是通过字典形式，index表示标签 |
| 创建含有行标签和列标签的Series | s1=pd.Series([1,2,3],index=[1,2,3],name=‘A’) s2=pd.Series([10,20,30],index=[1,2,3],name=‘B’) s3=pd.Series([100,200,300],index=[1,2,3],name=‘C’) | 创建Series时name表示这些数据的列标签，index表示行标签 |
| 将几个Series合并为DataFrame (正确做法） | pd.DataFrame(s1.name:s1,s2.name:s2,s3.name:s3) | 此方法将Series中的S1,S2,S3合并，并将原来的行标签作为行标签，将单个Series作为一列 |
| 将几个Series合并为DataFrame（错误方法） | pd.DataFrame([s1,s2,s3]) | 此方法虽然也能合并，但是标签错误，将单个Series作为一行 |
| 设置特定位置的值 | df[“name” ].at[0]=1 或者df.at[0,“name”] =1 | 令name列的第0个元素的值为1，at中只能为数字 |
| 对数据的某一列应用函数 | df.[“old”]=df.[“old”].apply(fx)或者用lambda函数代替fx函数，即df.[“old”]=df.[“old”].apply(lambda x:x+2) | 通过使用apply()方法来应用函数,fx为函数名，不加括号 |
| 排序 | df.sort_values(by=[‘old’,‘name’],inplace=True,ascending=[True,False]) | 排序使用sort_values函数，by为排序依据，先按old,后按name,inplace表示在原数据上修改，ascending表示升序降序，默认为True,即升序，False为降序,该式子表示old升序，name降序，即先对old升序排，再对name降序排 |
| 查看到符合条件的特定数值 | df.loc[df[‘old’].apply(fx)] 或者df.loc[df.old.apply(fx)]或者用lambda函数代替fx,即 df.loc[df[‘old’].apply(lambds x:x+2)] | loc用来定位特定位置，后边为方括号[]，df[‘old’].apply(fx)表示对df数据的old列使用fx函数进行筛选，然后通过loc返回筛选后的值，函数fx不用加括号 |
| 显示所有列 | pd.options.display.max_columns=888 pd.set_option(‘display.max_columns’, None)#显示所有列 pd.set_option(‘display.max_rows’, None)#显示所有行 pd.set_option(‘max_colwidth’,100) #设置value的显示长度为100，默认为50 | 可能由于列数太多无法显示所有列，因此通过设置max_columns来展示888（大于所有列）列 |
| 显示各个变量之间的相关系数表 | print(df.corr()) | 显示各个变量之间的相关系数，和stata几乎一样 |
| 数据合并1（EXCEL中的VLOOKUP功能 ） | table=df.merge(df1,how=‘left’,on=‘ID’).fillna(0) | 根据相同的’ID列’对df和df1进行合并,on表示根据哪一列进行合并(如果两个表对应的数名称不一样，不都是ID，那么可以将on替换为left_on和right_on，由于默认情况下，当df1中ID为nan时不进行合并，只取交集，因此通过how='left’，无论右边df1中ID列是否为nan,都按df列返回，即以左边df中的ID为基础进行合并,fillna(0)表示将所有的nan替换为0 |
| 数据合并2 | pd.contact([sheet1,sheet2]，axis=1) .reset_index(drop=True) | 同样数据纵向合并，但是是通过pandas而不是df,sheet1,sheet2表示需要合并的数据所在的sheet页，rest_index表示重新设置行标签，否则默认将sheet1，sheet2原本的标签直接照搬,axis=0表示竖着合并，axis=1表示横着合并 |
| 追加列 | df[“age”]=np.arrange(len(studets)) | 追加age列，数字一次为0，1，2递增数列 |
| 改变数据类型 | df.old= df.old.astype(int) | 将df表中的old列转换为int格式 |
| 去除重复数据 | df.drop_duplicates(subset=[‘name’,‘old’],inplace=True,keep=‘first’) | subset表示在那列上去除重复值，inplace表示是否在原数据上进行替换，keep表示当有重复时保留前边的重复值还是后边的 |
| 返回某个数据的位置 | a = df[(df.BoolCol3)&(df.attr22)].index.tolist() | 返回df数据中Boolcol为3，attr为22的标签 |
| 删除原标签，重新设置为0,1,2 | data.index=[i for i in range(data.shape[0])] | – |
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – | ||
| – |
一：读取文件，read_csv方法
- 1准备CSV文件
Train_A_001.csv文件内容如下：
0.916,4.37,-1.372,0.102,0.041,0.069,0.018
0.892,3.955,-1.277,0.015,-0.099,-0.066,0.018
0.908,3.334,-1.193,0.033,-0.098,-0.059,0.018
1.013,3.022,-1.082,0.151,0.015,0.035,0.018
1.111,2.97,-1.103,-0.048,-0.175,-0.171,0.019
1.302,3.043,-1.089,0.011,-0.085,-0.097,0.018
1.552,3.017,-1.052,0.066,-0.002,-0.036,0.019
1.832,2.796,-0.933,0.002,-0.028,-0.075,0.019
2.127,2.521,-0.749,0.011,0.041,-0.022,0.019
2.354,2.311,-0.623,-0.038,0.012,-0.056,0.019
2.537,2.024,-0.452,0.039,0.089,0.031,0.019
2.639,1.669,-0.277,-0.005,0.036,-0.008,0.019
2.707,1.314,-0.214,0.013,0.031,-0.005,0.019
2.81,0.926,-0.142,0.062,0.046,0.031,0.019
- 2直接读取文件内容
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data = pd.read_csv(filename)
print(data)
read_csv读取的数据类型为Dataframe，通过obj.dtypes可以查看每列的数据类型结果如下;
0.916 4.37 -1.372 0.102 0.041 0.069 0.018
0 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018
1 0.908 3.334 -1.193 0.033 -0.098 -0.059 0.018
2 1.013 3.022 -1.082 0.151 0.015 0.035 0.018
3 1.111 2.970 -1.103 -0.048 -0.175 -0.171 0.019
4 1.302 3.043 -1.089 0.011 -0.085 -0.097 0.018
5 1.552 3.017 -1.052 0.066 -0.002 -0.036 0.019
6 1.832 2.796 -0.933 0.002 -0.028 -0.075 0.019
7 2.127 2.521 -0.749 0.011 0.041 -0.022 0.019
8 2.354 2.311 -0.623 -0.038 0.012 -0.056 0.019
9 2.537 2.024 -0.452 0.039 0.089 0.031 0.019
10 2.639 1.669 -0.277 -0.005 0.036 -0.008 0.019
11 2.707 1.314 -0.214 0.013 0.031 -0.005 0.019
12 2.810 0.926 -0.142 0.062 0.046 0.031 0.019
由于该csv文件是没有列索引的，那么它默认你有列索引，并且把第一行的数据当做列索引，并且从第二行开始设置了行索引，所以说列索引的设置非常重要，起码在这里看来是这样的，那么如何设置呢，下面就具体分析一下。
- 3列索引 header=？的含义
当加上header=None的时候，表明原始文件没有列索引，这样的话会默认自动加上，除非你给定名称。结果如下：
0 1 2 3 4 5 6
0 0.916 4.370 -1.372 0.102 0.041 0.069 0.018
1 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018
2 0.908 3.334 -1.193 0.033 -0.098 -0.059 0.018
3 1.013 3.022 -1.082 0.151 0.015 0.035 0.018
4 1.111 2.970 -1.103 -0.048 -0.175 -0.171 0.019
5 1.302 3.043 -1.089 0.011 -0.085 -0.097 0.018
6 1.552 3.017 -1.052 0.066 -0.002 -0.036 0.019
7 1.832 2.796 -0.933 0.002 -0.028 -0.075 0.019
8 2.127 2.521 -0.749 0.011 0.041 -0.022 0.019
9 2.354 2.311 -0.623 -0.038 0.012 -0.056 0.019
10 2.537 2.024 -0.452 0.039 0.089 0.031 0.019
11 2.639 1.669 -0.277 -0.005 0.036 -0.008 0.019
12 2.707 1.314 -0.214 0.013 0.031 -0.005 0.019
13 2.810 0.926 -0.142 0.062 0.046 0.031 0.019
当加上header=0的时候，表明原始文件的第0行为列索引。结果如下：
0.916 4.37 -1.372 0.102 0.041 0.069 0.018
0 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018
1 0.908 3.334 -1.193 0.033 -0.098 -0.059 0.018
2 1.013 3.022 -1.082 0.151 0.015 0.035 0.018
3 1.111 2.970 -1.103 -0.048 -0.175 -0.171 0.019
4 1.302 3.043 -1.089 0.011 -0.085 -0.097 0.018
5 1.552 3.017 -1.052 0.066 -0.002 -0.036 0.019
6 1.832 2.796 -0.933 0.002 -0.028 -0.075 0.019
7 2.127 2.521 -0.749 0.011 0.041 -0.022 0.019
8 2.354 2.311 -0.623 -0.038 0.012 -0.056 0.019
9 2.537 2.024 -0.452 0.039 0.089 0.031 0.019
10 2.639 1.669 -0.277 -0.005 0.036 -0.008 0.019
11 2.707 1.314 -0.214 0.013 0.031 -0.005 0.019
12 2.810 0.926 -0.142 0.062 0.046 0.031 0.019
我们可以发现，第一行的数字被默认为列索引。
当没有列索引的时候，我们也可以自己指定索引名称，方便自己记录，代码如下：
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
#names表示指定列索引为a~f
data = pd.read_csv(filename,header=None,names=('a','b','c','d','e','f','g'))
print(data)
a b c d e f g
0 0.916 4.370 -1.372 0.102 0.041 0.069 0.018
1 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018
2 0.908 3.334 -1.193 0.033 -0.098 -0.059 0.018
3 1.013 3.022 -1.082 0.151 0.015 0.035 0.018
4 1.111 2.970 -1.103 -0.048 -0.175 -0.171 0.019
5 1.302 3.043 -1.089 0.011 -0.085 -0.097 0.018
6 1.552 3.017 -1.052 0.066 -0.002 -0.036 0.019
7 1.832 2.796 -0.933 0.002 -0.028 -0.075 0.019
8 2.127 2.521 -0.749 0.011 0.041 -0.022 0.019
9 2.354 2.311 -0.623 -0.038 0.012 -0.056 0.019
10 2.537 2.024 -0.452 0.039 0.089 0.031 0.019
11 2.639 1.669 -0.277 -0.005 0.036 -0.008 0.019
12 2.707 1.314 -0.214 0.013 0.031 -0.005 0.019
13 2.810 0.926 -0.142 0.062 0.046 0.031 0.019
4，行索引 index_col = ？的含义
从上面的代码，我们可以发现，没有行索引，只要设置了列索引就行，但是有些时候有些需求也是需要列索引为自己定义的名称
当设置行索引为None的时候，也就是index_col = None，同时设置列索引的时候，代码如下：
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data = pd.read_csv(filename,index_col=None,header=None)
print(data)
0 1 2 3 4 5 6
0 0.916 4.370 -1.372 0.102 0.041 0.069 0.018
1 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018
2 0.908 3.334 -1.193 0.033 -0.098 -0.059 0.018
3 1.013 3.022 -1.082 0.151 0.015 0.035 0.018
4 1.111 2.970 -1.103 -0.048 -0.175 -0.171 0.019
5 1.302 3.043 -1.089 0.011 -0.085 -0.097 0.018
6 1.552 3.017 -1.052 0.066 -0.002 -0.036 0.019
7 1.832 2.796 -0.933 0.002 -0.028 -0.075 0.019
8 2.127 2.521 -0.749 0.011 0.041 -0.022 0.019
9 2.354 2.311 -0.623 -0.038 0.012 -0.056 0.019
10 2.537 2.024 -0.452 0.039 0.089 0.031 0.019
11 2.639 1.669 -0.277 -0.005 0.036 -0.008 0.019
12 2.707 1.314 -0.214 0.013 0.031 -0.005 0.019
13 2.810 0.926 -0.142 0.062 0.046 0.031 0.019
当然了，当设置行索引为0的时候，也就是index_col = 0，则第一列为索引。
5，读取指定csv的某一列 usecols = [?]
在做数据分析的许多时候，我们会读取指定的某一列，使用的函数如下：
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data = pd.read_csv(filename,index_col=None,header=None,usecols=[1])
#使用第一列数据（列表默认从0开始的）
print(data)
1
0 4.370
1 3.955
2 3.334
3 3.022
4 2.970
5 3.043
6 3.017
7 2.796
8 2.521
9 2.311
10 2.024
11 1.669
12 1.314
13 0.926
要想一起读取三列，则代码如下：
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data = pd.read_csv(filename,index_col=None,header=None,usecols=[1,2,3])
print(data)
6 查看csv前几行内容head(?)
使用data.head(n)返回所导入的文件的前n行内容，示例如下：
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data1 = pd.read_csv(filename,index_col=None,header=None)
headdata = data1.head()#head()默认读取文件的前5行,也可以在括号内加如数字查看具体行数，比如head(10)等
print(headdata)
#head()如果里边没有数字默认读取5行
0 1 2 3 4 5 6
0 0.916 4.370 -1.372 0.102 0.041 0.069 0.018
1 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018
2 0.908 3.334 -1.193 0.033 -0.098 -0.059 0.018
3 1.013 3.022 -1.082 0.151 0.015 0.035 0.018
4 1.111 2.970 -1.103 -0.048 -0.175 -0.171 0.019
7，返回部分行和列的数据loc[?:?,?:?]或者iloc[?:?，？：？]（逗号前表示行，后表示列）
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data = pd.read_csv(filename,index_col=None,header=None)
data1 = data.loc[0,:]#loc[0,:]表示读取第0行，所有列的数据
print(data1)
data1 = data.loc[[1,3,5],:]#loc[[1,3,5],:]表示第1，3，5行，所有列的数据
data1 = data.loc[:,:]#[:,:]表示所有行所有列
data1 = data.loc[:,0]# 返回所有列-第0行的数据
loc和iloc都可以实现相同作用，但是loc以标签为索引，iloc以位置为索引
以**标签（行、列的名字）为索引选择数据—— x.loc[行标签,列标签]
以位置（第几行、第几列）**为索引选择数据—— x.iloc[行位置,列位置]
8 数据统计data.describe()和data.info()
data.describe()统计下数据量，标准值，平均值，最大值等，info()迅速获取数据描述获取总行数，每个属性的类型，非空值的数量
import pandas as pd
filename = r'Train_A/Train_A_001.csv'
data1 = pd.read_csv(filename,index_col=None,header=None)
print(data1.describe())
0 1 ... 5 6
count 14.000000 14.000000 ... 14.000000 14.000000
mean 1.764286 2.662286 ... -0.030643 0.018643
std 0.748950 0.957612 ... 0.063172 0.000497
min 0.892000 0.926000 ... -0.171000 0.018000
25% 1.037500 2.095750 ... -0.064250 0.018000
50% 1.692000 2.883000 ... -0.029000 0.019000
75% 2.491250 3.037750 ... 0.022000 0.019000
max 2.810000 4.370000 ... 0.069000 0.019000
[8 rows x 7 columns]
9 pandas读取csv后，获取列标签
我们读取到的数据，一般来说，第一行是列标签，可是如何获取第一行的内容呢？如下：
column_headers = list(df.columns.values)
以上面的csv文件为例，读取代码如下：
import pandas as pd
import numpy as np
data = pd.read_csv(file1,header=0,index_col=0)
column_header = list(data.columns.values)
print(column_header)
结果如下：
['flute_1', 'flute_2', 'flute_3']
10 获取每个值出现的次数data.value_counts()
data.value_counts() 获取每个值出现的次数
11 data.dropna() 返回略去丢失数据部分后的剩余数据
sample_incomplete_rows.dropna(subset=["total_bedrooms"])
12 data.fillna() 用指定的方法填充
median = housing["total_bedrooms"].median() #median用中位数填充
sample_incomplete_rows["total_bedrooms"].fillna(median, inplace=True)
#inplace表示时是否将原来的数值替换
二：pandas的基本数据结构
pandas是基于Numpy的一个非常好用的库，不论是读取，处理数据，使用它都非常简单。
pandas里面又定义了两种数据类型：Series(一系列数据)和DataFrame。
1，Series
series就如同列表一样，一系列数据，每个数据对应于一个索引值，比如这样一个列表：[9,3,8]，如果跟索引值写到一起，就是这样：
上面两种，只是表现形式上的差别罢了。
import pandas as pd
s = pd.Series([1,2,3,'python'])
print(s)
0 1
1 2
2 3
3 python
dtype: object
这里，我们实质上创建了一个Series对象，这个对象当然就有其属性和方法了，比如下面两个属性依次可以显示Series对象的数据值和索引：
s.values#显示Series对象的数据值
array([1, 2, 3, 'python'], dtype=object)
s.index#显示Series对象的索引
RangeIndex(start=0, stop=4, step=1)
由于列表的索引只能是从0开始的整数，Series数据类型在默认情况下，其索引也是如次，不过区别于列表的是，Series可以自定义索引：
s = pd.Series(['java','python'],index=['1','2'])
print(s)
1 java
2 python
dtype: object
自定义索引之后，我们就可以根据索引操作元素，series也可以学习list操作：
print(s['1'])
'java'
当然了，前面定义Series对象的是，用的是列表，即 Series() 方法的参数中，第一个列表就是其数据值，如果需要定义 index，放在后面，依然是一个列表。除了这种方法之外，还可以用下面的方法–字典定义 Series 对象：
s = {
'python':800,'java':600,'c++':1000}
s = pd.Series(s)
print(s)
python 800
java 600
c++ 1000
dtype: int64
这样的话，索引依然可以自定义，pandas的优势就在这里体现出来，如果自定义了索引，自定的索引会自动寻找原来的索引**，如果一样的话，就取代原来索引对应的值**，这个可以简称为“自动对齐”，我们举例说明：
s = pd.Series(s,index=['python','java','c','c++'])
s
python 800.0
java 600.0
c NaN
c++ 1000.0
dtype: float64
在里面，没有c，但是索引参数中有，于是其他能够“自动对齐”的照搬原值，依然可以在新的Series对象的索引中存在，并且可以自动为其赋值NaN，如果pandas中没有值，都对齐赋值给NaN，下面来一个更特殊的
ilist = ['a','b','c']
s = pd.Series(s,index=ilist)
s
a NaN
b NaN
c NaN
dtype: float64
这样的话，新得到的Series对象索引与s对象的值一个也不对应，所以都是NaN。pandas有专门的方法来判断值是否为空。
pd.isnull(s)
a True
b True
c True
dtype: bool
也可以判断不为空：
pd.notnull(s)
a False
b False
c False
dtype: bool
当然了，也可以对索引的名字，重新定义：
s = [1,2,3,4]
s = pd.Series(s,index=['python','java','c','c++'])
s
python 1
java 2
c 3
c++ 4
dtype: int64
s.index = ['a','b','c','d']
s
a 1
b 2
c 3
d 4
dtype: int64
2，DataFrame
DataFrame是一个表格型的数据结构，它含有一组有序的列，每类可以是不同的值类型（数值，字符串，布尔值）。DataFrame既有行索引也有列索引，它可以被看做由Series组成的字典（共同使用同一个索引）。跟其他类似的数据结构相比（如R的data.frame)DataFrame中面向行和面向列的操作基本上是平衡的，其实DataFrame中的数据是以一个或者多个二维块存放的（而不是列表，字典或者其他一维数据结构）。
DataFrame 是一种二维的数据结构，非常接近于电子表格或者类似 mysql 数据库的形式。它的竖行称之为 columns，横行跟前面的 Series 一样，称之为 index，也就是说可以通过 columns 和 index 来确定一个主句的位置。（有人把 DataFrame 翻译为“数据框”，是不是还可以称之为“筐”呢？向里面装数据嘛。)
首先给一个例子：
>>> import pandas as pd
>>> from pandas import Series, DataFrame
>>> data = {
"name":["yahoo","google","facebook"], "marks":
[200,400,800], "price":[9, 3, 7]}
>>> f1 = DataFrame(data)
>>> f1
marks name price
0 200 yahoo 9
1 400 google 3
2 800 facebook 7
这是定义一个 DataFrame 对象的常用方法——使用 dict 定义。字典的“键”（“name”，“marks”，“price”）就是 DataFrame 的 columns 的值（名称），字典中每个“键”的“值”是一个列表，它们就是那一竖列中的具体填充数据。上面的定义中没有确定索引，所以，按照惯例（Series 中已经形成的惯例）就是从 0 开始的整数。从上面的结果中很明显表示出来，这就是一个二维的数据结构（类似 excel 或者 mysql 中的查看效果）。
上面的数据显示中，columns 的顺序没有规定，就如同字典中键的顺序一样，但是在 DataFrame 中，columns 跟字典键相比，有一个明显不同，就是其顺序可以被规定，向下面这样做：
>>> f2 = DataFrame(data, columns=['name','price','marks'])
>>> f2
name price marks
0 yahoo 9 200
1 google 3 400
2 facebook 7 800
跟Series类似的，DataFrame数据的索引也可以自定义：
>>> f3 = DataFrame(data, columns=['name', 'price', 'marks', 'debt'], index=['a','b','c'])
>>> f3
name price marks debt
a yahoo 9 200 NaN
b google 3 400 NaN
c facebook 7 800 NaN
大家还要注意观察上面的显示结果。因为在定义 f3 的时候，columns 的参数中，比以往多了一项(‘debt’)，但是这项在 data 这个字典中并没有，所以 debt 这一竖列的值都是空的，在 Pandas 中，空就用 NaN 来代表了。
定义 DataFrame 的方法，除了上面的之外，还可以使用**“字典套字典”**的方式。
>>> newdata = {
"lang":{
"firstline":"python","secondline":"java"}, "price":{
"firstline":8000}}
>>> f4 = DataFrame(newdata)
>>> f4
lang price
firstline python 8000
secondline java NaN
在字典中就规定好数列名称（第一层键）和每横行索引（第二层字典键）以及对应的数据（第二层字典值），也就是在字典中规定好了每个数据格子中的数据，没有规定的都是空。
>>> DataFrame(newdata, index=["firstline","secondline","thirdline"])
lang price
firstline python 8000
secondline java NaN
thirdline NaN NaN
如果额外确定了索引，就如同上面显示一样，除非在字典中有相应的索引内容，否则都是 NaN。
前面定义了 DataFrame 数据（可以通过两种方法），它也是一种对象类型，比如变量 f3 引用了一个对象，它的类型是 DataFrame。承接以前的思维方法：对象有属性和方法。
>>> f3.columns
Index(['name', 'price', 'marks', 'debt'], dtype=object)
DataFrame 对象的 columns 属性，能够显示素有的 columns 名称。并且，还能用下面类似字典的方式，得到某竖列的全部内容（当然包含索引）：
>>> f3['name']
a yahoo
b google
c facebook
Name: name
这是什么？这其实就是一个 Series，或者说，可以将 DataFrame 理解为是有一个一个的 Series 组成的。
一直耿耿于怀没有数值的那一列，下面的操作是统一给那一列赋值：
>>> f3['debt'] = 89.2
>>> f3
name price marks debt
a yahoo 9 200 89.2
b google 3 400 89.2
c facebook 7 800 89.2
除了能够统一赋值之外，还能够“点对点”添加数值，结合前面的 Series，既然 DataFrame 对象的每竖列都是一个 Series 对象，那么可以先定义一个 Series 对象，然后把它放到 DataFrame 对象中。如下：
>>> sdebt = Series([2.2, 3.3], index=["a","c"]) #注意索引
>>> f3['debt'] = sdebt
将 Series 对象(sdebt 变量所引用) 赋给 f3[‘debt’]列，Pandas 的一个重要特性——自动对齐——在这里起做用了，在 Series 中，只有两个索引（“a”,“c”），它们将和 DataFrame 中的索引自动对齐。于是乎：
>>> f3
name price marks debt
a yahoo 9 200 2.2
b google 3 400 NaN
c facebook 7 800 3.3
自动对齐之后，没有被复制的依然保持 NaN。
还可以更精准的修改数据吗？当然可以，完全仿照字典的操作：
>>> f3["price"]["c"]= 300
>>> f3
name price marks debt
a yahoo 9 200 2.2
b google 3 400 NaN
c facebook 300 800 3.3
**
3，pandas.DataFrame.values
**
DataFrame.values 返回DataFrame的Numpy表示形式
仅返回DataFrame中的值，将删除轴标签
示例一：
所有列都是相同类型（例如：int64）的DataFrame会生成相同类型的数组。
>>> df = pd.DataFrame({
'age': [ 3, 29],
... 'height': [94, 170],
... 'weight': [31, 115]})
>>> df
age height weight
0 3 94 31
1 29 170 115
>>> df.dtypes
age int64
height int64
weight int64
dtype: object
>>> df.values
array([[ 3, 94, 31],
[ 29, 170, 115]], dtype=int64)
示例二：
具有混合类型列的DataFrame（例如，str / object，int64，float32）导致最宽泛类型的ndarray，其适应这些混合类型（例如，对象）。
>>> df2 = pd.DataFrame([('parrot', 24.0, 'second'),
... ('lion', 80.5, 1),
... ('monkey', np.nan, None)],
... columns=('name', 'max_speed', 'rank'))
>>> df2.dtypes
name object
max_speed float64
rank object
dtype: object
>>> df2.values
array([['parrot', 24.0, 'second'],
['lion', 80.5, 1],
['monkey', nan, None]], dtype=object)
**
三，DataFrame切片大全（包含多重索引）
**
这节主要学习如何对pandas的DataFrame进行切片，包括取某行，某列，某几行，某几列以及多重索引的取数方法。
测试的CSV文件如下（test.csv）：
注意：测试数据没有行标题和列标题
2.95072,3.37973,3.03758,0.711681,3.37973,3.37973
2.95072,3.37973,3.03758,0.711681,3.37973,3.37973
3.19946,3.72793,3.22612,0.899132,3.72793,3.72793
3.23699,3.72295,3.29885,0.988473,3.72295,3.72295
3.23179,3.71829,3.29314,0.96549,3.71829,3.71829
3.29573,3.76237,3.32046,0.978557,3.76237,3.76237
3.32537,3.82346,3.35758,1.04363,3.82346,3.82346
3.34407,3.87181,3.38804,1.05891,3.87181,3.87181
3.4196,3.88913,3.44196,1.12763,3.88913,3.88913
3.3904,3.87997,3.42206,1.10885,3.87997,3.87997
首先说明一下，直接read_csv和转换为DataFrame的效果，
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
print(type(filecontent))
df = pd.DataFrame(filecontent)
print(type(df))
先看结果：
<class 'pandas.core.frame.DataFrame'>
<class 'pandas.core.frame.DataFrame'>
从结果来看，所以说两个效果是一样的，转不转换都一样。
1，取DataFrame的某列三种方法
直接拿第四列的数据（列表默认从0开始取），代码如下：
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None)
df = pd.DataFrame(filecontent,index=None)
index4 = df.iloc[:,3]
print(index4)
结果：
0 0.711681
1 0.711681
2 0.899132
3 0.988473
4 0.965490
5 0.978557
6 1.043630
7 1.058910
8 1.127630
9 1.108850
Name: 3, dtype: float64
当加上索引，就取索引，两个效果是一样的，代码如下：
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
print(filecontent.a)
print(filecontent['a'])
结果：
0 2.95072
1 2.95072
2 3.19946
3 3.23699
4 3.23179
5 3.29573
6 3.32537
7 3.34407
8 3.41960
9 3.39040
Name: a, dtype: float64
0 2.95072
1 2.95072
2 3.19946
3 3.23699
4 3.23179
5 3.29573
6 3.32537
7 3.34407
8 3.41960
9 3.39040
Name: a, dtype: float64
2，取DataFrame某几列的两种方法
使用索引和不适用索引取多列的方法
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
df = pd.DataFrame(filecontent)
# 取某几列的方法一使用索引
result = df[['b','c']]
print(result)
# 取某几列的方法一不使用索引取前两列
result1 = df.iloc[:,:2]
print(result1)
结果：
b c
0 3.37973 3.03758
1 3.37973 3.03758
2 3.72793 3.22612
3 3.72295 3.29885
4 3.71829 3.29314
5 3.76237 3.32046
6 3.82346 3.35758
7 3.87181 3.38804
8 3.88913 3.44196
9 3.87997 3.42206
a b
0 2.95072 3.37973
1 2.95072 3.37973
2 3.19946 3.72793
3 3.23699 3.72295
4 3.23179 3.71829
5 3.29573 3.76237
6 3.32537 3.82346
7 3.34407 3.87181
8 3.41960 3.88913
9 3.39040 3.87997
3，取DataFrame的某行三种方法
代码如下;
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'])
df = pd.DataFrame(filecontent)
# 取某几行的方法一使用索引
result = df[1:2]
print(result)
print('************************************************')
# 取某几列的方法一不使用索引取第一行
result1 = df.ix[1]
print(result1)
print('************************************************')
# 取某几列的方法一不使用索引取第一行
result2 = df.iloc[1,:]
print(result2)
结果如下：
a b c d e f
1 2.95072 3.37973 3.03758 0.711681 3.37973 3.37973
************************************************
a 2.950720
b 3.379730
c 3.037580
d 0.711681
e 3.379730
f 3.379730
Name: 1, dtype: float64
************************************************
a 2.950720
b 3.379730
c 3.037580
d 0.711681
e 3.379730
f 3.379730
Name: 1, dtype: float64
4，取DataFrame的某几行的方法
代码如下：
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'],index_col=None)
df = pd.DataFrame(filecontent)
# 取某几行的方法一不使用索引取前两行
result1 = df.iloc[:2,]
print(result1)
结果如下：
a b c d e f
0 2.95072 3.37973 3.03758 0.711681 3.37973 3.37973
1 2.95072 3.37973 3.03758 0.711681 3.37973 3.37973
5，取DataFrame的某特定位置元素的方法
代码如下：
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'],index_col=None)
df = pd.DataFrame(filecontent)
# 取DataFrame的某特定位置元素的方法
result = df.ix[1,2]
print(result)
>>>3.0375799999999997
6，取DataFrame的多行多列的方法
代码如下：
import pandas as pd
filecontent = pd.read_csv('test.csv',header=None,names=['a','b','c','d','e','f'],index_col=None)
df = pd.DataFrame(filecontent)
# 取DataFrame的多行多列的方法
# 取前两行，前三列
result = df.ix[:2,:3]
print(result)
# 取前两行，前三列
result1 = df.iloc[:2,:3]
print(result1)
结果如下：
a b c
0 2.95072 3.37973 3.03758
1 2.95072 3.37973 3.03758
2 3.19946 3.72793 3.22612
a b c
0 2.95072 3.37973 3.03758
1 2.95072 3.37973 3.03758
四，Pandas其他方法
1，删除（drop）方法
删除Series的元素或者DataFrame的某一行（列）的意思，通过对象的方法，删除Series的一个元素。
其方法调用如下：
def drop(self, labels=None, axis=0, index=None, columns=None,
level=None, inplace=False, errors=‘raise’):
对象的 .drop(labels, axis=0) 方法返回的是一个新对象，元对象不会被改变。
1.1 删除Series的一个元素
In[11]: ser = Series([4.5,7.2,-5.3,3.6], index=['d','b','a','c'])
In[13]: ser.drop('c')
Out[13]:
d 4.5
b 7.2
a -5.3
dtype: float64
1.2 删除DataFrame的行或者列
drop函数默认删除行，列需要加axis = 1
In[17]: df = DataFrame(np.arange(9).reshape(3,3), index=['a','c','d'], columns=['oh','te','ca'])
In[18]: df
Out[18]:
oh te ca
a 0 1 2
c 3 4 5
d 6 7 8
In[19]: df.drop('a')
Out[19]:
oh te ca
c 3 4 5
d 6 7 8
In[20]: df.drop(['oh','te'],axis=1)
Out[20]:
ca
a 2
c 5
d 8
1.3 drop函数的inplace参数
采用drop方法，有下面三种等价的表达式
1. DF= DF.drop('column_name', axis=1)；
2. DF.drop('column_name',axis=1, inplace=True)
3. DF.drop([DF.columns[[0,1, 3]]], axis=1, inplace=True) # Note: zero indexed
注意：凡是会对原数组做出修改并返回一个新数组的，往往都会有一个inplace可选参数。如果手动设定位True（默认为False），那么原数组就直接被替换。也就是说，采用inplace = True之后，原数组名如（情况2 和3 所示）对应的内存值直接改变。
而采用inplace =False 之后，原数组名对应的内存值并不改变，需要将新的结果赋给一个新的数组或者覆盖原数组的内存位置。
1.4 drop函数的使用：数据类型转换
1df[‘Name’] = df[‘Name’].astype(np.datetime64)
DataFrame.astype() 方法可对整个DataFrame或某一列进行数据格式转换，支持Python和NumPy的数据类型。
2 python合并两个csv文件（列合并）
注意：要合并的两个文件行数需要相同，若不同可指定数组下标使其相同
代码如下：
# _*_ coding:utf-8 _*_
import csv
aFile = open('a.csv', 'r')
aInfo = csv.reader(aFile)
bfile = open('b.csv', 'r')
bInfo = csv.reader(bfile)
cfile = open('c.csv', 'w')
abcsv = csv.writer(cfile, dialect='excel')
a=[]
a=list()
b=[]
b=list()
for info in aInfo:
a.append(info)
for info in bInfo:
b.append(info )
for index in range(len(b)):
a[index+1].extend(b[index])
abcsv.writerow(a[index+1])
3，python合并（拼接）多个csv文件
当做数据分析与挖掘的时候，经常遇到要合并CSV文件的问题，所以此处记录一下使用python中的Pandas库进行拼接。
import pandas as pd
import os
orgin_dir = "Train_A"
result_dir = "result_A"
for filename in os.listdir(orgin_dir):
print(filename)
# header=None表示原始文件数据没有列索引，这样的话read_csv会自动加上列索引
a = pd.read_csv('Train_A/'+filename,header=None)
# header=0表示不保留列名，index=False表示不保留行索引，mode='a'表示附加方式写入，文件原有内容不会被清除
a.to_csv('all.csv',mode='a',index=False,header=False)
import pandas as pd
import os
orgin_dir = "Train_A"
result_dir = "result_A"
for filename in os.listdir(orgin_dir):
print(filename)
# header=None表示原始文件数据没有列索引，这样的话read_csv会自动加上列索引
pd.read_csv('Train_A/'+filename,header=None)
# header=0表示不保留列名，index=False表示不保留行索引，mode='a'表示附加方式写入，文件原有内容不会被清除
pd.to_csv('all.csv',mode='a',index=False,header=False)
4，排序sort_values 和sort_index
排序是按照某一列的大小进行排序，Python3.x目前提供两个函数
4.1 sort_index
这个函数似乎不建议使用了，推荐使用sort_values，详情参考：官方文档
参数
sort_index(axis=0, level=None, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’, sort_remaining=True, by=None)
参数说明
axis：0按照行名排序；1按照列名排序
level：默认None，否则按照给定的level顺序排列—貌似并不是，文档
ascending：默认True升序排列；False降序排列
inplace：默认False，否则排序之后的数据直接替换原来的数据框
kind：默认quicksort，排序的方法
na_position：缺失值默认排在最后{“first”,“last”}
by：按照那一列数据进行排序，但是by参数貌似不建议使用
举例：
## 对x1列升序排列，x2列升序。处理x1有相同值的情况
import pandas as pd
x = pd.DataFrame({
"x1":[1,2,2,3],"x2":[4,3,2,1]})
x.sort_index(by = ["x1","x2"],ascending = [False,True])
4.2 sort_values
参数
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind=‘quicksort’, na_position=‘last’)
参数说明
axis:{0 or ‘index’, 1 or ‘columns’}, default 0，默认按照索引排序，即纵向排序，如果为1，则是横向排序
by:str or list of str；如果axis=0，那么by=“列名”；如果axis=1，那么by=“行名”；
ascending:布尔型，True则升序，可以是[True,False]，即第一字段升序，第二个降序
inplace:布尔型，是否用排序后的数据框替换现有的数据框
kind:排序方法，{‘quicksort’, ‘mergesort’, ‘heapsort’}, default ‘quicksort’。似乎不用太关心
na_position : {‘first’, ‘last’}, default ‘last’，默认缺失值排在最后面
## 沿着轴方向按指定值排序
x.sort_values(by="x1",ascending= False)
## 沿着行方向按指定行排序
x.sort_values(by = 1,ascending=False,axis=1)
五，Pandas速查手册（翻译官网）
此外，在学习的时候，我参考了别人的知乎内容，并查看官网，然后汇总了pandas官网中比较常用的函数和方法，以方便自己记忆。其实这个比较全面的概括了pandas的所有知识点，只不过没有举例子，但是要是认真看了我上面的两个大的例子，学习下面的知识点，根本不费吹灰之力。
1，关键缩写和包的导入
首先，我们使用如下的缩写：
df：任意的Pandas DataFrame对象
s：任意的Pandas Series对象
同时导入pandas包和numpy包
import pandas as pd
import numpy as np
当看到np和pd的时候，我们就知道其是什么含义（这些缩写都是大家默认的）。
2，导入数据
pd.read_csv(filename)：从CSV文件导入数据
pd.read_table(filename)：从限定分隔符的文本文件导入数据
pd.read_excel(filename)：从Excel文件导入数据
pd.read_sql(query, connection_object)：从SQL表/库导入数据
pd.read_json(json_string)：从JSON格式的字符串导入数据
pd.read_html(url)：解析URL、字符串或者HTML文件，抽取其中的tables表格
pd.read_clipboard()：从你的粘贴板获取内容，并传给read_table()
pd.DataFrame(dict)：从字典对象导入数据，Key是列名，Value是数据
3，导出数据
df.to_csv(filename)：导出数据到CSV文件
df.to_excel(filename)：导出数据到Excel文件
df.to_sql(table_name, connection_object)：导出数据到SQL表
df.to_json(filename)：以Json格式导出数据到文本文件
4，创建测试对象
pd.DataFrame(np.random.rand(20,5))：创建20行5列的随机数组成的DataFrame对象
pd.Series(my_list)：从可迭代对象my_list创建一个Series对象
df.index = pd.date_range(‘1900/1/30’, periods=df.shape[0])：增加一个日期索引
5，查看，检查数据
df.head(n)：查看DataFrame对象的前n行
df.tail(n)：查看DataFrame对象的最后n行
df.shape()：查看行数和列数
df.info()：查看索引、数据类型和内存信息
df.describe()：查看数值型列的汇总统计
s.value_counts(dropna=False)：查看Series对象的唯一值和计数
df.apply(pd.Series.value_counts)：查看DataFrame对象中每一列的唯一值和计数
6，数据选取
df[col]：根据列名，并以Series的形式返回列
df[[col1, col2]]：以DataFrame形式返回多列
s.iloc[0]：按位置选取数据
s.loc[‘index_one’]：按索引选取数据
df.iloc[0,:]：返回第一行
df.iloc[0,0]：返回第一列的第一个元素
7，数据清理
df.columns = [‘a’,‘b’,‘c’]：重命名列名
pd.isnull()：检查DataFrame对象中的空值，并返回一个Boolean数组
pd.notnull()：检查DataFrame对象中的非空值，并返回一个Boolean数组
df.dropna()：删除所有包含空值的行
df.dropna(axis=1)：删除所有包含空值的列
df.dropna(axis=1,thresh=n)：删除所有小于n个非空值的行
df.fillna(x)：用x替换DataFrame对象中所有的空值
s.astype(float)：将Series中的数据类型更改为float类型
s.replace(1,‘one’)：用‘one’代替所有等于1的值
s.replace([1,3],[‘one’,‘three’])：用’one’代替1，用’three’代替3
df.rename(columns=lambda x: x + 1)：批量更改列名
df.rename(columns={‘old_name’: ‘new_ name’})：选择性更改列名
df.set_index(‘column_one’)：更改索引列
df.rename(index=lambda x: x + 1)：批量重命名索引
8，数据处理：Filter，Sort和GroupBy
df[df[col] > 0.5]：选择col列的值大于0.5的行
df.sort_values(col1)：按照列col1排序数据，默认升序排列
df.sort_values(col2, ascending=False)：按照列col1降序排列数据
df.sort_values([col1,col2], ascending=[True,False])：先按列col1升序排列，后按col2降序排列数据
df.groupby(col)：返回一个按列col进行分组的Groupby对象
df.groupby([col1,col2])：返回一个按多列进行分组的Groupby对象
df.groupby(col1)[col2]：返回按列col1进行分组后，列col2的均值
df.pivot_table(index=col1, values=[col2,col3], aggfunc=max)：创建一个按列col1进行分组，并计算col2和col3的最大值的数据透视表
df.groupby(col1).agg(np.mean)：返回按列col1分组的所有列的均值
data.apply(np.mean)：对DataFrame中的每一列应用函数np.mean
data.apply(np.max,axis=1)：对DataFrame中的每一行应用函数np.max
9，数据合并
df1.append(df2)：将df2中的行添加到df1的尾部
df.concat([df1, df2],axis=1)：将df2中的列添加到df1的尾部
df1.join(df2,on=col1,how=‘inner’)：对df1的列和df2的列执行SQL形式的join
10，数据统计
df.describe()：查看数据值列的汇总统计
df.mean()：返回所有列的均值
df.corr()：返回列与列之间的相关系数
df.count()：返回每一列中的非空值的个数
df.max()：返回每一列的最大值
df.min()：返回每一列的最小值
df.median()：返回每一列的中位数
df.std()：返回每一列的标准差