除了其他答案，在一个系列中还有map和apply。

Apply可以从一个系列中生成一个DataFrame;然而，map只会在另一个系列的每个单元格中放入一个系列，这可能不是您想要的。

In [40]: p=pd.Series([1,2,3])
In [41]: p
Out[31]:
0    1
1    2
2    3
dtype: int64

In [42]: p.apply(lambda x: pd.Series([x, x]))
Out[42]: 
   0  1
0  1  1
1  2  2
2  3  3

In [43]: p.map(lambda x: pd.Series([x, x]))
Out[43]: 
0    0    1
1    1
dtype: int64
1    0    2
1    2
dtype: int64
2    0    3
1    3
dtype: int64
dtype: object

另外，如果我有一个带有副作用的函数，比如“连接到web服务器”，为了清晰起见，我可能会使用apply。

series.apply(download_file_for_every_element) 

Map不仅可以使用函数，还可以使用字典或其他系列。假设你想操纵排列。

Take

1 2 3 4 5
2 1 4 5 3

这个排列的平方是

1 2 3 4 5
1 2 5 3 4

你可以用map来计算。不确定self-application是否有文档记录，但它在0.15.1中可以工作。

In [39]: p=pd.Series([1,0,3,4,2])

In [40]: p.map(p)
Out[40]: 
0    0
1    1
2    4
3    2
4    3
dtype: int64

为了增加上下文和直观感受，这里有一个明确而具体的例子来说明它们的区别。

假设您有如下所示的函数。（ 这个标签函数，将根据你提供的参数(x)的阈值，将值任意地分为'High'和'Low'。

def label(element, x):
    if element > x:
        return 'High'
    else:
        return 'Low'

在这个例子中，假设我们的数据框架有一列是随机数。

如果你尝试用map映射label函数:

df['ColumnName'].map(label, x = 0.8)

您将得到以下错误:

TypeError: map() got an unexpected keyword argument 'x'

现在使用相同的函数并使用apply，你会看到它是有效的:

df['ColumnName'].apply(label, x=0.8)

Series.apply()可以按元素接受额外的参数，而Series.map()方法将返回一个错误。

现在，如果您试图同时将相同的函数应用到数据帧中的多个列，则使用dataframe .applymap()。

df[['ColumnName','ColumnName2','ColumnName3','ColumnName4']].applymap(label)

最后，您还可以在dataframe上使用apply()方法，但dataframe .apply()方法具有不同的功能。df.apply()方法不是按元素应用函数，而是沿轴(按列或行)应用函数。在创建用于df.apply()的函数时，我们将其设置为接受一个序列，最常见的是一个列。

这里有一个例子:

df.apply(pd.value_counts)

当我们应用pd。函数，它计算了所有列的值计数。

注意，当我们使用df.apply()方法转换多个列时，这一点非常重要。这是可能的，因为pd。Value_counts函数作用于一个序列。如果我们尝试使用df.apply()方法将一个按元素工作的函数应用到多个列，则会得到一个错误:

例如:

def label(element):
    if element > 1:
        return 'High'
    else:
        return 'Low'

df[['ColumnName','ColumnName2','ColumnName3','ColumnName4']].apply(label)

这将导致以下错误:

ValueError: ('The truth value of a Series is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().', u'occurred at index Economy')

一般来说，只有当向量化函数不存在时，才应该使用apply()方法。回忆一下pandas使用向量化，即一次将操作应用到整个系列的过程，以优化性能。当我们使用apply()方法时，我们实际上是在遍历行，因此向量化方法可以比apply()方法更快地执行等效任务。

下面是一些已经存在的向量化函数的例子，你不想使用任何类型的apply/map方法重新创建它们:

Series.str.split() Splits each element in the Series Series.str.strip() Strips whitespace from each string in the Series. Series.str.lower() Converts strings in the Series to lowercase. Series.str.upper() Converts strings in the Series to uppercase. Series.str.get() Retrieves the ith element of each element in the Series. Series.str.replace() Replaces a regex or string in the Series with another string Series.str.cat() Concatenates strings in a Series. Series.str.extract() Extracts substrings from the Series matching a regex pattern.

基于cs95的答案

map在Series ONLY上定义 applymap只在DataFrames上定义 apply定义在BOTH上

举几个例子

In [3]: frame = pd.DataFrame(np.random.randn(4, 3), columns=list('bde'), index=['Utah', 'Ohio', 'Texas', 'Oregon'])

In [4]: frame
Out[4]:
            b         d         e
