blocks|key|197112|text|您可以将apply应用于原始数据的子集。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|197113|+dat+<-+data.frame(x=c(1,2),+y=c(3,4),+z=c(5,6))
+apply(dat[,c('x','z')],+1,+function(x)+sum(x)+)|code-block|syntax|javascript|197114|或者，如果您的函数只是sum，请使用矢量化版本：|197115|rowSums(dat[,c('x','z')])
[1]+6+8|197116|如果您想使用testFunc|197117|+testFunc+<-+function(a,+b)+a+%2B+b
+apply(dat[,c('x','z')],+1,+function(x)+testFunc(x[1],x[2]))|197118|编辑要按名称而不是按索引访问列，您可以执行以下操作：|BOLD|197119|+testFunc+<-+function(a,+b)+a+%2B+b
+apply(dat[,c('x','z')],+1,+function(y)+testFunc(y['z'],y['x']))|197120|entityMap^0|4|5|0|0|0|0|6|8|0|0|0|2|0|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|15|8|@$9|16|A|17|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|19|8|@$9|1A|A|1B|B|U]]|D|@]|E|$]]|$1|V|3|W|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|X|3|-4|5|6|7|1D|8|@]|D|@]|E|$]]]|Y|$]]

You can apply <code>apply</code> to a subset of the original data.

<pre><code> dat &lt;- data.frame(x=c(1,2), y=c(3,4), z=c(5,6))
 apply(dat[,c('x','z')], 1, function(x) sum(x) )
</code></pre>

or if your function is just sum use the vectorized version:

<pre><code>rowSums(dat[,c('x','z')])
[1] 6 8
</code></pre>

If you want to use <code>testFunc</code>

<pre><code> testFunc &lt;- function(a, b) a + b
 apply(dat[,c('x','z')], 1, function(x) testFunc(x[1],x[2]))
</code></pre>

EDIT To access columns by name and not index you can do something like this:

<pre><code> testFunc &lt;- function(a, b) a + b
 apply(dat[,c('x','z')], 1, function(y) testFunc(y['z'],y['x']))
</code></pre>

blocks|key|2823940|text|许多函数已经矢量化了，因此不需要任何迭代(既不需要for循环也不需要*pply函数)。你的testFunc就是这样一个例子。您可以简单地调用：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2823941|++testFunc(df[,+"x"],+df[,+"z"])|code-block|syntax|javascript|2823942|一般来说，我建议先尝试这种矢量化方法，看看它们是否能得到您想要的结果。|2823943|2823944|或者，如果您需要将多个参数传递给一个未矢量化的函数，那么mapply可能就是您要寻找的：|2823945|++mapply(power.t.test,+df[,+"x"],+df[,+"z"])|2823946|entityMap^0|P|3|Y|5|19|8|0|0|0|0|S|6|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@]|D|@]|E|$]]|$1|M|3|-4|5|6|7|12|8|@]|D|@]|E|$]]|$1|N|3|O|5|6|7|13|8|@$9|14|A|15|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|H|7|16|8|@]|D|@]|E|$I|J]]|$1|R|3|-4|5|6|7|17|8|@]|D|@]|E|$]]]|S|$]]

Many functions are vectorization already, and so there is no need for any iterations (neither <code>for</code> loops or <code>*pply</code> functions). Your <code>testFunc</code> is one such example. You can simply call: 

<pre><code> testFunc(df[, "x"], df[, "z"])
</code></pre>

In general, I would recommend trying such vectorization approaches first and see if they get you your intended results. 

<hr>

Alternatively, if you need to pass multiple arguments to a function which is not vectorized, <code>mapply</code> might be what you are looking for: 

<pre><code> mapply(power.t.test, df[, "x"], df[, "z"])
</code></pre>

blocks|key|2823951|text|使用mapply|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2823952|>+df+<-+data.frame(x=c(1,2),+y=c(3,4),+z=c(5,6))
>+df
++x+y+z
1+1+3+5
2+2+4+6
>+mapply(function(x,y)+x%2By,+df$x,+df$z)
[1]+6+8

