parameters: (self, expr: str, inplace: bool = False, **kwargs)
docstring: Query the columns of a DataFrame with a boolean expression.
  
          Parameters
          ----------
          expr : str
              The query string to evaluate.
  
              You can refer to variables
              in the environment by prefixing them with an '@' character like
              ``@a + b``.
  
              You can refer to column names that are not valid Python variable names
              by surrounding them in backticks. Thus, column names containing spaces
              or punctuations (besides underscores) or starting with digits must be
              surrounded by backticks. (For example, a column named "Area (cm^2)" would
              be referenced as ```Area (cm^2)```). Column names which are Python keywords
              (like "list", "for", "import", etc) cannot be used.
  
              For example, if one of your columns is called ``a a`` and you want
              to sum it with ``b``, your query should be ```a a` + b``.
  
              .. versionadded:: 0.25.0
                  Backtick quoting introduced.
  
              .. versionadded:: 1.0.0
                  Expanding functionality of backtick quoting for more than only spaces.
  
          inplace : bool
              Whether the query should modify the data in place or return
              a modified copy.
          **kwargs
              See the documentation for :func:`eval` for complete details
              on the keyword arguments accepted by :meth:`DataFrame.query`.
  
          Returns
          -------
          DataFrame or None
              DataFrame resulting from the provided query expression or
              None if ``inplace=True``.
  
          See Also
          --------
          eval : Evaluate a string describing operations on
              DataFrame columns.
          DataFrame.eval : Evaluate a string describing operations on
              DataFrame columns.
  
          Notes
          -----
          The result of the evaluation of this expression is first passed to
          :attr:`DataFrame.loc` and if that fails because of a
          multidimensional key (e.g., a DataFrame) then the result will be passed
          to :meth:`DataFrame.__getitem__`.
  
          This method uses the top-level :func:`eval` function to
          evaluate the passed query.
  
          The :meth:`~pandas.DataFrame.query` method uses a slightly
          modified Python syntax by default. For example, the ``&`` and ``|``
          (bitwise) operators have the precedence of their boolean cousins,
          :keyword:`and` and :keyword:`or`. This *is* syntactically valid Python,
          however the semantics are different.
  
          You can change the semantics of the expression by passing the keyword
          argument ``parser='python'``. This enforces the same semantics as
          evaluation in Python space. Likewise, you can pass ``engine='python'``
          to evaluate an expression using Python itself as a backend. This is not
          recommended as it is inefficient compared to using ``numexpr`` as the
          engine.
  
          The :attr:`DataFrame.index` and
          :attr:`DataFrame.columns` attributes of the
          :class:`~pandas.DataFrame` instance are placed in the query namespace
          by default, which allows you to treat both the index and columns of the
          frame as a column in the frame.
          The identifier ``index`` is used for the frame index; you can also
          use the name of the index to identify it in a query. Please note that
          Python keywords may not be used as identifiers.
  
          For further details and examples see the ``query`` documentation in
          :ref:`indexing <indexing.query>`.
  
          *Backtick quoted variables*
  
          Backtick quoted variables are parsed as literal Python code and
          are converted internally to a Python valid identifier.
          This can lead to the following problems.
  
          During parsing a number of disallowed characters inside the backtick
          quoted string are replaced by strings that are allowed as a Python identifier.
          These characters include all operators in Python, the space character, the
          question mark, the exclamation mark, the dollar sign, and the euro sign.
          For other characters that fall outside the ASCII range (U+0001..U+007F)
          and those that are not further specified in PEP 3131,
          the query parser will raise an error.
          This excludes whitespace different than the space character,
          but also the hashtag (as it is used for comments) and the backtick
          itself (backtick can also not be escaped).
  
          In a special case, quotes that make a pair around a backtick can
          confuse the parser.
          For example, ```it's` > `that's``` will raise an error,
          as it forms a quoted string (``'s > `that'``) with a backtick inside.
  
          See also the Python documentation about lexical analysis
          (https://docs.python.org/3/reference/lexical_analysis.html)
          in combination with the source code in :mod:`pandas.core.computation.parsing`.
  
          Examples
          --------
          >>> df = pd.DataFrame({'A': range(1, 6),
          ...                    'B': range(10, 0, -2),
          ...                    'C C': range(10, 5, -1)})
          >>> df
             A   B  C C
          0  1  10   10
          1  2   8    9
          2  3   6    8
          3  4   4    7
          4  5   2    6
          >>> df.query('A > B')
             A  B  C C
          4  5  2    6
  
          The previous expression is equivalent to
  
          >>> df[df.A > df.B]
             A  B  C C
          4  5  2    6
  
          For columns with spaces in their name, you can use backtick quoting.
  
          >>> df.query('B == `C C`')
             A   B  C C
          0  1  10   10
  
          The previous expression is equivalent to
  
          >>> df[df.B == df['C C']]
             A   B  C C
          0  1  10   10
docstring_summary: Query the columns of a DataFrame with a boolean expression.
docstring_tokens: Query the columns of a DataFrame with a boolean expression .
function: def query(self, expr: str, inplace: bool = False, **kwargs):
          """
          Query the columns of a DataFrame with a boolean expression.
  
          Parameters
          ----------
          expr : str
              The query string to evaluate.
  
              You can refer to variables
              in the environment by prefixing them with an '@' character like
              ``@a + b``.
  
              You can refer to column names that are not valid Python variable names
              by surrounding them in backticks. Thus, column names containing spaces
              or punctuations (besides underscores) or starting with digits must be
              surrounded by backticks. (For example, a column named "Area (cm^2)" would
              be referenced as ```Area (cm^2)```). Column names which are Python keywords
              (like "list", "for", "import", etc) cannot be used.
  
              For example, if one of your columns is called ``a a`` and you want
              to sum it with ``b``, your query should be ```a a` + b``.
  
              .. versionadded:: 0.25.0
                  Backtick quoting introduced.
  
              .. versionadded:: 1.0.0
                  Expanding functionality of backtick quoting for more than only spaces.
  
          inplace : bool
              Whether the query should modify the data in place or return
              a modified copy.
          **kwargs
              See the documentation for :func:`eval` for complete details
              on the keyword arguments accepted by :meth:`DataFrame.query`.
  
          Returns
          -------
          DataFrame or None
              DataFrame resulting from the provided query expression or
              None if ``inplace=True``.
  
          See Also
          --------
          eval : Evaluate a string describing operations on
              DataFrame columns.
          DataFrame.eval : Evaluate a string describing operations on
              DataFrame columns.
  
          Notes
          -----
          The result of the evaluation of this expression is first passed to
          :attr:`DataFrame.loc` and if that fails because of a
          multidimensional key (e.g., a DataFrame) then the result will be passed
          to :meth:`DataFrame.__getitem__`.
  
          This method uses the top-level :func:`eval` function to
          evaluate the passed query.
  
          The :meth:`~pandas.DataFrame.query` method uses a slightly
          modified Python syntax by default. For example, the ``&`` and ``|``
          (bitwise) operators have the precedence of their boolean cousins,
          :keyword:`and` and :keyword:`or`. This *is* syntactically valid Python,
          however the semantics are different.
  
          You can change the semantics of the expression by passing the keyword
          argument ``parser='python'``. This enforces the same semantics as
          evaluation in Python space. Likewise, you can pass ``engine='python'``
          to evaluate an expression using Python itself as a backend. This is not
          recommended as it is inefficient compared to using ``numexpr`` as the
          engine.
  
          The :attr:`DataFrame.index` and
          :attr:`DataFrame.columns` attributes of the
          :class:`~pandas.DataFrame` instance are placed in the query namespace
          by default, which allows you to treat both the index and columns of the
          frame as a column in the frame.
          The identifier ``index`` is used for the frame index; you can also
          use the name of the index to identify it in a query. Please note that
          Python keywords may not be used as identifiers.
  
          For further details and examples see the ``query`` documentation in
          :ref:`indexing <indexing.query>`.
  
          *Backtick quoted variables*
  
          Backtick quoted variables are parsed as literal Python code and
          are converted internally to a Python valid identifier.
          This can lead to the following problems.
  
          During parsing a number of disallowed characters inside the backtick
          quoted string are replaced by strings that are allowed as a Python identifier.
          These characters include all operators in Python, the space character, the
          question mark, the exclamation mark, the dollar sign, and the euro sign.
          For other characters that fall outside the ASCII range (U+0001..U+007F)
          and those that are not further specified in PEP 3131,
          the query parser will raise an error.
          This excludes whitespace different than the space character,
          but also the hashtag (as it is used for comments) and the backtick
          itself (backtick can also not be escaped).
  
          In a special case, quotes that make a pair around a backtick can
          confuse the parser.
          For example, ```it's` > `that's``` will raise an error,
          as it forms a quoted string (``'s > `that'``) with a backtick inside.
  
          See also the Python documentation about lexical analysis
          (https://docs.python.org/3/reference/lexical_analysis.html)
          in combination with the source code in :mod:`pandas.core.computation.parsing`.
  
          Examples
          --------
          >>> df = pd.DataFrame({'A': range(1, 6),
          ...                    'B': range(10, 0, -2),
          ...                    'C C': range(10, 5, -1)})
          >>> df
             A   B  C C
          0  1  10   10
          1  2   8    9
          2  3   6    8
          3  4   4    7
          4  5   2    6
          >>> df.query('A > B')
             A  B  C C
          4  5  2    6
  
          The previous expression is equivalent to
  
          >>> df[df.A > df.B]
             A  B  C C
          4  5  2    6
  
          For columns with spaces in their name, you can use backtick quoting.
  
          >>> df.query('B == `C C`')
             A   B  C C
          0  1  10   10
  
          The previous expression is equivalent to
  
          >>> df[df.B == df['C C']]
             A   B  C C
          0  1  10   10
          """
          inplace = validate_bool_kwarg(inplace, "inplace")
          if not isinstance(expr, str):
              msg = f"expr must be a string to be evaluated, {type(expr)} given"
              raise ValueError(msg)
          kwargs["level"] = kwargs.pop("level", 0) + 1
          kwargs["target"] = None
          res = self.eval(expr, **kwargs)
  
          try:
              result = self.loc[res]
          except ValueError:
              # when res is multi-dimensional loc raises, but this is sometimes a
              # valid query
              result = self[res]
  
          if inplace:
              self._update_inplace(result)
              return None
          else:
              return result
function_tokens: def query ( self , expr : str , inplace : bool = False , * * kwargs ) : inplace = validate_bool_kwarg ( inplace , "inplace" ) if not isinstance ( expr , str ) : msg = f"expr must be a string to be evaluated, {type(expr)} given" raise ValueError ( msg ) kwargs [ "level" ] = kwargs . pop ( "level" , 0 ) + 1 kwargs [ "target" ] = None res = self . eval ( expr , * * kwargs ) try : result = self . loc [ res ] except ValueError : # when res is multi-dimensional loc raises, but this is sometimes a # valid query result = self [ res ] if inplace : self . _update_inplace ( result ) return None else : return result