Python pandas学习总结

    |     2019年1月4日   |   IT   |     评论已关闭   |    156

本来打算学习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

噢!评论已关闭。