Utah    0.129885 -0.475957 -0.207679
Ohio   -2.978331 -1.015918  0.784675
Texas  -0.256689 -0.226366  2.262588
Oregon  2.605526  1.139105 -0.927518

In [5]: myformat=lambda x: f'{x:.2f}'

In [6]: frame.d.map(myformat)
Out[6]:
Utah      -0.48
Ohio      -1.02
Texas     -0.23
Oregon     1.14
Name: d, dtype: object

In [7]: frame.d.apply(myformat)
Out[7]:
Utah      -0.48
Ohio      -1.02
Texas     -0.23
Oregon     1.14
Name: d, dtype: object

In [8]: frame.applymap(myformat)
Out[8]:
            b      d      e
Utah     0.13  -0.48  -0.21
Ohio    -2.98  -1.02   0.78
Texas   -0.26  -0.23   2.26
Oregon   2.61   1.14  -0.93

In [9]: frame.apply(lambda x: x.apply(myformat))
Out[9]:
            b      d      e
Utah     0.13  -0.48  -0.21
Ohio    -2.98  -1.02   0.78
Texas   -0.26  -0.23   2.26
Oregon   2.61   1.14  -0.93


In [10]: myfunc=lambda x: x**2

In [11]: frame.applymap(myfunc)
Out[11]:
            b         d         e
Utah    0.016870  0.226535  0.043131
Ohio    8.870453  1.032089  0.615714
Texas   0.065889  0.051242  5.119305
Oregon  6.788766  1.297560  0.860289

In [12]: frame.apply(myfunc)
Out[12]:
            b         d         e
Utah    0.016870  0.226535  0.043131
Ohio    8.870453  1.032089  0.615714
Texas   0.065889  0.051242  5.119305
Oregon  6.788766  1.297560  0.860289

我的理解:

从功能上看:

如果函数具有需要在列/行内进行比较的变量，请使用 适用。

例如:lambda x: x.max()-x.mean()。

如果将函数应用于每个元素:

1>如果已定位某列/行，使用apply

2>如果应用于整个数据帧，使用applymap

majority = lambda x : x > 17
df2['legal_drinker'] = df2['age'].apply(majority)

def times10(x):
  if type(x) is int:
    x *= 10 
  return x
df2.applymap(times10)

@jeremiahbuddha提到apply适用于行/列，而applymap适用于元素。但似乎仍然可以使用apply进行元素计算....

frame.apply(np.sqrt)
Out[102]: 
               b         d         e
Utah         NaN  1.435159       NaN
Ohio    1.098164  0.510594  0.729748
Texas        NaN  0.456436  0.697337
Oregon  0.359079       NaN       NaN

frame.applymap(np.sqrt)
Out[103]: 
               b         d         e
Utah         NaN  1.435159       NaN
Ohio    1.098164  0.510594  0.729748
Texas        NaN  0.456436  0.697337
Oregon  0.359079       NaN       NaN

比较map, applymap和apply: Context Matters

第一个主要区别:定义

map在Series ONLY上定义 applymap只在DataFrames上定义 apply定义在BOTH上

第二个主要区别:INPUT参数

map接受字典、系列或可调用 Applymap和apply只接受可调用对象

第三个主要区别:行为

map是系列的元素 applymap是DataFrames的elementwise Apply也适用于elementwise，但适用于更复杂的操作和聚合。行为和返回值取决于函数。

第四个主要区别(最重要的一个):用例

map用于将值从一个域映射到另一个域，因此对性能进行了优化(例如，df['A']。Map ({1:'a'， 2:'b'， 3:'c'})) applymap适用于跨多行/列的elementwise转换(例如df[['A'， 'B'， 'C']]].applymap(str.strip)) Apply用于应用任何不能向量化的函数(例如df['sentence ']. Apply (nltk.sent_tokenize))。

另见什么时候我应该(不)想要在我的代码中使用熊猫apply() ?我写了一篇关于使用apply最合适的场景的文章(注意不是很多，但是有一些——apply通常很慢)。

总结

Footnotes map when passed a dictionary/Series will map elements based on the keys in that dictionary/Series. Missing values will be recorded as NaN in the output. applymap in more recent versions has been optimised for some operations. You will find applymap slightly faster than apply in some cases. My suggestion is to test them both and use whatever works better. map is optimised for elementwise mappings and transformation. Operations that involve dictionaries or Series will enable pandas to use faster code paths for better performance. Series.apply returns a scalar for aggregating operations, Series otherwise. Similarly for DataFrame.apply. Note that apply also has fastpaths when called with certain NumPy functions such as mean, sum, etc.