清理/填充缺失数据

pandas objects are equipped with various data manipulation methods for dealing with missing data.

Filling missing values: fillna

fillna() can “fill in” NA values with non-NA data in a couple of ways, which we illustrate:

Replace NA with a scalar value

  1. In [41]: df2
  2. Out[41]: 
  3.         one       two     three four   five  timestamp
  4. a       NaN  0.501113 -0.355322  bar  False        NaT
  5. c       NaN  0.580967  0.983801  bar  False        NaT
  6. e  0.057802  0.761948 -0.712964  bar   True 2012-01-01
  7. f -0.443160 -0.974602  1.047704  bar  False 2012-01-01
  8. h       NaN -1.053898 -0.019369  bar  False        NaT
  10. In [42]: df2.fillna(0)
  11. Out[42]: 
  12.         one       two     three four   five            timestamp
  13. a  0.000000  0.501113 -0.355322  bar  False                    0
  14. c  0.000000  0.580967  0.983801  bar  False                    0
  15. e  0.057802  0.761948 -0.712964  bar   True  2012-01-01 00:00:00
  16. f -0.443160 -0.974602  1.047704  bar  False  2012-01-01 00:00:00
  17. h  0.000000 -1.053898 -0.019369  bar  False                    0
  19. In [43]: df2['one'].fillna('missing')
  20. Out[43]: 
  21. a     missing
  22. c     missing
  23. e    0.057802
  24. f    -0.44316
  25. h     missing
  26. Name: one, dtype: object

Fill gaps forward or backward

Using the same filling arguments as reindexing, we can propagate non-NA values forward or backward:

  1. In [44]: df
  2. Out[44]: 
  3.         one       two     three
  4. a       NaN  0.501113 -0.355322
  5. c       NaN  0.580967  0.983801
  6. e  0.057802  0.761948 -0.712964
  7. f -0.443160 -0.974602  1.047704
  8. h       NaN -1.053898 -0.019369
  10. In [45]: df.fillna(method='pad')
  11. Out[45]: 
  12.         one       two     three
  13. a       NaN  0.501113 -0.355322
  14. c       NaN  0.580967  0.983801
  15. e  0.057802  0.761948 -0.712964
  16. f -0.443160 -0.974602  1.047704
  17. h -0.443160 -1.053898 -0.019369

Limit the amount of filling

If we only want consecutive gaps filled up to a certain number of data points, we can use the limit keyword:

  1. In [46]: df
  2. Out[46]: 
  3.    one       two     three
  4. a  NaN  0.501113 -0.355322
  5. c  NaN  0.580967  0.983801
  6. e  NaN       NaN       NaN
  7. f  NaN       NaN       NaN
  8. h  NaN -1.053898 -0.019369
  10. In [47]: df.fillna(method='pad', limit=1)
  11. Out[47]: 
  12.    one       two     three
  13. a  NaN  0.501113 -0.355322
  14. c  NaN  0.580967  0.983801
  15. e  NaN  0.580967  0.983801
  16. f  NaN       NaN       NaN
  17. h  NaN -1.053898 -0.019369

To remind you, these are the available filling methods:

MethodAction
pad / ffillFill values forward
bfill / backfillFill values backward

With time series data, using pad/ffill is extremely common so that the “last known value” is available at every time point.

ffill() is equivalent to fillna(method='ffill') and bfill() is equivalent to fillna(method='bfill')

Filling with a PandasObject

