如何在 Pandas 数据框的列中用零替换 NaN 值？

Question

我有一个熊猫数据框如下：

      itm Date                  Amount 
67    420 2012-09-30 00:00:00   65211
68    421 2012-09-09 00:00:00   29424
69    421 2012-09-16 00:00:00   29877
70    421 2012-09-23 00:00:00   30990
71    421 2012-09-30 00:00:00   61303
72    485 2012-09-09 00:00:00   71781
73    485 2012-09-16 00:00:00     NaN
74    485 2012-09-23 00:00:00   11072
75    485 2012-09-30 00:00:00  113702
76    489 2012-09-09 00:00:00   64731
77    489 2012-09-16 00:00:00     NaN

当我尝试将函数应用于 Amount 列时，出现以下错误：

ValueError: cannot convert float NaN to integer

我尝试使用数学模块中的 .isnan 应用函数 我尝试过 pandas .replace 属性 我尝试过 pandas 0.9 中的 .sparse 数据属性 我也尝试过 if NaN == NaN 函数中的语句。 我还看过这篇文章如何在 R 数据框中用零替换 NA 值？ 在看其他一些文章的时候。 我尝试过的所有方法都不起作用或无法识别 NaN。 任何提示或解决方案将不胜感激。

Answer 1

我相信DataFrame.fillna()会为您做到这一点。

链接到 Docs 以获取dataframe和Series 。

例子：

In [7]: df
Out[7]: 
          0         1
0       NaN       NaN
1 -0.494375  0.570994
2       NaN       NaN
3  1.876360 -0.229738
4       NaN       NaN

In [8]: df.fillna(0)
Out[8]: 
          0         1
0  0.000000  0.000000
1 -0.494375  0.570994
2  0.000000  0.000000
3  1.876360 -0.229738
4  0.000000  0.000000

要仅将 NaN 填充在一列中，请仅选择该列。 在这种情况下，我使用 inplace=True 来实际更改 df 的内容。

In [12]: df[1].fillna(0, inplace=True)
Out[12]: 
0    0.000000
1    0.570994
2    0.000000
3   -0.229738
4    0.000000
Name: 1

In [13]: df
Out[13]: 
          0         1
0       NaN  0.000000
1 -0.494375  0.570994
2       NaN  0.000000
3  1.876360 -0.229738
4       NaN  0.000000

编辑：

要避免SettingWithCopyWarning ，请使用内置的特定于列的功能：

df.fillna({1:0}, inplace=True)

Answer 2

不能保证切片返回视图或副本。 你可以做

df['column'] = df['column'].fillna(value)

Answer 3

您可以使用replace将NaN更改为0 ：

import pandas as pd
import numpy as np

# for column
df['column'] = df['column'].replace(np.nan, 0)

# for whole dataframe
df = df.replace(np.nan, 0)

# inplace
df.replace(np.nan, 0, inplace=True)

Answer 4

下面的代码对我有用。

import pandas

df = pandas.read_csv('somefile.txt')

df = df.fillna(0)

Answer 5

我只是想提供一些更新/特殊情况，因为看起来人们仍然来到这里。 如果您使用多索引或以其他方式使用索引切片器，则 inplace=True 选项可能不足以更新您选择的切片。 例如，在 2x2 级别的多索引中，这不会更改任何值（从 pandas 0.15 开始）：

idx = pd.IndexSlice
df.loc[idx[:,mask_1],idx[mask_2,:]].fillna(value=0,inplace=True)

“问题”是链接破坏了 fillna 更新原始数据帧的能力。 我将“问题”放在引号中，因为设计决策有充分的理由导致在某些情况下不通过这些链进行解释。 此外，这是一个复杂的示例（尽管我确实遇到过），但根据您的切片方式，这可能适用于较少级别的索引。

解决方案是 DataFrame.update：

df.update(df.loc[idx[:,mask_1],idx[[mask_2],:]].fillna(value=0))

它是一行，读起来相当好（有点），并消除了中间变量或循环的任何不必要的混乱，同时允许您将 fillna 应用于您喜欢的任何多级切片！

如果有人能找到这不起作用的地方，请在评论中发布，我一直在搞乱它并查看源代码，它似乎至少解决了我的多索引切片问题。

Answer 6

您还可以使用字典来填充 DataFrame 中特定列的 NaN 值，而不是用一些 oneValue 填充所有 DF。

import pandas as pd

df = pd.read_excel('example.xlsx')
df.fillna( {
        'column1': 'Write your values here',
        'column2': 'Write your values here',
        'column3': 'Write your values here',
        'column4': 'Write your values here',
        .
        .
        .
        'column-n': 'Write your values here'} , inplace=True)

Answer 7

填充缺失值的简单方法：-

