pandas.DataFrame.pivot_table — pandas 0.19.2 documentation
pandas.DataFrame.pivot_table
DataFrame.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
Create a spreadsheet-style pivot table as a DataFrame. The levels in the
pivot table will be stored in MultiIndex objects (hierarchical indexes) on
the index and columns of the result DataFrame
Parameters:data : DataFrame
values : column to aggregate, optional
index : column, Grouper, array, or list of the previous
If an array is passed, it must be the same length as the data. The list
can contain any of the other types (except list).
Keys to group by on the pivot table index.
If an array is passed, it
is being used as the same manner as column values.
columns : column, Grouper, array, or list of the previous
If an array is passed, it must be the same length as the data. The list
can contain any of the other types (except list).
Keys to group by on the pivot table column.
If an array is passed, it
is being used as the same manner as column values.
aggfunc : function or list of functions, default numpy.mean
If list of functions passed, the resulting pivot table will have
hierarchical columns whose top level are the function names (inferred
from the function objects themselves)
fill_value : scalar, default None
Value to replace missing values with
margins : boolean, default False
Add all row / columns (e.g. for subtotal / grand totals)
dropna : boolean, default True
Do not include columns whose entries are all NaN
margins_name : string, default ‘All’
Name of the row / column that will contain the totals
when margins is True.
Returns:table : DataFrame
foo one small
foo one large
foo one large
foo two small
foo two small
bar one large
bar one small
bar two small
bar two large
&&& table = pivot_table(df, values='D', index=['A', 'B'],
columns=['C'], aggfunc=np.sum)R语言系列（50）
转载自：/182577/widget/notes//note//
data.table可以看作是对大家熟悉的R数据格式data.frame的功能的扩展和增强。使用data.table可以对数据集进行快速的索引、指派、按组快速的连接、修正和删除列，以及对大型数据集的快速聚合（e.g. 100GB in RAM[1]）。
使用data.table对大型数据集进行处理可以大大加快编程速度和计算速度。速度的秘诀在于data.table采用了一种类似数据库的索引方式，称之为key。
1.data.table的创建和基本操作
创建一个data.table和创建data.frame很相似。
library(data.table)
# create a data.frame
DF &- data.frame(a = 1:20, b = rep(LETTERS[1:10], 2), c = rep(c(T, F), 10))
# create a data.table
DT &- data.table(a = 1:20, b = rep(LETTERS[1:10], 2), c = rep(c(T, F), 10))
head(DF, 3)
## 1 1 A TRUE
## 2 2 B FALSE
## 3 3 C TRUE
head(DT, 3)
## 1: 1 A TRUE
## 2: 2 B FALSE
## 3: 3 C TRUE
str(DF, 3)
## 'data.frame': 20 obs. of 3 variables:
## $ a: int 1 2 3 4 5 6 7 8 9 10 ...
## $ b: Factor w/ 10 levels &A&,&B&,&C&,&D&,..: 1 2 3 4 5 6 7 8 9 10 ...
## $ c: logi TRUE FALSE TRUE FALSE TRUE FALSE ...
str(DT, 3)
## Classes 'data.table' and 'data.frame': 20 obs. of 3 variables:
## $ a: int 1 2 3 4 5 6 7 8 9 10 ...
## $ b: chr &A& &B& &C& &D& ...
## $ c: logi TRUE FALSE TRUE FALSE TRUE FALSE ...
## - attr(*, &.internal.selfref&)=&externalptr&
看起来数据是一样的，但是在data.frame里，输入的字符型数据会默认转化为因子而在data.table里，字符型数据依然是字符。
也可以把一个已经存在的data.frame转化为data.table。下面采用鸢尾花数据集iris。
iris.dt &- data.table(iris)
## Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1: 5.1 3.5 1.4 0.2 setosa
## 2: 4.9 3.0 1.4 0.2 setosa
## 3: 4.7 3.2 1.3 0.2 setosa
## 4: 4.6 3.1 1.5 0.2 setosa
## 5: 5.0 3.6 1.4 0.2 setosa
## 146: 6.7 3.0 5.2 2.3 virginica
## 147: 6.3 2.5 5.0 1.9 virginica
## 148: 6.5 3.0 5.2 2.0 virginica
## 149: 6.2 3.4 5.4 2.3 virginica
## 150: 5.9 3.0 5.1 1.8 virginica
data.table对于大的数据集只输出前5行和后5行。
对data.table的行的操作，和data.frame是很相似的：
DT[c(1, 6), ]
## 1: 1 A TRUE
## 2: 6 F FALSE
DT[DT$a & 3, ] #DT[DT$a&3,]
## 1: 1 A TRUE
## 2: 2 B FALSE
但是对data.table的列操作和data.frame有很大不同。data.frame可以采用数字或者列名字符(或由它们组成的向量)访问相应的列。data.table可以通过真实列名（或列名向量）以及真实列名列表的方式访问相应的列，在后一种方式下输出的结果会保持data.table的形式。
请比较以下的结果：
# accessing columns data.frame
DF[, c(&a&, &b&)]
## data.table
## [1] &A& &B& &C& &D& &E& &F& &G& &H& &I& &J& &A& &B& &C& &D& &E& &F& &G&
## [18] &H& &I& &J&
DT[, c(a, b)]
DT[, list(b)]
DT[, list(a, b)]
data.table也可以把列名写成字符方式进行引用，此时要加上参数 with=F。请注意这两种使用方式的差别。
DT[, &b&, with = F]
str(DT[, &b&, with = F])
## Classes 'data.table' and 'data.frame': 20 obs. of 1 variable:
## $ b: chr &A& &B& &C& &D& ...
## - attr(*, &.internal.selfref&)=&externalptr&
str(DT[, &b&])
## chr &b&
看一下现在在内存中的data.table
## NAME NROW MB
## [1,] DT 20 1&
## [2,] iris.dt 150 1&
## COLS KEY
## [1,] a,b,c&
## [2,] Sepal.Length,Sepal.Width,Petal.Length,Petal.Width,Species&
## Total: 2MB
这里显示了data.table的名字、行数、MB的大小，列名以及KEY（尚未指派，是空的）。
key用来对data.table索引，能提供更快的计算速度。使用key的时候，需要使用setkey函数进行设置。可以把一个或多个列名设置为key。
# set one key
setkey(DT, b)
# show the DT again
## 1: 1 A TRUE
## 2: 11 A TRUE
## 3: 2 B FALSE
## 4: 12 B FALSE
## 5: 3 C TRUE
## 6: 13 C TRUE
## 7: 4 D FALSE
## 8: 14 D FALSE
## 9: 5 E TRUE
## 10: 15 E TRUE
## 11: 6 F FALSE
## 12: 16 F FALSE
## 13: 7 G TRUE
## 14: 17 G TRUE
## 15: 8 H FALSE
## 16: 18 H FALSE
## 17: 9 I TRUE
## 18: 19 I TRUE
## 19: 10 J FALSE
## 20: 20 J FALSE
此时DT这个data.table的b这一列已经被排序了。
key的用途之一是便于对data.table的行进行索引
DT[c(&A&, &D&), ]
## 1: A 1 TRUE
## 2: A 11 TRUE
## 3: D 4 FALSE
## 4: D 14 FALSE
这种检索比data.frame式的按照行的数字或表达式进行索引的运算速度要快(速度快的原因是data.frame式的索引是一种向量的扫描，即通过生成一个对每一行标记了TRUE/FALSE的向量实现的)。在较大的数据集diamonds（其实也很小，5w多行）来试一下。
library(ggplot2)
dia.dt &- data.table(diamonds)
system.time(dia.dt[dia.dt$color == &E&, ])
## user system elapsed&
## 0.004 0.000 0.006
setkey(dia.dt, color)
system.time(dia.dt[&E&, ])
## user system elapsed&
## 0.004 0.000 0.003
sessionInfo()
## R version 3.1.0 ()
## Platform: x86_64-pc-linux-gnu (64-bit)
当设置的key多于一个的时候，函数J（）可以用来设置索引条件：
setkey(DT, b, c)
DT[J(c(&A&, &B&), TRUE), ]
## 1: A TRUE 1
## 2: A TRUE 11
## 3: B TRUE NA
注：部分输出结果省略
3.data.table的基本用法
dt[i, j]：
&如果i不是一个data.table，执行的是类似data.frame的行的子集索引；
&如果i是一个data.table，就把i和dt的key进行连接（join），效果相当于插入；&
j可以是一个单独的列名，列名的表达式，或者列名表达式的列表，函数引用。
iris.dt &- data.table(iris)
iris.dt[, plot(Sepal.Length, Sepal.Width)]
by='colname',
&mult={'first', 'last', 'all'},&
nomatch={0, NA},&
roll={FALSE, TRUE}]
by对应分组操作变量名；
当dt的多个行与i匹配的时候，mult控制返回的方式；
&nomatch设定匹配方式，默认是内连接inner join（0），外连接outer join则设为NA； 当对一个时间序列进行匹配的时候，roll=TRUE可以通过选择之前最接近的时间进行不完全的匹配。
下面引用统计之都上的一个例子()：
a = data.frame(startdate = c(as.Date(&&), as.Date(&&)), enddate = c(as.Date(&&),&
&&&&as.Date(&&)), value = c(1, 2))
b = data.frame(date = seq.Date(as.Date(&&), by = &months&, length = 26))
a = data.table(a)
b = data.table(b)
setkey(a, startdate, enddate)
setkey(b, date)
a[b, ][c(1:4, 23:26)]
## startdate enddate value
a[b, roll = TRUE][c(1:4, 23:26)]
## startdate enddate value
关于data.table的基本操作也请参考： example(data.table)
4.使用data.table进行快速的分组计算
对数据的分组操作往往是进行一项数据分析工作必不可少的阶段。对于data.frame，有诸如stats包的aggregate函数，base包的apply族函数，plyr包的*ply族等适用的函数。data.tablen内置的分组计算函数，可以提高分组计算的速度。以ggplot2包的diamonds数据为例,按变量cut分组，对变量price求均值。分别使用aggregate,ddply和data.table,并比较运算时间。
str(diamonds)
## 'data.frame': 53940 obs. of 10 variables:
## $ carat : num 0.23 0.21 0.23 0.29 0.31 0.24 0.24 0.26 0.22 0.23 ...
## $ cut : Ord.factor w/ 5 levels &Fair&&&Good&&..: 5 4 2 4 2 3 3 3 1 3 ...
## $ color : Ord.factor w/ 7 levels &D&&&E&&&F&&&G&&..: 2 2 2 6 7 7 6 5 2 5 ...
## $ clarity: Ord.factor w/ 8 levels &I1&&&SI2&&&SI1&&..: 2 3 5 4 2 6 7 3 4 5 ...
library(plyr)
aggregate(price ~ cut, diamonds, mean)
## cut price
## 1 Fair 4359
## 2 Good 3929
## 3 Very Good 3982
## 4 Premium 4584
## 5 Ideal 3458
ddply(diamonds, .(cut), summarise, price.mean = mean(price))
## cut price.mean
## 1 Fair 4359
## 2 Good 3929
## 3 Very Good 3982
## 4 Premium 4584
## 5 Ideal 3458
dia.dt &- data.table(diamonds)
dia.dt[, list(price.mean = mean(price)), by = cut]
## cut price.mean
## 1: Ideal 3458
## 2: Premium 4584
## 3: Good 3929
## 4: Very Good 3982
## 5: Fair 4359
system.time(aggregate(price ~ cut, diamonds, mean))
## user system elapsed&
## 0.320 0.000 0.323
system.time(ddply(diamonds, .(cut), summarise, price.mean = mean(price)))
## user system elapsed&
## 0.012 0.000 0.012
system.time(dia.dt[, list(price.mean = mean(price)), by = cut])
## user system elapsed&
## 0.004 0.000 0.002
在这三种方法里data.table的运算速度是最快的。在上面的data.table中参数list(price.mean=mean(price))的含义是对变量price求均值，并把结果命名为price.mean。
使用data.table也可以对多个列进行分组计算：
dia.dt[, list(carat.max = max(carat), price.min = min(price)), by = list(cut,&
&&&&color)]
## cut color carat.max price.min
## 1: Ideal E 2.28 326
## 2: Premium E 3.05 326
## 3: Good E 3.00 327
## 4: Premium I 4.01 334
## 5: Good J 3.00 335
## 6: Very Good J 2.74 336
## 7: Very Good I 4.00 336
## 8: Very Good H 3.00 337
## 9: Fair E 2.04 337
## 10: Ideal J 3.01 340
## cut color carat.max price.min
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：199862次
积分：2639
积分：2639
排名：第12093名
转载：373篇如何拆分数据框列到多列-python,pandas,dataframes-CodeGo.net
如何拆分数据框列到多列
经过多次敦促下，我开始迁移我的ř脚本的Python。我的大部分在研究工作中所涉及的数据和我DataFrame从熊猫包对象。在我的剧本，我需要读取一个CSV文件，并导入数据到DataFrame对象。接下来，我需要转换的十六进制值转换成标柱DATA进位运算的数据，然后创建16个新栏目，每个位。
在我的文件例如输入数据test.txt如下所示 CodeGo.net，
前缀测试，区，行，列，数据
6_6，READ，0，0，0，BFED
6_6，READ，0，1，0，BB7D
6_6，读，0，2，0，FFF7
6_6，读，0，3，0，E7FF
6_6，READ，0,4，0，FBF8
6_6，READ，0,5，0，DE75
6_6，READ，0,6，0，DFFE
我的Python脚本test.py如下所示，
import glob
import pandas as pd
import numpy as np
fname = 'test.txt'
df = pd.read_csv(fname, comment="#")
dfs = df[df.TEST == 'READ']
# function to convert the hexstring into a binary string
def hex2bin(hstr):
return bin(int(hstr,16))[2:]
# convert the hexstring in column DATA to binarystring ROWDATA
dfs['BINDATA'] = dfs['DATA'].apply(hex2bin)
# get rid of the column DATA
del dfs['DATA']
当我运行这个脚本，并检查对象dfs，我得到以下，
PREFIX测试区排COL BINDATA
0 6_6阅读0 0 0 1101
1 6_6阅读0 1 0 1101
2 6_6阅读0 2 0 0111
3 6_6阅读0 3 0 1111
4 6_6阅读0 4 0 1000
5 6_6阅读0 5 0 0101
6 6_6阅读0 6 0 1110
所以，现在我不知道如何分割列BINDATA为16个新列（可能是B0，B0，B2，...，B15）。任何帮助将不胜感激。
感谢和放大器;的问候，
本文地址 ：CodeGo.net/9077276/
-------------------------------------------------------------------------------------------------------------------------
1.我不知道这是否可以做简单的（不循环），但这招：
for i in range(16):
dfs['B'+str(i)] = dfs['BINDATA'].str[i]
该str在这种情况下，我们只是指数的字符串存取权限的不同角色。
In [20]: dfs
BINDATA B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12 B13 B14 B15
1 1 1 1 1 1 1 1 1 0 1 1 0 1
1 1 1 0 1 1 0 1 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1 0 1 1 1
1 0 0 1 1 1 1 1 1 1 1 1 1 1
1 1 1 0 1 1 1 1 1 1 1 0 0 0
0 1 1 1 1 0 0 1 1 1 0 1 0 1
0 1 1 1 1 1 1 1 1 1 1 1 1 0
如果你希望他们为整数，而不是字符串，可以添加.astype(int)在for循环。
编辑：另一种方式来做到这一点（一oneliner，但是你要更改列在第二个步骤）：
In [34]: splitted = dfs['BINDATA'].apply(lambda x: pd.Series(list(x)))
In [35]: splitted.columns = ['B'+str(x) for x in splitted.columns]
In [36]: dfs.join(splitted)
BINDATA B0 B1 B2 B3 B4 B5 B6 B7 B8 B9 B10 B11 B12 B13 B14 B15
1 1 1 1 1 1 1 1 1 0 1 1 0 1
1 1 1 0 1 1 0 1 1 1 1 1 0 1
1 1 1 1 1 1 1 1 1 1 0 1 1 1
1 0 0 1 1 1 1 1 1 1 1 1 1 1
1 1 1 0 1 1 1 1 1 1 1 0 0 0
0 1 1 1 1 0 0 1 1 1 0 1 0 1
0 1 1 1 1 1 1 1 1 1 1 1 1 0
这里是你如何能做到这一点没有一个循环（但不是真的，因为有很多隐含的循环在这段代码）：
import pandas as pd
# read the above frame from the clipboard
df = pd.read_clipboard(converters={'BINDATA': str})
df = df.fillna(nan).replace('None', nan).dropna(axis=0, how='all')
# here are the lines that matter
bindata = df.BINDATA.apply(list).apply(Series)
bindata.columns = bindata.columns.map('B{0}'.format)
res = pd.concat([df, bindata], axis=1).convert_objects(convert_numeric=True)
本文标题 ：如何拆分数据框列到多列
本文地址 ：CodeGo.net/9077276/
Copyright (C) 2014 CodeGo.netPython 数据处理扩展包： pandas 模块的DataFrame介绍（创建和基本操作）
我的图书馆
Python 数据处理扩展包： pandas 模块的DataFrame介绍（创建和基本操作）
DataFrame是Pandas中的一个表结构的数据结构，包括三部分信息，表头（列的名称），表的内容（二维矩阵），索引（每行一个唯一的标记）。一、DataFrame的创建有多种方式可以创建DataFrame，下面举例介绍。例1： 通过list创建&&& import pandas as pd
&&& df = pd.DataFrame([[1,2,3],[4,5,6]])
[2 rows x 3 columns]上面代表，创建了一个2行3列的表格，创建时只指定了表格的内容（通过一个嵌套的list），没有指定列名和索引。这时列名就自动为 0,1,2 ；索引自动为数值0,1.我们可以指定列表和索引，如：&&& df = pd.DataFrame([[1,2,3],[4,5,6]],index=['row1','row2'],columns=['c1','c2','c3'])
[2 rows x 3 columns]可以看出，上面代码通过index和 columns参数指定了索引和列名。例2：创建例子&&& import numpy as np
&&& dates = pd.date_range('',periods=6)
&&& df = pd.DataFrame(np.random.randn(6,4) , index = dates,columns=list('abcd'))
-0....507129
-1....909333
0....572577
0....183397
1....202499
1....647935
[6 rows x 4 columns]上面代码创建的dates是个时间索引，np.random.randn 方法创建一个6行4列的随机数矩阵。最后的df使用 dates作为索引，使用np.random.randn 方法创建的矩阵作为内容，使用 list('abcd'）作为列名。&二、&DataFrame的一些基本操作&1、获取数据的行数len(df)或len(df.index)&2、显示索引、列和底层的numpy数据&&& df.index
&class 'pandas.tseries.index.DatetimeIndex'&
Length: 6, Freq: D, Timezone: None
&&& df.columns
Index([u'a', u'b', u'c', u'd'], dtype='object')
&&& df.values
array([[-0.2362202 ,
[-1., -1., -0.,
[ 0., -0.,
[ 0., -0., -0.6157519 , -1.],
[ 1., -1.,
[ 1., -2.,
1.]])说明，这个例子中的df使用的是上面创建的 DataFrame对象&3、显示数据df.head([n])& # 获取df中的前n行数据，n不指定，则默认为5df.tail([n])& # 获取df中的后n行数据，n不指定，则默认为5&&& dates = pd.date_range('',periods=100)
&&&df = pd.DataFrame(np.random.randn(100,4) , index = dates,columns=list('abcd' ))
&&& df.head()
-1....742626
0....517350
-0....659187
-1....160796
0....861413
[5 rows x 4 columns]
&&& df.tail()
-0....130948
-1....050591
0....463706
-0....257376
0....658781注意，head 和 tail 返回的是一个新的dataframe，与原来的无关&&4、按照索引排序newdf = df.sort_index(ascending=False,inplace=True)ascending=False 参数指定按照索引值的以降序方式排序，默认是以升序排序。inplace=True 指定为True时，表示会直接对df中的数据进行排序，函数返回值为None，newdf的值为None；如果不设置为True（默认为false），则不会对df中数据进行修改，会返回一个新的df，这时newdf就有内容，是一个新的排序后的df。&5、添加数据(append方法)&append方法可以添加数据到一个dataframe中，注意append方法不会影响原来的dataframe，会返回一个新的dataframe。语法：DataFrame.append(otherData,&ignore_index=False,&verify_integrity=False)&其中otherData参数是要添加的新数据，支持多种格式。ignore_index 参数默认值为False，如果为True，会对新生成的dataframe使用新的索引（自动产生），忽略原来数据的索引。verify_integrity参数默认值为False，如果为True，当ignore_index为False时，会检查添加的数据索引是否冲突，如果冲突，则会添加失败。举例说明1：dates = pd.date_range('',periods=10)
df = pd.DataFrame(np.random.randn(10,4) , index = dates,columns=list('abcd'))
dates1 = pd.date_range('',periods=2)
df1 = pd.DataFrame(np.random.randn(2,4) , index = dates1,columns=list('abcd'))
df.append(df1) # df1中的2行数据会加到df中，且新产生的df的各行的索引就是原来数据的索引
df.append(df1,ignore_index=True) # df1中的2行数据会加到df中，且新产生的df的索引会重新自动建立
df.append(df1,verify_integrity=True) #会报错，因为df1的索引和df2的索引冲突了说明，df1的列名必须和df一致，否则不是简单的添加行。而是会添加列，再添加行。举例2：&&& df.append({'a':10,'b':11,'c':12,'d':13},ignore_index=True)
10....000000上面代码是新产生的df会添加一行。这种操作，ignore_index参数值必须设置为True，否则会报错。举例3：&&& df.append({'e':10},ignore_index=True)
-0....640439 NaN
-0....179076 NaN
1....119433 NaN
0....048248 NaN
1....035601 NaN
0....931670 NaN
0....583740 NaN
-0....005968 NaN
0....377950 NaN
-1....738701 NaN
10可以看出，如果插入的数据，指定的列名不存在，新产生的df不仅会增加行，还会增加列。6、遍历数据&示例代码如下for index,row in df.iterrows():
print index #获取行的索引
print row.a #根据列名获取字段
print row[0]#根据列的序号（从0开始）获取字段7、查找数据创建如下的dataframedates = pd.date_range('',periods=10)df = pd.DataFrame(np.random.randn(10,4) , index = dates,columns=list('abcd'))可以有各种方式获取df中的全部或部分数据df['a']& #按照列名获取指定的列，返回的是一个Series，其中key是索引，value是该列对应的字段值df[:2] #获取前2行数据，效果等同 df[0:2]，返回的是一个新的dataframedf[2:5] #获取第3行~5行 这3条记录，返回的是一个新的dataframedf.loc[''] #获取指定索引的行，等同于 &df.loc['']，返回的是一个Series，其中key是列名，value是该列对应的字段值df.iloc[3]& #获取指定序号的行，这里是第4行&8、删除数据del df['a']& #删除dataframe中指定的列，这个是直接影响当前的dataframe，注意 del不是函数，是python中的内置语句，没有返回值df.drop(['a'],axis=1)& #删除指定的列，与上面的区别是不会影响原来的dataframe，dop方法会返回一个删除了指定列的新的dataframe说明，dop方法既可以删除列，也可以删除行，但上面创建的df无法被删除行（?），下面这个例子可以删除行data = pd.DataFrame(np.arange(16).reshape((4, 4)),index=['Ohio', 'Colorado', 'Utah', 'New York'],columns=['one', 'two', 'three', 'four'])
data.drop(['Colorado', 'Ohio'])上面代码中的dop方法删除了指定索引的两行，注意同删除列一样，drop方法不会影响原来的dataframe，会返回一个删除后的新的dataframe&9、增加列例子代码如下dates = pd.date_range('',periods=10)
df = pd.DataFrame(np.random.randn(10,3) , index = dates,columns=list('abc'))
df['d'] = pd.Series(np.random.randn(10),index=df.index)上面代码先是创建了一个dataframe，然后通过df['d'] 插入了一个新的列。如果指定的列名存在，会修改列的内容。&10、修改指定行或单元格数据df.values[i][j]= xxx& #其中i是行号，j是列号，都是从0开始df.values[1]=12& # 会把一行中的所有列中的数据设置为同一个值，这里的参数1是序号，这里为第2行数据df['a'] = 12& #这样会把指定列的所有数据都设置为同一个值，如这里的12。注意，如果指定的列名不存在，会新增列&11、插入行前面介绍的append方法是产生一个新的 dataframe，不会改变原来的dataframe。那有没有办法直接在当前的frame中插入一行数据呢？& 上面介绍的 df[列名] = xxx 是用来插入或修改列的信息。
TA的推荐TA的最新馆藏[转]&Data Science 入门测试解读（一）
这篇文章里包含了测试题的1-10题，小言在每道题前，都会附上原始数据，你可以试试，不看答案，能做出几道。几乎每道题都有各个选项的输出结果，以及分析，帮助你理解这个知识点。Dataframe named “df5”（Q10除外）Q：1）数据处理（类型区分）因为DataFrame里混合着类别特征列和连续数据特征列，每一个数据科学家需要知道怎么区别处理它们。那么如何计算列表里类别特征列的数量？A (df5.dtype == ‘object’).sum()B (df5.dtypes == object).sum()C (df5.dtypes == object).count()A'DataFrame' object has no attribute 'dtype'B8C13答案：B解读：当df中既有连续数据又有类别时，所有数据的类别被改为“object”每一列都有自己的dtype,df5.dtypes == object就是判断每一列的类型是否是objectsum()计算所有是object的列的数量，初看，只发现有7列object,但是打印出来：会发现Dependents是object,再看df5中该'Dependents'列都是数字，那么再去查原数据文件因为我取的是前5行，在第9行却出现了3+。那么可以推测在读取CSV文件时，每一列的类型就确定了，不会因取的前几行而改变。count()返回的是非null列的数量，在这里就是所有列的数量了，经过实验，即使有一列的值全是NaN,count仍然会把这一列当成非null列。Q:2) 数据处理（统计类别）找出在“Property_Area”类别列里的所有的类别A df5.Property_Area.indiviuals()B df5.Property_Area.distinct()C df5.Property_Area.unique()A'Series' object has no attribute 'indiviuals'B'Series' object has no attribute 'distinct'C['Urban' 'Rural']答案：C解读：经过搜索panda文档，文档中没有indiviuals()和distinct()，而unique的返回值是一个矩阵，可以索引。Q:3) 缺失值（寻找）有的列中会缺少值，那么请找出“LoanAmount”列中有多少缺失值？A df5.count().maximum()-df5.LoanAmount.count()B (df5.LoanAmount == NaN).sum()C (df5.isnull().sum()).LoanAmountA'Series' object has no attribute 'maximum'Bname 'NaN' is not definedC1答案：C解读：将A选项中，maximum()修改为max(),就对了，DataFrame的count()是计算每一列的非Nan数，返回的是个serial.serial的count()是计算该列的非NaN数，但是不建议这么计算缺失值个数，还是用选项C这种直接的方式更可靠在B选项中，可以看出NaN不能按照数值来使用。在C选项中，df5.isnull()返回的是一个Dataframe.然后sum()得到每一列的和,返回一个serial所以.LoanAmount就得到该索引的指。想对而言，还是C选项比较好，不容易出错。Q：4）处理缺失值-方法一（删除所在行）在Dataframe中的一些列里（“LoanAmount”）有缺失的值，如何把有缺失值的那一行去掉？A new_dataframe = df5[~df5.LoanAmount.isnull()]B new_dataframe = df5[df5.LoanAmount.isna()]C new_dataframe = df5[df5.LoanAmount.is_na()]AB'Series' object has no attribute 'isna'C'Series' object has no attribute 'is_na'答案：A解读：isnull()将列表的对应位置变成布尔值，然后取反但是放到df5[]中，就能滤掉false那一行，这是Dataframe的bool值索引的使用。Q：5）处理缺失值-方法二（删除缺失n个值以上的行）在DataFrame里，有一些行中，缺失了大量信息，那么就需要移除这些行。那么假设我们规定只要是缺失了超过0个值的行,即只要有一个缺失值就删除（因为我们的数据里只有一行缺失了一个值），就要移除。那么怎么做到呢？A temp = df5.dropna(axis = 0, how = ‘any’, thresh = 0)B temp = df5.dropna(axis = 0, how = ‘all’, thresh = 0)C temp = df5.dropna(axis = 0, how = ‘any’, thresh = df5.shape[ 1 ] - 0)ABC答案：C解读：dropna()函数，axis = 0 :行，axis = 1 :列；how = ‘any’ :该行或该列至少有thresh个非NaN时，将其保留， how = ‘all’ :仅在该行或该列全为NaN时，才抛弃该行（列）df5.shape返回一个列表，说明DataFrame的维度,结果如下。(5, 13)df5.shape[1]即列数，thresh = df5.shape[1] - 0 = 13 ,即至少有13个非NaN的行，才会被保留。Q：6）数据处理（类别合并）在整理数据的时候，你会发现在’Property_Area’这一列里，是Rural的行很少（原文里是Semiurban,但是我这里的数据没有Semiurban）,那么经过分析，可以把Rural和Urban合并成新类别City(这里不太合理，但是学会技术就好了)，怎么操作呢？A turn_dict = [‘Urban’ : ‘City’, ‘Rural’ : ‘City’] &df5.loc[ : , ‘Property_Area’] = df5.Property_Area . replace(turn_dict)B turn_dict = {‘Urban’ : ‘City’, ‘Rural’ : ‘City’} &df5.loc[ : , ‘Property_Area’] = df5.Property_Area . replace(turn_dict)C turn_dict = {‘Urban’ : ‘City’, ‘Rural’ : ‘City’} &df5.loc[ : , ‘Property_Area’] = df5.Property_Area . update(turn_dict)Ainvalid syntaxBC'dict' object has no attribute 'reindex_like'答案：B解读由上方的输出可知，df5.Property_Area是个serial, 而serial.update()的参数只能是serial,将serial完全替换：而serial.replace()的参数可以是dict,与update()相比，可以选则一部分替换，但是还需要赋值到df5.loc[]里，否则是无效的，如下：Q：7）数据分析（多条件统计）在看这些数据的时候，你会发现女性结婚的人的比例好像比较高，那么计算一下真实的比例。A (df5.loc[(df5.Gender == ‘male’) && (df5.Married == ‘yes’)].shape [ 1 ] / float(df5.shape[0]))
100B (df5.loc[(df5.Gender == ‘Male’) & (df5.Married == ‘Yes’)].shape[ 1 ] / float(df5.shape[0]))
100C (df5.loc[(df5.Gender == ‘male’) and (df5.Married == ‘yes’)].shape[ 0 ] / float(df5.shape[0])) * 100D None of theseAinvalid syntaxB260CThe truth value of a Series is ambiguous.答案：D解读：loc[]函数用标签来索引，loc[ : , : ] 逗号前是行索引，逗号后是列索引。若是只有一个参数，则是索引行（row）的，因为单参数索引列（column）是用df5[‘Gender’]：loc[]里也可以放bool值的列表：而df5.Gender == ‘Male’) & (df5.Married == ‘Yes’)得到的是个bool值列表：所以正确的表达是：Q：8）数据处理（训练数据和测试数据的columns不一致）如果你发现，给你提供的训练数据和测试数据的columns不一致，怎么找出那些在测试数据中，不在训练数据中的column? 测试数据的clomns如下：Loan_ID、Gender、 Married、Dependents、Education、 & Self_Employed、AgeA &set( test .columns ) .difference( set( df5 .columns ) )B &set( test .columns .tolist() ) - set(df5. columns. tolist())C &set(df5 .columns .tolist() ). difference(set(test. columns. tolist() ) )D &Both A and BAset(['Age'])Bset(['Age'])C答案：D解读set()是建立一个无序不重复集合，set(a).difference(set(b))→返回一个新的 set 包含 a 中有但是 b 中没有的元素index.tolist()返回一个index值组成的列表set(a)-set(b)→跟difference的作用一样。C选项错的原因是得到的是df5里有，test里没有的，恰恰相反。Q：9）数据处理（类型变量转换为数值型变量）有时候我们需要把类别类型列表下的各种类型数值化，方便算法使用数据。例如，如何把’Education’列表下的Graduate→1、Not Graduate→0 ？A - df5.ix[:, ‘Education’] = df5.Education.applymap({‘Graduate’:1,’Not Graduate’:0}).astype(int)B - df5.ix[:, ‘Education’] = df5.Education.map({‘Graduate’:1,’Not Graduate’:0}).astype(int)C - df5.ix[:, ‘Education’] = df5.Education.apply({‘Graduate’:1,’Not Graduate’:0}).astype(int)看到这道题的时候，是不是有点熟悉，再回过头看看第6题，我们先试试用第6题的方法，能不能解决这个问题：可以看出，完全正确。我们再来看这道题的方法。A'Series' object has no attribute 'applymap'BC'dict' object is not callable答案：B解读df5.ix[:,:]与df5.loc[:,:]的区别在于，ix[]可以用数字和lable混合索引，而loc[]只能用lable索引a.map(b)将b的指给a ,b可以是serial,也可以是dict，感觉跟replace差不多。.astype(int)强制将该serial的数据类型转换为intQ：10）数据处理（训练数据、测试数据的’类别列’ 数据存在差异）如图，上方是训练数据，下方是测试数据。它们 Product_ID 列的数据并不是在同一个集合，那么，在测试时有的 Product_ID 没有历史数据，就会带来麻烦。问题：如何确定test里的Product_ID都有历史数据，即是否在train里都出现过？因为没有原始数据，只取图片里的前三行建成DataFrameA - train.Product_ID.unique().contains(test.Product_ID.unique())B - set(test.Product_ID.unique()).issubset(set(train.Product_ID. unique()))C - train.Product_ID.unique() = test.Product_ID.unique()答案B（1）分析column.unique() : 得到这个column 的所有种类，返回数组print train.Product_ID.unique()
['P' 'P' 'P']set()：建立无序不重复集合s.issubset(t) ： s &= t &# 测试是否 s 中的每一个元素都在 t 中其实，这道题无须使用unique(),因为set()直接可以生成一个无序不重复的集合。（2）运行结果AAttributeError: 'numpy.ndarray' object has no attribute 'contains'BFalseCSyntaxError: invalid syntax
房产手机ERP最新文章
微信号：tkggwcw330027扫描二维码关注公众号
房上房中介管理系统手机ERP,使经纪人脱离电脑,解放出来,移动办公,效益提高一倍以上
Copyright2017.杨邱自媒体资讯站，让大家及时掌握各行各业第一手资讯新闻！