>+cbind(df,f+=+mapply(function(x,y)+x%2By,+df$x,+df$z)+)
++x+y+z+f
1+1+3+5+6
2+2+4+6+8|code-block|syntax|javascript|2823953|entityMap^0|2|6|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use <code>mapply</code>

<pre><code>&gt; df &lt;- data.frame(x=c(1,2), y=c(3,4), z=c(5,6))
&gt; df
 x y z
1 1 3 5
2 2 4 6
&gt; mapply(function(x,y) x+y, df$x, df$z)
[1] 6 8

&gt; cbind(df,f = mapply(function(x,y) x+y, df$x, df$z) )
 x y z f
1 1 3 5 6
2 2 4 6 8
</code></pre>

blocks|key|3036695|text|@user20877984的答案非常好。由于他们的总结比我之前的答案要好得多，下面是我(可能仍然是粗制滥造的)应用这个概念的尝试：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3036696|以基本方式使用do.call：|offset|length|style|CODE|3036697|powvalues+<-+list(power=0.9,delta=2)
do.call(power.t.test,powvalues)|code-block|syntax|javascript|3036698|处理完整的数据集：|3036699|#+get+the+example+data
df+<-+data.frame(delta=c(1,1,2,2),+power=c(.90,.85,.75,.45))

#>+df
#++delta+power
#1+++++1++0.90
#2+++++1++0.85
#3+++++2++0.75
#4+++++2++0.45|3036700|将power.t.test函数lapply到具有指定值的每一行：|3036701|result+<-+lapply(
++split(df,1:nrow(df)),
++function(x)+do.call(power.t.test,x)
)

>+str(result)
List+of+4
+$+1:List+of+8
++..$+n++++++++++:+num+22
++..$+delta++++++:+num+1
++..$+sd+++++++++:+num+1
++..$+sig.level++:+num+0.05
++..$+power++++++:+num+0.9
++..$+alternative:+chr+"two.sided"
++..$+note+++++++:+chr+"n+is+number+in+*each*+group"
++..$+method+++++:+chr+"Two-sample+t+test+power+calculation"
++..-+attr(*,+"class")=+chr+"power.htest"
+$+2:List+of+8
++..$+n++++++++++:+num+19
++..$+delta++++++:+num+1
++..$+sd+++++++++:+num+1
++..$+sig.level++:+num+0.05
++..$+power++++++:+num+0.85
...+...|3036702|entityMap^0|0|7|7|0|0|0|0|1|C|F|6|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@$D|Y|E|Z|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|13|8|@$D|14|E|15|F|G]|$D|16|E|17|F|G]]|9|@]|A|$]]|$1|S|3|T|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

@user20877984's answer is excellent. Since they summed it up far better than my previous answer, here is my (posibly still shoddy) attempt at an application of the concept:

Using <code>do.call</code> in a basic fashion:

<pre><code>powvalues &lt;- list(power=0.9,delta=2)
do.call(power.t.test,powvalues)
</code></pre>

Working on a full data set:

<pre><code># get the example data
df &lt;- data.frame(delta=c(1,1,2,2), power=c(.90,.85,.75,.45))

#&gt; df
# delta power
#1 1 0.90
#2 1 0.85
#3 2 0.75
#4 2 0.45
</code></pre>

<code>lapply</code> the <code>power.t.test</code> function to each of the rows of specified values:

<pre><code>result &lt;- lapply(
 split(df,1:nrow(df)),
 function(x) do.call(power.t.test,x)
)

&gt; str(result)
List of 4
 $ 1:List of 8
 ..$ n : num 22
 ..$ delta : num 1
 ..$ sd : num 1
 ..$ sig.level : num 0.05
 ..$ power : num 0.9
 ..$ alternative: chr "two.sided"
 ..$ note : chr "n is number in *each* group"
 ..$ method : chr "Two-sample t test power calculation"
 ..- attr(*, "class")= chr "power.htest"
 $ 2:List of 8
 ..$ n : num 19
 ..$ delta : num 1
 ..$ sd : num 1
 ..$ sig.level : num 0.05
 ..$ power : num 0.85