填充字符串列：当字符串列有缺失值和 NaN 值时。

df['string column name'].fillna(df['string column name'].mode().values[0], inplace = True)

填充数字列：当数字列有缺失值和 NaN 值时。

df['numeric column name'].fillna(df['numeric column name'].mean(), inplace = True)

用零填充 NaN：

df['column name'].fillna(0, inplace = True)

Answer 8

替换 pandas 中的 na 值

df['column_name'].fillna(value_to_be_replaced,inplace=True)

如果inplace = False ，它将返回修改后的值，而不是更新 df （数据框）。

Answer 9

考虑到上表中的特定列Amount是整数类型。 以下将是一个解决方案：

df['Amount'] = df.Amount.fillna(0).astype(int)

同样，您可以使用各种数据类型填充它，例如float 、 str等。

特别是，我会考虑数据类型来比较同一列的各种值。

Answer 10

用不同的方式替换不同列中的 nan：

   replacement= {'column_A': 0, 'column_B': -999, 'column_C': -99999}
   df.fillna(value=replacement)

Answer 11

将所有 nan 替换为 0

df = df.fillna(0)

Answer 12

已经有很多贡献了，但由于我是新来的，我仍然会提供意见。

在 Pandas DataFrame 中有两种方法可以用零替换NaN值：

1. fillna()：函数使用指定的方法填充 NA/NaN 值。
2. replace(): df.replace() 一个简单的方法，用于替换字符串、正则表达式、列表、字典

例子：

#NaN with zero on all columns
df2 = df.fillna(0)


#Using the inplace=True keyword in a pandas method changes the default behaviour.
    df.fillna(0, inplace = True)

# multiple columns appraoch
df[["Student", "ID"]] = df[["Student", "ID"]].fillna(0)

最后是 replace() 方法：

df["Student"] = df["Student"].replace(np.nan, 0)

Answer 13

这对我有用，但没有人提到它。 会不会有什么问题？

df.loc[df['column_name'].isnull(), 'column_name'] = 0

Answer 14

如果要将其转换为 pandas 数据框，也可以使用fillna来完成。

import numpy as np
df=np.array([[1,2,3, np.nan]])

import pandas as pd
df=pd.DataFrame(df)
df.fillna(0)

这将返回以下内容：

     0    1    2   3
0  1.0  2.0  3.0 NaN
>>> df.fillna(0)
     0    1    2    3
0  1.0  2.0  3.0  0.0

Answer 15

主要有两种选择； 如果仅用数字替换（跨列）填充或填充缺失值NaN / np.nan ：

df['Amount'].fillna(value=None, method= ,axis=1,)就足够了：

从文档：

value : 标量、dict、Series 或 DataFrame 用于填充孔的值（例如 0），或者是一个 dict/Series/DataFrame 值，指定用于每个索引（对于 Series）或列（对于 DataFrame）的值. （不在 dict/Series/DataFrame 中的值将不会被填充）。 此值不能是列表。

这意味着不再允许估算“字符串”或“常量”。

对于更专业的估算，请使用SimpleImputer() ：

from sklearn.impute import SimpleImputer
si = SimpleImputer(strategy='constant', missing_values=np.nan, fill_value='Replacement_Value')
df[['Col-1', 'Col-2']] = si.fit_transform(X=df[['C-1', 'C-2']])

Answer 16

如果要为特定列填充 NaN，可以使用 loc：

d1 = {"Col1" : ['A', 'B', 'C'],
     "fruits": ['Avocado', 'Banana', 'NaN']}
d1= pd.DataFrame(d1)

output:

Col1    fruits
0   A   Avocado
1   B   Banana
2   C   NaN


d1.loc[ d1.Col1=='C', 'fruits' ] =  'Carrot'


output:

Col1    fruits
0   A   Avocado
1   B   Banana
2   C   Carrot

Answer 17

我觉得也值得一提，解释一下fillna()的参数配置，比如Method、Axis、Limit等。

从我们拥有的文档中：

Series.fillna(value=None, method=None, axis=None, 
                 inplace=False, limit=None, downcast=None)
Fill NA/NaN values using the specified method.

参数

value [scalar, dict, Series, or DataFrame] Value to use to 
 fill holes (e.g. 0), alternately a dict/Series/DataFrame 
 of values specifying which value to use for each index 
 (for a Series) or column (for a DataFrame). Values not in 
 the dict/Series/DataFrame will not be filled. This 
 value cannot be a list.

method [{‘backfill’, ‘bfill’, ‘pad’, ‘ffill’, None}, 
 default None] Method to use for filling holes in 
 reindexed Series pad / ffill: propagate last valid 
 observation forward to next valid backfill / bfill: 
 use next valid observation to fill gap axis 
 [{0 or ‘index’}] Axis along which to fill missing values.

