Skip to main content
`Ctrl`+`K`

# pandas.DataFrame.rpow

DataFrame.rpow(other, axis='columns', level=None, fill_value=None)

  Get Exponential power of dataframe and other, element-wise (binary operator rpow).

  Equivalent to `other ** dataframe`, but with support to substitute a fill_value for missing data in one of the inputs. With reverse version, pow.

  Among flexible wrappers (add, sub, mul, div, floordiv, mod, pow) to arithmetic operators: +, -, *, /, //, %, **.

  Parameters:
    other scalar, sequence, Series, dict or DataFrame

      Any single or multiple element data structure, or list-like object.

    axis{0 or ‘index’, 1 or ‘columns’}

      Whether to compare by the index (0 or ‘index’) or columns. (1 or ‘columns’). For Series input, axis to match Series index on.

    level int or label

      Broadcast across a level, matching Index values on the passed MultiIndex level.

    fill_value float or None, default None

      Fill existing missing (NaN) values, and any new element needed for successful DataFrame alignment, with this value before computation. If data in both corresponding DataFrame locations is missing the result will be missing.

  Returns:
    DataFrame

      Result of the arithmetic operation.

  See also

  `DataFrame.add`

    Add DataFrames.

  `DataFrame.sub`

    Subtract DataFrames.

  `DataFrame.mul`

    Multiply DataFrames.

  `DataFrame.div`

    Divide DataFrames (float division).

  `DataFrame.truediv`

    Divide DataFrames (float division).

  `DataFrame.floordiv`

    Divide DataFrames (integer division).

  `DataFrame.mod`

    Calculate modulo (remainder after division).

  `DataFrame.pow`

    Calculate exponential power.

  Notes

  Mismatched indices will be unioned together.

  Examples

      >>> df = pd.DataFrame({'angles': [0, 3, 4],
      ...                    'degrees': [360, 180, 360]},
      ...                   index=['circle', 'triangle', 'rectangle'])
      >>> df
                 angles  degrees
      circle          0      360
      triangle        3      180
      rectangle       4      360

  Add a scalar with operator version which return the same results.

      >>> df + 1
                 angles  degrees
      circle          1      361
      triangle        4      181
      rectangle       5      361

      >>> df.add(1)
                 angles  degrees
      circle          1      361
      triangle        4      181
      rectangle       5      361

  Divide by constant with reverse version.

      >>> df.div(10)
                 angles  degrees
      circle        0.0     36.0
      triangle      0.3     18.0
      rectangle     0.4     36.0

      >>> df.rdiv(10)
                   angles   degrees
      circle          inf  0.027778
      triangle   3.333333  0.055556
      rectangle  2.500000  0.027778

  Subtract a list and Series by axis with operator version.

      >>> df - [1, 2]
                 angles  degrees
      circle         -1      358
      triangle        2      178
      rectangle       3      358

      >>> df.sub([1, 2], axis='columns')
                 angles  degrees
      circle         -1      358
      triangle        2      178
      rectangle       3      358

      >>> df.sub(pd.Series([1, 1, 1], index=['circle', 'triangle', 'rectangle']),
      ...        axis='index')
                 angles  degrees
      circle         -1      359
      triangle        2      179
      rectangle       3      359

  Multiply a dictionary by axis.

      >>> df.mul({'angles': 0, 'degrees': 2})
                  angles  degrees
      circle           0      720
      triangle         0      360
      rectangle        0      720

      >>> df.mul({'circle': 0, 'triangle': 2, 'rectangle': 3}, axis='index')
                  angles  degrees
      circle           0        0
      triangle         6      360
      rectangle       12     1080

  Multiply a DataFrame of different shape with operator version.

      >>> other = pd.DataFrame({'angles': [0, 3, 4]},
      ...                      index=['circle', 'triangle', 'rectangle'])
      >>> other
                 angles
      circle          0
      triangle        3
      rectangle       4

      >>> df * other
                 angles  degrees
      circle          0      NaN
      triangle        9      NaN
      rectangle      16      NaN

      >>> df.mul(other, fill_value=0)
                 angles  degrees
      circle          0      0.0
      triangle        9      0.0
      rectangle      16      0.0

  Divide by a MultiIndex by level.

      >>> df_multindex = pd.DataFrame({'angles': [0, 3, 4, 4, 5, 6],
      ...                              'degrees': [360, 180, 360, 360, 540, 720]},
      ...                             index=[['A', 'A', 'A', 'B', 'B', 'B'],
      ...                                    ['circle', 'triangle', 'rectangle',
      ...                                     'square', 'pentagon', 'hexagon']])
      >>> df_multindex
                   angles  degrees
      A circle          0      360
        triangle        3      180
        rectangle       4      360
      B square          4      360
        pentagon        5      540
        hexagon         6      720

      >>> df.div(df_multindex, level=1, fill_value=0)
                   angles  degrees
      A circle        NaN      1.0
        triangle      1.0      1.0
        rectangle     1.0      1.0
      B square        0.0      0.0
        pentagon      0.0      0.0
        hexagon       0.0      0.0

      >>> df_pow = pd.DataFrame({'A': [2, 3, 4, 5],
      ...                        'B': [6, 7, 8, 9]})
      >>> df_pow.pow(2)
          A   B
      0   4  36
      1   9  49
      2  16  64
      3  25  81