... ...
</code></pre>

blocks|key|2824042|text|data.frame是list，所以..。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2824043|对于矢量化函数，+do.call通常是一个很好的选择。但是参数的名称起作用了。这里使用参数x和y而不是a和b来调用testFunc。...允许传递不相关的参数而不会导致错误：|BOLD|2824044|do.call(+function(x,z,...)+testFunc(x,z),+df+)|code-block|syntax|javascript|2824045|对于非矢量化函数，mapply将起作用，但您需要匹配arg的顺序或显式命名它们：|2824046|mapply(testFunc,+df$x,+df$z)|2824047|有时apply会起作用，因为当所有参数都是相同类型时，将data.frame强制转换为矩阵不会因为更改数据类型而导致问题。你的例子就是这样的。|2824048|如果您的函数是在另一个函数中调用的，并且所有参数都传递到该函数中，那么有一个比这些方法更巧妙的方法。如果您想走这条路，请研究lm()主体的前几行。|2824049|entityMap^0|0|A|B|4|0|2|6|9|7|1L|8|1U|3|0|0|2|6|9|6|0|0|2|5|S|A|0|1Q|4|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|H]|$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|I|3|J|5|K|7|1B|8|@]|D|@]|E|$L|M]]|$1|N|3|O|5|6|7|1C|8|@$9|1D|A|1E|B|H]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|P|3|Q|5|K|7|1H|8|@]|D|@]|E|$L|M]]|$1|R|3|S|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|T|3|U|5|6|7|1N|8|@$9|1O|A|1P|B|C]]|D|@]|E|$]]|$1|V|3|-4|5|6|7|1Q|8|@]|D|@]|E|$]]]|W|$]]

A <code>data.frame</code> is a <code>list</code>, so ...

For vectorized functions <code>do.call</code> is usually a good bet. But the names of arguments come into play. Here your <code>testFunc</code> is called with args x and y in place of a and b. The <code>...</code> allows irrelevant args to be passed without causing an error: 

<pre><code>do.call( function(x,z,...) testFunc(x,z), df )
</code></pre>

For non-vectorized functions, <code>mapply</code> will work, but you need to match the ordering of the args or explicitly name them:

<pre><code>mapply(testFunc, df$x, df$z)
</code></pre>

Sometimes <code>apply</code> will work - as when all args are of the same type so coercing the <code>data.frame</code> to a matrix does not cause problems by changing data types. Your example was of this sort.

If your function is to be called within another function into which the arguments are all passed, there is a much slicker method than these. Study the first lines of the body of <code>lm()</code> if you want to go that route.

blocks|key|3036767|text|其他人已经正确地指出，mapply就是为了这个目的而设计的，但是(为了完整性)一个概念上更简单的方法就是使用for循环。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|3036768|for+(row+in+1:nrow(df))+{+
++++df$newvar[row]+<-+testFunc(df$x[row],+df$z[row])+
}|code-block|syntax|javascript|3036769|entityMap^0|B|6|1I|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]|$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|S|8|@]|D|@]|E|$]]]|L|$]]

Others have correctly pointed out that <code>mapply</code> is made for this purpose, but (for the sake of completeness) a conceptually simpler method is just to use a <code>for</code> loop. 

<pre><code>for (row in 1:nrow(df)) { 
 df$newvar[row] &lt;- testFunc(df$x[row], df$z[row]) 
}
</code></pre>

blocks|key|197245|text|如果data.frame列的类型不同，那么apply()就有问题。行迭代的一个微妙之处在于，当列是不同类型时，apply(a.data.frame,+1,+...)如何将隐式类型转换为字符类型。因子和数值列。下面是一个示例，在一列中使用一个因子来修改一个数字列：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|197246|mean.height+=+list(BOY=69.5,+GIRL=64.0)