You can also fillna using a dict or Series that is alignable. The labels of the dict or index of the Series must match the columns of the frame you wish to fill. The use case of this is to fill a DataFrame with the mean of that column.

  1. In [48]: dff = pd.DataFrame(np.random.randn(10,3), columns=list('ABC'))
  3. In [49]: dff.iloc[3:5,0] = np.nan
  5. In [50]: dff.iloc[4:6,1] = np.nan
  7. In [51]: dff.iloc[5:8,2] = np.nan
  9. In [52]: dff
  10. Out[52]: 
  11.           A         B         C
  12. 0  0.758887  2.340598  0.219039
  13. 1 -1.235583  0.031785  0.701683
  14. 2 -1.557016 -0.636986 -1.238610
  15. 3       NaN -1.002278  0.654052
  16. 4       NaN       NaN  1.053999
  17. 5  0.651981       NaN       NaN
  18. 6  0.109001 -0.533294       NaN
  19. 7 -1.037831 -1.150016       NaN
  20. 8 -0.687693  1.921056 -0.121113
  21. 9 -0.258742 -0.706329  0.402547
  23. In [53]: dff.fillna(dff.mean())
  24. Out[53]: 
  25.           A         B         C
  26. 0  0.758887  2.340598  0.219039
  27. 1 -1.235583  0.031785  0.701683
  28. 2 -1.557016 -0.636986 -1.238610
  29. 3 -0.407125 -1.002278  0.654052
  30. 4 -0.407125  0.033067  1.053999
  31. 5  0.651981  0.033067  0.238800
  32. 6  0.109001 -0.533294  0.238800
  33. 7 -1.037831 -1.150016  0.238800
  34. 8 -0.687693  1.921056 -0.121113
  35. 9 -0.258742 -0.706329  0.402547
  37. In [54]: dff.fillna(dff.mean()['B':'C'])
  38. Out[54]: 
  39.           A         B         C
  40. 0  0.758887  2.340598  0.219039
  41. 1 -1.235583  0.031785  0.701683
  42. 2 -1.557016 -0.636986 -1.238610
  43. 3       NaN -1.002278  0.654052
  44. 4       NaN  0.033067  1.053999
  45. 5  0.651981  0.033067  0.238800
  46. 6  0.109001 -0.533294  0.238800
  47. 7 -1.037831 -1.150016  0.238800
  48. 8 -0.687693  1.921056 -0.121113
  49. 9 -0.258742 -0.706329  0.402547

Same result as above, but is aligning the ‘fill’ value which is a Series in this case.

  1. In [55]: dff.where(pd.notna(dff), dff.mean(), axis='columns')
  2. Out[55]: 
  3.           A         B         C
  4. 0  0.758887  2.340598  0.219039
  5. 1 -1.235583  0.031785  0.701683
  6. 2 -1.557016 -0.636986 -1.238610
  7. 3 -0.407125 -1.002278  0.654052
  8. 4 -0.407125  0.033067  1.053999
  9. 5  0.651981  0.033067  0.238800
  10. 6  0.109001 -0.533294  0.238800
  11. 7 -1.037831 -1.150016  0.238800
  12. 8 -0.687693  1.921056 -0.121113
  13. 9 -0.258742 -0.706329  0.402547

Dropping axis labels with missing data: dropna

You may wish to simply exclude labels from a data set which refer to missing data. To do this, use dropna():

  1. In [56]: df
  2. Out[56]: 
  3.    one       two     three
  4. a  NaN  0.501113 -0.355322
  5. c  NaN  0.580967  0.983801
  6. e  NaN  0.000000  0.000000
  7. f  NaN  0.000000  0.000000
  8. h  NaN -1.053898 -0.019369
  10. In [57]: df.dropna(axis=0)
  11. Out[57]: 
  12. Empty DataFrame
  13. Columns: [one, two, three]
  14. Index: []
  16. In [58]: df.dropna(axis=1)
  17. Out[58]: 
  18.         two     three
  19. a  0.501113 -0.355322
  20. c  0.580967  0.983801
  21. e  0.000000  0.000000
  22. f  0.000000  0.000000
  23. h -1.053898 -0.019369
  25. In [59]: df['one'].dropna()
  26. Out[59]: Series([], Name: one, dtype: float64)

An equivalent dropna() is available for Series. DataFrame.dropna has considerably more options than Series.dropna, which can be examined in the API.

Interpolation

New in version 0.21.0: The limit_area keyword argument was added.

