1、pandas 学习（一） —— read_csv ，read_excel
- 对 DataFrame 对象迭代得到的是其各个属性列的列名
一、生成数据表
1、首先导入pandas库，一般都会用到numpy库，所以我们先导入备用：import numpy as np import pandas as pd- 1
- 2
2、导入CSV或者xlsx文件：
df = pd.DataFrame(pd.read_csv('name.csv',header=1))
df = pd.DataFrame(pd.read_excel('name.xlsx'))
和
df =pd.read_csv('name.csv',header=1)
df = pd.read_excel('name.xlsx')效果是一样的
df = pd.read_csv(file_name) # 数据文件路径,从文件读取数据返回 DataFrameprint len(df) # excel 有多少行df.head(6)表示显示前6行数据，若head()中不带参数则会显示全部数据。
df.tail(6)表示显示后6行数据，若tail()中不带参数则也会显示全部数据。print data.columns 把data所有的列显示出来
df['d'] ="liulina"
例子：df=pd.DataFrame({"A":[1,2,3,4],"B":[5,6,7,8],"C":[1,1,1,1]}) print df # df=df[df.A>=2 ] # df=df[ df.A<4 ] y_hat = [0,0,1,1] print y_hat df['d'] =y_hat print df结果：A B C 0 1 5 1 1 2 6 1 2 3 7 1 3 4 8 1 [0, 0, 1, 1] A B C d 0 1 5 1 0 1 2 6 1 0 2 3 7 1 1 3 4 8 1 1a.describe()对每一列数据进行统计，包括计数，均值，std，各个分位数等。
# coding=utf-8
import numpy as np
import xgboost as xgb
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.ensemble import RandomForestClassifier
import pandas as pd
import csv
from pandas import DataFrame
data = pd.read_csv('finalData.csv') # 数据文件路径,data 是list
print data.columns.size #'finalData.csv' 文件的列数
print len(data) #'finalData.csv' 文件的行数
df=DataFrame([{'A':'11','B':'12'},{'A':'111','B':'121'},{'A':'1111','B':'1211'}])
print df # df 也是list
print df.columns.size#列数 2
print df.iloc[:,0].size#行数 3
print df.ix[[0]].index.values[0]#索引值 0
print df.ix[[0]].values[0][0]#第一行第一列的值 11
print df.ix[[1]].values[0][1]#第二行第二列的值 121print df.iloc[:,1] # 取所有行，第2列数据
94
165496
A B
0 11 12
1 111 121
2 1111 1211
2
3
0
11
121二、选择对象
1.选择特定列和行的数据
a['x'] 那么将会返回columns为x的列，注意这种方式一次只能返回一个列。a.x与a['x']意思一样。
取行数据，通过切片[]来选择
如：a[0:3] 则会返回前三行的数据。
2.loc是通过标签来选择数据
a.loc['one']则会默认表示选取行为'one'的行；
a.loc[:,['a','b'] ] 表示选取所有的行以及columns为a,b的列；
a.loc[['one','two'],['a','b']] 表示选取'one'和'two'这两行以及columns为a,b的列；
a.loc['one','a']与a.loc[['one'],['a']]作用是一样的，不过前者只显示对应的值，而后者会显示对应的行和列标签。
3.iloc则是直接通过位置来选择数据
这与通过标签选择类似
a.iloc[1:2,1:2] 则会显示第一行第一列的数据;(切片后面的值取不到)
a.iloc[1:2] 即后面表示列的值没有时，默认选取行位置为1的数据;
a.iloc[[0,2],[1,2]] 即可以自由选取行位置，和列位置对应的数据。前两行，第一列的数据
4.使用条件来选择
使用单独的列来选择数据
a[a.c>0] 表示选择c列中大于0的数据
使用where来选择数据
a[a>0] 表直接选择a中所有大于0的数据
使用isin()选出特定列中包含特定值的行
a1=a.copy()
a1[a1['one'].isin(['2','3'])] 表显示满足条件：列one中的值包含'2','3'的所有行。
三、设置值（赋值）
赋值操作在上述选择操作的基础上直接赋值即可。
例a.loc[:,['a','c']]=9 即将a和c列的所有行中的值设置为9
a.iloc[:,[1,3]]=9 也表示将1和2列的所有行中的值设置为9
同时也依然可以用条件来直接赋值
a[a>0]=-a 表示将a中所有大于0的数转化为负值
四、缺失值处理
在pandas中，使用np.nan来代替缺失值，这些值将默认不会包含在计算中。
1.reindex()方法
用来对指定轴上的索引进行改变/增加/删除操作，这将返回原始数据的一个拷贝。
a.reindex(index=list(a.index)+['five'],columns=list(a.columns)+['d'])
a.reindex(index=['one','five'],columns=list(a.columns)+['d'])
即用index=[]表示对index进行操作，columns表对列进行操作。
2.对缺失值进行填充
a.fillna(value=x)
表示用值为x的数来对缺失值进行填充
3.去掉包含缺失值的行
a.dropna(how='any')
表示去掉所有包含缺失值的行
五、合并
1.contact
contact(a1,axis=0/1，keys=['xx','xx','xx',...])，其中a1表示要进行进行连接的列表数据,axis=1时表横着对数据进行连接。axis=0或不指定时，表将数据竖着进行连接。a1中要连接的数据有几个则对应几个keys，设置keys是为了在数据连接以后区分每一个原始a1中的数据。
例：a1=[b['a'],b['c']]
result=pd.concat(a1,axis=1，keys=['1','2'])
2.Append 将一行或多行数据连接到一个DataFrame上
a.append(a[2:],ignore_index=True)
表示将a中的第三行以后的数据全部添加到a中，若不指定ignore_index参数，则会把添加的数据的index保留下来，若ignore_index=Ture则会对所有的行重新自动建立索引。
3.merge类似于SQL中的join
设a1,a2为两个dataframe,二者中存在相同的键值，两个对象连接的方式有下面几种：
(1)内连接，pd.merge(a1, a2, on='key')
(2)左连接，pd.merge(a1, a2, on='key', how='left')
(3)右连接，pd.merge(a1, a2, on='key', how='right')
(4)外连接， pd.merge(a1, a2, on='key', how='outer')
至于四者的具体差别，具体学习参考sql中相应的语法。
1). 基本成员函数
- df.dtypes：会按列给出各个列的数据类型；
df.columns，获取列名，可直接通过
.的形式进行索引；
比如一个 df.columns 的返回值为：
Index([u'dt', u'kind', u'value'], dtype='object')- 1
可直接索引的含义在于，使用
df.dt或者df.kind或者df.value进行索引，获取某列的全部值（ 注，pandas 的特点，以列进行索引和修改）。同时索引多个列以构成一个新的表格，df[['dt', 'value']] # 这样得到的仍然是 dataframe- 1
支持
[]的索引方式，但关键字必须是 list 的形式（['dt', 'value']），而不可以是 tupledf.assign()：指定新的列（如果列名已存在，则替换；如果不存在，在添加该列），返回一个新的 DataFrame，不对原始的 DataFrame 进行修改；
- 当然其也可以接收一个 lambda 型的函数对象，该函数对象接收的参数则是原始的 dataframe；
# 接收 lambda 型函数对象， >> import pandas >> import numpy as np >> df = DataFrame({'A':range(1, 6), 'B':np.random.randn(5)}) >> df.assign(ln_A=lambda x: np.log(x.A)) A B ln_A 0 1 0.456539 0.000000 1 2 1.022736 0.693147 2 3 -0.158207 1.098612 3 4 0.951304 1.386294 4 5 -1.024661 1.609438 # 此时 df 本身并未发生任何改变； >> df.assign(A = range(21, 26)) A B 0 21 0.456539 1 22 1.022736 2 23 -0.158207 3 24 0.951304 4 25 -1.024661- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
set_index()：将某列设置为索引列；
2、numpy 的用法
<< df
a b c
0 0 2 4
1 6 8 10
2 12 14 16
3 18 20 22
4 24 26 28
5 30 32 34
6 36 38 40
7 42 44 46
8 48 50 52
9 54 56 58
1.range()返回的是range object，而np.arange()返回的是numpy.ndarray() range尽可用于迭代，而np.arange作用远不止于此，它是一个序列，可被当做向量使用。
2.range()不支持步长为小数，np.arange()支持步长为小数
3.两者都可用于迭代
4.两者都有三个参数，以第一个参数为起点，第三个参数为步长，截止到第二个参数之前的不包括第二个参数的数据序列
某种意义上，和STL中由迭代器组成的区间是一样的，即左闭右开的区间。[first, last)或者不加严谨地写作[first:step:last)
1）range()函数
- 函数说明： range(start, stop[, step]) -> range object，根据start与stop指定的范围以及step设定的步长，生成一个序列。
参数含义：start:计数从start开始。默认是从0开始。例如range（5）等价于range（0， 5）;
end:技术到end结束，但不包括end.例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
scan：每次跳跃的间距，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)
函数返回的是一个range object
例子：[python] view plain copy -
- >>> range(0,5) #生成一个range object,而不是[0,1,2,3,4]
- [0,1,2,3,4]
- >>> c = [i for i in range(0,5)] #从0 开始到4，不包括5，默认的间隔为1
- >>> c
- [0, 1, 2, 3, 4]
- >>> c = [i for i in range(0,5,2)] #间隔设为2
- >>> c
- [0, 2, 4]
- >>> range(0,1,0.1) #range中的setp 不能使float
- Traceback (most recent call last):
- File ”<pyshell#5>”, line 1, in <module>
- range(0,1,0.1)
- TypeError: ’float’ object cannot be interpreted as an integer
2）arrange()函数
- 函数说明：arange([start,] stop[, step,], dtype=None)根据start与stop指定的范围以及step设定的步长，生成一个 ndarray。 dtype : dtype
The type of the output array. If `dtype` is not given, infer the data
type from the other input arguments.
- >>> np.arange(3)
- array([0, 1, 2])
- >>> np.arange(3.0)
- array([ 0., 1., 2.])
- >>> np.arange(3,7)
- array([3, 4, 5, 6])
- >>> np.arange(3,7,2)
- array([3, 5])
- >>> arange(0,1,0.1)
- array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
3、pandas.loc 选取指定列进行操作
今天发现用pandas里面的数据结构可以减少大量的编程工作，从现在开始逐渐积累，记录一下：
使用标签选取数据：
df.loc[行标签,列标签]
df.loc['a':'b']#选取ab两行数据
df.loc[:,'one']#选取one列的数据df.loc的第一个参数是行标签，第二个参数为列标签（可选参数，默认为所有列标签），两个参数既可以是列表也可以是单个字符，如果两个参数都为列表则返回的是DataFrame，否则，则为Series。
示例代码：
- df.loc[ (df.Cabin.notnull()), 'Cabin' ] = "Yes"
python中pandas库中DataFrame对行和列的操作使用方法
import numpy as np
import pandas as pd
from pandas import Sereis, DataFrame
ser = Series(np.arange(3.))
data = DataFrame(np.arange(16).reshape(4,4),index=list('abcd'),columns=list('wxyz'))
data['w'] #选择表格中的'w'列，使用类字典属性,返回的是Series类型
data.w #选择表格中的'w'列，使用点属性,返回的是Series类型
data[['w']] #选择表格中的'w'列，返回的是DataFrame类型
data[['w','z']] #选择表格中的'w'、'z'列
data[0:2] #返回第1行到第2行的所有行，前闭后开，包括前不包括后
data[1:2] #返回第2行，从0计，返回的是单行，通过有前后值的索引形式，
#如果采用data[1]则报错
data.ix[1:2] #返回第2行的第三种方法，返回的是DataFrame，跟data[1:2]同
data['a':'b'] #利用index值进行切片，返回的是**前闭后闭**的DataFrame,
#即末端是包含的
data.irow(0) #取data的第一行
data.icol(0) #取data的第一列
data.head() #返回data的前几行数据，默认为前五行，需要前十行则data.head(10)
data.tail() #返回data的后几行数据，默认为后五行，需要后十行则data.tail(10)
ser.iget_value(0) #选取ser序列中的第一个
ser.iget_value(-1) #选取ser序列中的最后一个，这种轴索引包含索引器的series不能采用ser[-1]去获取最后一个，这会引起歧义。
data.iloc[-1] #选取DataFrame最后一行，返回的是Series
data.iloc[-1:] #选取DataFrame最后一行，返回的是DataFrame
data.loc['a',['w','x']] #返回‘a’行'w'、'x'列，这种用于选取行索引列索引已知
data.iat[1,1] #选取第二行第二列，用于已知行、列位置的选取。下面是简单的例子使用验证：
import pandas as pd
from pandas import Series, DataFrame
import numpy as np
data = DataFrame(np.arange(15).reshape(3,5),index=['one','two','three'],columns=['a','b','c','d','e'])
data
Out[7]:
a b c d e
one 0 1 2 3 4
two 5 6 7 8 9
three 10 11 12 13 14
#对列的操作方法有如下几种
data.icol(0) #选取第一列
E:\Anaconda2\lib\site-packages\spyder\utils\ipython\start_kernel.py:1: FutureWarning: icol(i) is deprecated. Please use .iloc[:,i]
# -*- coding: utf-8 -*-
Out[35]:
one 0
two 5
three 10
Name: a, dtype: int32
data['a']
Out[8]:
one 0
two 5
three 10
Name: a, dtype: int32
data.a
Out[9]:
one 0
two 5
three 10
Name: a, dtype: int32
data[['a']]
Out[10]:
a
one 0
two 5
three 10
data.ix[:,[0,1,2]] #不知道列名只知道列的位置时
Out[13]:
a b c
one 0 1 2
two 5 6 7
three 10 11 12
data.ix[1,[0]] #选择第2行第1列的值
Out[14]:
a 5
Name: two, dtype: int32
data.ix[[1,2],[0]] #选择第2,3行第1列的值
Out[15]:
a
two 5
three 10
data.ix[1:3,[0,2]] #选择第2-4行第1、3列的值
Out[17]:
a c
two 5 7
three 10 12
data.ix[1:2,2:4] #选择第2-3行，3-5（不包括5）列的值
Out[29]:
c d
two 7 8
data.ix[data.a>5,3]
Out[30]:
three 13
Name: d, dtype: int32
data.ix[data.b>6,3:4] #选择'b'列中大于6所在的行中的第4列，有点拗口
Out[31]:
d
three 13
data.ix[data.a>5,2:4] #选择'a'列中大于5所在的行中的第3-5（不包括5）列
Out[32]:
c d
three 12 13
data.ix[data.a>5,[2,2,2]] #选择'a'列中大于5所在的行中的第2列并重复3次
Out[33]:
c c c
three 12 12 12
#还可以行数或列数跟行名列名混着用
data.ix[1:3,['a','e']]
Out[24]:
a e
two 5 9
three 10 14
data.ix['one':'two',[2,1]]
Out[25]:
c b
one 2 1
two 7 6
data.ix[['one','three'],[2,2]]
Out[26]:
c c
one 2 2
three 12 12
data.ix['one':'three',['a','c']]
Out[27]:
a c
one 0 2
two 5 7
three 10 12
data.ix[['one','one'],['a','e','d','d','d']]
Out[28]:
a e d d d
one 0 4 3 3 3
one 0 4 3 3 3
#对行的操作有如下几种：
data[1:2] #（不知道列索引时）选择第2行，不能用data[1]，可以用data.ix[1]
Out[18]:
a b c d e
two 5 6 7 8 9
data.irow(1) #选取第二行
Out[36]:
a 5
b 6
c 7
d 8
e 9
Name: two, dtype: int32
data.ix[1] #选择第2行
Out[20]:
a 5
b 6
c 7
d 8
e 9
Name: two, dtype: int32
data['one':'two'] #当用已知的行索引时为前闭后闭区间，这点与切片稍有不同。
Out[22]:
a b c d e
one 0 1 2 3 4
two 5 6 7 8 9
data.ix[1:3] #选择第2到4行，不包括第4行，即前闭后开区间。
Out[23]:
a b c d e
two 5 6 7 8 9
three 10 11 12 13 14
data.ix[-1:] #取DataFrame中最后一行，返回的是DataFrame类型,**注意**这种取法是有使用条件的，只有当行索引不是数字索引时才可以使用，否则可以选用`data[-1:]`--返回DataFrame类型或`data.irow(-1)`--返回Series类型
Out[11]:
a b c d e
three 10 11 12 13 14
data[-1:] #跟上面一样，取DataFrame中最后一行，返回的是DataFrame类型
Out[12]:
a b c d e
three 10 11 12 13 14
data.ix[-1] #取DataFrame中最后一行，返回的是Series类型，这个一样，行索引不能是数字时才可以使用
Out[13]:
a 10
b 11
c 12
d 13
e 14
Name: three, dtype: int32
data.tail(1) #返回DataFrame中的最后一行
data.head(1) #返回DataFrame中的第一行
7972
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