inplace [bool, default False] If True, fill 
 in-place. Note: this will modify any other views
 on this object (e.g., a no-copy slice for a 
 column in a DataFrame).

limit [int,defaultNone] If method is specified, 
 this is the maximum number of consecutive NaN 
 values to forward/backward fill. In other words, 
 if there is a gap with more than this number of 
 consecutive NaNs, it will only be partially filled. 
 If method is not specified, this is the maximum 
 number of entries along the entire axis where NaNs
 will be filled. Must be greater than 0 if not None.

downcast [dict, default is None] A dict of item->dtype 
 of what to downcast if possible, or the string ‘infer’ 
 which will try to downcast to an appropriate equal 
 type (e.g. float64 to int64 if possible).

好的。 让我们从method=参数开始，它有前向填充（ffill）和后向填充（bfill） ffill 正在向前复制前一个非缺失值。

例如：

import pandas as pd
import numpy as np
inp = [{'c1':10, 'c2':np.nan, 'c3':200}, {'c1':np.nan,'c2':110, 'c3':210}, {'c1':12,'c2':np.nan, 'c3':220},{'c1':12,'c2':130, 'c3':np.nan},{'c1':12,'c2':np.nan, 'c3':240}]
df = pd.DataFrame(inp)

  c1       c2      c3
0   10.0     NaN      200.0
1   NaN   110.0 210.0
2   12.0     NaN      220.0
3   12.0     130.0 NaN
4   12.0     NaN      240.0

前向填充：

df.fillna(method="ffill")

    c1     c2      c3
0   10.0      NaN 200.0
1   10.0    110.0   210.0
2   12.0    110.0   220.0
3   12.0    130.0   220.0
4   12.0    130.0   240.0

向后填充：

df.fillna(method="bfill")

    c1      c2     c3
0   10.0    110.0   200.0
1   12.0    110.0   210.0
2   12.0    130.0   220.0
3   12.0    130.0   240.0
4   12.0      NaN   240.0

Axis Parameter 帮助我们选择填充的方向：

填写方向：

填充：

Axis = 1 
Method = 'ffill'
----------->
  direction 

df.fillna(method="ffill", axis=1)

       c1   c2      c3
0   10.0     10.0   200.0
1    NaN    110.0   210.0
2   12.0     12.0   220.0
3   12.0    130.0   130.0
4   12.0    12.0    240.0

Axis = 0 # by default 
Method = 'ffill'
|
|       # direction 
|
V
e.g: # This is the ffill default
df.fillna(method="ffill", axis=0)

    c1     c2      c3
0   10.0      NaN   200.0
1   10.0    110.0   210.0
2   12.0    110.0   220.0
3   12.0    130.0   220.0
4   12.0    130.0   240.0

填充：

axis= 0
method = 'bfill'
^
|
|
|
df.fillna(method="bfill", axis=0)

    c1     c2      c3
0   10.0    110.0   200.0
1   12.0    110.0   210.0
2   12.0    130.0   220.0
3   12.0    130.0   240.0
4   12.0      NaN   240.0

axis = 1
method = 'bfill'
<-----------
df.fillna(method="bfill", axis=1)
        c1     c2       c3
0    10.0   200.0   200.0
1   110.0   110.0   210.0
2    12.0   220.0   220.0
3    12.0   130.0     NaN
4    12.0   240.0   240.0

# alias:
#  'fill' == 'pad' 
#   bfill == backfill

限制参数：

df
    c1     c2      c3
0   10.0      NaN   200.0
1    NaN    110.0   210.0
2   12.0      NaN   220.0
3   12.0    130.0     NaN
4   12.0      NaN   240.0

仅替换跨列的第一个 NaN 元素：

df.fillna(value = 'Unavailable', limit=1)
            c1           c2          c3
0          10.0 Unavailable       200.0
1   Unavailable       110.0       210.0
2          12.0         NaN       220.0
3          12.0       130.0 Unavailable
4          12.0         NaN       240.0

df.fillna(value = 'Unavailable', limit=2)

           c1            c2          c3
0          10.0 Unavailable       200.0
1   Unavailable       110.0       210.0
2          12.0 Unavailable       220.0
3          12.0       130.0 Unavailable
4          12.0         NaN       240.0

向下转换参数：

df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   c1      4 non-null      float64
 1   c2      2 non-null      float64
 2   c3      4 non-null      float64
dtypes: float64(3)
memory usage: 248.0 bytes

df.fillna(method="ffill",downcast='infer').info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   c1      5 non-null      int64  
 1   c2      4 non-null      float64
 2   c3      5 non-null      int64  
dtypes: float64(1), int64(2)
memory usage: 248.0 bytes