Both Series and DataFrame objects have interpolate() that, by default, performs linear interpolation at missing datapoints.

  1. In [60]: ts
  2. Out[60]: 
  3. 2000-01-31    0.469112
  4. 2000-02-29         NaN
  5. 2000-03-31         NaN
  6. 2000-04-28         NaN
  7. 2000-05-31         NaN
  8. 2000-06-30         NaN
  9. 2000-07-31         NaN
  10.                 ...   
  11. 2007-10-31   -3.305259
  12. 2007-11-30   -5.485119
  13. 2007-12-31   -6.854968
  14. 2008-01-31   -7.809176
  15. 2008-02-29   -6.346480
  16. 2008-03-31   -8.089641
  17. 2008-04-30   -8.916232
  18. Freq: BM, Length: 100, dtype: float64
  20. In [61]: ts.count()
  21. Out[61]: 61
  23. In [62]: ts.interpolate().count()
  24. Out[62]: 100
  26. In [63]: ts.interpolate().plot()
  27. Out[63]: <matplotlib.axes._subplots.AxesSubplot at 0x7f20cf59ca58>

_images/series_interpolate.png

Index aware interpolation is available via the method keyword:

  1. In [64]: ts2
  2. Out[64]: 
  3. 2000-01-31    0.469112
  4. 2000-02-29         NaN
  5. 2002-07-31   -5.689738
  6. 2005-01-31         NaN
  7. 2008-04-30   -8.916232
  8. dtype: float64
  10. In [65]: ts2.interpolate()
  11. Out[65]: 
  12. 2000-01-31    0.469112
  13. 2000-02-29   -2.610313
  14. 2002-07-31   -5.689738
  15. 2005-01-31   -7.302985
  16. 2008-04-30   -8.916232
  17. dtype: float64
  19. In [66]: ts2.interpolate(method='time')
  20. Out[66]: 
  21. 2000-01-31    0.469112
  22. 2000-02-29    0.273272
  23. 2002-07-31   -5.689738
  24. 2005-01-31   -7.095568
  25. 2008-04-30   -8.916232
  26. dtype: float64

For a floating-point index, use method='values':

  1. In [67]: ser
  2. Out[67]: 
  3. 0.0      0.0
  4. 1.0      NaN
  5. 10.0    10.0
  6. dtype: float64
  8. In [68]: ser.interpolate()
  9. Out[68]: 
  10. 0.0      0.0
  11. 1.0      5.0
  12. 10.0    10.0
  13. dtype: float64
  15. In [69]: ser.interpolate(method='values')
  16. Out[69]: 
  17. 0.0      0.0
  18. 1.0      1.0
  19. 10.0    10.0
  20. dtype: float64

You can also interpolate with a DataFrame:

  1. In [70]: df = pd.DataFrame({'A': [1, 2.1, np.nan, 4.7, 5.6, 6.8],
  2.    ....:                    'B': [.25, np.nan, np.nan, 4, 12.2, 14.4]})
  3.    ....: 
  5. In [71]: df
  6. Out[71]: 
  7.      A      B
  8. 0  1.0   0.25
  9. 1  2.1    NaN
  10. 2  NaN    NaN
  11. 3  4.7   4.00
  12. 4  5.6  12.20
  13. 5  6.8  14.40
  15. In [72]: df.interpolate()
  16. Out[72]: 
  17.      A      B
  18. 0  1.0   0.25
  19. 1  2.1   1.50
  20. 2  3.4   2.75
  21. 3  4.7   4.00
  22. 4  5.6  12.20
  23. 5  6.8  14.40

The method argument gives access to fancier interpolation methods. If you have scipy installed, you can pass the name of a 1-d interpolation routine to method. You’ll want to consult the full scipy interpolation documentation and reference guide for details. The appropriate interpolation method will depend on the type of data you are working with.

  • If you are dealing with a time series that is growing at an increasing rate, method='quadratic' may be appropriate.
  • If you have values approximating a cumulative distribution function, then method='pchip' should work well.
  • To fill missing values with goal of smooth plotting, consider method='akima'.

警告

