本来打算学习pandas模块，并写一个博客记录一下自己的学习，但是不知道怎么了，最近好像有点急功近利，就想把别人的东西复制过来，当心沉下来，自己自觉地将原本写满的pandas学习笔记删除了，这次打算写上自己的学习记录，这里送给自己一句话，同时送给看这篇博客的人，共勉
当你迷茫的时候，当你饱受煎熬的时候，请停下来，想想自己学习的初衷，想想自己写博客的初衷，爱你所爱，行你所行，听从你心，无问西东。
好了，正文开始。
pandas是做数据分析非常重要的一个模块，它使得数据分析的工作变得更快更简单。由于现实世界中数据源的格式非常多，但是pandas也支持了不同数据格式的导入方法，所以学习pandas非常有必要。
本文首先记录一下自己学习read_csv的笔记，当然了自己需要用什么，就学习什么，而不是记录人家read_csv的所有方法，要是想看所有的方法详解可以去官网，要想学习Pandas建议先看下面2个网站。
官网地址如下：https://pandas.pydata.org/
官网教程如下（十分钟搞定pandas）：https://pandas.pydata.org/pandas-docs/stable/10min.html
NAN （数值数据类型的一类数），全称Not a Number ，表示未定义或者不可表示的值。
一：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，直接读取文件内容
read_csv读取的数据类型为Dataframe，通过obj.dtypes可以查看每列的数据类型
首先说一下，我这段csv文件是没有列索引的，那么我的读取代码如下可以读取到什么呢？
import pandas as pd filename = r'Train_A/Train_A_001.csv' data = pd.read_csv(filename) print(data)
结果如下;
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
大家可以发现，它默认你有列索引，并且把第一行的数据当做列索引，并且从第二行开始设置了行索引，所以说列索引的设置非常重要，起码在这里看来是这样的，那么如何设置呢，下面就具体分析一下。
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'
data = pd.read_csv(filename,header=None,names=('a','b','c','d','e','f','g'))
print(data)
通过上述代码，我们可以指定列索引为a~f，结果如下：
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
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]) print(data)
上面意思是使用第一列数据（列表默认从0开始的啊），结果如下：
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)
结果如下：
1 2 3 0 4.370 -1.372 0.102 1 3.955 -1.277 0.015 2 3.334 -1.193 0.033 3 3.022 -1.082 0.151 4 2.970 -1.103 -0.048 5 3.043 -1.089 0.011 6 3.017 -1.052 0.066 7 2.796 -0.933 0.002 8 2.521 -0.749 0.011 9 2.311 -0.623 -0.038 10 2.024 -0.452 0.039 11 1.669 -0.277 -0.005 12 1.314 -0.214 0.013 13 0.926 -0.142 0.062
6 读取csv前几行内容
使用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) # print(data1) #读取文件的前5行 headdata = data1.head(5) print(headdata)
运行效果，返回前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返回了第一行所有列的数据，也就是说第一行的数据：
import pandas as pd filename = r'Train_A/Train_A_001.csv' data = pd.read_csv(filename,index_col=None,header=None) # print(data1) data1 = data.loc[0,:] print(data1)
由此我们可以推断出，某几行-所有列的数据，代码如下：
import pandas as pd filename = r'Train_A/Train_A_001.csv' data = pd.read_csv(filename,index_col=None,header=None) # print(data1) # 返回第n行所有列的数据 data1 = data.loc[[1,3,5],:] print(data1)
结果展示一下：
0 1 2 3 4 5 6 1 0.892 3.955 -1.277 0.015 -0.099 -0.066 0.018 3 1.013 3.022 -1.082 0.151 0.015 0.035 0.018 5 1.302 3.043 -1.089 0.011 -0.085 -0.097 0.018
8，返回所有行-所有列
获取所有行所有列，直接看代码：
import pandas as pd filename = r'Train_A/Train_A_001.csv' data = pd.read_csv(filename,index_col=None,header=None) # print(data1) # 返回第n行所有列的数据 data1 = data.loc[:,:] print(data1)
结果就是所有行，所有列，这里就不展示了。
9，返回某行-所有列
import pandas as pd filename = r'Train_A/Train_A_001.csv' data = pd.read_csv(filename,index_col=None,header=None) # print(data1) # 返回所有列-某行的数据 data1 = data.loc[:,0] print(data1)
运行效果如下：
0 0.916 1 0.892 2 0.908 3 1.013 4 1.111 5 1.302 6 1.552 7 1.832 8 2.127 9 2.354 10 2.537 11 2.639 12 2.707 13 2.810 Name: 0, dtype: float64
10，数据统计
describe()统计下数据量，标准值，平均值，最大值等
data.describe()
就拿上面的csv文件为例，读取结果，解析如下：
import pandas as pd filename = r'Train_A/Train_A_001.csv' data1 = pd.read_csv(filename,index_col=None,header=None) # print(data1) 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]
既然了解了pandas，以后也需要使用，那么我就不止想学习读取csv了，我还想学习基本的pandas数据结构，起码以后使用会知道一些，下面学习一下pandas其的基本数据结构。
二：pandas的基本数据结构
pandas是基于Numpy的一个非常好用的库，正如名字一样，人见人爱，之所以如下，就在于不论是读取，处理数据，使用它都非常简单。
pandas有两种自己独有的基本数据结构，即使如此，但是它依然只是Python的一个库，所以Python中有的数据类型在这里依然使用，同样还可以使用类自己定义的数据类型，只不过，pandas里面又定义了两种数据类型：Series和DataFrame。
1，Series
series就如同列表一样，一系列数据，每个数据对应于一个索引值，比如这样一个列表：[9,3,8]，如果跟索引值写到一起，就是这样：
这种样式我们已经熟悉了，不过有些时候，需要将其竖起来表示：
上面两种，只是表现形式上的差别罢了。
Series就是“竖起来”的列表。举个例子：
import pandas as pd s = pd.Series([1,2,3,'python']) s 0 1 1 2 2 3 3 python dtype: object
另外一点也很像列表，就是里面的元素的类型，由我们任意决定。
这里，我们实质上创建了一个Series对象，这个对象当然就有其属性和方法了，比如下面两个属性依次可以显示Series对象的数据值和索引：
s.values array([1, 2, 3, 'python'], dtype=object) s.index RangeIndex(start=0, stop=4, step=1)
由于列表的索引只能是从0开始的整数，Series数据类型在默认情况下，其索引也是如次，不过区别于列表的是，Series可以自定义索引：
s = pd.Series(['java','python'],index=['1','2']) s 1 java 2 python dtype: object
自定义索引之后，我们就可以根据索引操作元素，series也可以学习list操作：
s['1'] 'java'
当然了，前面定义Series对象的是，用的是列表，即 Series() 方法的参数中，第一个列表就是其数据值，如果需要定义 index，放在后面，依然是一个列表。除了这种方法之外，还可以用下面的方法定义 Series 对象：
s = {'python':800,'java':600,'c++':1000}
s = pd.Series(s)
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
三，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是数据
原文：
pd.read_csv(filename) | From a CSV file pd.read_table(filename) | From a delimited text file (like TSV) pd.read_excel(filename) | From an Excel file pd.read_sql(query, connection_object) | Read from a SQL table/database pd.read_json(json_string) | Read from a JSON formatted string, URL or file. pd.read_html(url) | Parses an html URL, string or file and extracts tables to a list of dataframes pd.read_clipboard() | Takes the contents of your clipboard and passes it to read_table() pd.DataFrame(dict) | From a dict, keys for columns names, values for data as lists
3，导出数据
- df.to_csv(filename)：导出数据到CSV文件
- df.to_excel(filename)：导出数据到Excel文件
- df.to_sql(table_name, connection_object)：导出数据到SQL表
- df.to_json(filename)：以Json格式导出数据到文本文件
原文：
df.to_csv(filename) | Write to a CSV file df.to_excel(filename) | Write to an Excel file df.to_sql(table_name, connection_object) | Write to a SQL table df.to_json(filename) | Write to a file in JSON format
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])：增加一个日期索引
原文：
pd.DataFrame(np.random.rand(20,5)) | 5 columns and 20 rows of random floats
pd.Series(my_list) | Create a series from an iterable my_list
df.index = pd.date_range('1900/1/30', periods=df.shape[0]) | Add a date index
5，查看，检查数据
- df.head(n)：查看DataFrame对象的前n行
- df.tail(n)：查看DataFrame对象的最后n行
- df.shape()：查看行数和列数
- http://df.info()：查看索引、数据类型和内存信息
- df.describe()：查看数值型列的汇总统计
- s.value_counts(dropna=False)：查看Series对象的唯一值和计数
- df.apply(pd.Series.value_counts)：查看DataFrame对象中每一列的唯一值和计数
原文：
df.head(n) | First n rows of the DataFrame df.tail(n) | Last n rows of the DataFrame df.shape | Number of rows and columns df.info() | Index, Datatype and Memory information df.describe() | Summary statistics for numerical columns s.value_counts(dropna=False) | View unique values and counts df.apply(pd.Series.value_counts) | Unique values and counts for all columns
6，数据选取
- df[col]：根据列名，并以Series的形式返回列
- df[[col1, col2]]：以DataFrame形式返回多列
- s.iloc[0]：按位置选取数据
- s.loc['index_one']：按索引选取数据
- df.iloc[0,:]：返回第一行
- df.iloc[0,0]：返回第一列的第一个元素
原文：
df[col] | Returns column with label col as Series df[[col1, col2]] | Returns columns as a new DataFrame s.iloc[0] | Selection by position s.loc['index_one'] | Selection by index df.iloc[0,:] | First row df.iloc[0,0] | First element of first column
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)：批量重命名索引
原文：
df.columns = ['a','b','c'] | Rename columns
pd.isnull() | Checks for null Values, Returns Boolean Arrray
pd.notnull() | Opposite of pd.isnull()
df.dropna() | Drop all rows that contain null values
df.dropna(axis=1) | Drop all columns that contain null values
df.dropna(axis=1,thresh=n) | Drop all rows have have less than n non null values
df.fillna(x) | Replace all null values with x
s.fillna(s.mean()) | Replace all null values with the mean (mean can be replaced with almost any function from the statistics section)
s.astype(float) | Convert the datatype of the series to float
s.replace(1,'one') | Replace all values equal to 1 with 'one'
s.replace([1,3],['one','three']) | Replace all 1 with 'one' and 3 with 'three'
df.rename(columns=lambda x: x + 1) | Mass renaming of columns
df.rename(columns={'old_name': 'new_ name'}) | Selective renaming
df.set_index('column_one') | Change the index
df.rename(index=lambda x: x + 1) | Mass renaming of index
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
原文：
df[df[col] > 0.5] | Rows where the column col is greater than 0.5 df[(df[col] > 0.5) & (df[col] < 0.7)] | Rows where 0.7 > col > 0.5 df.sort_values(col1) | Sort values by col1 in ascending order df.sort_values(col2,ascending=False) | Sort values by col2 in descending order df.sort_values([col1,col2],ascending=[True,False]) | Sort values by col1 in ascending order then col2 in descending order df.groupby(col) | Returns a groupby object for values from one column df.groupby([col1,col2]) | Returns groupby object for values from multiple columns df.groupby(col1)[col2] | Returns the mean of the values in col2, grouped by the values in col1 (mean can be replaced with almost any function from the statistics section) df.pivot_table(index=col1,values=[col2,col3],aggfunc=mean) | Create a pivot table that groups by col1 and calculates the mean of col2 and col3 df.groupby(col1).agg(np.mean) | Find the average across all columns for every unique col1 group df.apply(np.mean) | Apply the function np.mean() across each column nf.apply(np.max,axis=1) | Apply the function np.max() across each row
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
原文：
df1.append(df2) | Add the rows in df1 to the end of df2 (columns should be identical) pd.concat([df1, df2],axis=1) | Add the columns in df1 to the end of df2 (rows should be identical) df1.join(df2,on=col1,how='inner') | SQL-style join the columns in df1 with the columns on df2 where the rows for col have identical values. how can be one of 'left', 'right', 'outer', 'inner'
10，数据统计
- df.describe()：查看数据值列的汇总统计
- df.mean()：返回所有列的均值
- df.corr()：返回列与列之间的相关系数
- df.count()：返回每一列中的非空值的个数
- df.max()：返回每一列的最大值
- df.min()：返回每一列的最小值
- df.median()：返回每一列的中位数
- df.std()：返回每一列的标准差
原文：
df.describe() | Summary statistics for numerical columns df.mean() | Returns the mean of all columns df.corr() | Returns the correlation between columns in a DataFrame df.count() | Returns the number of non-null values in each DataFrame column df.max() | Returns the highest value in each column df.min() | Returns the lowest value in each column df.median() | Returns the median of each column df.std() | Returns the standard deviation of each column
参考http://wiki.jikexueyuan.com/project/start-learning-python/311.html
https://zhuanlan.zhihu.com/p/25630700
https://www.dataquest.io/blog/pandas-cheat-sheet/