I have a Python Pandas dataframe df:

    d=[[&#39;hello&#39;,1,&#39;GOOD&#39;,&#39;long.kw&#39;],
       [1.2,&#39;chipotle&#39;,np.nan,&#39;bingo&#39;],
       [&#39;various&#39;,np.nan,3000,123.456]]                                                    
    t=pd.DataFrame(data=d, columns=[&#39;A&#39;,&#39;B&#39;,&#39;C&#39;,&#39;D&#39;]) 
which looks like this:

    print(t)
             A         B     C        D
    0    hello         1  GOOD  long.kw
    1      1.2  chipotle   NaN    bingo
    2  various       NaN  3000  123.456
I am trying to create a new column which is a `list` of the values in `A`, `B`, `C`, and `D`.  So it would look like this:

    t[&#39;combined&#39;]                                             
    
    Out[125]: 
    0        [hello, 1, GOOD, long.kw]
    1        [1.2, chipotle, nan, bingo]
    2        [various, nan, 3000, 123.456]
    Name: combined, dtype: object

I am trying this code:

    t[&#39;combined&#39;] = t.apply(lambda x: list([x[&#39;A&#39;],
                                            x[&#39;B&#39;],
                                            x[&#39;C&#39;],
                                            x[&#39;D&#39;]]),axis=1)    

Which returns this error:

    ValueError: Wrong number of items passed 4, placement implies 1 
    
What is puzzling to me is if remove one of the columns that I want to put in the list (or add another column to the dataframe that I DON&#39;T add to the list), my code works.  

For instance, run this code:

    t[&#39;combined&#39;] = t.apply(lambda x: list([x[&#39;A&#39;],
                                            x[&#39;B&#39;],
                                            x[&#39;D&#39;]]),axis=1)      

Returns this which is perfect if I only wanted the 3 columns:

    print(t)
             A         B     C        D                 combined
    0    hello         1  GOOD  long.kw      [hello, 1, long.kw]
    1      1.2  chipotle   NaN    bingo   [1.2, chipotle, bingo]
    2  various       NaN  3000  123.456  [various, nan, 123.456]
                                        
I am at a complete loss as to why requesting the &#39;combined&#39; list be made of all columns in the dataframe would create an error, but selecting all but 1 column to create the &#39;combined&#39; list and the list is created as expected.                                        




Pandas - combine column values into a list in a new column

As described [here](https://stackoverflow.com/a/1374131/460138), a quick way to append array b to array a in javascript is `a.push.apply(a, b)`.

You&#39;ll note that the object a is used twice.  Really we just want the `push` function, and `b.push.apply(a, b)` accomplishes exactly the same thing -- the first argument of apply supplies the `this` for the applied function.

I thought it might make more sense to directly use the methods of the Array object: `Array.push.apply(a, b)`.  But this doesn&#39;t work!  

I&#39;m curious why not, and if there&#39;s a better way to accomplish my goal.  (Applying the `push` function without needing to invoke a specific array twice.)

Why doesn&#39;t Array.push.apply work?

I have some problems with the Pandas apply function, when using multiple columns with the following dataframe

    df = DataFrame ({&#39;a&#39; : np.random.randn(6),
                     &#39;b&#39; : [&#39;foo&#39;, &#39;bar&#39;] * 3,
                     &#39;c&#39; : np.random.randn(6)})

and the following function

    def my_test(a, b):
        return a % b

When I try to apply this function with :
 
    df[&#39;Value&#39;] = df.apply(lambda row: my_test(row[a], row[c]), axis=1)

I get the error message:

    NameError: (&quot;global name &#39;a&#39; is not defined&quot;, u&#39;occurred at index 0&#39;)

I do not understand this message, I defined the name properly. 

I would highly appreciate any help on this issue

Update

Thanks for your help. I made indeed some syntax mistakes with the code, the index should be put &#39;&#39;. However I still get the same issue using a more complex function such as:

    def my_test(a):
        cum_diff = 0
        for ix in df.index():
            cum_diff = cum_diff + (a - df[&#39;a&#39;][ix])
        return cum_diff 


Why isn&#39;t my Pandas &#39;apply&#39; function referencing multiple columns working?

I want to apply a function with arguments to a series in python pandas:

    x = my_series.apply(my_function, more_arguments_1)
    y = my_series.apply(my_function, more_arguments_2)
    ...

The [documentation][1] describes support for an apply method, but it doesn&#39;t accept any arguments.  Is there a different method that accepts arguments?  Alternatively, am I missing a simple workaround?

**Update (October 2017):**  Note that since this question was originally asked that pandas `apply()` has been updated to handle positional and keyword arguments and the documentation link above now reflects that and shows how to include either type of argument.

  [1]: https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.apply.html

python pandas: apply a function with arguments to a series

I have a pandas DataFrame, `df_test`.  It contains a column &#39;size&#39; which represents size in bytes.  I&#39;ve calculated KB, MB, and GB using the following code:

    df_test = pd.DataFrame([
        {&#39;dir&#39;: &#39;/Users/uname1&#39;, &#39;size&#39;: 994933},
        {&#39;dir&#39;: &#39;/Users/uname2&#39;, &#39;size&#39;: 109338711},
    ])
    
    df_test[&#39;size_kb&#39;] = df_test[&#39;size&#39;].astype(int).apply(lambda x: locale.format(&quot;%.1f&quot;, x / 1024.0, grouping=True) + &#39; KB&#39;)
    df_test[&#39;size_mb&#39;] = df_test[&#39;size&#39;].astype(int).apply(lambda x: locale.format(&quot;%.1f&quot;, x / 1024.0 ** 2, grouping=True) + &#39; MB&#39;)
    df_test[&#39;size_gb&#39;] = df_test[&#39;size&#39;].astype(int).apply(lambda x: locale.format(&quot;%.1f&quot;, x / 1024.0 ** 3, grouping=True) + &#39; GB&#39;)
    
    df_test


                 dir       size       size_kb   size_mb size_gb
    0  /Users/uname1     994933      971.6 KB    0.9 MB  0.0 GB
    1  /Users/uname2  109338711  106,776.1 KB  104.3 MB  0.1 GB
    
    [2 rows x 5 columns]

I&#39;ve run this over 120,000 rows and time it takes about 2.97 seconds per column * 3 = ~9 seconds according to %timeit.

Is there anyway I can make this faster?  For example, can I instead of returning one column at a time from apply and running it 3 times, can I return all three columns in one pass to insert back into the original dataframe?

The other questions I&#39;ve found all want to **take multiple values and return a single value**. I want to **take a single value and return multiple columns**.

Return multiple columns from pandas apply()

I&#39;m having trouble with a data frame and couldn&#39;t really resolve that issue myself:&lt;br&gt;
The &lt;b&gt;dataframe&lt;/b&gt; has arbitrary &lt;b&gt;properties as columns&lt;/b&gt; and &lt;b&gt;each row&lt;/b&gt; represents one &lt;b&gt;data set&lt;/b&gt;.&lt;p&gt;
The question is:&lt;br&gt;
How to &lt;b&gt;get rid of columns where for &lt;i&gt;ALL&lt;/i&gt; rows the value is NA&lt;/b&gt;?


Remove columns from dataframe where ALL values are NA

I have seen many answers posted to questions on Stack Overflow involving the use of the Pandas method `apply`. I have also seen users commenting under them saying that &quot;`apply` is slow, and should be avoided&quot;. 

I have read many articles on the topic of performance that explain `apply` is slow. I have also seen a disclaimer in the docs about how `apply` is simply a convenience function for passing UDFs (can&#39;t seem to find that now). So, the general consensus is that `apply` should be avoided if possible. However, this raises the following questions: 

1. If `apply` is so bad, then why is it in the API?
2. How and when should I make my code `apply`-free?
3. Are there ever any situations where `apply` is _good_ (better than other possible solutions)? 

When should I (not) want to use pandas apply() in my code?

...regarding execution time and / or memory.

If this is not true, prove it with a code snippet. Note that speedup by vectorization does not count. The speedup must come from `apply` (`tapply`, `sapply`, ...) itself.


Is R&#39;s apply family more than syntactic sugar?

Suppose I have a n by 2 matrix and a function that takes a 2-vector as one of its arguments. I would like to apply the function to each row of the matrix and get a n-vector. How to do this in R?

For example, I would like to compute the density of a 2D standard Normal distribution on three points:

    bivariate.density(x = c(0, 0), mu = c(0, 0), sigma = c(1, 1), rho = 0){
    	exp(-1/(2*(1-rho^2))*(x[1]^2/sigma[1]^2+x[2]^2/sigma[2]^2-2*rho*x[1]*x[2]/(sigma[1]*sigma[2]))) * 1/(2*pi*sigma[1]*sigma[2]*sqrt(1-rho^2))
    }
    
    out &lt;- rbind(c(1, 2), c(3, 4), c(5, 6))

How to apply the function to each row of `out`?

How to pass values for the other arguments besides the points to the function in the way you specify? 



Apply a function to every row of a matrix or a data frame

So we are used to say to every R new user that &quot;*`apply` isn&#39;t vectorized, check out the Patrick Burns [R Inferno](http://www.burns-stat.com/pages/Tutor/R_inferno.pdf) Circle 4*&quot; which says (I quote):

&gt; A common reflex is to use a function in the apply family. **This is not**
&gt; **vectorization, it is loop-hiding**. The apply function has a for loop in
&gt; its definition. The lapply function buries the loop, but execution
&gt; times tend to be roughly equal to an explicit for loop.

Indeed, a quick look on the `apply` source code reveals the loop:

    grep(&quot;for&quot;, capture.output(getAnywhere(&quot;apply&quot;)), value = TRUE)
    ## [1] &quot;        for (i in 1L:d2) {&quot;  &quot;    else for (i in 1L:d2) {&quot;

Ok so far, but a look at `lapply` or `vapply` actually reveals a completely different picture:

    lapply
    ## function (X, FUN, ...) 
    ## {
    ##     FUN &lt;- match.fun(FUN)
    ##     if (!is.vector(X) || is.object(X)) 
    ##        X &lt;- as.list(X)
    ##     .Internal(lapply(X, FUN))
    ## }
    ## &lt;bytecode: 0x000000000284b618&gt;
    ## &lt;environment: namespace:base&gt;

So apparently there is no R `for` loop hiding there, rather they are calling internal C written function. 

A quick look in the [rabbit](https://github.com/wch/r-source/blob/trunk/src/main/names.c#L627-L630) [hole](https://github.com/wch/r-source/blob/trunk/src/main/apply.c#L34) reveals pretty much the same picture

Moreover, let&#39;s take the `colMeans` function for example, which was never accused in not being vectorised

    colMeans
    # function (x, na.rm = FALSE, dims = 1L) 
    # {
    #   if (is.data.frame(x)) 
    #     x &lt;- as.matrix(x)
    #   if (!is.array(x) || length(dn &lt;- dim(x)) &lt; 2L) 
    #     stop(&quot;&#39;x&#39; must be an array of at least two dimensions&quot;)
    #   if (dims &lt; 1L || dims &gt; length(dn) - 1L) 
    #     stop(&quot;invalid &#39;dims&#39;&quot;)
    #   n &lt;- prod(dn[1L:dims])
    #   dn &lt;- dn[-(1L:dims)]
    #   z &lt;- if (is.complex(x)) 
    #     .Internal(colMeans(Re(x), n, prod(dn), na.rm)) + (0+1i) * 
    #     .Internal(colMeans(Im(x), n, prod(dn), na.rm))
    #   else .Internal(colMeans(x, n, prod(dn), na.rm))
    #   if (length(dn) &gt; 1L) {
    #     dim(z) &lt;- dn
    #     dimnames(z) &lt;- dimnames(x)[-(1L:dims)]
    #   }
    #   else names(z) &lt;- dimnames(x)[[dims + 1]]
    #   z
    # }
    # &lt;bytecode: 0x0000000008f89d20&gt;
    #   &lt;environment: namespace:base&gt;

Huh? It also just calls `.Internal(colMeans(...` which we can also find in the [rabbit hole](https://github.com/wch/r-source/blob/trunk/src/main/names.c#L731). So how is this different from `.Internal(lapply(..`?

Actually a quick benchmark reveals that `sapply` performs no worse than `colMeans` and much better than a `for` loop for a big data set

    m &lt;- as.data.frame(matrix(1:1e7, ncol = 1e5))
    system.time(colMeans(m))
    # user  system elapsed 
    # 1.69    0.03    1.73 
    system.time(sapply(m, mean))
    # user  system elapsed 
    # 1.50    0.03    1.60 
    system.time(apply(m, 2, mean))
    # user  system elapsed 
    # 3.84    0.03    3.90 
    system.time(for(i in 1:ncol(m)) mean(m[, i]))
    # user  system elapsed 
    # 13.78    0.01   13.93 

In other words, is it correct to say that `lapply` and `vapply` **are actually vectorised** (compared to `apply` which is a `for` loop that also calls `lapply`) and what did Patrick Burns really mean to say?


Is the &quot;*apply&quot; family really not vectorized?

I have a dataframe that may look like this:

    A        B        C
    foo      bar      foo bar
    bar foo  foo      bar

I want to look through every element of each row (or every element of each column) and apply the following function to get the subsequent DF:

    def foo_bar(x):
        return x.replace(&#39;foo&#39;, &#39;wow&#39;)

    A        B        C
    wow      bar      wow bar
    bar wow  wow      bar

Is there a simple one-liner that can apply a function to each cell? 

This is a simplistic example so there may be an easier way to execute this specific example other than applying a function, but what I am really asking about is how to apply a function in every cell within a dataframe. 

Apply function to each cell in DataFrame

I want to apply my custom function (it uses an if-else ladder) to these six columns (`ERI_Hispanic`, `ERI_AmerInd_AKNatv`, `ERI_Asian`, `ERI_Black_Afr.Amer`, `ERI_HI_PacIsl`, `ERI_White`) in each row of my dataframe.

I&#39;ve tried different methods from other questions but still can&#39;t seem to find the right answer for my problem.  The critical piece of this is that if the person is counted as Hispanic they can&#39;t be counted as anything else.  Even if they have a &quot;1&quot; in another ethnicity column they still are counted as Hispanic not two or more races.  Similarly, if the sum of all the ERI columns is greater than 1 they are counted as two or more races and can&#39;t be counted as a unique ethnicity(except for Hispanic).  Hopefully this makes sense.  Any help will be greatly appreciated. 

Its almost like doing a for loop through each row and if each record meets a criterion they are added to one list and eliminated from the original.  

From the dataframe below I need to calculate a new column based on the following spec in SQL:

**CRITERIA**

    IF [ERI_Hispanic] = 1 THEN RETURN “Hispanic”
    ELSE IF SUM([ERI_AmerInd_AKNatv] + [ERI_Asian] + [ERI_Black_Afr.Amer] + [ERI_HI_PacIsl] + [ERI_White]) &gt; 1 THEN RETURN “Two or More”
    ELSE IF [ERI_AmerInd_AKNatv] = 1 THEN RETURN “A/I AK Native”
    ELSE IF [ERI_Asian] = 1 THEN RETURN “Asian”
    ELSE IF [ERI_Black_Afr.Amer] = 1 THEN RETURN “Black/AA”
    ELSE IF [ERI_HI_PacIsl] = 1 THEN RETURN “Haw/Pac Isl.”
    ELSE IF [ERI_White] = 1 THEN RETURN “White”

Comment: If the ERI Flag for Hispanic is True (1), the employee is classified as “Hispanic”

Comment: If more than 1 non-Hispanic ERI Flag is true, return “Two or More”


**DATAFRAME**

    	 lname			fname		rno_cd	eri_afr_amer	eri_asian	eri_hawaiian	eri_hispanic	eri_nat_amer	eri_white	rno_defined
    0	 MOST	 		JEFF	 	E	    0	 			0	 		0	 			0	 			0	 			1	 		White
    1	 CRUISE		 	TOM		 	E	 	0	 			0	 		0	 			1	 			0	 			0	 		White
    2	 DEPP	 		JOHNNY		 		0	 			0	 		0	 			0	 			0	 			1	 		Unknown
    3	 DICAP	 		LEO			 		0	 			0	 		0	 			0	 			0	 			1	 		Unknown
    4	 BRANDO		 	MARLON	 	E	 	0	 			0	 		0	 			0	 			0	 			0	 		White
    5	 HANKS		 	TOM		 	0	 					0	 		0	 			0	 			0	 			1	 		Unknown
    6	 DENIRO	 		ROBERT	 	E	 	0	 			1	 		0	 			0	 			0	 			1	 		White
    7	 PACINO		 	AL			E	 	0	 			0	 		0	 			0	 			0	 			1	 		White
    8	 WILLIAMS	 	ROBIN		E	 	0	 			0	 		1	 			0	 			0	 			0	 		White
    9	 EASTWOOD	 	CLINT	 	E	 	0	 			0	 		0	 			0	 			0	 			1	 		White

pandas create new column based on values from other columns / apply a function of multiple columns, row-wise

I know that loops are slow in `R` and that I should try to do things in a vectorised manner instead.

But, why? Why are loops slow and `apply` is fast? `apply` calls several sub-functions -- that doesn&#39;t seem fast.

**Update:** I&#39;m sorry, the question was ill-posed. I was confusing vectorisation with `apply`. My question should have been, 

**&quot;Why is vectorisation faster?&quot;**

Why are loops slow in R?

How does the `Math.max.apply()` work?.

    &lt;!DOCTYPE html&gt;
    &lt;html&gt;
    &lt;head&gt;
    &lt;meta charset=utf-8 /&gt;
    &lt;title&gt;JS Bin&lt;/title&gt;
    &lt;/head&gt;
    &lt;body&gt;
      &lt;script&gt;
          var list = [&quot;12&quot;,&quot;23&quot;,&quot;100&quot;,&quot;34&quot;,&quot;56&quot;,
                                        &quot;9&quot;,&quot;233&quot;];
          console.log(Math.max.apply(Math,list));    
      &lt;/script&gt;
    &lt;/body&gt;
    &lt;/html&gt;

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max

The above code finds the Max number in the List. Can anyone tell me how does the below code work?. It seems it works if i pass `null or Math.` 

    console.log(Math.max.apply(Math,list));

Does all the `user-defined/Native functions` have call and apply method which we can use?.

How does the Math.max.apply() work?

I see that in different plugins and codes, but I don&#39;t understand what does that function... In the jQuery api isn&#39;t referenced!

What&#39;s the .apply jQuery function?

I want to use the apply function on a dataframe, but only apply the function to the last 5 columns.

    B&lt;- by(wifi,(wifi$Room),FUN=function(y){apply(y, 2, A)})

This applies A to all the columns of y

    B&lt;- by(wifi,(wifi$Room),FUN=function(y){apply(y[4:9], 2, A)})

This applies A only to columns 4-9 of y, but the total return of B strips off the first 3 columns... I still want those, I just don&#39;t want A applied to them.

    wifi[,1:3]+B 

also does not do what I expected/wanted.

R Apply() function on specific dataframe columns

How could I generalise the function below to take N arguments?  (Using call or apply?)

Is there a programmatic way to apply arguments to &#39;new&#39;? I don&#39;t want the constructor to be treated like a plain function.

    /**
     * This higher level function takes a constructor and arguments
     * and returns a function, which when called will return the 
     * lazily constructed value.
     * 
     * All the arguments, except the first are pased to the constructor.
     * 
     * @param {Function} constructor
     */ 

    function conthunktor(Constructor) {
    	var args = Array.prototype.slice.call(arguments, 1);
    	return function() {
    		console.log(args);
    		if (args.length === 0) {
    			return new Constructor();
    		}
    		if (args.length === 1) {
    			return new Constructor(args[0]);
    		}
    		if (args.length === 2) {
    			return new Constructor(args[0], args[1]);
    		}
    		if (args.length === 3) {
    			return new Constructor(args[0], args[1], args[2]);
    		}
    		throw(&quot;too many arguments&quot;);    
    	}
    }


qUnit test:
    
    test(&quot;conthunktorTest&quot;, function() {
    	function MyConstructor(arg0, arg1) {
    		this.arg0 = arg0;
    		this.arg1 = arg1;
    	}
    	MyConstructor.prototype.toString = function() {
    		return this.arg0 + &quot; &quot; + this.arg1;
    	}
    	
    	var thunk = conthunktor(MyConstructor, &quot;hello&quot;, &quot;world&quot;);
    	var my_object = thunk();
    	deepEqual(my_object.toString(), &quot;hello world&quot;);
    });

How can I call a javascript constructor using call or apply?

The documentation says

&gt; `vapply` is similar to `sapply`, but has a pre-specified type of return value, so it can be safer [...] to use.

Could you please elaborate as to why it is generally safer, maybe providing examples?

---

P.S.: I know the answer and I already tend to avoid `sapply`. I just wish there was a nice answer here on SO so I can point my coworkers to it. Please, no &quot;read the manual&quot; answer.

Why is `vapply` safer than `sapply`?

I have a dataframe with a timeindex and 3 columns containing the coordinates of a 3D vector:

                             x             y             z
    ts
    2014-05-15 10:38         0.120117      0.987305      0.116211
    2014-05-15 10:39         0.117188      0.984375      0.122070
    2014-05-15 10:40         0.119141      0.987305      0.119141
    2014-05-15 10:41         0.116211      0.984375      0.120117
    2014-05-15 10:42         0.119141      0.983398      0.118164


I would like to apply a transformation to each row that also returns a vector

    def myfunc(a, b, c):
        do something
        return e, f, g

but if I do:

    df.apply(myfunc, axis=1)

I end up with a Pandas series whose elements are tuples. This is beacause apply will take the result of myfunc without unpacking it. How can I change myfunc so that I obtain a new df with 3 columns?



**Edit:**

All solutions below work. The Series solution does allow for column names, the List solution seem to execute faster.


    def myfunc1(args):
        e=args[0] + 2*args[1]
        f=args[1]*args[2] +1
        g=args[2] + args[0] * args[1]
        return pd.Series([e,f,g], index=[&#39;a&#39;, &#39;b&#39;, &#39;c&#39;])

    def myfunc2(args):
        e=args[0] + 2*args[1]
        f=args[1]*args[2] +1
        g=args[2] + args[0] * args[1]
        return [e,f,g]

    %timeit df.apply(myfunc1 ,axis=1)

    100 loops, best of 3: 4.51 ms per loop

    %timeit df.apply(myfunc2 ,axis=1)

    100 loops, best of 3: 2.75 ms per loop

pandas apply function that returns multiple values to rows in pandas dataframe

I tried this:

    // mod.js
    var a = 1;
    this.b = 2;
    exports.c = 3;

    // test.js
    var mod = require(&#39;./mod.js&#39;);
    console.log(mod.a);    // undefined
    console.log(mod.b);    // 2
    console.log(mod.c);    // 3, so this === exports?

So I image that require() may be implement like this:

    var require = function (file) {
        var exports = {};
        var run = function (file) {
            // include &quot;file&quot; here and run
        };
        run.apply(exports, [file]);
        return exports;
    }

Is that right? Please help me to understand require(), or where can I find the source code. Thanks!

How does require() in node.js work?

I would like to use Pandas `df.apply` but only for certain rows

As an example, I want to do something like this, but my actual issue is a little more complicated:

    import pandas as pd
    import math
    z = pd.DataFrame({&#39;a&#39;:[4.0,5.0,6.0,7.0,8.0],&#39;b&#39;:[6.0,0,5.0,0,1.0]})
    z.where(z[&#39;b&#39;] != 0, z[&#39;a&#39;] / z[&#39;b&#39;].apply(lambda l: math.log(l)), 0)

What I want in this example is the value in &#39;a&#39; divided by the log of the value in &#39;b&#39; for each row, and for rows where &#39;b&#39; is 0, I simply want to return 0.

Pandas apply but only for rows where a condition is met

I&#39;m trying to apply a function to all rows of a pandas DataFrame (actually just one column in that DataFrame)

I&#39;m sure this is a syntax error but I&#39;m know sure what I&#39;m doing wrong

    df[&#39;col&#39;].apply(lambda x, y:(x - y).total_seconds(), args=[d1], axis=1)

The `col` column contains a bunch a `datetime.datetime` objects and and `d1` is the earliest of them.  I&#39;m trying to get a column of the total number of seconds for each of the rows

**EDIT** I keep getting the following error

    TypeError: &lt;lambda&gt;() got an unexpected keyword argument &#39;axis&#39;

I don&#39;t understand why `axis` is getting passed to my `lambda` function

**EDIT 2**

I&#39;ve also tried doing

    def diff_dates(d1, d2):
        return (d1-d2).total_seconds()

    df[&#39;col&#39;].apply(diff_dates, args=[d1], axis=1)

And I get the same error

Trouble passing in lambda to apply for pandas DataFrame

I have a vector of strings.

    d &lt;- c(&quot;Mon&quot;,&quot;Tues&quot;,&quot;Wednes&quot;,&quot;Thurs&quot;,&quot;Fri&quot;,&quot;Satur&quot;,&quot;Sun&quot;)

for which I want to paste the string &quot;day&quot; on each element of the vector in a way similar to this.

    week &lt;- apply(d, &quot;day&quot;, paste, sep=&#39;&#39;)

How to paste a string on each element of a vector of strings using apply in R?

I&#39;m trying to get the min/max for each column in a large data frame, as part of *getting to know my data*. My first try was:

    apply(t,2,max,na.rm=1)

It treats everything as a character vector, because the first few columns are character types. So max of some of the numeric columns is coming out as `&quot;   -99.5&quot;`.

I then tried this:

    sapply(t,max,na.rm=1)

but it complains about *max not meaningful for factors*. (`lapply` is the same.) What is confusing me is that `apply` thought `max` was perfectly meaningful for factors, e.g. it returned &quot;ZEBRA&quot; for column 1.

BTW, I took a look at https://stackoverflow.com/questions/2482125/r-using-sapply-on-vector-of-posixct and one of the answers says &quot;*When you use sapply, your objects are coerced to numeric,...*&quot;. Is this what is happening to me? If so, is there an alternative apply function that does not coerce? Surely it is a common need, as one of the key features of the data frame type is that each column can be a different type.

All Apply Solutions on Gang of Coders

Total of 24 Apply Solutions