These methods require scipy.

  1. In [73]: df.interpolate(method='barycentric')
  2. Out[73]: 
  3.       A       B
  4. 0  1.00   0.250
  5. 1  2.10  -7.660
  6. 2  3.53  -4.515
  7. 3  4.70   4.000
  8. 4  5.60  12.200
  9. 5  6.80  14.400
  11. In [74]: df.interpolate(method='pchip')
  12. Out[74]: 
  13.          A          B
  14. 0  1.00000   0.250000
  15. 1  2.10000   0.672808
  16. 2  3.43454   1.928950
  17. 3  4.70000   4.000000
  18. 4  5.60000  12.200000
  19. 5  6.80000  14.400000
  21. In [75]: df.interpolate(method='akima')
  22. Out[75]: 
  23.           A          B
  24. 0  1.000000   0.250000
  25. 1  2.100000  -0.873316
  26. 2  3.406667   0.320034
  27. 3  4.700000   4.000000
  28. 4  5.600000  12.200000
  29. 5  6.800000  14.400000

When interpolating via a polynomial or spline approximation, you must also specify the degree or order of the approximation:

  1. In [76]: df.interpolate(method='spline', order=2)
  2. Out[76]: 
  3.           A          B
  4. 0  1.000000   0.250000
  5. 1  2.100000  -0.428598
  6. 2  3.404545   1.206900
  7. 3  4.700000   4.000000
  8. 4  5.600000  12.200000
  9. 5  6.800000  14.400000
  11. In [77]: df.interpolate(method='polynomial', order=2)
  12. Out[77]: 
  13.           A          B
  14. 0  1.000000   0.250000
  15. 1  2.100000  -2.703846
  16. 2  3.451351  -1.453846
  17. 3  4.700000   4.000000
  18. 4  5.600000  12.200000
  19. 5  6.800000  14.400000

Compare several methods:

  1. In [78]: np.random.seed(2)
  3. In [79]: ser = pd.Series(np.arange(1, 10.1, .25)**2 + np.random.randn(37))
  5. In [80]: bad = np.array([4, 13, 14, 15, 16, 17, 18, 20, 29])
  7. In [81]: ser[bad] = np.nan
  9. In [82]: methods = ['linear', 'quadratic', 'cubic']
  11. In [83]: df = pd.DataFrame({m: ser.interpolate(method=m) for m in methods})
  13. In [84]: df.plot()
  14. Out[84]: <matplotlib.axes._subplots.AxesSubplot at 0x7f20cf573fd0>

_images/compare_interpolations.png

Another use case is interpolation at new values. Suppose you have 100 observations from some distribution. And let’s suppose that you’re particularly interested in what’s happening around the middle. You can mix pandas’ reindex and interpolate methods to interpolate at the new values.

  1. In [85]: ser = pd.Series(np.sort(np.random.uniform(size=100)))
  3. # interpolate at new_index
  4. In [86]: new_index = ser.index | pd.Index([49.25, 49.5, 49.75, 50.25, 50.5, 50.75])
  6. In [87]: interp_s = ser.reindex(new_index).interpolate(method='pchip')
  8. In [88]: interp_s[49:51]
  9. Out[88]: 
  10. 49.00    0.471410
  11. 49.25    0.476841
  12. 49.50    0.481780
  13. 49.75    0.485998
  14. 50.00    0.489266
  15. 50.25    0.491814
  16. 50.50    0.493995
  17. 50.75    0.495763
  18. 51.00    0.497074
  19. dtype: float64

Interpolation Limits

Like other pandas fill methods, interpolate() accepts a limit keyword argument. Use this argument to limit the number of consecutive NaN values filled since the last valid observation:

  1. In [89]: ser = pd.Series([np.nan, np.nan, 5, np.nan, np.nan, np.nan, 13, np.nan, np.nan])
  3. # fill all consecutive values in a forward direction
  4. In [90]: ser.interpolate()
  5. Out[90]: 
  6. 0     NaN
  7. 1     NaN
  8. 2     5.0
  9. 3     7.0
  10. 4     9.0
  11. 5    11.0
  12. 6    13.0
  13. 7    13.0
  14. 8    13.0
  15. dtype: float64
  17. # fill one consecutive value in a forward direction
  18. In [91]: ser.interpolate(limit=1)
  19. Out[91]: 
  20. 0     NaN
  21. 1     NaN
  22. 2     5.0
  23. 3     7.0
  24. 4     NaN
  25. 5     NaN
  26. 6    13.0
  27. 7    13.0
  28. 8     NaN
  29. dtype: float64