subjects+=+data.frame(gender+=+factor(c("BOY",+"GIRL",+"GIRL",+"BOY"))
+++++++++,+height+=+c(71.0,+59.3,+62.1,+62.1))

apply(height,+1,+function(x)+x[2]+-+mean.height[[x[1]]])|code-block|syntax|javascript|197247|减法失败，因为列被转换为字符类型。|197248|一种解决方法是将第二列反向转换为一个数字：|197249|apply(subjects,+1,+function(x)+as.numeric(x[2])+-+mean.height[[x[1]]])|197250|但是，通过保持列的分隔并使用mapply()，可以避免转换|197251|mapply(function(x,y)+y+-+mean.height[[x]],+subjects$gender,+subjects$height)|197252|因为[[+]]不接受向量参数，所以需要mapply()。因此，列迭代可以在减法之前通过更丑陋的代码向[]传递一个向量来完成：|197253|subjects$height+-+unlist(mean.height[subjects$gender])|197254|entityMap^0|L|7|1J|R|0|0|0|0|0|E|8|0|0|2|5|J|8|1E|2|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]|$9|13|A|14|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|D|@]|E|$]]|$1|M|3|N|5|6|7|17|8|@]|D|@]|E|$]]|$1|O|3|P|5|H|7|18|8|@]|D|@]|E|$I|J]]|$1|Q|3|R|5|6|7|19|8|@$9|1A|A|1B|B|C]]|D|@]|E|$]]|$1|S|3|T|5|H|7|1C|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|W|3|X|5|H|7|1K|8|@]|D|@]|E|$I|J]]|$1|Y|3|-4|5|6|7|1L|8|@]|D|@]|E|$]]]|Z|$]]

If data.frame columns are different types, <code>apply()</code> has a problem.
A subtlety about row iteration is how <code>apply(a.data.frame, 1, ...)</code> does 
implicit type conversion to character types when columns are different types;
eg. a factor and numeric column. Here's an example, using a factor 
in one column to modify a numeric column:

<pre><code>mean.height = list(BOY=69.5, GIRL=64.0)

subjects = data.frame(gender = factor(c("BOY", "GIRL", "GIRL", "BOY"))
 , height = c(71.0, 59.3, 62.1, 62.1))

apply(height, 1, function(x) x[2] - mean.height[[x[1]]])
</code></pre>

The subtraction fails because the columns are converted to character types.

One fix is to back-convert the second column to a number:

<pre><code>apply(subjects, 1, function(x) as.numeric(x[2]) - mean.height[[x[1]]])
</code></pre>

But the conversions can be avoided by keeping the columns separate 
and using <code>mapply()</code>:

<pre><code>mapply(function(x,y) y - mean.height[[x]], subjects$gender, subjects$height)
</code></pre>

<code>mapply()</code> is needed because <code>[[ ]]</code> does not accept a vector argument. So the column
iteration could be done before the subtraction by passing a vector to <code>[]</code>,
by a bit more ugly code:

<pre><code>subjects$height - unlist(mean.height[subjects$gender])
</code></pre>

