notebook/test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/wxnacy/PycharmProjects/study/notebook\r\n"
     ]
    }
   ],
   "source": [
    "!echo $PYTHONPATH"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'mysql://root:wxnacy@127.0.0.1:3306/study?charset=utf8mb4'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import config\n",
    "config.DATABASE_URL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "./static\n"
     ]
    }
   ],
   "source": [
    "import os;print(os.path.dirname('./test.html'.replace('./', './static/')))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'./statictest.html'"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'./test.html'.replace('./', './static')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%E9%9D%A2%E8%AF%95%E9%A2%9864.%E6%B1%821%2B2%2B%E2%80%A6%2Bn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'%E9%9D%A2%E8%AF%95%E9%A2%9864.%E6%B1%821%2B2%2B%E2%80%A6%2Bn.html'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = '面试题64.求1+2+…+n.html'\n",
    "import urllib\n",
    "urllib.parse.quote(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "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.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.Engine`\n",
      "    and its underlying :class:`.Dialect` and :class:`_pool.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.Engine`, the underlying :class:`.Dialect`,\n",
      "    as well as the\n",
      "    :class:`_pool.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:`_sa.create_engine()` usage.\n",
      "    \n",
      "    Once established, the newly resulting :class:`_engine.Engine` will\n",
      "    request a connection from the underlying :class:`_pool.Pool` once\n",
      "    :meth:`_engine.Engine.connect` is called, or a method which depends on it\n",
      "    such as :meth:`_engine.Engine.execute` is invoked.   The\n",
      "    :class:`_pool.Pool` in turn\n",
      "    will establish the first actual DBAPI connection when this request\n",
      "    is received.   The :func:`_sa.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",
      "    :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, causes\n",
      "        all :class:`.String` datatypes to act as though the\n",
      "        :paramref:`.String.convert_unicode` flag has been set to ``True``,\n",
      "        regardless of a setting of ``False`` on an individual :class:`.String`\n",
      "        type.  This has the effect of causing all :class:`.String` -based\n",
      "        columns to accommodate Python Unicode objects directly as though the\n",
      "        datatype were the :class:`.Unicode` type.\n",
      "    \n",
      "        .. deprecated:: 1.3\n",
      "    \n",
      "            The :paramref:`_sa.create_engine.convert_unicode` parameter\n",
      "            is deprecated and will be removed in a future release.\n",
      "            All modern DBAPIs now support Python Unicode directly and this\n",
      "            parameter is unnecessary.\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 default log\n",
      "        handler, which defaults to ``sys.stdout`` for output.   If set to the\n",
      "        string ``\"debug\"``, result rows will be printed to the standard output\n",
      "        as well. The ``echo`` attribute of ``Engine`` can be modified at any\n",
      "        time to turn logging on and off; direct control of logging is also\n",
      "        available using the standard Python ``logging`` module.\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :ref:`dbengine_logging` - further detail on how to configure\n",
      "            logging.\n",
      "    \n",
      "    :param echo_pool=False: if True, the connection pool will log\n",
      "        informational output such as when connections are invalidated\n",
      "        as well as when connections are recycled to the default log handler,\n",
      "        which defaults to ``sys.stdout`` for output.   If set to the string\n",
      "        ``\"debug\"``, the logging will include pool checkouts and checkins.\n",
      "        Direct control of logging is also available using the standard Python\n",
      "        ``logging`` module.\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :ref:`dbengine_logging` - further detail on how to configure\n",
      "            logging.\n",
      "    \n",
      "    \n",
      "    :param empty_in_strategy:  The SQL compilation strategy to use when\n",
      "        rendering an IN or NOT IN expression for :meth:`.ColumnOperators.in_`\n",
      "        where the right-hand side\n",
      "        is an empty set.   This is a string value that may be one of\n",
      "        ``static``, ``dynamic``, or ``dynamic_warn``.   The ``static``\n",
      "        strategy is the default, and an IN comparison to an empty set\n",
      "        will generate a simple false expression \"1 != 1\".   The ``dynamic``\n",
      "        strategy behaves like that of SQLAlchemy 1.1 and earlier, emitting\n",
      "        a false expression of the form \"expr != expr\", which has the effect\n",
      "        of evaluting to NULL in the case of a null expression.\n",
      "        ``dynamic_warn`` is the same as ``dynamic``, however also emits a\n",
      "        warning when an empty set is encountered; this because the \"dynamic\"\n",
      "        comparison is typically poorly performing on most databases.\n",
      "    \n",
      "        .. versionadded:: 1.2  Added the ``empty_in_strategy`` setting and\n",
      "           additionally defaulted the behavior for empty-set IN comparisons\n",
      "           to a static boolean expression.\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 DBAPIs own encoding facilities.**\n",
      "    \n",
      "        .. note:: The ``encoding`` parameter deals only with in-Python\n",
      "           encoding issues that were prevalent with many DBAPIs under  Python\n",
      "           2.  Under Python 3 it is mostly unused.   For  DBAPIs that require\n",
      "           client encoding configurations, such as those of MySQL and Oracle,\n",
      "           please consult specific :ref:`dialect documentation\n",
      "           <dialect_toplevel>` for details.\n",
      "    \n",
      "        All modern DBAPIs that work in Python 3 necessarily feature direct\n",
      "        support for Python unicode strings.   Under Python 2, this was not\n",
      "        always the case.  For those scenarios where the DBAPI is detected as\n",
      "        not supporting a Python ``unicode`` object under Python 2, this\n",
      "        encoding is used to determine the source/destination encoding.  It is\n",
      "        **not used** for those cases where the DBAPI handles unicode directly.\n",
      "    \n",
      "        To properly configure a system to accommodate Python ``unicode``\n",
      "        objects, the DBAPI should be configured to handle unicode to the\n",
      "        greatest degree as is appropriate - see the notes on unicode pertaining\n",
      "        to the specific target database in use at :ref:`dialect_toplevel`.\n",
      "    \n",
      "        Areas where string encoding may need to be accommodated\n",
      "        outside of the DBAPI, nearly always under **Python 2 only**,\n",
      "        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 all of the above\n",
      "        values as Python ``unicode`` objects, which in Python 3 are just known\n",
      "        as ``str``.  In Python 2, the DBAPI does not specify unicode behavior\n",
      "        at all, so SQLAlchemy must make decisions for each of the above values\n",
      "        on a per-DBAPI basis - implementations are completely inconsistent in\n",
      "        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 hide_parameters: Boolean, when set to True, SQL statement parameters\n",
      "        will not be displayed in INFO logging nor will they be formatted into\n",
      "        the string representation of :class:`.StatementError` objects.\n",
      "    \n",
      "        .. versionadded:: 1.3.8\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\n",
      "        per-:class:`_engine.Connection` basis as well, using the\n",
      "        :paramref:`.Connection.execution_options.isolation_level`\n",
      "        feature.\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :attr:`_engine.Connection.default_isolation_level`\n",
      "            - view default level\n",
      "    \n",
      "            :paramref:`.Connection.execution_options.isolation_level`\n",
      "            - set per :class:`_engine.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 json_deserializer: for dialects that support the\n",
      "        :class:`_types.JSON`\n",
      "        datatype, this is a Python callable that will convert a JSON string\n",
      "        to a Python object.  By default, the Python ``json.loads`` function is\n",
      "        used.\n",
      "    \n",
      "        .. versionchanged:: 1.3.7  The SQLite dialect renamed this from\n",
      "           ``_json_deserializer``.\n",
      "    \n",
      "    :param json_serializer: for dialects that support the :class:`_types.JSON`\n",
      "        datatype, this is a Python callable that will render a given object\n",
      "        as JSON.   By default, the Python ``json.dumps`` function is used.\n",
      "    \n",
      "        .. versionchanged:: 1.3.7  The SQLite dialect renamed this from\n",
      "           ``_json_serializer``.\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``, which may be affected via the\n",
      "        :paramref:`_sa.create_engine.max_identifier_length` parameter,\n",
      "        is used instead.   The value of\n",
      "        :paramref:`_sa.create_engine.label_length`\n",
      "        may not be larger than that of\n",
      "        :paramref:`_sa.create_engine.max_identfier_length`.\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :paramref:`_sa.create_engine.max_identifier_length`\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_identifier_length: integer; override the max_identifier_length\n",
      "        determined by the dialect.  if ``None`` or zero, has no effect.  This\n",
      "        is the database's configured maximum number of characters that may be\n",
      "        used in a SQL identifier such as a table name, column name, or label\n",
      "        name. All dialects determine this value automatically, however in the\n",
      "        case of a new database version for which this value has changed but\n",
      "        SQLAlchemy's dialect has not been adjusted, the value may be passed\n",
      "        here.\n",
      "    \n",
      "        .. versionadded:: 1.3.9\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :paramref:`_sa.create_engine.label_length`\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.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_pre_ping: boolean, if True will enable the connection pool\n",
      "        \"pre-ping\" feature that tests connections for liveness upon\n",
      "        each checkout.\n",
      "    \n",
      "        .. versionadded:: 1.2\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :ref:`pool_disconnects_pessimistic`\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",
      "        .. seealso::\n",
      "    \n",
      "            :ref:`pool_setting_recycle`\n",
      "    \n",
      "    :param pool_reset_on_return='rollback': set the\n",
      "        :paramref:`_pool.Pool.reset_on_return` parameter of the underlying\n",
      "        :class:`_pool.Pool` object, which can be set to the values\n",
      "        ``\"rollback\"``, ``\"commit\"``, or ``None``.\n",
      "    \n",
      "        .. seealso::\n",
      "    \n",
      "            :paramref:`_pool.Pool.reset_on_return`\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 pool_use_lifo=False: use LIFO (last-in-first-out) when retrieving\n",
      "        connections from :class:`.QueuePool` instead of FIFO\n",
      "        (first-in-first-out). Using LIFO, a server-side timeout scheme can\n",
      "        reduce the number of connections used during non- peak   periods of\n",
      "        use.   When planning for server-side timeouts, ensure that a recycle or\n",
      "        pre-ping strategy is in use to gracefully   handle stale connections.\n",
      "    \n",
      "          .. versionadded:: 1.3\n",
      "    \n",
      "          .. seealso::\n",
      "    \n",
      "            :ref:`pool_use_lifo`\n",
      "    \n",
      "            :ref:`pool_disconnects`\n",
      "    \n",
      "    :param plugins: string list of plugin names to load.  See\n",
      "        :class:`.CreateEnginePlugin` for background.\n",
      "    \n",
      "        .. versionadded:: 1.2.3\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": [
    "from sqlalchemy import create_engine\n",
    "help(create_engine)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "14 % 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-12 % -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-123 // -10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1230"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "-123 * 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 * -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = '12'\n",
    "res[:3]\n",
    "1 // 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 1]\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nums = [0, 0, 1, 1, 2, 3, 4]\n",
    "print(nums[:3])\n",
    "for i in range(len(nums)):\n",
    "    print(i)\n",
    "    if i == 3:\n",
    "        nums.remove(i)\n",
    "    \n",
    "[1, 2][:2]\n",
    "[1, 2, 3, 4, 5, 6][:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2020, 6, 13, 12, 24, 55)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from datetime import date\n",
    "date(2020, 6, 22).isoformat()\n",
    "from datetime import datetime\n",
    "datetime(2020, 6, 13, 12, 24, 55)\n"
   ]
  }
 ],
 "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}