By default, NaN values are filled in a forward direction. Use limit_direction parameter to fill backward or from both directions.

  1. # fill one consecutive value backwards
  2. In [92]: ser.interpolate(limit=1, limit_direction='backward')
  3. Out[92]: 
  4. 0     NaN
  5. 1     5.0
  6. 2     5.0
  7. 3     NaN
  8. 4     NaN
  9. 5    11.0
  10. 6    13.0
  11. 7     NaN
  12. 8     NaN
  13. dtype: float64
  15. # fill one consecutive value in both directions
  16. In [93]: ser.interpolate(limit=1, limit_direction='both')
  17. Out[93]: 
  18. 0     NaN
  19. 1     5.0
  20. 2     5.0
  21. 3     7.0
  22. 4     NaN
  23. 5    11.0
  24. 6    13.0
  25. 7    13.0
  26. 8     NaN
  27. dtype: float64
  29. # fill all consecutive values in both directions
  30. In [94]: ser.interpolate(limit_direction='both')
  31. Out[94]: 
  32. 0     5.0
  33. 1     5.0
  34. 2     5.0
  35. 3     7.0
  36. 4     9.0
  37. 5    11.0
  38. 6    13.0
  39. 7    13.0
  40. 8    13.0
  41. dtype: float64

By default, NaN values are filled whether they are inside (surrounded by) existing valid values, or outside existing valid values. Introduced in v0.23 the limit_area parameter restricts filling to either inside or outside values.

  1. # fill one consecutive inside value in both directions
  2. In [95]: ser.interpolate(limit_direction='both', limit_area='inside', limit=1)
  3. Out[95]: 
  4. 0     NaN
  5. 1     NaN
  6. 2     5.0
  7. 3     7.0
  8. 4     NaN
  9. 5    11.0
  10. 6    13.0
  11. 7     NaN
  12. 8     NaN
  13. dtype: float64
  15. # fill all consecutive outside values backward
  16. In [96]: ser.interpolate(limit_direction='backward', limit_area='outside')
  17. Out[96]: 
  18. 0     5.0
  19. 1     5.0
  20. 2     5.0
  21. 3     NaN
  22. 4     NaN
  23. 5     NaN
  24. 6    13.0
  25. 7     NaN
  26. 8     NaN
  27. dtype: float64
  29. # fill all consecutive outside values in both directions
  30. In [97]: ser.interpolate(limit_direction='both', limit_area='outside')
  31. Out[97]: 
  32. 0     5.0
  33. 1     5.0
  34. 2     5.0
  35. 3     NaN
  36. 4     NaN
  37. 5     NaN
  38. 6    13.0
  39. 7    13.0
  40. 8    13.0
  41. dtype: float64

Replacing Generic Values

Often times we want to replace arbitrary values with other values.

replace() in Series and replace() in DataFrame provides an efficient yet flexible way to perform such replacements.

For a Series, you can replace a single value or a list of values by another value:

  1. In [98]: ser = pd.Series([0., 1., 2., 3., 4.])
  3. In [99]: ser.replace(0, 5)
  4. Out[99]: 
  5. 0    5.0
  6. 1    1.0
  7. 2    2.0
  8. 3    3.0
  9. 4    4.0
  10. dtype: float64

You can replace a list of values by a list of other values:

  1. In [100]: ser.replace([0, 1, 2, 3, 4], [4, 3, 2, 1, 0])
  2. Out[100]: 
  3. 0    4.0
  4. 1    3.0
  5. 2    2.0
  6. 3    1.0
  7. 4    0.0
  8. dtype: float64