blocks|key|197263|text|dplyr包带来的新答案|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|197264|如果要应用的函数是矢量化的，那么可以使用dplyr包中的mutate函数：|197265|>+library(dplyr)
>+myf+<-+function(tens,+ones)+{+10+*+tens+%2B+ones+}
>+x+<-+data.frame(hundreds+=+7:9,+tens+=+1:3,+ones+=+4:6)
>+mutate(x,+value+=+myf(tens,+ones))
++hundreds+tens+ones+value
1++++++++7++++1++++4++++14
2++++++++8++++2++++5++++25
3++++++++9++++3++++6++++36|code-block|syntax|javascript|197266|使用plyr包的旧答案|197267|在我看来，最适合这项任务的工具是plyr包中的mdply。|197268|示例：|197269|>+library(plyr)
>+x+<-+data.frame(tens+=+1:3,+ones+=+4:6)
>+mdply(x,+function(tens,+ones)+{+10+*+tens+%2B+ones+})
++tens+ones+V1
1++++1++++4+14
2++++2++++5+25
3++++3++++6+36|197270|不幸的是，正如Bertjan+Broeksema指出的那样，如果没有在mdply调用中使用数据框的所有列，这种方法就会失败。例如,|197271|>+library(plyr)
>+x+<-+data.frame(hundreds+=+7:9,+tens+=+1:3,+ones+=+4:6)
>+mdply(x,+function(tens,+ones)+{+10+*+tens+%2B+ones+})
Error+in+(function+(tens,+ones)++:+unused+argument+(hundreds+=+7)|197272|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/users/1683513/bertjan-broeksema^0|0|5|0|K|5|S|6|0|0|2|4|0|G|4|N|5|0|0|0|Z|5|7|H|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1E|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1F|8|@$9|1G|A|1H|B|C]]|D|@]|E|$]]|$1|O|3|P|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1N|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1O|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1P|8|@$9|1Q|A|1R|B|C]]|D|@$9|1S|A|1T|1|1U]]|E|$]]|$1|W|3|X|5|J|7|1V|8|@]|D|@]|E|$K|L]]|$1|Y|3|-4|5|6|7|1W|8|@]|D|@]|E|$]]]|Z|$10|$5|11|12|13|E|$14|15]]]]

<h2>New answer with <code>dplyr</code> package</h2>

If the function that you want to apply is vectorized,
then you could use the <code>mutate</code> function from the <code>dplyr</code> package:

<pre><code>&gt; library(dplyr)
&gt; myf &lt;- function(tens, ones) { 10 * tens + ones }
&gt; x &lt;- data.frame(hundreds = 7:9, tens = 1:3, ones = 4:6)
&gt; mutate(x, value = myf(tens, ones))
 hundreds tens ones value
1 7 1 4 14
2 8 2 5 25
3 9 3 6 36
</code></pre>

<h2>Old answer with <code>plyr</code> package</h2>

In my humble opinion,
the tool best suited to the task is <code>mdply</code> from the <code>plyr</code> package.

Example:

<pre><code>&gt; library(plyr)
&gt; x &lt;- data.frame(tens = 1:3, ones = 4:6)
&gt; mdply(x, function(tens, ones) { 10 * tens + ones })
 tens ones V1
1 1 4 14
2 2 5 25
3 3 6 36
</code></pre>

Unfortunately, as <a href="https://stackoverflow.com/users/1683513/bertjan-broeksema">Bertjan Broeksema</a> pointed out,
this approach fails if you don't use all the columns of the data frame
in the <code>mdply</code> call.
For example,

<pre><code>&gt; library(plyr)
&gt; x &lt;- data.frame(hundreds = 7:9, tens = 1:3, ones = 4:6)
&gt; mdply(x, function(tens, ones) { 10 * tens + ones })
Error in (function (tens, ones) : unused argument (hundreds = 7)
</code></pre>

blocks|key|3036907|text|这是另一种方法。它更直观。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3036908|我觉得其中一些答案没有考虑到的一个关键方面是，apply()让您可以轻松地进行行计算，但仅适用于矩阵(全是数字)数据|3036909|对列的操作仍然可以用于数据帧：|3036910|as.data.frame(lapply(df,+myFunctionForColumn()))|code-block|syntax|javascript|3036911|为了对行进行操作，我们首先进行转置。|3036912|tdf<-as.data.frame(t(df))
as.data.frame(lapply(tdf,+myFunctionForRow()))|3036913|缺点是我相信R会复制你的数据表。这可能是记忆问题。(这真的很可悲，因为对于tdf来说，只做原始df的迭代器在编程上很简单，从而节省了内存，但R不允许指针或迭代器引用。)|3036914|另外，一个相关的问题是如何对数据帧中的每个单元进行操作。|3036915|newdf+<-+as.data.frame(lapply(df,+function(x)+{sapply(x,+myFunctionForEachCell()}))|3036916|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|11|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|T|5|H|7|14|8|@]|9|@]|A|$I|J]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Here is an alternate approach. It is more intuitive.

