code: def find(self, *_clauses, **kwargs):
          
          if not self.exists:
              return iter([])
  
          _limit = kwargs.pop('_limit', None)
          _offset = kwargs.pop('_offset', 0)
          order_by = kwargs.pop('order_by', None)
          _streamed = kwargs.pop('_streamed', False)
          _step = kwargs.pop('_step', QUERY_STEP)
          if _step is False or _step == 0:
              _step = None
  
          order_by = self._args_to_order_by(order_by)
          args = self._args_to_clause(kwargs, clauses=_clauses)
          query = self.table.select(whereclause=args,
                                    limit=_limit,
                                    offset=_offset)
          if len(order_by):
              query = query.order_by(*order_by)
  
          conn = self.db.executable
          if _streamed:
              conn = self.db.engine.connect()
              conn = conn.execution_options(stream_results=True)
  
          return ResultIter(conn.execute(query),
                            row_type=self.db.row_type,
                            step=_step)
docs: Perform a simple search on the table.
  
          Simply pass keyword arguments as ``filter``.
          ::
  
              results = table.find(country='France')
              results = table.find(country='France', year=1980)
  
          Using ``_limit``::
  
              # just return the first 10 rows
              results = table.find(country='France', _limit=10)
  
          You can sort the results by single or multiple columns. Append a minus
          sign to the column name for descending order::
  
              # sort results by a column 'year'
              results = table.find(country='France', order_by='year')
              # return all rows sorted by multiple columns (descending by year)
              results = table.find(order_by=['country', '-year'])
  
          To perform complex queries with advanced filters or to perform
          aggregation, use :py:meth:`db.query() <dataset.Database.query>`
          instead.