Untitled6.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function read_sql_query in module pandas.io.sql:\n",
      "\n",
      "read_sql_query(sql, con, index_col=None, coerce_float=True, params=None, parse_dates=None, chunksize=None)\n",
      "    Read SQL query into a DataFrame.\n",
      "    \n",
      "    Returns a DataFrame corresponding to the result set of the query\n",
      "    string. Optionally provide an `index_col` parameter to use one of the\n",
      "    columns as the index, otherwise default integer index will be used.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    sql : string SQL query or SQLAlchemy Selectable (select or text object)\n",
      "        to be executed.\n",
      "    con : SQLAlchemy connectable(engine/connection) or database string URI\n",
      "        or sqlite3 DBAPI2 connection\n",
      "        Using SQLAlchemy makes it possible to use any DB supported by that\n",
      "        library.\n",
      "        If a DBAPI2 object, only sqlite3 is supported.\n",
      "    index_col : string or list of strings, optional, default: None\n",
      "        Column(s) to set as index(MultiIndex)\n",
      "    coerce_float : boolean, default True\n",
      "        Attempt to convert values to non-string, non-numeric objects (like\n",
      "        decimal.Decimal) to floating point, useful for SQL result sets\n",
      "    params : list, tuple or dict, optional, default: None\n",
      "        List of parameters to pass to execute method.  The syntax used\n",
      "        to pass parameters is database driver dependent. Check your\n",
      "        database driver documentation for which of the five syntax styles,\n",
      "        described in PEP 249's paramstyle, is supported.\n",
      "        Eg. for psycopg2, uses %(name)s so use params={'name' : 'value'}\n",
      "    parse_dates : list or dict, default: None\n",
      "        - List of column names to parse as dates\n",
      "        - Dict of ``{column_name: format string}`` where format string is\n",
      "          strftime compatible in case of parsing string times or is one of\n",
      "          (D, s, ns, ms, us) in case of parsing integer timestamps\n",
      "        - Dict of ``{column_name: arg dict}``, where the arg dict corresponds\n",
      "          to the keyword arguments of :func:`pandas.to_datetime`\n",
      "          Especially useful with databases without native Datetime support,\n",
      "          such as SQLite\n",
      "    chunksize : int, default None\n",
      "        If specified, return an iterator where `chunksize` is the number of\n",
      "        rows to include in each chunk.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    DataFrame\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Any datetime values with time zone information parsed via the `parse_dates`\n",
      "    parameter will be converted to UTC\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    read_sql_table : Read SQL database table into a DataFrame\n",
      "    read_sql\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(pd.read_sql_query)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from sqlalchemy import create_engine"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function create_engine in module sqlalchemy.engine:\n",
      "\n",
      "create_engine(*args, **kwargs)\n",
      "    Create a new :class:`.Engine` instance.\n",
      "    \n",
      "    The standard calling form is to send the URL as the\n",
      "    first positional argument, usually a string\n",
      "    that indicates database dialect and connection arguments::\n",
      "    \n",
      "    \n",
      "        engine = create_engine(\"postgresql://scott:tiger@localhost/test\")\n",
      "    \n",
      "    Additional keyword arguments may then follow it which\n",
      "    establish various options on the resulting :class:`.Engine`\n",
      "    and its underlying :class:`.Dialect` and :class:`.Pool`\n",
      "    constructs::\n",
      "    \n",
      "        engine = create_engine(\"mysql://scott:tiger@hostname/dbname\",\n",
      "                                    encoding='latin1', echo=True)\n",
      "    \n",
      "    The string form of the URL is\n",
      "    ``dialect[+driver]://user:password@host/dbname[?key=value..]``, where\n",
      "    ``dialect`` is a database name such as ``mysql``, ``oracle``,\n",
      "    ``postgresql``, etc., and ``driver`` the name of a DBAPI, such as\n",
      "    ``psycopg2``, ``pyodbc``, ``cx_oracle``, etc.  Alternatively,\n",
      "    the URL can be an instance of :class:`~sqlalchemy.engine.url.URL`.\n",
      "    \n",
      "    ``**kwargs`` takes a wide variety of options which are routed\n",
      "    towards their appropriate components.  Arguments may be specific to\n",
      "    the :class:`.Engine`, the underlying :class:`.Dialect`, as well as the\n",
      "    :class:`.Pool`.  Specific dialects also accept keyword arguments that\n",
      "    are unique to that dialect.   Here, we describe the parameters\n",
      "    that are common to most :func:`.create_engine()` usage.\n",
      "    \n",
      "    Once established, the newly resulting :class:`.Engine` will\n",
      "    request a connection from the underlying :class:`.Pool` once\n",
      "    :meth:`.Engine.connect` is called, or a method which depends on it\n",
      "    such as :meth:`.Engine.execute` is invoked.   The :class:`.Pool` in turn\n",
      "    will establish the first actual DBAPI connection when this request\n",
      "    is received.   The :func:`.create_engine` call itself does **not**\n",
      "    establish any actual DBAPI connections directly.\n",
      "    \n",
      "    .. seealso::\n",
      "    \n",
      "        :doc:`/core/engines`\n",
      "    \n",
      "        :doc:`/dialects/index`\n",
      "    \n",
      "        :ref:`connections_toplevel`\n",
      "    \n",
      "    :param case_sensitive=True: if False, result column names\n",
      "       will match in a case-insensitive fashion, that is,\n",
      "       ``row['SomeColumn']``.\n",
      "    \n",
      "       .. versionchanged:: 0.8\n",
      "           By default, result row names match case-sensitively.\n",
      "           In version 0.7 and prior, all matches were case-insensitive.\n",
      "    \n",
      "    :param connect_args: a dictionary of options which will be\n",
      "        passed directly to the DBAPI's ``connect()`` method as\n",
      "        additional keyword arguments.  See the example\n",
      "        at :ref:`custom_dbapi_args`.\n",
      "    \n",
      "    :param convert_unicode=False: if set to True, sets\n",
      "        the default behavior of ``convert_unicode`` on the\n",
      "        :class:`.String` type to ``True``, regardless\n",
      "        of a setting of ``False`` on an individual\n",
      "        :class:`.String` type, thus causing all :class:`.String`\n",
      "        -based columns\n",
      "        to accommodate Python ``unicode`` objects.  This flag\n",
      "        is useful as an engine-wide setting when using a\n",
      "        DBAPI that does not natively support Python\n",
      "        ``unicode`` objects and raises an error when\n",
      "        one is received (such as pyodbc with FreeTDS).\n",
      "    \n",
      "        See :class:`.String` for further details on\n",
      "        what this flag indicates.\n",
      "    \n",
      "    :param creator: a callable which returns a DBAPI connection.\n",
      "        This creation function will be passed to the underlying\n",
      "        connection pool and will be used to create all new database\n",
      "        connections. Usage of this function causes connection\n",
      "        parameters specified in the URL argument to be bypassed.\n",
      "    \n",
      "    :param echo=False: if True, the Engine will log all statements\n",
      "        as well as a repr() of their parameter lists to the engines\n",
      "        logger, which defaults to sys.stdout. The ``echo`` attribute of\n",
      "        ``Engine`` can be modified at any time to turn logging on and\n",
      "        off. If set to the string ``\"debug\"``, result rows will be\n",
      "        printed to the standard output as well. This flag ultimately\n",
      "        controls a Python logger; see :ref:`dbengine_logging` for\n",
      "        information on how to configure logging directly.\n",
      "    \n",
      "    :param echo_pool=False: if True, the connection pool will log\n",
      "        all checkouts/checkins to the logging stream, which defaults to\n",
      "        sys.stdout. This flag ultimately controls a Python logger; see\n",
      "        :ref:`dbengine_logging` for information on how to configure logging\n",
      "        directly.\n",
      "    \n",
      "    :param encoding: Defaults to ``utf-8``.  This is the string\n",
      "        encoding used by SQLAlchemy for string encode/decode\n",
      "        operations which occur within SQLAlchemy, **outside of\n",
      "        the DBAPI.**  Most modern DBAPIs feature some degree of\n",
      "        direct support for Python ``unicode`` objects,\n",
      "        what you see in Python 2 as a string of the form\n",
      "        ``u'some string'``.  For those scenarios where the\n",
      "        DBAPI is detected as not supporting a Python ``unicode``\n",
      "        object, this encoding is used to determine the\n",
      "        source/destination encoding.  It is **not used**\n",
      "        for those cases where the DBAPI handles unicode\n",
      "        directly.\n",
      "    \n",
      "        To properly configure a system to accommodate Python\n",
      "        ``unicode`` objects, the DBAPI should be\n",
      "        configured to handle unicode to the greatest\n",
      "        degree as is appropriate - see\n",
      "        the notes on unicode pertaining to the specific\n",
      "        target database in use at :ref:`dialect_toplevel`.\n",
      "    \n",
      "        Areas where string encoding may need to be accommodated\n",
      "        outside of the DBAPI include zero or more of:\n",
      "    \n",
      "        * the values passed to bound parameters, corresponding to\n",
      "          the :class:`.Unicode` type or the :class:`.String` type\n",
      "          when ``convert_unicode`` is ``True``;\n",
      "        * the values returned in result set columns corresponding\n",
      "          to the :class:`.Unicode` type or the :class:`.String`\n",
      "          type when ``convert_unicode`` is ``True``;\n",
      "        * the string SQL statement passed to the DBAPI's\n",
      "          ``cursor.execute()`` method;\n",
      "        * the string names of the keys in the bound parameter\n",
      "          dictionary passed to the DBAPI's ``cursor.execute()``\n",
      "          as well as ``cursor.setinputsizes()`` methods;\n",
      "        * the string column names retrieved from the DBAPI's\n",
      "          ``cursor.description`` attribute.\n",
      "    \n",
      "        When using Python 3, the DBAPI is required to support\n",
      "        *all* of the above values as Python ``unicode`` objects,\n",
      "        which in Python 3 are just known as ``str``.  In Python 2,\n",
      "        the DBAPI does not specify unicode behavior at all,\n",
      "        so SQLAlchemy must make decisions for each of the above\n",
      "        values on a per-DBAPI basis - implementations are\n",
      "        completely inconsistent in their behavior.\n",
      "    \n",
      "    :param execution_options: Dictionary execution options which will\n",
      "        be applied to all connections.  See\n",
      "        :meth:`~sqlalchemy.engine.Connection.execution_options`\n",
      "    \n",
      "    :param implicit_returning=True: When ``True``, a RETURNING-\n",
      "        compatible construct, if available, will be used to\n",
      "        fetch newly generated primary key values when a single row\n",
      "        INSERT statement is emitted with no existing returning()\n",
      "        clause.  This applies to those backends which support RETURNING\n",
      "        or a compatible construct, including PostgreSQL, Firebird, Oracle,\n",
      "        Microsoft SQL Server.   Set this to ``False`` to disable\n",
      "        the automatic usage of RETURNING.\n",
      "    \n",
      "    :param isolation_level: this string parameter is interpreted by various\n",
      "        dialects in order to affect the transaction isolation level of the\n",
      "        database connection.   The parameter essentially accepts some subset of\n",
      "        these string arguments: ``\"SERIALIZABLE\"``, ``\"REPEATABLE_READ\"``,\n",
      "        ``\"READ_COMMITTED\"``, ``\"READ_UNCOMMITTED\"`` and ``\"AUTOCOMMIT\"``.\n",
      "        Behavior here varies per backend, and\n",
      "        individual dialects should be consulted directly.\n",
      "    \n",
      "        Note that the isolation level can also be set on a per-:class:`.Connection`\n",
      "        basis as well, using the\n",
      "        :paramref:`.Connection.execution_options.isolation_level`\n",
      "        feature.\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :attr:`.Connection.default_isolation_level` - view default level\n",
      "    \n",
      "            :paramref:`.Connection.execution_options.isolation_level`\n",
      "            - set per :class:`.Connection` isolation level\n",
      "    \n",
      "            :ref:`SQLite Transaction Isolation <sqlite_isolation_level>`\n",
      "    \n",
      "            :ref:`PostgreSQL Transaction Isolation <postgresql_isolation_level>`\n",
      "    \n",
      "            :ref:`MySQL Transaction Isolation <mysql_isolation_level>`\n",
      "    \n",
      "            :ref:`session_transaction_isolation` - for the ORM\n",
      "    \n",
      "    :param label_length=None: optional integer value which limits\n",
      "        the size of dynamically generated column labels to that many\n",
      "        characters. If less than 6, labels are generated as\n",
      "        \"_(counter)\". If ``None``, the value of\n",
      "        ``dialect.max_identifier_length`` is used instead.\n",
      "    \n",
      "    :param listeners: A list of one or more\n",
      "        :class:`~sqlalchemy.interfaces.PoolListener` objects which will\n",
      "        receive connection pool events.\n",
      "    \n",
      "    :param logging_name:  String identifier which will be used within\n",
      "        the \"name\" field of logging records generated within the\n",
      "        \"sqlalchemy.engine\" logger. Defaults to a hexstring of the\n",
      "        object's id.\n",
      "    \n",
      "    :param max_overflow=10: the number of connections to allow in\n",
      "        connection pool \"overflow\", that is connections that can be\n",
      "        opened above and beyond the pool_size setting, which defaults\n",
      "        to five. this is only used with :class:`~sqlalchemy.pool.QueuePool`.\n",
      "    \n",
      "    :param module=None: reference to a Python module object (the module\n",
      "        itself, not its string name).  Specifies an alternate DBAPI module to\n",
      "        be used by the engine's dialect.  Each sub-dialect references a\n",
      "        specific DBAPI which will be imported before first connect.  This\n",
      "        parameter causes the import to be bypassed, and the given module to\n",
      "        be used instead. Can be used for testing of DBAPIs as well as to\n",
      "        inject \"mock\" DBAPI implementations into the :class:`.Engine`.\n",
      "    \n",
      "    :param paramstyle=None: The `paramstyle <http://legacy.python.org/dev/peps/pep-0249/#paramstyle>`_\n",
      "        to use when rendering bound parameters.  This style defaults to the\n",
      "        one recommended by the DBAPI itself, which is retrieved from the\n",
      "        ``.paramstyle`` attribute of the DBAPI.  However, most DBAPIs accept\n",
      "        more than one paramstyle, and in particular it may be desirable\n",
      "        to change a \"named\" paramstyle into a \"positional\" one, or vice versa.\n",
      "        When this attribute is passed, it should be one of the values\n",
      "        ``\"qmark\"``, ``\"numeric\"``, ``\"named\"``, ``\"format\"`` or\n",
      "        ``\"pyformat\"``, and should correspond to a parameter style known\n",
      "        to be supported by the DBAPI in use.\n",
      "    \n",
      "    :param pool=None: an already-constructed instance of\n",
      "        :class:`~sqlalchemy.pool.Pool`, such as a\n",
      "        :class:`~sqlalchemy.pool.QueuePool` instance. If non-None, this\n",
      "        pool will be used directly as the underlying connection pool\n",
      "        for the engine, bypassing whatever connection parameters are\n",
      "        present in the URL argument. For information on constructing\n",
      "        connection pools manually, see :ref:`pooling_toplevel`.\n",
      "    \n",
      "    :param poolclass=None: a :class:`~sqlalchemy.pool.Pool`\n",
      "        subclass, which will be used to create a connection pool\n",
      "        instance using the connection parameters given in the URL. Note\n",
      "        this differs from ``pool`` in that you don't actually\n",
      "        instantiate the pool in this case, you just indicate what type\n",
      "        of pool to be used.\n",
      "    \n",
      "    :param pool_logging_name:  String identifier which will be used within\n",
      "       the \"name\" field of logging records generated within the\n",
      "       \"sqlalchemy.pool\" logger. Defaults to a hexstring of the object's\n",
      "       id.\n",
      "    \n",
      "    :param pool_size=5: the number of connections to keep open\n",
      "        inside the connection pool. This used with\n",
      "        :class:`~sqlalchemy.pool.QueuePool` as\n",
      "        well as :class:`~sqlalchemy.pool.SingletonThreadPool`.  With\n",
      "        :class:`~sqlalchemy.pool.QueuePool`, a ``pool_size`` setting\n",
      "        of 0 indicates no limit; to disable pooling, set ``poolclass`` to\n",
      "        :class:`~sqlalchemy.pool.NullPool` instead.\n",
      "    \n",
      "    :param pool_recycle=-1: this setting causes the pool to recycle\n",
      "        connections after the given number of seconds has passed. It\n",
      "        defaults to -1, or no timeout. For example, setting to 3600\n",
      "        means connections will be recycled after one hour. Note that\n",
      "        MySQL in particular will disconnect automatically if no\n",
      "        activity is detected on a connection for eight hours (although\n",
      "        this is configurable with the MySQLDB connection itself and the\n",
      "        server configuration as well).\n",
      "    \n",
      "    :param pool_reset_on_return='rollback': set the \"reset on return\"\n",
      "        behavior of the pool, which is whether ``rollback()``,\n",
      "        ``commit()``, or nothing is called upon connections\n",
      "        being returned to the pool.  See the docstring for\n",
      "        ``reset_on_return`` at :class:`.Pool`.\n",
      "    \n",
      "        .. versionadded:: 0.7.6\n",
      "    \n",
      "    :param pool_timeout=30: number of seconds to wait before giving\n",
      "        up on getting a connection from the pool. This is only used\n",
      "        with :class:`~sqlalchemy.pool.QueuePool`.\n",
      "    \n",
      "    :param strategy='plain': selects alternate engine implementations.\n",
      "        Currently available are:\n",
      "    \n",
      "        * the ``threadlocal`` strategy, which is described in\n",
      "          :ref:`threadlocal_strategy`;\n",
      "        * the ``mock`` strategy, which dispatches all statement\n",
      "          execution to a function passed as the argument ``executor``.\n",
      "          See `example in the FAQ\n",
      "          <http://docs.sqlalchemy.org/en/latest/faq/metadata_schema.html#how-can-i-get-the-create-table-drop-table-output-as-a-string>`_.\n",
      "    \n",
      "    :param executor=None: a function taking arguments\n",
      "        ``(sql, *multiparams, **params)``, to which the ``mock`` strategy will\n",
      "        dispatch all statement execution. Used only by ``strategy='mock'``.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "class help(create_engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = range(10)\n",
    "import itertools\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#iterl = itertools.combinations(l,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#iterl.next()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = itertools.combinations([1,2,3],2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<itertools.combinations object at 0x000001AE6A322A48>\n"
     ]
    }
   ],
   "source": [
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<itertools.combinations at 0x1ae6a322a48>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}