One key aspect I feel some of the answers did not take into account, which I point out for posterity, is apply() lets you do row calculations easily, but only for matrix (all numeric) data

operations on columns are possible still for dataframes:

<pre><code>as.data.frame(lapply(df, myFunctionForColumn()))
</code></pre>

To operate on rows, we make the transpose first.

<pre><code>tdf&lt;-as.data.frame(t(df))
as.data.frame(lapply(tdf, myFunctionForRow()))
</code></pre>

The downside is that I believe R will make a copy of your data table.
Which could be a memory issue. (This is truly sad, because it is programmatically simple for tdf to just be an iterator to the original df, thus saving memory, but R does not allow pointer or iterator referencing.)

Also, a related question, is how to operate on each individual cell in a dataframe. 

<pre><code>newdf &lt;- as.data.frame(lapply(df, function(x) {sapply(x, myFunctionForEachCell()}))
</code></pre>

blocks|key|2824225|text|我来这里寻找tidyverse函数名--我知道它存在。为(我的)未来参考和tidyverse爱好者添加这个：purrrlyr:invoke_rows+(旧版本中为purrr:invoke_rows)。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2824226|通过与原始问题中的标准统计方法连接，broom包可能会有所帮助。|2824227|entityMap|0|LINK|mutability|MUTABLE|url|http://tidyverse.org/|1|https://github.com/tidyverse/broom^0|11|9|1I|K|29|H|6|9|0|0|I|5|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@$9|Y|A|Z|1|10]]|E|$]]|$1|F|3|G|5|6|7|11|8|@]|D|@$9|12|A|13|1|14]]|E|$]]|$1|H|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|I|$J|$5|K|L|M|E|$N|O]]|P|$5|K|L|M|E|$N|Q]]]]

I came here looking for <a href="http://tidyverse.org/" rel="nofollow noreferrer">tidyverse</a> function name - which I knew existed. Adding this for (my) future reference and for <code>tidyverse</code> enthusiasts: <code>purrrlyr:invoke_rows</code> (<code>purrr:invoke_rows</code> in older versions). 

With connection to standard stats methods as in the original question, the <a href="https://github.com/tidyverse/broom" rel="nofollow noreferrer">broom</a> package would probably help.

blocks|key|194883|text|data.table也有一种非常直观的方式来做到这一点：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|194884|library(data.table)

sample_fxn+=+function(x,y,z){
++++return((x%2By)*z)
}

df+=+data.table(A+=+1:5,B=seq(2,10,2),C+=+6:10)
>+df
+++A++B++C
1:+1++2++6
2:+2++4++7
3:+3++6++8
4:+4++8++9
5:+5+10+10|code-block|syntax|javascript|194885|可以在括号内调用:=运算符，以使用函数添加新列|194886|df[,new_column+:=+sample_fxn(A,B,C)]
>+df
+++A++B++C+new_column
1:+1++2++6+++++++++18
2:+2++4++7+++++++++42
3:+3++6++8+++++++++72
4:+4++8++9++++++++108
5:+5+10+10++++++++150|194887|使用这种方法也很容易接受常量作为参数：|194888|df[,new_column2+:=+sample_fxn(A,B,2)]

>+df
+++A++B++C+new_column+new_column2
1:+1++2++6+++++++++18+++++++++++6
2:+2++4++7+++++++++42++++++++++12
3:+3++6++8+++++++++72++++++++++18
4:+4++8++9++++++++108++++++++++24
5:+5+10+10++++++++150++++++++++30|194889|entityMap^0|0|A|0|0|8|2|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|13|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

<code>data.table</code> has a really intuitive way of doing this as well:

<pre><code>library(data.table)

sample_fxn = function(x,y,z){
 return((x+y)*z)
}

df = data.table(A = 1:5,B=seq(2,10,2),C = 6:10)
&gt; df
 A B C
1: 1 2 6
2: 2 4 7
3: 3 6 8
4: 4 8 9
5: 5 10 10
</code></pre>

The <code>:=</code> operator can be called within brackets to add a new column using a function

<pre><code>df[,new_column := sample_fxn(A,B,C)]
&gt; df
 A B C new_column
1: 1 2 6 18
2: 2 4 7 42
3: 3 6 8 72
4: 4 8 9 108
5: 5 10 10 150
</code></pre>

It's also easy to accept constants as arguments as well using this method:

<pre><code>df[,new_column2 := sample_fxn(A,B,2)]

&gt; df
 A B C new_column new_column2
1: 1 2 6 18 6
2: 2 4 7 42 12
3: 3 6 8 72 18
4: 4 8 9 108 24
5: 5 10 10 150 30
</code></pre>

blocks|key|2824255|text|一个非常好的函数是来自plyr的adply，特别是当您想要将结果附加到原始数据帧时。这个函数和它的近亲ddply为我省去了很多麻烦和代码！|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2824256|df_appended+<-+adply(df,+1,+mutate,+sum=x%2Bz)|code-block|syntax|javascript|2824257|或者，您可以调用所需的函数。|2824258|df_appended+<-+adply(df,+1,+mutate,+sum=testFunc(x,z))|2824259|entityMap^0|B|4|G|5|1F|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

A really nice function for this is <code>adply</code> from <code>plyr</code>, especially if you want to append the result to the original dataframe. This function and its cousin <code>ddply</code> have saved me a lot of headaches and lines of code!

<pre><code>df_appended &lt;- adply(df, 1, mutate, sum=x+z)
</code></pre>

Alternatively, you can call the function you desire.

<pre><code>df_appended &lt;- adply(df, 1, mutate, sum=testFunc(x,z))
</code></pre>

I have a dataframe with multiple columns. For each row in the dataframe, I want to call a function on the row, and the input of the function is using multiple columns from that row. For example, let's say I have this data and this testFunc which accepts two args:

<pre><code>&gt; df &lt;- data.frame(x=c(1,2), y=c(3,4), z=c(5,6))
&gt; df
 x y z
1 1 3 5
2 2 4 6
&gt; testFunc &lt;- function(a, b) a + b
</code></pre>

Let's say I want to apply this testFunc to columns x and z. So, for row 1 I want 1+5, and for row 2 I want 2 + 6. Is there a way to do this without writing a for loop, maybe with the apply function family?

I tried this: 

<pre><code>&gt; df[,c('x','z')]
 x z
1 1 5
2 2 6
&gt; lapply(df[,c('x','z')], testFunc)
Error in a + b : 'b' is missing
</code></pre>

But got error, any ideas?

EDIT: the actual function I want to call is not a simple sum, but it is power.t.test. I used a+b just for example purposes. The end goal is to be able to do something like this (written in pseudocode):

<pre><code>df = data.frame(
 delta=c(delta_values), 
 power=c(power_values), 
 sig.level=c(sig.level_values)
)

lapply(df, power.t.test(delta_from_each_row_of_df, 
 power_from_each_row_of_df, 
 sig.level_from_each_row_of_df
))
</code></pre>

where the result is a vector of outputs for power.t.test for each row of df.

Call apply-like function on each row of dataframe with multiple arguments from each row

我有一个包含多列的数据帧。对于数据帧中的每一行，我想在该行上调用一个函数，该函数的输入使用该行中的多个列。例如，假设我有这个数据和这个接受两个参数的testFunc：> df <- data.frame(x=c(1,2), y=c(3,4), z=c(5,6))> df x y z1 1 3 52 2 4 6> te...

问使用来自每行的多个参数对数据帧的每一行调用类似apply的函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用来自每行的多个参数对数据帧的每一行调用类似apply的函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用来自每行的多个参数对数据帧的每一行调用类似apply的函数
EN