You can also specify a mapping dict:

  1. In [101]: ser.replace({0: 10, 1: 100})
  2. Out[101]: 
  3. 0     10.0
  4. 1    100.0
  5. 2      2.0
  6. 3      3.0
  7. 4      4.0
  8. dtype: float64

For a DataFrame, you can specify individual values by column:

  1. In [102]: df = pd.DataFrame({'a': [0, 1, 2, 3, 4], 'b': [5, 6, 7, 8, 9]})
  3. In [103]: df.replace({'a': 0, 'b': 5}, 100)
  4. Out[103]: 
  5.      a    b
  6. 0  100  100
  7. 1    1    6
  8. 2    2    7
  9. 3    3    8
  10. 4    4    9

Instead of replacing with specified values, you can treat all given values as missing and interpolate over them:

  1. In [104]: ser.replace([1, 2, 3], method='pad')
  2. Out[104]: 
  3. 0    0.0
  4. 1    0.0
  5. 2    0.0
  6. 3    0.0
  7. 4    4.0
  8. dtype: float64

String/Regular Expression Replacement

Note: Python strings prefixed with the r character such as r’hello world’ are so-called “raw” strings. They have different semantics regarding backslashes than strings without this prefix. Backslashes in raw strings will be interpreted as an escaped backslash, e.g., r’’ == ‘\‘. You should read about them if this is unclear.

Replace the ‘.’ with NaN (str -> str):

  1. In [105]: d = {'a': list(range(4)), 'b': list('ab..'), 'c': ['a', 'b', np.nan, 'd']}
  3. In [106]: df = pd.DataFrame(d)
  5. In [107]: df.replace('.', np.nan)
  6. Out[107]: 
  7.    a    b    c
  8. 0  0    a    a
  9. 1  1    b    b
  10. 2  2  NaN  NaN
  11. 3  3  NaN    d

Now do it with a regular expression that removes surrounding whitespace (regex -> regex):

  1. In [108]: df.replace(r'\s*\.\s*', np.nan, regex=True)
  2. Out[108]: 
  3.    a    b    c
  4. 0  0    a    a
  5. 1  1    b    b
  6. 2  2  NaN  NaN
  7. 3  3  NaN    d

Replace a few different values (list -> list):

  1. In [109]: df.replace(['a', '.'], ['b', np.nan])
  2. Out[109]: 
  3.    a    b    c
  4. 0  0    b    b
  5. 1  1    b    b
  6. 2  2  NaN  NaN
  7. 3  3  NaN    d

list of regex -> list of regex:

  1. In [110]: df.replace([r'\.', r'(a)'], ['dot', '\1stuff'], regex=True)
  2. Out[110]: 
  3.    a       b       c
  4. 0  0  �stuff  �stuff
  5. 1  1       b       b
  6. 2  2     dot     NaN
  7. 3  3     dot       d

Only search in column 'b' (dict -> dict):

  1. In [111]: df.replace({'b': '.'}, {'b': np.nan})
  2. Out[111]: 
  3.    a    b    c
  4. 0  0    a    a
  5. 1  1    b    b
  6. 2  2  NaN  NaN
  7. 3  3  NaN    d

Same as the previous example, but use a regular expression for searching instead (dict of regex -> dict):

  1. In [112]: df.replace({'b': r'\s*\.\s*'}, {'b': np.nan}, regex=True)
  2. Out[112]: 
  3.    a    b    c
  4. 0  0    a    a
  5. 1  1    b    b
  6. 2  2  NaN  NaN
  7. 3  3  NaN    d

You can pass nested dictionaries of regular expressions that use regex=True:

  1. In [113]: df.replace({'b': {'b': r''}}, regex=True)
  2. Out[113]: 
  3.    a  b    c
  4. 0  0  a    a
  5. 1  1       b
  6. 2  2  .  NaN
  7. 3  3  .    d

Alternatively, you can pass the nested dictionary like so:

  1. In [114]: df.replace(regex={'b': {r'\s*\.\s*': np.nan}})
  2. Out[114]: 
  3.    a    b    c
  4. 0  0    a    a
  5. 1  1    b    b
  6. 2  2  NaN  NaN
  7. 3  3  NaN    d

You can also use the group of a regular expression match when replacing (dict of regex -> dict of regex), this works for lists as well.

  1. In [115]: df.replace({'b': r'\s*(\.)\s*'}, {'b': r'\1ty'}, regex=True)
  2. Out[115]: 
  3.    a    b    c
  4. 0  0    a    a
  5. 1  1    b    b
  6. 2  2  .ty  NaN
  7. 3  3  .ty    d

You can pass a list of regular expressions, of which those that match will be replaced with a scalar (list of regex -> regex).

  1. In [116]: df.replace([r'\s*\.\s*', r'a|b'], np.nan, regex=True)
  2. Out[116]: 
  3.    a   b    c
  4. 0  0 NaN  NaN
  5. 1  1 NaN  NaN
  6. 2  2 NaN  NaN
  7. 3  3 NaN    d

All of the regular expression examples can also be passed with the to_replace argument as the regex argument. In this case the value argument must be passed explicitly by name or regex must be a nested dictionary. The previous example, in this case, would then be:

  1. In [117]: df.replace(regex=[r'\s*\.\s*', r'a|b'], value=np.nan)
  2. Out[117]: 
  3.    a   b    c
  4. 0  0 NaN  NaN
  5. 1  1 NaN  NaN
  6. 2  2 NaN  NaN
  7. 3  3 NaN    d

This can be convenient if you do not want to pass regex=True every time you want to use a regular expression.

Note: Anywhere in the above replace examples that you see a regular expression a compiled regular expression is valid as well.

Numeric Replacement

replace() is similar to fillna().

  1. In [118]: df = pd.DataFrame(np.random.randn(10, 2))
  3. In [119]: df[np.random.rand(df.shape[0]) > 0.5] = 1.5
  5. In [120]: df.replace(1.5, np.nan)
  6. Out[120]: 
  7.           0         1
  8. 0 -0.844214 -1.021415
  9. 1  0.432396 -0.323580
  10. 2  0.423825  0.799180
  11. 3  1.262614  0.751965
  12. 4       NaN       NaN
  13. 5       NaN       NaN
  14. 6 -0.498174 -1.060799
  15. 7  0.591667 -0.183257
  16. 8  1.019855 -1.482465
  17. 9       NaN       NaN

Replacing more than one value is possible by passing a list.

  1. In [121]: df00 = df.values[0, 0]
  3. In [122]: df.replace([1.5, df00], [np.nan, 'a'])
  4. Out[122]: 
  5.           0         1
  6. 0         a  -1.02141
  7. 1  0.432396  -0.32358
  8. 2  0.423825   0.79918
  9. 3   1.26261  0.751965
  10. 4       NaN       NaN
  11. 5       NaN       NaN
  12. 6 -0.498174   -1.0608
  13. 7  0.591667 -0.183257
  14. 8   1.01985  -1.48247
  15. 9       NaN       NaN
  17. In [123]: df[1].dtype
  18. Out[123]: dtype('float64')

You can also operate on the DataFrame in place:

  1. In [124]: df.replace(1.5, np.nan, inplace=True)

警告

When replacing multiple bool or datetime64 objects, the first argument to replace (to_replace) must match the type of the value being replaced. For example,

  2. s = pd.Series([True, False, True])
  3. s.replace({'a string': 'new value', True: False})  # raises
  5. TypeError: Cannot compare types 'ndarray(dtype=bool)' and 'str'

will raise a TypeError because one of the dict keys is not of the correct type for replacement.

However, when replacing a single object such as,

  1. In [125]: s = pd.Series([True, False, True])
  3. In [126]: s.replace('a string', 'another string')
  4. Out[126]: 
  5. 0     True
  6. 1    False
  7. 2     True
  8. dtype: bool

the original NDFrame object will be returned untouched. We’re working on unifying this API, but for backwards compatibility reasons we cannot break the latter behavior. See GH6354 for more details.