Ngram_Spark_Wikipedia.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "-oVTkslwlY-8",
        "HAvwHhiwl-y6",
        "oyFmuUmX-HJP",
        "xinQrfhe-jKd",
        "7V3QFtX4Bxie",
        "4XR6I1wU_OkG",
        "namYGx7b_bYf",
        "vnVaJa7PsRuL"
      ]
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Step1: Install Librarys"
      ],
      "metadata": {
        "id": "-oVTkslwlY-8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install wikipedia\n",
        "!pip install pyspark"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DtokUid3lckx",
        "outputId": "8781eddc-840b-43a4-ff3e-c389efd0600c"
      },
      "execution_count": 198,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: wikipedia in /usr/local/lib/python3.10/dist-packages (1.4.0)\n",
            "Requirement already satisfied: beautifulsoup4 in /usr/local/lib/python3.10/dist-packages (from wikipedia) (4.12.3)\n",
            "Requirement already satisfied: requests<3.0.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from wikipedia) (2.31.0)\n",
            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.0.0->wikipedia) (3.3.2)\n",
            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.0.0->wikipedia) (3.7)\n",
            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.0.0->wikipedia) (2.0.7)\n",
            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3.0.0,>=2.0.0->wikipedia) (2024.2.2)\n",
            "Requirement already satisfied: soupsieve>1.2 in /usr/local/lib/python3.10/dist-packages (from beautifulsoup4->wikipedia) (2.5)\n",
            "Requirement already satisfied: pyspark in /usr/local/lib/python3.10/dist-packages (3.5.1)\n",
            "Requirement already satisfied: py4j==0.10.9.7 in /usr/local/lib/python3.10/dist-packages (from pyspark) (0.10.9.7)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step2: Import Librarys"
      ],
      "metadata": {
        "id": "HAvwHhiwl-y6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import wikipedia\n",
        "import pyspark\n",
        "import os\n",
        "import sys\n",
        "import shutil\n",
        "import re"
      ],
      "metadata": {
        "id": "MokuCNPEmDPB"
      },
      "execution_count": 199,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step3: get wikipedia dataset"
      ],
      "metadata": {
        "id": "e3Nu2e9e-TZS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataset1 = wikipedia.page('Python (programming language)').content\n",
        "dataset2 = [\"to be or not to be this is the problem\"]\n",
        "\n",
        "dataset1 = re.sub(r'[\\n\\t]', ' ', dataset1)\n",
        "dataset1 = re.sub(r'\\s+', ' ', dataset1.strip())\n",
        "dataset1 = [dataset1]"
      ],
      "metadata": {
        "id": "ZbCQ_NEq-Wxv"
      },
      "execution_count": 261,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step4: Define Ngram functions"
      ],
      "metadata": {
        "id": "oyFmuUmX-HJP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def ngrams(line, N):\n",
        "    words = line.split()\n",
        "    ngrams = [tuple(words[i:i+N]) for i in range(len(words)-N+1)]\n",
        "    return ngrams\n",
        "\n",
        "def generate_ngrams(rdd, n):\n",
        "    rdd = rdd.flatMap(lambda line: ngrams(line, n))\\\n",
        "             .map(lambda ngram: (ngram, 1))\\\n",
        "             .reduceByKey(lambda x, y: x + y)\\\n",
        "             .sortBy(lambda x: x[1], ascending=False)\n",
        "    return rdd\n"
      ],
      "metadata": {
        "id": "8VqZfYBg-Lb7"
      },
      "execution_count": 262,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step5: Set Paths"
      ],
      "metadata": {
        "id": "xinQrfhe-jKd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "home = \"/content/\"\n",
        "log = home + \"log/\"\n",
        "output_dir = home + \"output.txt\""
      ],
      "metadata": {
        "id": "cEeGvX6l_DRP"
      },
      "execution_count": 217,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step6: Make directory for log folder"
      ],
      "metadata": {
        "id": "7V3QFtX4Bxie"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "path = \"/content/log\"\n",
        "os.makedirs(path, exist_ok=True)"
      ],
      "metadata": {
        "id": "8z_ngsloB2RW"
      },
      "execution_count": 218,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step7: set vaiables"
      ],
      "metadata": {
        "id": "4XR6I1wU_OkG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "worker_count = 2\n",
        "file_size = sys.getsizeof(dataset2)\n",
        "partition_size = 30\n",
        "partition_count = int(file_size / partition_size)"
      ],
      "metadata": {
        "id": "LQRQrM2f_Q6w"
      },
      "execution_count": 219,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step8: Manage and configure the SparkContext"
      ],
      "metadata": {
        "id": "namYGx7b_bYf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "conf = pyspark.SparkConf()\\\n",
        " .setAppName(\"word_counter\")\\\n",
        " .set(\"spark.eventLog.enabled\", \"true\") \\\n",
        " .set(\"spark.eventLog.dir\", log) \\\n",
        " .setMaster(\"local[\" + str(worker_count) + \"]\")\n",
        "\n",
        "spark = pyspark.sql.SparkSession.builder\\\n",
        " .config(\"spark.executor.memory\", \"10g\") \\\n",
        " .config(\"spark.driver.memory\", \"10g\") \\\n",
        " .config(conf=conf).getOrCreate()\n",
        "sc = spark.sparkContext"
      ],
      "metadata": {
        "id": "JJI22yVW_d-U"
      },
      "execution_count": 220,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step9: Run the program"
      ],
      "metadata": {
        "id": "O0Wr6XhxCISE"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 264,
      "metadata": {
        "id": "_8RNRJ0nheV-",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ae37025e-e1f7-423f-cc2a-1c96af52acc8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[(('of', 'the'), 36), (('in', 'the'), 24), (('is', 'a'), 19), (('of', 'Python'), 19), (('such', 'as'), 18), (('as', 'a'), 15), (('be', 'used'), 15), (('to', 'the'), 14), (('Python', 'is'), 13), (('to', 'be'), 13), (('can', 'be'), 13), (('the', 'Python'), 13), (('in', 'Python'), 12), (('from', 'the'), 11), (('statement,', 'which'), 11), (('with', 'the'), 10), (('used', 'to'), 10), (('to', 'a'), 9), (('with', 'a'), 8), (('Python', 'uses'), 8), (('standard', 'library'), 8), (('part', 'of'), 8), (('and', 'a'), 7), (('the', 'same'), 7), (('to', 'Python'), 7), (('Python', 'has'), 7), (('programming', 'languages'), 7), (('used', 'in'), 7), (('as', 'the'), 7), (('of', 'a'), 7), (('written', 'in'), 7), (('subset', 'of'), 7), (('will', 'be'), 6), (('Python', '2.7'), 6), (('and', 'is'), 6), (('use', 'of'), 6), (('by', 'the'), 6), (('Python', '3'), 6), (('Python', '3.12'), 6), (('is', 'also'), 6), (('it', 'is'), 6), (('may', 'be'), 6), (('It', 'is'), 6), (('and', 'the'), 6), (('==', 'Python'), 5), (('for', 'the'), 5), (('has', 'a'), 5), (('does', 'not'), 5), (('the', 'standard'), 5), (('Python', 'as'), 5), (('in', 'a'), 5), (('are', 'not'), 5), (('a', 'scripting'), 5), (('rather', 'than'), 5), (('scripting', 'language'), 5), (('a', 'subset'), 5), (('Guido', 'van'), 5), (('released', 'in'), 5), (('on', 'the'), 5), (('Python', 'to'), 5), (('that', 'the'), 4), (('is', 'used'), 4), (('the', 'use'), 4), (('was', 'released'), 4), (('many', 'other'), 4), (('better', 'than'), 4), (('to', 'other'), 4), (('==', \"Python's\"), 4), (('with', 'Python'), 4), (('release', 'in'), 4), (('the', 'version'), 4), (('(latest', 'release'), 4), (('as', 'of'), 4), (('of', 'its'), 4), (('is', 'the'), 4), (('is', 'not'), 4), (('possible', 'to'), 4), (('uses', 'the'), 4), (('number', 'of'), 4), (('version', 'number'), 4), (('number', 'is'), 4), (('programming', 'language'), 4), (('Python,', 'a'), 4), (('used', 'as'), 4), (('van', 'Rossum'), 4), (('is', 'better'), 4), (('contrast', 'to'), 4), (('a', 'Python'), 4), (('example,', 'the'), 4), (('to', 'machine'), 4), (('code', 'is'), 4), (('Python', 'in'), 3), (('and', 'has'), 3), (('use', 'in'), 3), (('out', 'of'), 3), (('removed', 'in'), 3), (('other', 'languages,'), 3), (('executes', 'a'), 3), (('block', 'of'), 3), (('a', 'generator'), 3), (('is', 'possible'), 3), (('Perl,', 'and'), 3), (('compiles', 'a'), 3), (('in', 'Python.'), 3), (('of', 'programming'), 3), (('Archived', 'from'), 3), (('the', 'original'), 3), (('Python', '2'), 3), (('be', 'removed'), 3), (('to', 'do'), 3), (('by', 'using'), 3), (('other', 'languages'), 3), (('the', 'current'), 3), (('similar', 'to'), 3), (('There', 'are'), 3), (('(1,', '2,'), 3), (('which', 'is'), 3), (('use', 'the'), 3), (('are', 'also'), 3), (('syntax,', 'and'), 3), (('Python', 'and'), 3), (('a', 'similar'), 3), (('most', 'popular'), 3), (('Python', 'community'), 3), (('the', 'language,'), 3), (('also', 'has'), 3), (('use', 'Python'), 3), (('===', 'Python'), 3), (('from', 'a'), 3), (('in', 'Python:'), 3), (('many', 'of'), 3), (('because', 'of'), 3), (('It', 'also'), 3), (('and', 'more'), 3), (('of', 'their'), 3), (('support', 'for'), 3), (('large', 'standard'), 3), (('in', 'its'), 3), (('Monty', 'Python'), 3), (('a', 'block'), 3), (('code', 'block'), 3), (('a', 'value'), 3), (('floor', 'division'), 3), (('written', 'as'), 3), (('cannot', 'be'), 3), (('Python', 'can'), 3), (('and', 'negative'), 3), (('often', 'used'), 3), (('used', 'for'), 3), (('means', 'that'), 3), (('compiles', 'Python'), 3), ((\"Python's\", 'development'), 3), (('and', 'many'), 3), (('(for', 'example,'), 3), (('In', 'Python,'), 3), (('operator', 'for'), 3), (('of', 'this'), 3), (('b', 'is'), 3), (('is', 'incremented.'), 3), (('original', 'on'), 3), (('due', 'to'), 3), (('one', 'of'), 3), (('a', 'large'), 3), (('It', 'has'), 3), (('statement,', 'used'), 3), (('they', 'are'), 3), (('Its', 'design'), 2), (('ABC', 'programming'), 2), (('Python', '2.0'), 2), (('machine', 'learning'), 2), (('major', 'new'), 2), (('list', 'comprehensions,'), 2), (('code', 'to'), 2), (('3.8', 'and'), 2), (('support', 'Python'), 2), (('Python', 'versions'), 2), (('of', 'security'), 2), (('2023,', 'Python'), 2), (('and', '3.10'), 2), (('functional', 'programming'), 2), (('combination', 'of'), 2), (('ways', 'to'), 2), (('languages,', 'but'), 2), (('comedy', 'group'), 2), (('wide', 'range'), 2), (('a', 'rough'), 2), (('it', 'does'), 2), (('to', 'delimit'), 2), (('in', 'indentation'), 2), (('is', 'always'), 2), (('a', 'function'), 2), (('+', 'operator'), 2), (('libraries', 'such'), 2), (('values', 'to'), 2), (('equal', 'sign'), 2), (('Python', '3.6'), 2), (('shells,', 'Perl,'), 2), (('ending', 'with'), 2), (('===', 'Methods'), 2), (('can', 'also'), 2), (('the', 'equation'), 2), (('a', '<'), 2), (('in', 'C,'), 2), (('arbitrary', 'precision'), 2), (('Web', 'Server'), 2), (('==', '==='), 2), (('CPython', 'is'), 2), (('Python,', 'and'), 2), (('for', 'many'), 2), (('fork', 'of'), 2), (('to', 'JavaScript,'), 2), (('Python', 'code.'), 2), (('Python', 'are'), 2), (('3', 'to'), 2), (('on', 'a'), 2), (('other', 'programming'), 2), (('Python', 'design'), 2), (('and', 'will'), 2), (('and', 'its'), 2), (('to', 'show'), 2), (('a', 'standard'), 2), (('generators', 'like'), 2), (('has', 'been'), 2), (('is', 'often'), 2), (('was', 'a'), 2), (('from', 'his'), 2), (('new', 'features'), 2), (('are', 'supported'), 2), (('2.7', 'and'), 2), (('In', '2022,'), 2), (('it', 'was'), 2), (('at', 'least'), 2), (('the', 'new'), 2), (('lot', 'of'), 2), (('operator', 'in'), 2), (('3.11', 'for'), 2), (('more', 'will'), 2), (('Starting', 'with'), 2), (('programming', 'and'), 2), (('Zen', 'of'), 2), (('addition', 'of'), 2), (('all', 'of'), 2), (('parts', 'of'), 2), (('range', 'of'), 2), (('related', 'to'), 2), (('is', 'called'), 2), (('languages', 'use'), 2), (('for', 'use'), 2), (('of', 'code'), 2), (('handled', 'by'), 2), (('before', 'it'), 2), (('the', 'reference'), 2), (('returns', 'a'), 2), (('value', 'from'), 2), (('not', 'support'), 2), (('//', 'and'), 2), (('named', 'a'), 2), (('distinction', 'between'), 2), (('5),', 'which'), 2), (('nature', 'of'), 2), (('an', 'assignment'), 2), (('single', 'or'), 2), (('is', 'for'), 2), (('Python', 'also'), 2), (('of', 'classes'), 2), (('is', 'less'), 2), (('language', 'to'), 2), (('well', 'as'), 2), (('operating', 'systems'), 2), (('===', 'Other'), 2), (('interpreter', 'of'), 2), (('Julia', 'source'), 2), (('the', 'primary'), 2), (('the', 'language'), 2), (('releases', 'are'), 2), (('will', 'emit'), 2), (('natural', 'language'), 2), (('Media.', 'ISBN'), 2), (('design', 'philosophy'), 2), (('Python', 'was'), 2), (('with', 'many'), 2), (('3', 'December'), 2), (('and', 'later'), 2), (('3.12', 'adds'), 2), (('a', 'lot'), 2), (('pattern', 'matching'), 2), (('years', 'of'), 2), (('metaprogramming', 'and'), 2), (('Python', '3.8.'), 2), (('was', 'designed'), 2), (('should', 'be'), 2), (('Python', 'provides'), 2), (('languages', 'such'), 2), (('or', 'a'), 2), (('restricted', 'subset'), 2), (('the', 'British'), 2), (('include:', 'The'), 2), (('which', 'executes'), 2), (('a', 'specified'), 2), (('code', 'and'), 2), (('if', 'the'), 2), (('referred', 'to'), 2), (('name', 'is'), 2), (('division', '(or'), 2), (('expression', 'named'), 2), (('or', 'double'), 2), (('and', 'ending'), 2), (('The', 'third'), 2), (('a', 'number'), 2), (('semantics', 'of'), 2), (('also', 'be'), 2), (('then', 'be'), 2), (('module', 'provides'), 2), (('command', 'line'), 2), (('of', 'Python.'), 2), (('Python', 'programs'), 2), (('available', 'for'), 2), (('Python.', 'The'), 2), (('===', 'Performance'), 2), (('the', 'code'), 2), (('Python.', '=='), 2), (('uses', 'Python'), 2), (('also', 'been'), 2), (('similar', 'syntax,'), 2), (('uses', 'indentation'), 2), (('2012.', 'Retrieved'), 2), (('on', 'Python'), 2), (('late', '1980s'), 2), (('the', 'ABC'), 2), (('Python', '3.0,'), 2), (('the', 'last'), 2), (('as', 'one'), 2), (('popular', 'programming'), 2), (('cycle-detecting', 'garbage'), 2), (('issues', 'were'), 2), (('Python', '2,'), 2), (('improved', 'error'), 2), (('claims', 'to'), 2), (('an', 'experimental'), 2), (('typing', 'and'), 2), (('library', 'and'), 2), (('way', 'to'), 2), ((\"Python's\", 'developers'), 2), (('the', 'CPython'), 2), (('reference', 'implementation'), 2), (('since', 'Python'), 2), (('group', 'Monty'), 2), (('that', 'is'), 2), (('and', 'semantics'), 2), (('The', 'assignment'), 2), (('an', 'iterable'), 2), (('the', 'variable'), 2), (('assignment', 'statement'), 2), (('used', 'by'), 2), (('as', 'part'), 2), (('Conditional', 'expressions'), 2), (('keys', 'of'), 2), (('2,', '3),'), 2), (('is', 'then'), 2), (('the', 'equal'), 2), (('In', 'Python'), 2), (('expressions', 'and'), 2), (('classes', 'are'), 2), (('a', 'is'), 2), (('for', 'both'), 2), (('For', 'example,'), 2), (('a', 'significant'), 2), (('run', 'under'), 2), (('have', 'been'), 2), (('in', 'many'), 2), (('compiled', 'to'), 2), (('to', 'C++'), 2), (('format', 'code'), 2), (('languages', 'in'), 2), (('indentation', 'and'), 2), (('a', 'programming'), 2), (('2.0', 'was'), 2), (('3.0,', 'released'), 2), (('the', 'most'), 2), (('operating', 'system.'), 2), (('released', 'on'), 2), (('Python', '3.'), 2), (('security', 'issues'), 2), (('Python', '3.11'), 2), (('the', 'Zen'), 2), (('for', 'adding'), 2), (('syntax', 'and'), 2), (('is', 'more'), 2), (('a', 'string'), 2), (('CPython', 'reference'), 2), (('just-in-time', 'compiler'), 2), (('language,', 'or'), 2), (('a', 'restricted'), 2), (('instead', 'of'), 2), (('a', 'wide'), 2), (('to', 'program'), 2), (('but', 'in'), 2), (('block', 'The'), 2), (('is', 'true'), 2), (('object-oriented', 'programming'), 2), (('to', 'create'), 2), (('and', 'from'), 2), (('behavior', 'of'), 2), (('c.', 'Python'), 2), (('to', 'many'), 2), (('t', '+'), 2), (('+', '(4,'), 2), (('that', 'can'), 2), (('in', 'an'), 2), (('in', 'contrast'), 2), (('instances', 'of'), 2), (('modules', 'for'), 2), (('Server', 'Gateway'), 2), (('Python', 'Package'), 2), (('==', 'Development'), 2), (('interpreter', 'for'), 2), (('Python.', 'It'), 2), (('until', 'Python'), 2), (('of', 'CPython'), 2), (('up', 'the'), 2), (('and', 'some'), 2), (('Python,', 'or'), 2), (('machine', 'code.'), 2), (('expected', 'to'), 2), (('years', 'after'), 2), (('the', 'language.'), 2), (('programs', 'like'), 2), (('Python-inspired', 'syntax.'), 2), ((\"O'Reilly\", 'Media.'), 2), (('programming', 'language.'), 2), (('language.', 'Its'), 2), (('the', 'late'), 2), (('a', 'successor'), 2), (('successor', 'to'), 2), (('was', 'the'), 2), (('As', 'of'), 2), (('and', '3.11'), 2), (('changes', 'in'), 2), (('for', 'exception'), 2), (('faster', 'than'), 2), (('and', 'Python'), 2), (('later', 'versions'), 2), (('philosophy', 'and'), 2), (('uses', 'dynamic'), 2), (('Python', 'features'), 2), (('designed', 'to'), 2), (('language', 'with'), 2), (('for', 'example,'), 2), (('at', 'the'), 2), (('using', 'a'), 2), (('but', 'it'), 2), (('This', 'is'), 2), (('British', 'comedy'), 2), (('reference', 'to'), 2), (('not', 'use'), 2), (('curly', 'brackets'), 2), (('===', \"Python's\"), 2), (('as', 'its'), 2), (('only', 'a'), 2), (('of', 'division'), 2), (('are', 'written'), 2), (('a', 'distinction'), 2), (('side', 'of'), 2), (('Python', 'allows'), 2), (('using', 'the'), 2), (('also', 'supports'), 2), (('positive', 'and'), 2), (('2.7', 'to'), 2), (('a', 'positive'), 2), (('the', 'expression'), 2), (('less', 'than'), 2), (('is', 'commonly'), 2), (('graphical', 'user'), 2), (('Python', 'implementations'), 2), (('is', 'written'), 2), (('C', 'and'), 2), (('Python', '3.9,'), 2), (('implementations', '==='), 2), (('used', 'with'), 2), (('compatible', 'with'), 2), (('machine', 'code'), 2), (('to', 'compile'), 2), (('compile', 'to'), 2), (('used', 'from'), 2), (('new', 'features,'), 2), (('design', 'and'), 2), (('libraries', 'like'), 2), (('including', 'in'), 2), (('(as', 'a'), 2), (('language', 'that'), 2), (('general-purpose', 'programming'), 1), (('of', 'significant'), 1), (('dynamically', 'typed'), 1), (('functional', 'programming.'), 1), (('programming.', 'It'), 1), (('\"batteries', 'included\"'), 1), (('language', 'due'), 1), (('and', 'first'), 1), (('1991', 'as'), 1), (('as', 'Python'), 1), (('Python', '0.9.0.'), 1), (('major', 'revision'), 1), (('with', 'earlier'), 1), (('Python', 'consistently'), 1), (('programming', 'languages,'), 1), (('has', 'gained'), 1), (('widespread', 'use'), 1), (('learning', 'community.'), 1), (('Rossum', 'at'), 1), (('(CWI)', 'in'), 1), (('language,', 'which'), 1), (('by', 'SETL,'), 1), (('implementation', 'began'), 1), (('12', 'July'), 1), (('July', '2018,'), 1), (('2018,', 'when'), 1), (('dictator', 'for'), 1), (('his', 'long-term'), 1), (('self-titled', '\"BDFL-emeritus\").'), 1), (('active', 'Python'), 1), (('five-member', 'Steering'), 1), (('lead', 'the'), 1), (('October', '2000,'), 1), (('features', 'such'), 1), (('collection,', 'reference'), 1), (('on', '3'), 1), (('December', '2008,'), 1), (('2008,', 'with'), 1), (('backported', 'to'), 1), (('Python', '2.6.x'), 1), (('the', '2to3'), 1), (('2', 'code'), 1), (('Python', \"2.7's\"), 1), (('code', 'could'), 1), (('could', 'not'), 1), (('be', 'forward-ported'), 1), (('security', 'patches'), 1), (('improvements', 'will'), 1), (('e.g.', '3.7.17,'), 1), (('the', 'final'), 1), (('final', '3.7.x'), 1), (('officially', 'unsupported,'), 1), (('implementation,', 'PyPy,'), 1), (('(plus', '3.9'), 1), (('security', 'updates\".'), 1), (('since', 'all'), 1), (('issues', 'leading'), 1), (('possible', 'remote'), 1), (('Python', '3.10.4'), 1), (('issues.', 'When'), 1), (('When', 'Python'), 1), (('Python', '3.9.13'), 1), (('announced', 'that'), 1), (('series', '(joining'), 1), (('the', 'older'), 1), (('On', '7'), 1), (('3.7.14.', 'As'), 1), (('stable', 'release,'), 1), (('and', '3.12'), 1), (('only', 'versions'), 1), (('opposed', 'to'), 1), (('just', 'security)'), 1), (('in', '3.11'), 1), (('include', 'increased'), 1), (('error', 'reporting.'), 1), (('fact', 'every'), 1), (('3.5', 'adds'), 1), (('some', 'syntax)'), 1), (('syntax)', 'to'), 1), (('of', 'typing'), 1), (('e.g.', 'new'), 1), (('new', 'type'), 1), (('and', 'case'), 1), (('structural', 'pattern'), 1), (('3.12', 'also'), 1), (('outdated', 'modules'), 1), (('in', 'Development'), 1), (('3.11', 'claims'), 1), (('than', 'Python'), 1), (('messages,', 'and'), 1), (('the', \"'security\"), 1), ((\"'security\", \"support'\"), 1), (('end-of-life.', 'Python'), 1), (('3.13', 'introduced'), 1), (('introduced', 'an'), 1), (('incremental', '(shorter'), 1), (('collection', 'in'), 1), (('API.', 'Some'), 1), (('Some', 'standard'), 1), (('deprecated', 'classes,'), 1), (('versions', 'have'), 1), (('from', 'one'), 1), (('a', 'half);'), 1), (('support', '(for'), 1), (('==', 'Design'), 1), (('Object-oriented', 'programming'), 1), (('supported,', 'and'), 1), (('and', 'aspect-oriented'), 1), (('other', 'paradigms'), 1), (('and', 'logic'), 1), (('programming.', 'Python'), 1), (('memory', 'management.'), 1), (('resolution', '(late'), 1), (('method', 'and'), 1), (('programming', 'in'), 1), (('tradition.', 'It'), 1), (('expressions.', 'The'), 1), (('borrowed', 'from'), 1), (('from', 'Haskell'), 1), (('philosophy', 'is'), 1), (('as:', 'Beautiful'), 1), (('ugly.', 'Explicit'), 1), (('complex.', 'Complex'), 1), (('features', 'regularly'), 1), (('received', 'criticism'), 1), (('criticism', 'for'), 1), (('unnecessary', 'language'), 1), (('bloat.', 'Responses'), 1), (('Responses', 'to'), 1), (('these', 'criticisms'), 1), (('guideline', 'rather'), 1), (('a', 'rule.'), 1), (('been', 'so'), 1), (('the', 'assignment'), 1), (('Nevertheless,', 'rather'), 1), (('building', 'all'), 1), (('extensible', 'via'), 1), (('programmable', 'interfaces'), 1), (('which', 'espoused'), 1), (('the', 'opposite'), 1), (('opposite', 'approach.'), 1), (('Python', 'claims'), 1), (('while', 'giving'), 1), (('a', 'choice'), 1), (('to', \"Perl's\"), 1), ((\"Perl's\", '\"there'), 1), (('only', 'one—obvious'), 1), (('one—obvious', 'way'), 1), (('many', 'ways'), 1), (('example,', 'at'), 1), (('literal,', 'with'), 1), (('to', 'which'), 1), (('Python', 'book'), 1), (('author,', 'wrote:'), 1), (('compliment', 'in'), 1), (('and', 'reject'), 1), (('implementation', 'that'), 1), (('clarity.', 'Execution'), 1), (('by', 'moving'), 1), (('moving', 'speed-critical'), 1), (('it', 'either'), 1), (('full', 'speed-up'), 1), (('semantics', 'are'), 1), (('slightly', 'changed.'), 1), (('aim', 'for'), 1), (('it', 'to'), 1), (('fun', 'to'), 1), (('name—a', 'tribute'), 1), (('reference', 'materials,'), 1), (('terms', '\"spam\"'), 1), (('\"spam\"', 'and'), 1), (('pythonic,', 'which'), 1), (('may', 'use'), 1), (('Python', 'idioms'), 1), (('be', 'natural'), 1), (('or', 'show'), 1), (('with', \"Python's\"), 1), (('emphasis', 'on'), 1), (('on', 'readability.'), 1), (('difficult', 'to'), 1), (('language', 'is'), 1), (('==', 'Syntax'), 1), (('readable', 'language.'), 1), (('where', 'other'), 1), (('rarely', 'used.'), 1), (('syntactic', 'exceptions'), 1), (('Pascal.', '==='), 1), (('whitespace', 'indentation,'), 1), (('indentation,', 'rather'), 1), (('increase', 'in'), 1), (('end', 'of'), 1), (('block.', 'Thus,'), 1), (('represents', 'its'), 1), (('rule.', 'Some'), 1), (('indentation', 'this'), 1), (('meaning.', 'The'), 1), (('size', 'is'), 1), (('is', 'four'), 1), (('along', 'with'), 1), (('with', 'else'), 1), (('for', 'statement,'), 1), (('each', 'element'), 1), (('the', 'attached'), 1), (('as', 'long'), 1), (('long', 'as'), 1), (('raised', 'in'), 1), (('attached', 'code'), 1), (('except', 'clauses'), 1), (('except*', 'in'), 1), (('groups);', 'it'), 1), (('it', 'also'), 1), (('also', 'ensures'), 1), (('block', 'is'), 1), (('always', 'run'), 1), (('regardless', 'of'), 1), (('exits', 'The'), 1), (('to', 'raise'), 1), (('local', 'namespace'), 1), (('or', 'method'), 1), (('releasing', 'the'), 1), (('opening', 'and'), 1), (('closing', 'a'), 1), (('common', 'try/finally'), 1), (('a', 'loop'), 1), (('continue', 'statement,'), 1), (('current', 'iteration'), 1), (('The', 'del'), 1), (('the', 'value,'), 1), (('and', 'producing'), 1), (('is', 'redefined'), 1), (('debugging', 'to'), 1), (('implement', 'coroutines'), 1), (('return', 'a'), 1), (('The', 'import'), 1), (('whose', 'functions'), 1), (('or', 'variables'), 1), (('be', 'rebound'), 1), (('any', 'time'), 1), (('any', 'object.'), 1), (('fixed', 'data'), 1), (('to', 'some'), 1), (('object', 'with'), 1), (('called', 'dynamic'), 1), (('statically-typed', 'languages,'), 1), (('variable', 'may'), 1), (('value', 'of'), 1), (('and,', 'according'), 1), (('to', 'Van'), 1), (('*', 'operators'), 1), (('multiplication', 'are'), 1), (('are', 'two'), 1), (('and', 'floating-point/division.'), 1), (('**', 'operator'), 1), (('the', '+'), 1), (('for', 'string'), 1), (('specified', 'number'), 1), (('NumPy', 'for'), 1), (('called', 'the'), 1), (('was', 'introduced'), 1), (('to', 'variables'), 1), (('expression.', 'In'), 1), (('compares', 'by'), 1), (('identities', '(comparison'), 1), (('comparisons', 'may'), 1), (('<=', 'b'), 1), (('and,', 'or,'), 1), (('expression.', 'Anonymous'), 1), (('there', 'may'), 1), (('expressions', 'are'), 1), (('y', '(different'), 1), (('(different', 'in'), 1), (('lists', 'and'), 1), (('are', 'mutable,'), 1), (('as', '(1,'), 1), (('are', 'immutable'), 1), (('operator', 'can'), 1), (('tuples,', 'which'), 1), (('not', 'directly'), 1), (('modify', 'their'), 1), (('Thus,', 'given'), 1), (('t', 'initially'), 1), (('which', 'yields'), 1), (('3,', '4,'), 1), (('assigned', 'back'), 1), (('back', 'to'), 1), (('t', 'while'), 1), (('are', 'optional'), 1), (('tuples', 'in'), 1), (('unambiguous', 'contexts.'), 1), (('multiple', 'expressions,'), 1), (('each', 'evaluating'), 1), (('property,', 'etc.)'), 1), (('etc.)', 'are'), 1), (('manner', 'to'), 1), (('to', 'that'), 1), (('forming', 'tuple'), 1), (('tuple', 'literals—and,'), 1), (('a', 'whole,'), 1), (('statement.', 'The'), 1), (('iterable', 'object'), 1), (('that', 'produces'), 1), (('produces', 'the'), 1), (('same', 'number'), 1), (('writable', 'expressions;'), 1), (('functions', 'analogously'), 1), (('C—e.g.', '\"spam=%s'), 1), (('\"spam=%s', 'eggs=%d\"'), 1), (('\"spam=blah', 'eggs=2\".'), 1), (('Python', '2.6+'), 1), (('format()', 'method'), 1), (('\"spam={0}', 'eggs={1}\".format(\"blah\",'), 1), (('added', '\"f-strings\":'), 1), (('=', '2;'), 1), ((\"f'spam={spam}\", \"eggs={eggs}'.\"), 1), (('by', '\"adding\"'), 1), (('\"spam\"', '+'), 1), (('If', 'strings'), 1), (('\"2\"', 'returns'), 1), (('has', 'various'), 1), (('literals:', 'Delimited'), 1), (('Unix', 'shells,'), 1), (('languages,', 'single'), 1), (('as', 'an'), 1), (('an', 'escape'), 1), (('became', 'available'), 1), (('three', 'single'), 1), (('double', 'quotes),'), 1), (('lines', 'and'), 1), (('and', 'function'), 1), (('documents', 'in'), 1), (('denoted', 'by'), 1), (('r.', 'Escape'), 1), (('are', 'useful'), 1), (('useful', 'where'), 1), (('common,', 'such'), 1), (('regular', 'expressions'), 1), (('(Compare', '\"@-quoting\"'), 1), (('in', 'C#.)'), 1), (('index', 'and'), 1), (('in', 'lists,'), 1), (('a[start:stop]', 'or'), 1), (('relative', 'to'), 1), (('the', 'end.'), 1), (('Slices', 'take'), 1), (('up', 'to,'), 1), (('including,', 'the'), 1), (('stride,', 'allows'), 1), (('elements', 'to'), 1), (('indexes', 'may'), 1), (('omitted—for', 'example,'), 1), (('slice', 'is'), 1), (('and', 'statements'), 1), (('Common', 'Lisp,'), 1), (('Scheme,', 'or'), 1), (('some', 'functionality.'), 1), (('functionality.', 'For'), 1), (('List', 'comprehensions'), 1), (('vs.', 'for-loops'), 1), (('The', 'eval()'), 1), (('vs.', 'exec()'), 1), (('the', 'former'), 1), (('list', 'and'), 1), (('other', 'comprehensions'), 1), (('cannot', 'form'), 1), (('expression', 'of'), 1), (('conditional', 'statement.'), 1), (('statement.', '==='), 1), (('normal', 'methods'), 1), (('Class.method(instance,', 'argument).'), 1), (('have', 'an'), 1), (('instance', 'data,'), 1), (('other', 'object-oriented'), 1), (('dunder', 'methods'), 1), (('beginning', 'and'), 1), (('with', 'double-underscores),'), 1), (('user-defined', 'classes'), 1), (('native', 'operations'), 1), (('duck', 'typing'), 1), (('constraints', 'are'), 1), (('not', 'checked'), 1), (('at', 'compile'), 1), (('may', 'fail,'), 1), (('fail,', 'signifying'), 1), (('suitable', 'type.'), 1), (('forbidding', 'operations'), 1), (('well-defined', '(for'), 1), (('most', 'often'), 1), (('New', 'instances'), 1), (('calling', 'the'), 1), (('class', '(for'), 1), (('are', 'instances'), 1), (('reflection.', 'Before'), 1), (('and', 'new-style;'), 1), (('current', 'Python'), 1), (('style.', 'Python'), 1), (('optional', 'type'), 1), (('to', 'catch'), 1), (('usual', 'symbols'), 1), (('e.g.', '4'), 1), (('exponentiation,', 'e.g.'), 1), (('e.g.', '5**3'), 1), (('125', 'and'), 1), (('These', 'operators'), 1), (('work', 'like'), 1), (('like', 'in'), 1), (('in', 'traditional'), 1), (('math;', 'with'), 1), (('(+', 'and'), 1), (('negative', 'numbers'), 1), (('division', 'has'), 1), (('Python', '(i.e.'), 1), (('since', '3.0)'), 1), (('was', 'introduced.'), 1), (('2,', '-7//3'), 1), (('==', '2.0'), 1), (('from', '__future__'), 1), (('module', 'used'), 1), (('division', '(see'), 1), (('above).', 'In'), 1), (('is', 'floor'), 1), (('towards', 'negative'), 1), (('from', 'most'), 1), (('adds', 'consistency.'), 1), (('+', 'b)//b'), 1), (('1', 'is'), 1), (('However,', 'maintaining'), 1), (('result', 'of'), 1), (('of', 'a%b'), 1), (('is,', 'as'), 1), (('as', 'expected,'), 1), (('the', 'half-open'), 1), (('has', 'to'), 1), (('lie', 'in'), 1), (('function', 'for'), 1), (('a', 'float'), 1), (('float', 'to'), 1), (('the', 'nearest'), 1), (('nearest', 'integer.'), 1), (('tie-breaking,', 'Python'), 1), (('and', 'round(2.5)'), 1), (('is', '1.0,'), 1), (('allows', 'Boolean'), 1), (('with', 'general'), 1), (('than', 'b'), 1), (('expression', 'would'), 1), (('evaluate', 'a'), 1), (('resulting', 'in'), 1), (('for', 'all'), 1), (('integer', 'operations.'), 1), (('operations.', 'The'), 1), (('modes.', 'The'), 1), (('the', 'fractions'), 1), (('numbers.', 'Due'), 1), (('mathematics', 'library,'), 1), (('native', 'capabilities,'), 1), (('problems', 'such'), 1), (('data', 'processing'), 1), (('integer:', '=='), 1), (('commonly', 'cited'), 1), (('Internet-facing', 'applications,'), 1), (('supported.', 'It'), 1), (('includes', 'modules'), 1), (('generating', 'pseudorandom'), 1), (('with', 'arbitrary-precision'), 1), (('and', 'unit'), 1), (('the', 'Web'), 1), (('wsgiref', 'follows'), 1), (('333—but', 'most'), 1), (('library', 'is'), 1), (('is', 'cross-platform'), 1), (('code,', 'only'), 1), (('a', 'few'), 1), (('modules', 'need'), 1), (('need', 'altering'), 1), (('altering', 'or'), 1), (('of', '17'), 1), (('March', '2024,'), 1), (('repository', 'for'), 1), (('for', 'third-party'), 1), (('contains', 'over'), 1), (('over', '523,000'), 1), (('environments', '=='), 1), (('to', 'function'), 1), (('which', 'users'), 1), (('an', 'Integrated'), 1), (('Integrated', 'development'), 1), (('called', 'IDLE,'), 1), (('beginner-oriented.', 'Other'), 1), (('including', 'IDLE'), 1), (('IPython,', 'add'), 1), (('further', 'abilities'), 1), (('As', 'well'), 1), (('desktop', 'integrated'), 1), (('there', 'are'), 1), (('and', 'hosting'), 1), (('commercial', 'IDE'), 1), (('===', 'CPython'), 1), (('own', 'C'), 1), (('they', 'can'), 1), (('be', 'implemented'), 1), (('programs', 'into'), 1), (('its', 'virtual'), 1), (('machine.', 'CPython'), 1), (('and', 'most'), 1), (('modern', 'Unix-like'), 1), (('including', 'macOS'), 1), (('Apple', 'M1'), 1), (('M1', 'Macs,'), 1), (('Python', '3.9.1,'), 1), (('installer),', 'with'), 1), (('Platform', 'portability'), 1), (('and', '2'), 1), (('2', 'development,'), 1), (('but', 'support'), 1), (('a', 'fast,'), 1), (('3.8.', 'Its'), 1), (('compiler', 'often'), 1), (('significant', 'fork'), 1), (('microthreads;', 'it'), 1), (('stack', 'in'), 1), (('thus', 'allowing'), 1), (('massively', 'concurrent'), 1), (('programs.', 'PyPy'), 1), (('MicroPython', 'and'), 1), (('and', 'CircuitPython'), 1), (('including', 'Lego'), 1), (('runtime', 'that'), 1), (('execution', 'of'), 1), (('3.8', 'that'), 1), (('eager', 'evaluation'), 1), (('a', 'method-at-a-time'), 1), (('e.g.', '8-bit'), 1), (('ATmega', '328P-based'), 1), (('Arduino,', 'as'), 1), (('full', 'Python'), 1), (('will', 'not'), 1), (('under', 'Snek.\"'), 1), (('not', 'including'), 1), (('with', '32-bit'), 1), (('smaller).', '==='), 1), (('developed,', 'but'), 1), (('are', 'now'), 1), (('now', 'unsupported:'), 1), (('project', 'named'), 1), (('named', 'Unladen'), 1), (('Swallow', 'in'), 1), (('the', 'aim'), 1), (('data', 'types'), 1), (('2', 'interpreter'), 1), (('60', 'mobile'), 1), (('Nokia', 'in'), 1), (('in', '2005.'), 1), (('implemented', 'many'), 1), (('modules', 'from'), 1), (('for', 'integrating'), 1), (('The', 'Nokia'), 1), (('GTK', 'widget'), 1), (('written', 'and'), 1), (('unrestricted', 'Python,'), 1), (('statically', 'typed'), 1), (('(via', 'LLVM)'), 1), (('supports', 'native'), 1), (('native', 'multithreading.'), 1), (('also', 'usable'), 1), (('PyJL', 'compiles/transpiles'), 1), (('source', 'code\".'), 1), (('high', 'performance,'), 1), (('performance,', 'no'), 1), (('tool', 'can'), 1), (('that', 'for'), 1), (('a', 'faster'), 1), (('code', 'can'), 1), (('machine', 'code,'), 1), (('RPython', 'can'), 1), (('build', 'the'), 1), (('→', '11l'), 1), (('C++', '(C++17).'), 1), (('Verilog', 'or'), 1), (('VHDL', 'code.'), 1), (('(or', 'not'), 1), (('Grumpy', '(latest'), 1), (('2017)', 'transpiles'), 1), (('2.7', 'programs'), 1), (('programs', '(and'), 1), (('from', 'later'), 1), (('program.', 'Pyrex'), 1), (('Pyrex', '(latest'), 1), (('non-numerical', '(combinatorial)'), 1), (('was', 'presented'), 1), (('development', 'is'), 1), (('conducted', 'largely'), 1), (('Enhancement', 'Proposal'), 1), (('process,', 'the'), 1), (('design', 'decisions.'), 1), (('coding', 'style'), 1), (('is', 'covered'), 1), (('in', 'PEP'), 1), (('8.', 'Outstanding'), 1), (('development', 'of'), 1), (('python-dev', 'is'), 1), (('development.', 'Specific'), 1), (('source-code', 'repository'), 1), (('running', 'Mercurial,'), 1), (('moved', 'to'), 1), (('2017.', \"CPython's\"), 1), (('in', 'three'), 1), (('three', 'types,'), 1), (('be', 'manually'), 1), (('ported.', 'The'), 1), (('first', 'part'), 1), (('second', 'part'), 1), (('Each', 'major'), 1), (('bug', 'fixes'), 1), (('which', 'introduce'), 1), (('about', 'every'), 1), (('a', 'sufficient'), 1), (('release.', 'Security'), 1), (('release-candidates', 'are'), 1), (('and', 'for'), 1), (('final', 'releases.'), 1), (('for', 'each'), 1), (('monitors', 'the'), 1), (('state', 'of'), 1), (('suite', 'during'), 1), (('development.', 'The'), 1), (('meaning', 'Python'), 1), (('need', 'to'), 1), (('be', 'modified,'), 1), (('code', 'will'), 1), (('DeprecationWarning', 'since'), 1), (('used', 'instead.'), 1), (('http.server.CGIHTTPRequestHandler', 'will'), 1), (('a', 'DeprecationWarning,'), 1), (('that', 'code'), 1), (('both', 'security'), 1), (('and', 'functionality'), 1), (('are', 'deprecated,'), 1), (('e.g.', 'creating'), 1), (('a', 'typing.NamedTuple'), 1), (('class', 'using'), 1), (('keyword', 'arguments'), 1), (('Python', '3.15.'), 1), (('3.15.', '=='), 1), (('Tools', 'that'), 1), (('generate', 'documentation'), 1), (('Pdoc', 'and'), 1), (('forks,', 'Doxygen'), 1), (('is', 'derived'), 1), (('Python,', 'whom'), 1), (('Python', 'creator'), 1), (('creator', 'Guido'), 1), (('language.', 'Monty'), 1), (('references', 'appear'), 1), (('traditional', 'foo'), 1), (('and', 'bar.'), 1), (('Python', 'documentation'), 1), (('is', 'related'), 1), (('names', 'of'), 1), (('applications', 'or'), 1), (('binding', 'of'), 1), (('SDL', 'to'), 1), (('bind', 'Qt'), 1), (('==', 'Since'), 1), (('Programming', 'Community'), 1), (('Index', 'where'), 1), (('where', 'as'), 1), (('C++,', 'and'), 1), (('selected', 'as'), 1), (('as', 'Programming'), 1), (('Year', '(for'), 1), (('in', '2007,'), 1), (('of', '2020).'), 1), (('Python', 'include'), 1), (('include', 'Wikipedia,'), 1), (('Wikipedia,', 'Google,'), 1), (('ILM', 'and'), 1), (('for', 'web'), 1), (('applications,', 'e.g.'), 1), (('e.g.', 'via'), 1), (('these', 'applications.'), 1), (('Pyramid,', 'TurboGears,'), 1), (('Bottle,', 'and'), 1), (('and', 'Zope'), 1), (('support', 'developers'), 1), (('develop', 'the'), 1), (('Ajax-based', 'applications.'), 1), (('applications.', 'SQLAlchemy'), 1), (('data', 'mapper'), 1), (('database.', 'Twisted'), 1), (('program', 'communications'), 1), (('communications', 'between'), 1), (('(for', 'example)'), 1), (('NumPy,', 'SciPy'), 1), (('and', 'Matplotlib'), 1), (('effective', 'use'), 1), (('Astropy', 'providing'), 1), (('system', 'with'), 1), (('numerical', 'mathematics,'), 1), (('number', 'theory,'), 1), (('calculus.', 'OpenCV'), 1), (('like', 'TensorFlow,'), 1), (('modular', 'architecture,'), 1), (('rich', 'text'), 1), (('text', 'processing'), 1), (('processing', 'tools,'), 1), (('The', 'combination'), 1), (('for', 'AI'), 1), (('Prolog', 'providing'), 1), (('providing', 'knowledge'), 1), (('knowledge', 'representation'), 1), (('and', 'reasoning'), 1), (('Janus', 'system,'), 1), (('particular,', 'exploits'), 1), (('languages,', 'in'), 1), (('dynamic', 'typing,'), 1), (('their', 'data'), 1), (('processing,', 'visual'), 1), (('and', 'handling'), 1), (('of', 'semantic'), 1), (('The', 'Natlog'), 1), (('text-to-text', 'generators'), 1), (('like', 'GPT3'), 1), (('interface', '(GUI)'), 1), (('(GUI)', 'by'), 1), (('like', 'Tkinter.'), 1), (('many', 'software'), 1), (('language,', 'including'), 1), (('software', 'such'), 1), (('as', 'Abaqus,'), 1), (('3D', 'parametric'), 1), (('Cinema', '4D,'), 1), (('Lightwave,', 'Houdini,'), 1), (('effects', 'compositor'), 1), (('capella.', 'GNU'), 1), (('Debugger', 'uses'), 1), (('show', 'complex'), 1), (('as', 'C++'), 1), (('promotes', 'Python'), 1), (('writing', 'scripts'), 1), (('ArcGIS.', 'It'), 1), (('has', 'also'), 1), (('in', 'several'), 1), (('games,', 'and'), 1), (('Google', 'App'), 1), (('include', 'Python'), 1), (('It', 'ships'), 1), (('with', 'most'), 1), (('Linux', 'distributions,'), 1), (('a', 'package),'), 1), (('NetBSD,', 'and'), 1), (('and', 'can'), 1), (('while', 'Red'), 1), (('Red', 'Hat'), 1), (('Linux', 'and'), 1), (('the', 'Anaconda'), 1), (('its', 'package'), 1), (('the', 'information'), 1), (('software', 'for'), 1), (('Laptop', 'per'), 1), (('at', 'Sugar'), 1), (('Sugar', 'Labs'), 1), (('Labs', 'as'), 1), (('Raspberry', 'Pi'), 1), (('Pi', 'single-board'), 1), (('single-board', 'computer'), 1), (('its', 'main'), 1), (('user-programming', 'language.'), 1), (('replace', 'Java'), 1), (('Version', '4.0'), 1), (('from', '7'), 1), (('Python', '=='), 1), (('philosophy', 'have'), 1), (('programming', 'languages:'), 1), (('Boo', 'uses'), 1), (('Acknowledgements', 'document'), 1), (('first', 'among'), 1), (('languages', 'that'), 1), (('CoffeeScript,', 'a'), 1), (('has', 'Python-inspired'), 1), (('ECMAScript–JavaScript', 'borrowed'), 1), (('iterators', 'and'), 1), (('Python.', 'GDScript,'), 1), (('Python,', 'built-in'), 1), (('Go', 'is'), 1), (('is', 'designed'), 1), (('the', '\"speed'), 1), (('language', 'like'), 1), (('Python\"', 'and'), 1), (('slicing', 'arrays.'), 1), (('arrays.', 'Groovy'), 1), (('was', 'motivated'), 1), (('\"as', 'usable'), 1), (('for', 'general'), 1), (('programming', 'as'), 1), (('Python', '(e.g.'), 1), (('still', 'missing'), 1), (('classes,', 'and'), 1), (('and', 'adding'), 1), (('has', 'said:'), 1), (('was', 'more'), 1), (('more', 'object-oriented'), 1), (('object-oriented', 'than'), 1), (('than', 'Python.'), 1), ((\"That's\", 'why'), 1), (('Swift,', 'a'), 1), (('language', 'developed'), 1), (('has', 'some'), 1), (('some', 'Python-inspired'), 1), (('syntax.', 'Kotlin'), 1), (('boilerplate', 'code'), 1), (('the', 'practice'), 1), (('of', 'requiring'), 1), (('describing', 'the'), 1), (('the', 'rationale'), 1), (('rationale', 'for,'), 1), (('and', 'Swift.'), 1), (('semantics', 'pip'), 1), (('List', 'of'), 1), (('===', 'Sources'), 1), (('\"AI', 'in'), 1), (('AI', 'Expert'), 1), (('Newsletter.', 'Amzi!.'), 1), (('March', '2012.'), 1), (('Index\".', 'Pypi.python.org.'), 1), (('Retrieved', '17'), 1), (('17', 'July'), 1), (('Peter', '(2009).'), 1), (('Saddle', 'River,'), 1), (('River,', 'NJ:'), 1), (('==', 'Further'), 1), (('Allen', 'B.'), 1), (('(May', '2012).'), 1), (('Like', 'a'), 1), (('Computer', 'Scientist'), 1), (('1.6.6', 'ed.).'), 1), (('Press.', 'ISBN'), 1), (('August', '2008).'), 1), (('2008).', '\"The'), 1), (('December', '2008.'), 1), (('Mark', '(2013).'), 1), (('Python', '(5th'), 1), (('Programming', 'in'), 1), (('ISBN', '978-0-321-68056-3.'), 1), (('Official', 'website'), 1), (('code', 'readability'), 1), (('readability', 'with'), 1), (('procedural),', 'object-oriented'), 1), (('object-oriented', 'and'), 1), (('its', 'comprehensive'), 1), (('standard', 'library.'), 1), (('2000.', 'Python'), 1), (('in', '2008,'), 1), (('2008,', 'was'), 1), (('a', 'major'), 1), (('revision', 'not'), 1), (('backward-compatible', 'with'), 1), (('versions.', 'Python'), 1), (('Python', '2.'), 1), (('was', 'invented'), 1), (('invented', 'in'), 1), (('programming', 'language,'), 1), (('was', 'inspired'), 1), (('SETL,', 'capable'), 1), (('the', 'Amoeba'), 1), (('Its', 'implementation'), 1), (('began', 'in'), 1), (('Van', 'Rossum'), 1), (('his', '\"permanent'), 1), (('\"permanent', 'vacation\"'), 1), (('\"benevolent', 'dictator'), 1), (('for', 'life\"'), 1), (('a', 'title'), 1), (('bestowed', 'upon'), 1), (('long-term', 'commitment'), 1), (('commitment', 'as'), 1), (('chief', 'decision-maker'), 1), (('In', 'January'), 1), (('on', '16'), 1), (('16', 'October'), 1), (('many', 'major'), 1), (('and', 'Unicode'), 1), (('2to3', 'utility,'), 1), (('automates', 'the'), 1), (('translation', 'of'), 1), (('end-of-life', 'was'), 1), (('set', 'for'), 1), (('for', '2015,'), 1), (('postponed', 'to'), 1), (('patches', 'or'), 1), (('other', 'improvements'), 1), (('a', 'different'), 1), (('different', 'unofficial'), 1), (('unofficial', 'Python'), 1), (('continues', 'to'), 1), (('2021', '(and'), 1), (('in', '2022),'), 1), (('updates', 'were'), 1), (('all', 'Python'), 1), (('leading', 'to'), 1), (('to', 'possible'), 1), (('execution', 'and'), 1), (('poisoning.', 'In'), 1), (('3.8.13,', 'because'), 1), (('the', '3.9'), 1), (('(joining', 'the'), 1), (('fixes', 'in'), 1), (('September', '2022,'), 1), (('a', 'potential'), 1), (('potential', 'denial-of-service'), 1), (('3.12', 'is'), 1), (('the', 'stable'), 1), (('with', 'active'), 1), (('to', 'just'), 1), (('security)', 'support.'), 1), (('3.11', 'from'), 1), (('increased', 'program'), 1), (('program', 'execution'), 1), (('and', 'improved'), 1), (('in', 'fact'), 1), (('type', '(recent'), 1), (('added', 'a'), 1), (('type', 'union'), 1), (('(soft)', 'keywords,'), 1), (('matching', 'statements.'), 1), (('statements.', 'Python'), 1), (('drops', 'outdated'), 1), (('see', 'below'), 1), (('between', '10'), 1), (('Python', '3.10,'), 1), (('of', 'that.'), 1), (('Python', '3.8'), 1), (('the', 'oldest'), 1), (('(albeit', 'in'), 1), (('Python', '3.7'), 1), (('programs', 'with'), 1), (('of', 'objects)'), 1), (('19', 'dead'), 1), (('functions', 'and'), 1), (('and', 'methods,'), 1), (('methods,', 'and'), 1), (('3.15', 'and'), 1), (('(for', 'same'), 1), (('as', 'before).'), 1), (('features', '=='), 1), (('features', 'support'), 1), (('supported', 'via'), 1), (('design', 'by'), 1), (('contract', 'and'), 1), (('dynamic', 'typing'), 1), (('counting', 'and'), 1), (('name', 'resolution'), 1), (('for', 'functional'), 1), (('the', 'Lisp'), 1), (('dictionaries,', 'sets,'), 1), (('has', 'two'), 1), (('and', 'functools)'), 1), (('functools)', 'that'), 1), (('implement', 'functional'), 1), (('and', 'Standard'), 1), (('core', 'philosophy'), 1), (('is', 'summarized'), 1), (('of', 'some'), 1), (('that', 'Guido'), 1), (('than', 'building'), 1), (('modules.', 'This'), 1), (('This', 'compact'), 1), (('popular', 'as'), 1), (('applications.', 'Van'), 1), (('and', 'easily'), 1), (('stemmed', 'from'), 1), (('his', 'frustrations'), 1), (('with', 'ABC,'), 1), (('approach.', 'Python'), 1), (('a', 'simpler,'), 1), (('and', 'grammar'), 1), (('grammar', 'while'), 1), (('choice', 'in'), 1), (('in', 'their'), 1), (('their', 'coding'), 1), (('one', 'way'), 1), (('do', 'it\"'), 1), (('it\"', 'motto,'), 1), (('preferably', 'only'), 1), (('In', 'practice,'), 1), (('three', 'ways'), 1), (('to', 'format'), 1), (('format', 'a'), 1), (('with', 'no'), 1), (('a', 'programmer'), 1), (('Alex', 'Martelli,'), 1), (('not', 'considered'), 1), (('reject', 'patches'), 1), (('that', 'would'), 1), (('cost', 'of'), 1), (('Execution', 'speed'), 1), (('compiler', 'like'), 1), (('like', 'PyPy.'), 1), (('PyPy.', 'It'), 1), (('either', \"doesn't\"), 1), (('speed-up', 'that'), 1), (('expected,', 'since'), 1), (('compiled,', 'and'), 1), (('possibly', 'semantics'), 1), (('is', 'reflected'), 1), (('playful', 'approaches'), 1), (('approaches', 'to'), 1), (('to', 'tutorials'), 1), (('\"eggs\"', '(a'), 1), (('in', 'examples,'), 1), (('examples,', 'instead'), 1), (('\"foo\"', 'and'), 1), (('and', '\"bar\".'), 1), (('\"bar\".', 'A'), 1), (('neologism', 'in'), 1), (('is', 'pythonic,'), 1), (('meanings', 'related'), 1), (('style.', '\"Pythonic\"'), 1), (('show', 'fluency'), 1), (('readability.', 'Code'), 1), (('or', 'reads'), 1), (('like', 'a'), 1), (('formatting', 'is'), 1), (('often', 'uses'), 1), (('use', 'punctuation.'), 1), (('delimit', 'blocks,'), 1), (('allowed', 'but'), 1), (('used.', 'It'), 1), (('has', 'fewer'), 1), (('special', 'cases'), 1), (('C', 'or'), 1), (('or', 'Pascal.'), 1), (('brackets', 'or'), 1), (('blocks.', 'An'), 1), (('comes', 'after'), 1), (('current', 'block.'), 1), (('termed', 'the'), 1), (('way;', 'but'), 1), (('in', 'most,'), 1), (('has', 'no'), 1), (('spaces.', '==='), 1), (('Statements', 'and'), 1), (('flow', '==='), 1), (('over', 'an'), 1), (('local', 'variable'), 1), (('condition', 'is'), 1), (('try', 'statement,'), 1), (('allows', 'exceptions'), 1), (('and', 'handled'), 1), (('that', 'clean-up'), 1), (('or', 're-raise'), 1), (('re-raise', 'a'), 1), (('a', 'class,'), 1), (('method', 'The'), 1), (('example,', 'acquiring'), 1), (('the', 'lock;'), 1), (('lock;', 'or'), 1), (('allowing', 'resource-acquisition-is-initialization'), 1), (('try/finally', 'idiom'), 1), (('idiom', 'The'), 1), (('exits', 'a'), 1), (('loop', 'The'), 1), (('The', 'continue'), 1), (('the', 'rest'), 1), (('del', 'statement,'), 1), (('to', 'before'), 1), (('pass', 'statement,'), 1), (('an', 'empty'), 1), (('conditions', 'that'), 1), (('function', '(and'), 1), (('function', 'The'), 1), (('from', 'statements,'), 1), (('to', 'import'), 1), (('modules', 'whose'), 1), (('current', 'program'), 1), (('(=)', 'binds'), 1), (('binds', 'a'), 1), (('generic', 'reference'), 1), (('type;', 'however,'), 1), (('it', 'always'), 1), (('type.', 'This'), 1), (('to', 'statically-typed'), 1), (('a', 'certain'), 1), (('Python', 'does'), 1), (('better', 'support'), 1), ((\"Python's\", 'generators.'), 1), (('Before', '2.5,'), 1), (('data', 'was'), 1), (('passed', 'unidirectionally'), 1), (('generator.', 'From'), 1), (('2.5', 'on,'), 1), (('on,', 'it'), 1), (('to', 'pass'), 1), (('pass', 'data'), 1), (('generator', 'function;'), 1), (('function;', 'and'), 1), (('stack', 'levels.'), 1), ((\"Python's\", 'expressions'), 1), (('operators', 'for'), 1), (('the', 'behavior'), 1), (('two', 'types'), 1), (('of', 'divisions'), 1), (('(or', 'integer'), 1), (('for', 'exponentiation.'), 1), (('string', 'concatenation.'), 1), (('the', '*'), 1), (('*', 'operator'), 1), (('as', 'NumPy'), 1), (('The', 'syntax'), 1), (('syntax', ':=,'), 1), (('operator\",', 'was'), 1), (('assigns', 'values'), 1), (('larger', 'expression.'), 1), (('Python,', '=='), 1), (('compare', 'object'), 1), (('(comparison', 'by'), 1), (('and', 'comparisons'), 1), (('chained—for', 'example,'), 1), (('a', '<='), 1), (('a', 'more'), 1), (('Anonymous', 'functions'), 1), (('are', 'implemented'), 1), (('expressions;', 'however,'), 1), (('only', 'one'), 1), (('in', 'each'), 1), (('each', 'body.'), 1), (('as', 'x'), 1), (('else', 'y'), 1), (('in', 'order'), 1), (('order', 'of'), 1), (('operands', 'from'), 1), (('the', 'c'), 1), ((':', 'y'), 1), (('operator', 'common'), 1), (('tuples.', 'Lists'), 1), (('3],', 'are'), 1), (('mutable,', 'and'), 1), (('dictionaries', '(dictionary'), 1), (('keys', 'must'), 1), (('be', 'immutable'), 1), (('in', 'Python).'), 1), (('thus', 'can'), 1), (('the', \"tuple's\"), 1), (('their', 'contents,'), 1), (('a', 'new'), 1), (('both.', 'Thus,'), 1), (('variable', 't'), 1), (('3),', 'executing'), 1), (('t', '='), 1), (('yields', '(1,'), 1), (('2,', '3,'), 1), (('of', 't'), 1), (('immutable', 'nature'), 1), (('contexts.', 'Python'), 1), (('expressions,', 'each'), 1), (('to', 'anything'), 1), (('(to', 'a'), 1), (('a', 'variable,'), 1), (('writable', 'property,'), 1), (('are', 'associated'), 1), (('put', 'on'), 1), (('assignment', 'statement.'), 1), (('expects', 'an'), 1), (('of', 'values'), 1), (('values', 'as'), 1), (('expressions;', 'when'), 1), (('through', 'them,'), 1), (('them,', 'it'), 1), (('it', 'assigns'), 1), (('assigns', 'each'), 1), (('each', 'of'), 1), (('corresponding', 'expression'), 1), (('expression', 'on'), 1), (('to', 'printf'), 1), (('%', '(\"blah\",'), 1), (('evaluates', 'to'), 1), (('2.6+', 'and'), 1), (('supplemented', 'by'), 1), (('e.g.', '\"spam={0}'), 1), (('spam', '='), 1), ((\"eggs={eggs}'.\", 'Strings'), 1), (('(with', 'the'), 1), (('operator', 'as'), 1), (('returns', '\"spameggs\".'), 1), (('as', 'strings'), 1), (('than', 'integers,'), 1), (('integers,', 'e.g.'), 1), (('+', '\"2\"'), 1), (('unlike', 'in'), 1), (('single', 'and'), 1), (('work', 'the'), 1), (('the', 'backslash'), 1), (('(\\\\)', 'as'), 1), (('character.', 'String'), 1), (('span', 'multiple'), 1), (('and', 'Ruby.'), 1), (('varieties,', 'denoted'), 1), (('by', 'prefixing'), 1), (('string', 'literal'), 1), (('literal', 'with'), 1), (('Escape', 'sequences'), 1), (('not', 'interpreted;'), 1), (('interpreted;', 'hence'), 1), (('backslashes', 'are'), 1), (('array', 'index'), 1), (('lists,', 'denoted'), 1), (('slice', 'parameter,'), 1), (('be', 'omitted—for'), 1), (('entire', 'list.'), 1), (('a', 'shallow'), 1), (('shallow', 'copy.'), 1), (('duplicating', 'some'), 1), (('if', 'blocks'), 1), (('built-in', 'functions'), 1), (('for', 'expressions,'), 1), (('expressions,', 'the'), 1), (('the', 'latter'), 1), (('cannot', 'contain'), 1), (('case', 'is'), 1), (('a', '='), 1), (('form', 'part'), 1), (('the', 'conditional'), 1), (('a', 'conditional'), 1), (('objects', 'are'), 1), (('the', \"object's\"), 1), (('an', 'explicit'), 1), (('parameter', 'to'), 1), (('the', 'implicit'), 1), (('self', '(or'), 1), (('in', 'some'), 1), (('(e.g.,', 'C++,'), 1), (('C++,', 'Java,'), 1), (('methods,', 'often'), 1), (('names', 'beginning'), 1), (('operations', 'including'), 1), (('operations', 'and'), 1), (('type', 'conversion.'), 1), (('conversion.', '==='), 1), (('typed', 'objects'), 1), (('untyped', 'variable'), 1), (('names.', 'Type'), 1), (('rather,', 'operations'), 1), (('operations', 'on'), 1), (('operations', 'that'), 1), (('make', 'sense'), 1), (('using', 'classes,'), 1), (('the', 'class'), 1), (('or', 'EggsClass()),'), 1), (('of', 'itself),'), 1), (('itself),', 'allowing'), 1), (('old-style', 'and'), 1), (('the', 'semantics'), 1), (('type', 'annotations.'), 1), (('annotations.', 'These'), 1), (('enforced', 'by'), 1), (('tools', 'such'), 1), (('Python', 'compiler'), 1), (('which', 'leverages'), 1), (('the', 'usual'), 1), (('symbols', 'for'), 1), (('for', 'arithmetic'), 1), (('*,', '/),'), 1), (('/),', 'the'), 1), (('the', 'floor'), 1), (('operator', '//'), 1), (('negative,', 'e.g.'), 1), (('-2).', 'It'), 1), (('for', 'exponentiation,'), 1), (('==', '3.0,'), 1), (('traditional', 'math;'), 1), (('rules,', 'the'), 1), (('the', 'operators'), 1), (('be', 'unary'), 1), (('The', 'division'), 1), (('3.0)', 'changed'), 1), (('changed', '/'), 1), (('to', 'always'), 1), (('division,', 'e.g.'), 1), (('introduced.', 'So'), 1), (('==', '2,'), 1), (('-7//3', '=='), 1), (('==', '-3,'), 1), (('==', '-3.0.'), 1), (('import', 'division'), 1), (('causes', 'a'), 1), (('a', 'module'), 1), (('3.0', 'rules'), 1), (('rules', 'for'), 1), (('3.0', 'is'), 1), (('languages,', 'adds'), 1), (('For', 'instance,'), 1), (('b)//b', '=='), 1), (('==', 'a//b'), 1), (('also', 'means'), 1), (('validity', 'of'), 1), (('[0,', 'b),'), 1), (('positive', 'integer,'), 1), (('interval', '(b,'), 1), (('provides', 'a'), 1), (('3', 'uses'), 1), (('produce', '2.'), 1), (('3', 'used'), 1), (('1.0,', 'round(-0.5)'), 1), (('b', '<'), 1), (('would', 'first'), 1), (('or', '1,'), 1), (('all', 'integer'), 1), (('The', 'Decimal'), 1), (('provides', 'decimal'), 1), (('The', 'Fraction'), 1), (('Fraction', 'class'), 1), (('fractions', 'module'), 1), (('third-party', 'library'), 1), (('that', 'further'), 1), (('the', 'native'), 1), (('capabilities,', 'it'), 1), (('frequently', 'used'), 1), (('a', 'scientific'), 1), (('aid', 'in'), 1), (('in', 'problems'), 1), (('World!\"', 'program:'), 1), (('the', 'factorial'), 1), (('==', 'Libraries'), 1), (('tools', 'suited'), 1), (('tasks', 'and'), 1), (('its', 'greatest'), 1), (('greatest', 'strengths.'), 1), (('standard', 'formats'), 1), (('formats', 'and'), 1), (('MIME', 'and'), 1), (('It', 'includes'), 1), (('connecting', 'to'), 1), (('databases,', 'generating'), 1), (('pseudorandom', 'numbers,'), 1), (('expressions,', 'and'), 1), (('Interface', '(WSGI)'), 1), (('(WSGI)', 'implementation'), 1), (('implementation', 'wsgiref'), 1), (('PEP', '333—but'), 1), (('their', 'code,'), 1), (('most', 'of'), 1), (('official', 'repository'), 1), (('of', 'functionality,'), 1), (('==', 'Most'), 1), (('implementations', '(including'), 1), (('(REPL),', 'permitting'), 1), (('function', 'as'), 1), (('users', 'enter'), 1), (('receive', 'results'), 1), (('results', 'immediately.'), 1), (('immediately.', 'Python'), 1), (('with', 'an'), 1), (('environment', '(IDE)'), 1), (('more', 'beginner-oriented.'), 1), (('state', 'retention,'), 1), (('standard', 'desktop'), 1), (('web', 'browser-based'), 1), (('for', 'developing'), 1), (('developing', 'science-'), 1), (('and', 'math-related'), 1), (('math-related', 'programs;'), 1), (('programs;', 'PythonAnywhere,'), 1), (('a', 'browser-based'), 1), (('a', 'commercial'), 1), (('emphasizing', 'scientific'), 1), (('computing.', '=='), 1), (('===', 'Reference'), 1), (('implementation', 'of'), 1), (('the', 'C89'), 1), (('C89', 'standard'), 1), (('standard', '(Python'), 1), (('uses', 'C11)'), 1), (('with', 'several'), 1), (('select', 'C99'), 1), (('CPython', 'includes'), 1), (('third-party', 'extensions'), 1), (('not', 'limited'), 1), (('executed', 'by'), 1), (('is', 'distributed'), 1), (('native', 'Python,'), 1), (('platforms,', 'including'), 1), (('(starting', 'with'), 1), (('fails', 'to'), 1), (('to', 'install'), 1), (('install', 'on'), 1), (('on', 'Windows'), 1), (('Windows', 'XP'), 1), (('supported', 'until'), 1), (('most', 'modern'), 1), (('Macs,', 'since'), 1), (('3.9.1,', 'with'), 1), (('was', 'one'), 1), (('earliest', 'priorities.'), 1), (('OS/2', 'and'), 1), (('platforms.)', 'Python,'), 1), (('multi-threading', 'support.'), 1), (('support.', '==='), 1), (('PyPy', 'is'), 1), (('and', '3.8.'), 1), (('Its', 'just-in-time'), 1), (('often', 'brings'), 1), (('it.', 'Stackless'), 1), (('Stackless', 'Python'), 1), (('CPython', 'that'), 1), (('way,', 'thus'), 1), (('allowing', 'massively'), 1), (('version.', 'MicroPython'), 1), (('for', 'microcontrollers,'), 1), (('microcontrollers,', 'including'), 1), (('Pyston', 'is'), 1), (('a', 'variant'), 1), (('the', 'execution'), 1), (('programs.', 'Cinder'), 1), (('CPython', '3.8'), 1), (('of', 'optimizations,'), 1), (('bytecode', 'inline'), 1), (('evaluation', 'of'), 1), (('and', 'an'), 1), (('compiler.', 'Snek'), 1), (('Embedded', 'Computing'), 1), (('(compatible', 'with'), 1), (('microcontrollers', 'such'), 1), (('as', 'ATmega'), 1), (('Snek', 'programs'), 1), (('a', 'full'), 1), (('simplifying', 'to'), 1), (('number', 'type'), 1), (('except', 'smaller).'), 1), (('Unsupported', 'implementations'), 1), (('2009,', 'with'), 1), (('multithreading', 'ability'), 1), (('the', 'global'), 1), (('lock.', 'Psyco'), 1), (('Psyco', 'is'), 1), (('and', 'transforms'), 1), (('The', 'emitted'), 1), (('specialized', 'for'), 1), (('certain', 'data'), 1), (('is', 'faster'), 1), (('standard', 'Python'), 1), (('code.', 'Psyco'), 1), (('2.7', 'or'), 1), (('for', 'Series'), 1), (('phones', 'released'), 1), (('additional', 'modules'), 1), (('N900', 'also'), 1), (('Python', 'with'), 1), (('and', 'run'), 1), (('languages', '==='), 1), (('compilers/transpilers', 'to'), 1), (('high-level', 'object'), 1), (('languages,', 'with'), 1), (('code', '(via'), 1), (('resulting', 'code'), 1), (('C-level', 'API'), 1), (('API', 'calls'), 1), (('into', 'the'), 1), (('and', 'high-performance'), 1), (('can', 'claim'), 1), (('do', 'that'), 1), (('code;', 'i.e.'), 1), (('known', 'not'), 1), (('faster', 'language'), 1), (('language', 'or'), 1), (('many', 'cases'), 1), (('and', 'based'), 1), (('based', 'that'), 1), (('into', 'C.'), 1), (('C++', '(C++11).'), 1), (('→', 'C++'), 1), (('transpiler', 'compiles'), 1), (('Specialized:', 'MyHDL'), 1), (('that', 'converts'), 1), (('and', 'latest'), 1), (('IronPython', 'allows'), 1), (('alpha,', 'released'), 1), (('Jython', 'compiles'), 1), (('Java', 'bytecode,'), 1), (('bytecode,', 'allowing'), 1), (('the', 'Java'), 1), (('Java', 'libraries'), 1), (('Python', 'program.'), 1), (('2010)', 'and'), 1), (('to', 'C'), 1), (('and', 'C++'), 1), (('various', 'Python'), 1), (('also', 'benchmarked'), 1), (('The', 'Computer'), 1), (('Proposal', '(PEP)'), 1), (('primary', 'mechanism'), 1), (('collecting', 'community'), 1), (('and', 'documenting'), 1), (('corresponds', 'with'), 1), (('list', 'python-dev'), 1), (('primary', 'forum'), 1), (('were', 'originally'), 1), (('bug', 'tracker'), 1), (('foundation.', 'In'), 1), (('a', 'self-hosted'), 1), (('public', 'releases'), 1), (('come', 'in'), 1), (('manually', 'ported.'), 1), (('releases', 'happen'), 1), (('after', '2.0.'), 1), (('2.0.', 'According'), 1), (('According', 'to'), 1), (('to', 'Guido'), 1), (('van', 'Rossum,'), 1), (('Rossum,', 'a'), 1), (('version', '4.0'), 1), (('4.0', 'is'), 1), (('happen.', 'Major'), 1), (('Major', 'or'), 1), (('but', 'introduce'), 1), (('introduce', 'new'), 1), (('3.9,', 'these'), 1), (('are', 'expected'), 1), (('for', 'several'), 1), (('after', 'its'), 1), (('introduce', 'no'), 1), (('features,', 'occur'), 1), (('occur', 'about'), 1), (('3', 'months'), 1), (('are', 'made'), 1), (('of', 'bugs'), 1), (('these', 'releases.'), 1), (('Many', 'alpha,'), 1), (('previews', 'and'), 1), (('before', 'final'), 1), (('rough', 'schedule'), 1), (('schedule', 'for'), 1), (('delayed', 'if'), 1), (('team', 'monitors'), 1), (('special', 'Python'), 1), (('Python', 'mentoring'), 1), (('extensions', 'need'), 1), (('matching', 'to'), 1), (('dropped', 'some'), 1), (('outdated', 'modules,'), 1), (('be', 'dropped'), 1), (('deprecated', 'as'), 1), (('deprecated', 'array'), 1), (('since', '3.13'), 1), (('3.13', 'and'), 1), ((\"'w'\", 'format'), 1), (('instead.', 'Part'), 1), (('ctypes', 'is'), 1), (('3.15.', 'Using'), 1), (('code', 'already'), 1), (('a', 'high'), 1), (('creating', 'a'), 1), (('typing.NamedTuple', 'class'), 1), (('more)', 'will'), 1), (('==', 'Tools'), 1), (('can', 'generate'), 1), (('==', 'Naming'), 1), (('whom', 'Python'), 1), (('while', 'developing'), 1), (('appear', 'frequently'), 1), (('Python', 'code'), 1), (('are', 'spam'), 1), (('bar.', 'The'), 1), (('various', 'references'), 1), (('references', 'to'), 1), (('sometimes', 'referred'), 1), (('to', 'as'), 1), (('The', 'prefix'), 1), (('Python', 'applications'), 1), (('PyQt', 'and'), 1), (('==', 'Popularity'), 1), (('ten', 'most'), 1), (('TIOBE', 'Programming'), 1), (('popular', 'language'), 1), (('language', '(ahead'), 1), (('(ahead', 'of'), 1), (('C,', 'C++,'), 1), (('and', 'Java).'), 1), (('the', 'Year'), 1), (('\"the', 'highest'), 1), (('2007,', '2010,'), 1), (('have', 'done'), 1), (('four', 'times'), 1), (('Yahoo!,', 'CERN,'), 1), (('NASA,', 'Facebook,'), 1), (('Facebook,', 'Amazon,'), 1), (('Amazon,', 'Instagram,'), 1), (('and', 'ITA.'), 1), (('mostly', 'in'), 1), (('==', 'Uses'), 1), (('Uses', '=='), 1), (('web', 'applications,'), 1), (('via', 'mod_wsgi'), 1), (('to', 'facilitate'), 1), (('applications.', 'Web'), 1), (('like', 'Django,'), 1), (('Tornado,', 'Flask,'), 1), (('Flask,', 'Bottle,'), 1), (('Zope', 'support'), 1), (('applications.', 'Pyjs'), 1), (('and', 'IronPython'), 1), (('IronPython', 'can'), 1), (('between', 'computers,'), 1), (('by', 'Dropbox.'), 1), (('providing', 'domain-specific'), 1), (('its', 'library'), 1), (('including', 'algebra,'), 1), (('bindings', 'with'), 1), (('rich', 'set'), 1), (('of', 'features'), 1), (('processing.', 'Python'), 1), (('artificial', 'intelligence'), 1), (('and', 'machine'), 1), (('of', 'libraries'), 1), (('Prolog', 'has'), 1), (('applications,', 'with'), 1), (('with', 'Prolog'), 1), (('representation', 'and'), 1), (('the', 'similarites'), 1), (('between', 'these'), 1), (('of', 'dynamic'), 1), (('the', 'simple'), 1), (('Typical', 'applications'), 1), (('applications', 'of'), 1), (('web', 'data.'), 1), (('implemented', 'in'), 1), (('in', 'Python,'), 1), (('Python,', 'uses'), 1), (('DALL-E', 'or'), 1), (('Diffusion.', 'Python'), 1), (('for', 'graphical'), 1), (('been', 'successfully'), 1), (('products', 'as'), 1), (('in', 'finite'), 1), (('like', 'FreeCAD,'), 1), (('animation', 'packages'), 1), (('Max,', 'Blender,'), 1), (('MotionBuilder,', 'Softimage,'), 1), (('the', 'visual'), 1), (('Nuke,', '2D'), 1), (('and', 'Paint'), 1), (('Paint', 'Shop'), 1), (('and', 'musical'), 1), (('notation', 'programs'), 1), (('structures', 'such'), 1), (('containers.', 'Esri'), 1), (('best', 'choice'), 1), (('for', 'writing'), 1), (('the', 'three'), 1), (('available', 'programming'), 1), (('two', 'being'), 1), (('component.', 'It'), 1), (('distributions,', 'AmigaOS'), 1), (('line', '(terminal).'), 1), (('use', 'installers'), 1), (('Python:', 'Ubuntu'), 1), (('Linux', 'uses'), 1), (('Portage.', 'Python'), 1), (('development.', 'Most'), 1), (('the', 'Sugar'), 1), (('to', 'replace'), 1), (('Scripting', 'Provider'), 1), (('February', '2013.'), 1), (('by', 'Python'), 1), (('and', 'philosophy'), 1), (('have', 'influenced'), 1), (('indentation,', 'a'), 1), (('model.', 'Cobra'), 1), (('lists', 'Python'), 1), (('Python', 'first'), 1), (('generators', 'from'), 1), (('dynamic', 'language'), 1), (('for', 'slicing'), 1), (('general', 'programming'), 1), (('(e.g.', 'still'), 1), (('e.g.', 'struct).'), 1), (('and', 'similar'), 1), (('more', 'powerful'), 1), (('powerful', 'than'), 1), (('by', 'Apple,'), 1), (('Java', 'features,'), 1), (('minimizing', 'boilerplate'), 1), (('enhanced', 'developer'), 1), (('have', 'also'), 1), (('by', 'other'), 1), (('and', 'issues'), 1), (('change', 'to'), 1), (('also', '=='), 1), (('pip', '(package'), 1), (('Jocelyn,', 'ed.'), 1), (('ed.', '(August'), 1), (('on', '26'), 1), ((':', 'Python'), 1), (('2013.', 'Russell,'), 1), (('Upper', 'Saddle'), 1), (('Hall.', 'ISBN'), 1), (('978-0-13-604259-4.', '=='), 1), (('reading', '=='), 1), (('==', 'Downey,'), 1), (('B.', '(May'), 1), (('ed.).', 'Cambridge'), 1), (('on', '29'), 1), (('2008.', 'Retrieved'), 1), (('2010.', 'Lutz,'), 1), (('Learning', 'Python'), 1), (('(5th', 'ed.).'), 1), (('2022).', 'Fluent'), 1), (('Fluent', 'Python.'), 1), (('Python.', \"O'Reilly\"), 1), (('==', 'External'), 1), (('External', 'links'), 1), (('emphasizes', 'code'), 1), (('is', 'dynamically'), 1), (('and', 'garbage-collected.'), 1), (('It', 'supports'), 1), (('multiple', 'programming'), 1), (('programming', 'paradigms,'), 1), (('including', 'structured'), 1), (('structured', '(particularly'), 1), (('(particularly', 'procedural),'), 1), (('to', 'its'), 1), (('0.9.0.', 'Python'), 1), (('at', 'Centrum'), 1), (('Wiskunde', '&'), 1), (('capable', 'of'), 1), (('interfacing', 'with'), 1), (('1989.', 'Van'), 1), (('Rossum', 'shouldered'), 1), (('shouldered', 'sole'), 1), (('the', 'lead'), 1), (('when', 'he'), 1), (('(BDFL),', 'a'), 1), (('reflect', 'his'), 1), (('since', 'come'), 1), (('of', 'retirement'), 1), (('elected', 'a'), 1), (('to', 'lead'), 1), (('comprehensions,', 'cycle-detecting'), 1), (('garbage', 'collection,'), 1), (('counting,', 'and'), 1), (('features', 'backported'), 1), (('and', '2.7.x.'), 1), (('the', 'translation'), 1), (('2020', 'out'), 1), (('forward-ported', 'to'), 1), (('be', 'released'), 1), (('released', 'for'), 1), (('Currently', 'only'), 1), (('supported', '(2023'), 1), (('3.10),', 'with'), 1), (('the', 'plus'), 1), (('some)', '\"backported'), 1), (('\"backported', 'security'), 1), (('In', '2021'), 1), (('(and', 'again'), 1), (('security', 'updates'), 1), (('were', 'expedited,'), 1), (('expedited,', 'since'), 1), (('insecure', '(including'), 1), (('expedited', 'and'), 1), (('3.9.13', 'was'), 1), (('in', 'May'), 1), (('May', '2022,'), 1), (('3.9', 'series'), 1), (('and', '3.7)'), 1), (('would', 'only'), 1), (('the', 'future.'), 1), (('future.', 'On'), 1), (('7', 'September'), 1), (('four', 'new'), 1), (('releases', 'were'), 1), (('were', 'made'), 1), (('3.10.7,', '3.9.14,'), 1), (('3.11', 'are'), 1), (('active', '(as'), 1), (('from', '3.10'), 1), (('execution', 'speed'), 1), (('least', '3.5'), 1), (('new', '(soft)'), 1), (('support', 'e.g.'), 1), (('union', 'operator'), 1), (('3.10),', 'and'), 1), (('handling,', 'and'), 1), (('keywords,', 'for'), 1), (('functionality,', 'and'), 1), (('and', 'future'), 1), (('section.', 'Python'), 1), (('on', 'top'), 1), (('other', 'changes.'), 1), (('27', 'June'), 1), (('phase),', 'due'), 1), (('reaching', 'end-of-life.'), 1), (('pauses', 'for'), 1), (('library', 'modules,'), 1), (('modules,', '19'), 1), (('Python', '3.15'), 1), (('and', 'or'), 1), (('3.16.', 'Starting'), 1), (('full', 'support'), 1), (('half);', 'followed'), 1), (('and', 'features'), 1), (('a', 'multi-paradigm'), 1), (('and', 'structured'), 1), (('support', 'functional'), 1), (('and', 'metaobjects).'), 1), (('metaobjects).', 'Many'), 1), (('extensions,', 'including'), 1), (('of', 'reference'), 1), (('reference', 'counting'), 1), (('a', 'cycle-detecting'), 1), (('for', 'memory'), 1), (('(late', 'binding),'), 1), (('binding),', 'which'), 1), (('names', 'during'), 1), (('execution.', 'Its'), 1), (('Lisp', 'tradition.'), 1), (('filter,mapandreduce', 'functions;'), 1), (('functions;', 'list'), 1), (('comprehensions,', 'dictionaries,'), 1), (('and', 'generator'), 1), (('functional', 'tools'), 1), (('Haskell', 'and'), 1), (('Python', '(PEP'), 1), (('aphorisms', 'such'), 1), (('Beautiful', 'is'), 1), (('complicated.', 'Readability'), 1), (('However,', 'Python'), 1), (('and', 'received'), 1), (('had', 'been'), 1), (('Benevolent', 'Dictator'), 1), (('Dictator', 'for'), 1), (('Life', 'following'), 1), (('the', 'addition'), 1), (('3.8.', 'Nevertheless,'), 1), (('its', 'core,'), 1), (('be', 'highly'), 1), (('via', 'modules.'), 1), (('compact', 'modularity'), 1), (('has', 'made'), 1), (('means', 'of'), 1), (('to', 'existing'), 1), (('vision', 'of'), 1), (('frustrations', 'with'), 1), (('less-cluttered', 'syntax'), 1), (('methodology.', 'In'), 1), (('more', 'than'), 1), (('motto,', 'Python'), 1), (('embraces', 'a'), 1), (('\"there', 'should'), 1), (('practice,', 'however,'), 1), (('however,', 'Python'), 1), (('achieve', 'the'), 1), (('one', 'a'), 1), (('use.', 'Alex'), 1), (('Fellow', 'at'), 1), (('book', 'author,'), 1), (('\"To', 'describe'), 1), (('describe', 'something'), 1), (('something', 'as'), 1), (('as', \"'clever'\"), 1), (('culture.\"', \"Python's\"), 1), (('non-critical', 'parts'), 1), (('speed', 'at'), 1), (('the', 'cost'), 1), (('modules', 'written'), 1), (('or', 'by'), 1), (('dynamic', 'language,'), 1), (('for', 'it'), 1), (('be', 'fun'), 1), (('Python—and', 'in'), 1), (('occasionally', 'playful'), 1), (('a', 'Monty'), 1), (('community', 'is'), 1), (('\"Pythonic\"', 'code'), 1), (('or', 'conform'), 1), ((\"Python's\", 'minimalist'), 1), (('from', 'another'), 1), (('called', 'unpythonic.'), 1), (('an', 'easily'), 1), (('is', 'visually'), 1), (('and', 'often'), 1), (('uses', 'English'), 1), (('English', 'keywords'), 1), (('keywords', 'where'), 1), (('cases', 'than'), 1), (('uses', 'whitespace'), 1), (('keywords,', 'to'), 1), (('after', 'certain'), 1), (('certain', 'statements;'), 1), (('feature', 'is'), 1), (('is', 'sometimes'), 1), (('off-side', 'rule.'), 1), (('no', 'semantic'), 1), (('recommended', 'indent'), 1), (('===', 'Statements'), 1), ((\"Python's\", 'statements'), 1), (('assignment', 'statement,'), 1), (('=', 'The'), 1), (('if', 'statement,'), 1), (('else', 'and'), 1), (('capturing', 'each'), 1), (('while', 'statement,'), 1), (('true', 'The'), 1), (('The', 'try'), 1), (('which', 'allows'), 1), (('exceptions', 'raised'), 1), (('clauses', '(or'), 1), (('ensures', 'that'), 1), (('how', 'the'), 1), (('The', 'class'), 1), (('def', 'statement,'), 1), (('which', 'defines'), 1), (('defines', 'a'), 1), (('with', 'statement,'), 1), (('within', 'a'), 1), (('a', 'context'), 1), (('manager', '(for'), 1), (('lock', 'before'), 1), (('rest', 'of'), 1), (('value,', 'and'), 1), (('error', 'if'), 1), (('redefined', 'The'), 1), (('The', 'pass'), 1), (('should', 'apply'), 1), (('The', 'yield'), 1), (('an', 'operator);'), 1), (('operator);', 'used'), 1), (('to', 'implement'), 1), (('to', 'return'), 1), (('variables', 'can'), 1), (('separate,', 'dynamically'), 1), (('time', 'to'), 1), (('to', 'any'), 1), (('without', 'a'), 1), (('data', 'type;'), 1), (('always', 'refers'), 1), (('some', 'object'), 1), (('tail', 'call'), 1), (('call', 'optimization'), 1), (('or', 'first-class'), 1), (('first-class', 'continuations,'), 1), (('continuations,', 'and,'), 1), (('according', 'to'), 1), (('provided', 'by'), 1), (('by', 'extending'), 1), (('extending', \"Python's\"), 1), (('data', 'back'), 1), (('it', 'can'), 1), (('are', 'similar'), 1), (('the', '**'), 1), (('string', 'a'), 1), (('times.', 'The'), 1), (('infix', 'operator.'), 1), (('intended', 'to'), 1), (('by', 'libraries'), 1), (('introduced', 'in'), 1), (('<=', 'c.'), 1), (('and', 'not'), 1), (('of', 'expression'), 1), (('a', 'list'), 1), (('generator', 'expression.'), 1), (('functions', 'are'), 1), (('lambda', 'expressions;'), 1), (('however,', 'there'), 1), (('expression', 'in'), 1), (('of', 'operands'), 1), (('c', '?'), 1), (('x', ':'), 1), (('makes', 'a'), 1), (('between', 'lists'), 1), (('and', 'tuples.'), 1), (('Lists', 'are'), 1), (('immutable', 'in'), 1), (('Python).', 'Tuples,'), 1), (('3),', 'are'), 1), (('concatenate', 'two'), 1), (('contents,', 'but'), 1), (('produces', 'a'), 1), (('new', 'tuple'), 1), (('the', 'elements'), 1), (('of', 'both.'), 1), (('executing', 't'), 1), (('5)', 'first'), 1), (('4,', '5),'), 1), (('then', 'assigned'), 1), (('effectively', '\"modifying'), 1), (('of', 'tuple'), 1), (('objects.', 'Parentheses'), 1), (('be', 'assigned'), 1), (('literals—and,', 'as'), 1), (('are', 'put'), 1), (('sign', 'in'), 1), (('The', 'statement'), 1), (('the', 'right-hand'), 1), (('a', '\"string'), 1), (('\"string', 'format\"'), 1), (('eggs=%d\"', '%'), 1), (('3+,', 'this'), 1), (('was', 'supplemented'), 1), (('the', 'format()'), 1), (('the', 'str'), 1), (('class,', 'e.g.'), 1), (('eggs={1}\".format(\"blah\",', '2).'), 1), (('2;', \"f'spam={spam}\"), 1), (('be', 'concatenated'), 1), (('them', '(with'), 1), (('\"eggs\"', 'returns'), 1), (('numbers,', 'they'), 1), (('are', 'added'), 1), (('added', 'as'), 1), (('and', 'Perl-influenced'), 1), (('same.', 'Both'), 1), (('interpolation', 'became'), 1), (('3.6', 'as'), 1), (('\"formatted', 'string'), 1), (('string', 'literals\".'), 1), (('Raw', 'string'), 1), (('where', 'literal'), 1), (('and', 'Windows-style'), 1), (('Windows-style', 'paths.'), 1), (('\"@-quoting\"', 'in'), 1), (('slicing', 'expressions'), 1), (('expressions', 'in'), 1), (('a[key],', 'a[start:stop]'), 1), (('or', 'a[start:stop:step].'), 1), (('Indexes', 'are'), 1), (('zero-based,', 'and'), 1), (('negative', 'indexes'), 1), (('indexes', 'are'), 1), (('index', 'up'), 1), (('not', 'including,'), 1), (('stop', 'index.'), 1), (('a[:]', 'returns'), 1), (('a', 'copy'), 1), (('Lisp,', 'Scheme,'), 1), (('This', 'leads'), 1), (('leads', 'to'), 1), (('eval()', 'vs.'), 1), (('statement);', 'the'), 1), (('for', 'statements'), 1), (('all', 'being'), 1), (('statements.', 'A'), 1), (('=', '1'), 1), (('conditional', 'expression'), 1), (('attached', 'to'), 1), (('class;', 'the'), 1), (('the', 'syntax'), 1), (('methods', 'and'), 1), (('syntactic', 'sugar'), 1), (('argument).', 'Python'), 1), (('to', 'access'), 1), (('(or', 'this)'), 1), (('provides', 'methods,'), 1), (('often', 'called'), 1), (('(due', 'to'), 1), (('to', 'their'), 1), (('double-underscores),', 'to'), 1), (('classes', 'to'), 1), (('to', 'modify'), 1), (('how', 'they'), 1), (('are', 'handled'), 1), (('including', 'length,'), 1), (('length,', 'comparison,'), 1), (('in', 'arithmetic'), 1), (('arithmetic', 'operations'), 1), (('uses', 'duck'), 1), (('time;', 'rather,'), 1), (('that', 'it'), 1), (('adding', 'a'), 1), (('silently', 'attempting'), 1), (('attempting', 'to'), 1), (('them.', 'Python'), 1), (('constructed', 'by'), 1), (('example,', 'SpamClass()'), 1), (('classes', '(both'), 1), (('syntax):', 'old-style'), 1), (('only', 'support'), 1), (('new', 'style.'), 1), (('Python', 'supports'), 1), (('supports', 'optional'), 1), (('but', 'may'), 1), (('external', 'tools'), 1), (('compiler', 'called'), 1), (('mypyc,', 'which'), 1), (('type', 'annotations'), 1), (('operators', '(+,'), 1), (('(+,', '-,'), 1), (('division', 'operator'), 1), (('be', 'negative,'), 1), (('-3', '=='), 1), (('has', '**'), 1), (('5**3', '=='), 1), (('9**0.5', '=='), 1), (('3.0,', 'and'), 1), (('matrix‑multiplication', 'operator'), 1), (('operator', '@'), 1), (('.', 'These'), 1), (('infix', '(+'), 1), (('and', '-'), 1), (('to', 'represent'), 1), (('floating-point', 'results.'), 1), (('results.', 'The'), 1), (('changed', 'significantly'), 1), (('e.g.', '5/2'), 1), (('The', 'floor'), 1), (('7//3', '=='), 1), (('7.5//3', '=='), 1), (('-7.5//3', '=='), 1), (('for', 'division'), 1), (('(see', 'above).'), 1), (('Python', 'terms,'), 1), (('//', 'is'), 1), (('Rounding', 'towards'), 1), (('negative', 'infinity,'), 1), (('infinity,', 'though'), 1), (('though', 'different'), 1), (('consistency.', 'For'), 1), (('equation', '(a'), 1), (('(a', '+'), 1), (('a//b', '+'), 1), (('always', 'true.'), 1), (('a%b', '=='), 1), (('the', 'validity'), 1), (('while', 'the'), 1), (('expected,', 'in'), 1), (('integer,', 'it'), 1), (('is', 'negative.'), 1), (('even:', 'round(1.5)'), 1), (('2.', 'Versions'), 1), (('used', 'round-away-from-zero:'), 1), (('multiple', 'equality'), 1), (('c', 'tests'), 1), (('whether', 'a'), 1), (('than', 'c.'), 1), (('first', 'evaluate'), 1), (('b,', 'resulting'), 1), (('in', '0'), 1), (('the', 'decimal'), 1), (('pre-defined', 'arbitrary'), 1), (('class', 'in'), 1), (('to', \"Python's\"), 1), ((\"Python's\", 'extensive'), 1), (('the', 'third-party'), 1), (('NumPy', 'that'), 1), (('further', 'extends'), 1), (('to', 'aid'), 1), (('numerical', 'data'), 1), (('==', 'Programming'), 1), (('examples', '=='), 1), (('\"Hello,', 'World!\"'), 1), (('factorial', 'of'), 1), (('protocols', 'such'), 1), (('as', 'MIME'), 1), (('HTTP', 'are'), 1), (('creating', 'graphical'), 1), (('user', 'interfaces,'), 1), (('relational', 'databases,'), 1), (('arbitrary-precision', 'decimals,'), 1), (('regular', 'expressions,'), 1), (('unit', 'testing.'), 1), (('Some', 'parts'), 1), (('are', 'covered'), 1), (('by', 'their'), 1), (('code,', 'internal'), 1), (('documentation,', 'and'), 1), (('because', 'most'), 1), (('Python', 'code,'), 1), (('few', 'modules'), 1), (('variant', 'implementations.'), 1), (('Python', 'software,'), 1), (('functionality,', 'including:'), 1), (('CPython)', 'include'), 1), (('permitting', 'them'), 1), (('for', 'which'), 1), (('also', 'comes'), 1), (('comes', 'with'), 1), (('shells,', 'including'), 1), (('as', 'improved'), 1), (('improved', 'auto-completion,'), 1), (('PyCharm,', 'IntelliJ'), 1), (('Idea,', 'Visual'), 1), (('Visual', 'Studio'), 1), (('including', 'SageMath,'), 1), (('science-', 'and'), 1), (('browser-based', 'IDE'), 1), (('Canopy', 'IDE,'), 1), (('==', 'Implementations'), 1), (('Implementations', '=='), 1), (('3.11', 'uses'), 1), (('several', 'select'), 1), (('versions—e.g.', 'they'), 1), (('implemented', 'with'), 1), (('with', 'C11'), 1), (('C11', 'or'), 1), (('by', 'its'), 1), (('a', 'mixture'), 1), (('Windows', '(starting'), 1), (('3.9,', 'the'), 1), (('Python', 'installer'), 1), (('deliberately', 'fails'), 1), (('7', 'and'), 1), (('3.5)', 'and'), 1), (('Unix-like', 'systems,'), 1), (('with', 'experimental'), 1), (('for', 'VMS.'), 1), (('Python', '1'), 1), (('even', 'OS/2'), 1), (('and', 'Solaris'), 1), (('Solaris', 'were'), 1), (('Python,', 'since'), 1), (('since', '3.7,'), 1), (('only', 'supports'), 1), (('Other', 'implementations'), 1), (('significant', 'speed'), 1), (('speed', 'improvement'), 1), (('some', 'libraries'), 1), (('in', 'C'), 1), (('call', 'stack'), 1), (('same', 'way,'), 1), (('concurrent', 'programs.'), 1), (('PyPy', 'also'), 1), (('a', 'stackless'), 1), (('are', 'Python'), 1), (('Mindstorms', 'EV3.'), 1), (('variant', 'of'), 1), (('just-in-time', 'compilation'), 1), (('Cinder', 'is'), 1), (('performance-oriented', 'fork'), 1), (('contains', 'a'), 1), (('of', 'coroutines,'), 1), (('bytecode', 'compiler.'), 1), (('with', 'MicroPython)'), 1), (('MicroPython)', '\"is'), 1), (('write', 'Snek'), 1), (('is', 'an'), 1), (('an', 'imperative'), 1), (('/', 'classes,'), 1), (('to', 'one'), 1), (('one', 'number'), 1), (('single-precision', '(similar'), 1), (('Other', 'just-in-time'), 1), (('compilers', 'have'), 1), (('but', 'are'), 1), (('unsupported:', 'Google'), 1), (('in', '2009,'), 1), (('speeding', 'up'), 1), (('improving', 'its'), 1), (('to', 'scale'), 1), (('scale', 'to'), 1), (('to', 'thousands'), 1), (('of', 'cores,'), 1), (('at', 'runtime.'), 1), (('runtime.', 'The'), 1), (('emitted', 'code'), 1), (('is', 'specialized'), 1), (('types', 'and'), 1), (('Psyco', 'does'), 1), (('or', 'later.'), 1), (('PyS60', 'was'), 1), (('mobile', 'phones'), 1), (('released', 'by'), 1), (('2005.', 'It'), 1), (('the', 'modules'), 1), (('integrating', 'with'), 1), (('Nokia', 'N900'), 1), (('supports', 'Python'), 1), (('be', 'written'), 1), (('the', 'target'), 1), (('Cross-compilers', 'to'), 1), (('either', 'unrestricted'), 1), (('language', 'similar'), 1), (('and', 'Pyjs'), 1), (('in', '2012)'), 1), (('to', 'JavaScript.'), 1), (('JavaScript.', 'Codon'), 1), (('Codon', 'compiles'), 1), (('typed', 'Python'), 1), (('The', 'resulting'), 1), (('usable', 'with'), 1), (('Python', 'via'), 1), (('calls', 'into'), 1), (('interpreter.', 'PyJL'), 1), (('compiles/transpiles', 'a'), 1), (('\"human-readable,', 'maintainable,'), 1), (('code\".', 'Despite'), 1), (('for', 'arbitrary'), 1), (('cases', 'speedup'), 1), (('speedup', 'is'), 1), (('few', 'or'), 1), (('code.', 'The'), 1), (('faster', 'Julia'), 1), (('from', 'Python,'), 1), (('way.', 'Nuitka'), 1), (('LLVM', 'to'), 1), (('Pythran', 'compiles'), 1), (('the', 'PyPy'), 1), (('11l', '→'), 1), (('C++', 'transpiler'), 1), (('(C++17).', 'Specialized:'), 1), (('code.', 'Older'), 1), (('3.x', 'and'), 1), (('2', 'to'), 1), (('to', 'Go.'), 1), (('allows', 'running'), 1), (('also', 'available'), 1), (('3.4,', 'although'), 1), (('.NET', 'Common'), 1), (('libraries', 'from'), 1), (('in', '2010)'), 1), (('Skin', '(latest'), 1), (('2013)', 'compile'), 1), (('C++', 'respectively.'), 1), (('presented', 'at'), 1), (('EuroSciPy', \"'13.\"), 1), ((\"'13.\", \"Python's\"), 1), (('performance', 'compared'), 1), (('Computer', 'Language'), 1), (('largely', 'through'), 1), (('through', 'the'), 1), (('(PEP)', 'process,'), 1), (('mechanism', 'for'), 1), (('for', 'proposing'), 1), (('features,', 'collecting'), 1), (('community', 'input'), 1), (('on', 'issues,'), 1), (('issues,', 'and'), 1), (('documenting', 'Python'), 1), (('decisions.', 'Python'), 1), (('style', 'is'), 1), (('Outstanding', 'PEPs'), 1), (('Specific', 'issues'), 1), (('were', 'migrated'), 1), (('migrated', 'to'), 1), (('Development', 'originally'), 1), (('place', 'on'), 1), (('repository', 'running'), 1), (('GitHub', 'in'), 1), (('in', 'January'), 1), (('January', '2017.'), 1), (('by', 'which'), 1), (('versions,', 'where'), 1), (('to', 'break'), 1), (('break', 'and'), 1), (('incremented.', 'These'), 1), (('8', 'years'), 1), (('is', 'very'), 1), (('very', 'unlikely'), 1), (('the', 'previous'), 1), (('version', 'but'), 1), (('supported', 'by'), 1), (('fixes', 'for'), 1), (('release.', 'Bugfix'), 1), (('no', 'new'), 1), (('every', '3'), 1), (('been', 'fixed'), 1), (('fixed', 'upstream'), 1), (('and', 'final'), 1), (('alpha,', 'beta,'), 1), (('also', 'released'), 1), (('releases.', 'Although'), 1), (('there', 'is'), 1), (('by', 'running'), 1), (('running', 'the'), 1), (('during', 'development.'), 1), (('PyCon.', 'There'), 1), (('wstr', 'meaning'), 1), (('Python', 'extensions'), 1), (('modified,', 'and'), 1), (('added', 'pattern'), 1), (('dropped', 'in'), 1), (('of', '3.13;'), 1), (('array', \"'u'\"), 1), ((\"'u'\", 'format'), 1), (('3.16.', 'The'), 1), (('also', 'deprecated'), 1), (('DeprecationWarning,', 'and'), 1), (('in', '3.15.'), 1), (('Using', 'that'), 1), (('functionality', 'bugs.'), 1), (('module', 'are'), 1), (('deprecated,', 'e.g.'), 1), (('to', 'denote'), 1), (('and', 'such'), 1), (('disallowed', 'in'), 1), (('generators', '=='), 1), (('include', 'pydoc'), 1), (('its', 'forks,'), 1), (('Doxygen', 'and'), 1), (('Monty', 'Python,'), 1), (('enjoyed', 'while'), 1), (('the', 'metasyntactic'), 1), (('metasyntactic', 'variables'), 1), (('and', 'eggs'), 1), (('official', 'Python'), 1), (('contains', 'various'), 1), (('Users', 'of'), 1), (('prefix', 'Py-'), 1), (('in', 'names'), 1), (('(commonly', 'used'), 1), (('create', 'games);'), 1), (('and', 'PyGTK,'), 1), (('Python', 'respectively;'), 1), (('2003,', 'Python'), 1), (('consistently', 'ranked'), 1), (('ranked', 'in'), 1), (('the', 'top'), 1), (('the', 'TIOBE'), 1), (('of', 'C,'), 1), (('was', 'selected'), 1), (('year\")', 'in'), 1), (('2020', '(the'), 1), (('(the', 'only'), 1), (('only', 'language'), 1), (('Instagram,', 'Spotify,'), 1), (('Spotify,', 'and'), 1), (('entities', 'like'), 1), (('ITA.', 'The'), 1), (('The', 'social'), 1), (('social', 'news'), 1), (('mod_wsgi', 'for'), 1), (('With', 'Web'), 1), (('has', 'evolved'), 1), (('Pyjs', 'and'), 1), (('to', 'develop'), 1), (('client-side', 'of'), 1), (('mapper', 'to'), 1), (('Twisted', 'is'), 1), (('used', '(for'), 1), (('SciPy', 'and'), 1), (('scientific', 'computing,'), 1), (('Biopython', 'and'), 1), (('functionality.', 'SageMath'), 1), (('notebook', 'interface'), 1), (('theory,', 'and'), 1), (('and', 'calculus.'), 1), (('OpenCV', 'has'), 1), (('a', 'rich'), 1), (('set', 'of'), 1), (('for', 'computer'), 1), (('learning', 'projects'), 1), (('help', 'of'), 1), (('Pytorch,', 'scikit-learn'), 1), (('architecture,', 'simple'), 1), (('simple', 'syntax,'), 1), (('particularly', 'useful'), 1), (('capablities.', 'The'), 1), (('system,', 'in'), 1), (('exploits', 'the'), 1), (('these', 'two'), 1), (('two', 'languages,'), 1), (('part', 'because'), 1), (('recursive', 'nature'), 1), (('combination', 'include'), 1), (('language', 'processing,'), 1), (('visual', 'query'), 1), (('data.', 'The'), 1), (('Clause', 'Grammars'), 1), (('and', 'text-to-image'), 1), (('user', 'interface'), 1), (('Tkinter.', 'Python'), 1), (('embedded', 'in'), 1), (('software', 'products'), 1), (('finite', 'element'), 1), (('element', 'method'), 1), (('Abaqus,', '3D'), 1), (('3D', 'animation'), 1), (('packages', 'such'), 1), (('as', '3ds'), 1), (('Houdini,', 'Maya,'), 1), (('2D', 'imaging'), 1), (('GIMP,', 'Inkscape,'), 1), (('like', 'scorewriter'), 1), (('GNU', 'Debugger'), 1), (('printer', 'to'), 1), (('choice', 'for'), 1), (('scripts', 'in'), 1), (('in', 'ArcGIS.'), 1), (('in', 'Google'), 1), (('other', 'two'), 1), (('and', 'Go.'), 1), (('Go.', 'Many'), 1), (('Many', 'operating'), 1), (('systems', 'include'), 1), (('standard', 'component.'), 1), (('(terminal).', 'Many'), 1), (('installers', 'written'), 1), (('the', 'Ubiquity'), 1), (('management', 'system,'), 1), (('XO,', 'developed'), 1), (('LibreOffice', 'includes'), 1), (('Provider', 'is'), 1), (('4.0', 'from'), 1), (('7', 'February'), 1), (('2013.', '=='), 1), (('==', 'Languages'), 1), (('influenced', 'many'), 1), (('languages:', 'Boo'), 1), (('uses', 'indentation,'), 1), (('Cobra', 'uses'), 1), (('its', 'Acknowledgements'), 1), (('among', 'languages'), 1), (('language', 'very'), 1), (('of', 'working'), 1), (('the', 'desire'), 1), (('desire', 'to'), 1), (('be', '\"as'), 1), (('usable', 'for'), 1), (('superset', 'of'), 1), (('wanted', 'a'), 1), (('language.\"', 'Swift,'), 1), (('developer', 'efficiency.'), 1), (('efficiency.', \"Python's\"), 1), (('development', 'practices'), 1), (('other', 'languages.'), 1), (('a', 'document'), 1), (('for,', 'and'), 1), (('surrounding,', 'a'), 1), (('(in', 'Python,'), 1), (('in', 'Tcl,'), 1), (('Erlang,', 'and'), 1), (('manager)', 'List'), 1), (('languages', 'History'), 1), (('Paine,', 'Jocelyn,'), 1), (('in', 'Python\".'), 1), (('26', 'March'), 1), (('11', 'February'), 1), (('J.', '&'), 1), (('Intelligence:', 'A'), 1), (('NJ:', 'Prentice'), 1), (('Prentice', 'Hall.'), 1), (('Downey,', 'Allen'), 1), (('to', 'Think'), 1), (('Scientist', '(version'), 1), (('(version', '1.6.6'), 1), (('of', 'Programming'), 1), (('Python\".', 'Computerworld.'), 1), (('ed.).', \"O'Reilly\"), 1), (('Professional.', 'ISBN'), 1), (('Luciano', '(May'), 1), (('(May', '2022).'), 1), (('significant', 'indentation.'), 1), (('indentation.', 'Python'), 1), (('garbage-collected.', 'It'), 1), (('and', 'functional'), 1), (('comprehensive', 'standard'), 1), (('Rossum', 'began'), 1), (('language', 'and'), 1), (('it', 'in'), 1), (('2.7.18,', 'released'), 1), (('release', 'of'), 1), (('consistently', 'ranks'), 1), (('ranks', 'as'), 1), (('languages,', 'and'), 1), (('gained', 'widespread'), 1), (('==', 'History'), 1), (('the', 'Netherlands'), 1), (('in', 'December'), 1), (('responsibility', 'for'), 1), (('the', 'project,'), 1), (('developer,', 'until'), 1), (('he', 'announced'), 1), (('vacation\"', 'from'), 1), (('responsibilities', 'as'), 1), (('community', 'bestowed'), 1), (('upon', 'him'), 1), (('to', 'reflect'), 1), (('the', \"project's\"), 1), (('come', 'out'), 1), (('retirement', 'and'), 1), (('Python', 'core'), 1), (('developers', 'elected'), 1), (('a', 'five-member'), 1), (('Steering', 'Council'), 1), (('Unicode', 'support.'), 1), (('support.', 'Python'), 1), (('major', 'features'), 1), (('Releases', 'of'), 1), (('3', 'include'), 1), (('utility,', 'which'), 1), (('which', 'automates'), 1), ((\"2.7's\", 'end-of-life'), 1), (('initially', 'set'), 1), (('concern', 'that'), 1), (('body', 'of'), 1), (('easily', 'be'), 1), (('No', 'further'), 1), (('or', 'other'), 1), (('fixed', 'in'), 1), (('3.7.x', 'release).'), 1), (('While', 'Python'), 1), (('is', 'officially'), 1), (('i.e.', '\"2.7.18+\"'), 1), (('\"2.7.18+\"', '(plus'), 1), (('3.9', 'and'), 1), (('plus', 'meaning'), 1), (('versions', 'were'), 1), (('2.7)', 'because'), 1), (('3.10.4', 'and'), 1), (('and', '3.9.12'), 1), (('3.9.12', 'were'), 1), (('and', '3.8.13,'), 1), (('of', 'many'), 1), (('many', 'security'), 1), (('was', 'announced'), 1), (('older', 'series'), 1), (('3.7)', 'would'), 1), (('only', 'receive'), 1), (('security', 'fixes'), 1), (('new', 'releases'), 1), (('denial-of-service', 'attack:'), 1), (('attack:', '3.10.7,'), 1), (('3.9.14,', '3.8.14,'), 1), (('3.8.14,', 'and'), 1), (('versions', 'with'), 1), (('(as', 'opposed'), 1), (('Notable', 'changes'), 1), (('speed', 'and'), 1), (('every', 'Python'), 1), (('since', 'at'), 1), (('releases', 'have'), 1), (('in', '3.10),'), 1), (('the', 'match'), 1), (('for', 'structural'), 1), (('future', 'versions'), 1), (('and', '60%'), 1), (('another', '5%'), 1), (('top', 'of'), 1), (('has', 'improved'), 1), (('Since', '27'), 1), (('June', '2023,'), 1), (('3.8', 'is'), 1), (('Python', '(albeit'), 1), ((\"support'\", 'phase),'), 1), (('3.7', 'reaching'), 1), (('(shorter', 'pauses'), 1), (('objects)', 'garbage'), 1), (('experimental', 'JIT'), 1), (('JIT', 'compiler,'), 1), (('the', 'C'), 1), (('dead', 'batteries,'), 1), (('or', '3.16.'), 1), (('with', '3.13,'), 1), (('total', 'support'), 1), (('language.', 'Object-oriented'), 1), (('structured', 'programming'), 1), (('are', 'fully'), 1), (('(including', 'metaprogramming'), 1), (('Many', 'other'), 1), (('including', 'design'), 1), (('logic', 'programming.'), 1), (('a', 'combination'), 1), (('management.', 'It'), 1), (('during', 'program'), 1), (('program', 'execution.'), 1), (('offers', 'some'), 1), (('some', 'support'), 1), (('sets,', 'and'), 1), (('library', 'has'), 1), (('tools', 'borrowed'), 1), (('Standard', 'ML.'), 1), (('Its', 'core'), 1), (('summarized', 'in'), 1), (('than', 'complex.'), 1), (('Complex', 'is'), 1), (('than', 'complicated.'), 1), (('violate', 'these'), 1), (('these', 'principles'), 1), (('language', 'bloat.'), 1), (('rule.', 'The'), 1), (('The', 'addition'), 1), (('as', 'Benevolent'), 1), (('following', 'vitriol'), 1), (('functionality', 'into'), 1), (('into', 'its'), 1), (('core,', 'Python'), 1), (('highly', 'extensible'), 1), (('modularity', 'has'), 1), (('it', 'particularly'), 1), (('interfaces', 'to'), 1), (('existing', 'applications.'), 1), (('interpreter', 'stemmed'), 1), (('to', 'strive'), 1), (('simpler,', 'less-cluttered'), 1), (('giving', 'developers'), 1), (('developers', 'a'), 1), (('coding', 'methodology.'), 1), (('be', 'one—and'), 1), (('one—and', 'preferably'), 1), (('philosophy.', 'In'), 1), (('provides', 'many'), 1), (('are,', 'for'), 1), (('least', 'three'), 1), (('a', 'Fellow'), 1), (('Python', 'Software'), 1), (('a', 'compliment'), 1), (('Python', 'culture.\"'), 1), (('usually', 'strive'), 1), (('strive', 'to'), 1), (('premature', 'optimization'), 1), (('optimization', 'and'), 1), (('patches', 'to'), 1), (('offer', 'marginal'), 1), (('marginal', 'increases'), 1), (('in', 'languages'), 1), (('to', 'cross-compile'), 1), (('provide', 'the'), 1), (('the', 'full'), 1), (('be', 'expected,'), 1), (('very', 'dynamic'), 1), (('are', 'slightly'), 1), (('use.', 'This'), 1), (('in', 'occasionally'), 1), (('and', '\"eggs\"'), 1), (('the', 'often-used'), 1), (('common', 'neologism'), 1), (('well,', 'be'), 1), (('Code', 'that'), 1), (('is', 'difficult'), 1), (('understand', 'or'), 1), (('rough', 'transcription'), 1), (('transcription', 'from'), 1), (('unpythonic.', '=='), 1), (('Syntax', 'and'), 1), (('is', 'meant'), 1), (('easily', 'readable'), 1), (('Its', 'formatting'), 1), (('punctuation.', 'Unlike'), 1), (('Unlike', 'many'), 1), (('languages,', 'it'), 1), (('use', 'curly'), 1), (('brackets', 'to'), 1), (('blocks,', 'and'), 1), (('and', 'semicolons'), 1), (('statements', 'are'), 1), (('are', 'allowed'), 1), (('exceptions', 'and'), 1), (('than', 'curly'), 1), (('An', 'increase'), 1), (('indentation', 'comes'), 1), (('statements;', 'a'), 1), (('indentation', 'signifies'), 1), (('the', 'end'), 1), (('the', \"program's\"), 1), (('visual', 'structure'), 1), (('structure', 'accurately'), 1), (('accurately', 'represents'), 1), (('semantic', 'structure.'), 1), (('this', 'way;'), 1), (('most,', 'indentation'), 1), (('indentation', 'has'), 1), (('The', 'recommended'), 1), (('statement,', 'using'), 1), (('which', 'conditionally'), 1), (('code,', 'along'), 1), (('of', 'else-if)'), 1), (('The', 'for'), 1), (('iterable', 'object,'), 1), (('variable', 'for'), 1), (('use', 'by'), 1), (('attached', 'block'), 1), (('The', 'while'), 1), (('block', 'to'), 1), (('be', 'caught'), 1), (('caught', 'and'), 1), (('(or', 'new'), 1), (('new', 'syntax'), 1), (('clean-up', 'code'), 1), (('code', 'in'), 1), (('the', 'block'), 1), (('The', 'raise'), 1), (('a', 'caught'), 1), (('and', 'attaches'), 1), (('class,', 'for'), 1), (('context', 'manager'), 1), (('a', 'lock'), 1), (('run,', 'then'), 1), (('replacing', 'a'), 1), (('The', 'break'), 1), (('which', 'exits'), 1), (('which', 'skips'), 1), (('skips', 'the'), 1), (('iteration', 'and'), 1), (('continues', 'with'), 1), (('next', 'The'), 1), (('which', 'removes'), 1), (('removes', 'a'), 1), (('a', 'variable—deleting'), 1), (('variable—deleting', 'the'), 1), (('the', 'name'), 1), (('name', 'to'), 1), (('producing', 'an'), 1), (('an', 'error'), 1), (('syntactically', 'needed'), 1), (('assert', 'statement,'), 1), (('in', 'debugging'), 1), (('to', 'check'), 1), (('apply', 'The'), 1), (('yield', 'statement,'), 1), (('which', 'returns'), 1), (('(and', 'also'), 1), (('coroutines', 'The'), 1), (('The', 'return'), 1), (('import', 'and'), 1), (('import', 'modules'), 1), (('statement', '(=)'), 1), (('a', 'name'), 1), (('dynamically', 'allocated'), 1), (('rebound', 'at'), 1), (('at', 'any'), 1), (('refers', 'to'), 1), (('a', 'type.'), 1), (('where', 'each'), 1), (('contain', 'only'), 1), (('optimization', 'or'), 1), (('Van', 'Rossum,'), 1), (('However,', 'better'), 1), (('functionality', 'is'), 1), (('is', 'provided'), 1), (('generators.', 'Before'), 1), (('generators', 'were'), 1), (('lazy', 'iterators;'), 1), (('unidirectionally', 'out'), 1), (('the', 'generator.'), 1), (('back', 'into'), 1), (('into', 'a'), 1), (('from', 'version'), 1), (('be', 'passed'), 1), (('passed', 'through'), 1), (('through', 'multiple'), 1), (('and', '*'), 1), (('addition,', 'subtraction,'), 1), (('subtraction,', 'and'), 1), (('types', 'of'), 1), (('for', 'duplicating'), 1), (('is', 'intended'), 1), (('the', '\"walrus'), 1), (('\"walrus', 'operator\",'), 1), (('variables', 'as'), 1), (('a', 'larger'), 1), (('==', 'compares'), 1), ((\"Python's\", 'is'), 1), (('is', 'operator'), 1), (('operator', 'may'), 1), (('to', 'compare'), 1), (('by', 'reference),'), 1), (('Boolean', 'operators.'), 1), (('a', 'type'), 1), (('list', 'comprehension,'), 1), (('comprehension,', 'and'), 1), (('general', 'expression'), 1), (('be', 'only'), 1), (('body.', 'Conditional'), 1), (('c', 'else'), 1), (('?', 'x'), 1), (('and', 'cannot'), 1), (('(dictionary', 'keys'), 1), (('and', 'thus'), 1), (('as', 'keys'), 1), ((\"tuple's\", 'elements'), 1), (('elements', 'are'), 1), (('immutable.', 'The'), 1), (('tuple', 'containing'), 1), (('=', 't'), 1), (('first', 'evaluates'), 1), (('evaluates', 't'), 1), (('(4,', '5),'), 1), (('t—thereby', 'effectively'), 1), (('the', 'contents\"'), 1), (('conforming', 'to'), 1), (('optional', 'for'), 1), (('for', 'tuples'), 1), (('features', 'sequence'), 1), (('variable,', 'writable'), 1), (('identical', 'manner'), 1), (('whole,', 'are'), 1), (('left-hand', 'side'), 1), (('statement', 'expects'), 1), (('left.', 'Python'), 1), (('that', 'functions'), 1), (('analogously', 'to'), 1), (('strings', 'in'), 1), (('in', 'C—e.g.'), 1), (('2)', 'evaluates'), 1), (('to', '\"spam=blah'), 1), (('and', '3+,'), 1), (('method', 'of'), 1), (('2).', 'Python'), 1), (('\"f-strings\":', 'spam'), 1), (('eggs', '='), 1), (('Strings', 'in'), 1), (('\"adding\"', 'them'), 1), (('as', 'for'), 1), (('adding', 'integers'), 1), (('e.g.', '\"spam\"'), 1), (('\"2\"', '+'), 1), (('Delimited', 'by'), 1), (('by', 'single'), 1), (('double', 'quotes;'), 1), (('quotes;', 'unlike'), 1), (('Perl-influenced', 'languages,'), 1), (('double', 'quotes'), 1), (('Both', 'use'), 1), (('escape', 'character.'), 1), (('available', 'in'), 1), (('as', '\"formatted'), 1), (('literals\".', 'Triple-quoted'), 1), (('may', 'span'), 1), (('function', 'like'), 1), (('literal', 'backslashes'), 1), (('paths.', '(Compare'), 1), (('has', 'array'), 1), (('as', 'a[key],'), 1), (('are', 'relative'), 1), (('end.', 'Slices'), 1), (('start', 'index'), 1), (('to,', 'but'), 1), (('but', 'not'), 1), (('the', 'stop'), 1), (('called', 'step'), 1), (('be', 'skipped'), 1), (('skipped', 'and'), 1), (('and', 'reversed.'), 1), (('reversed.', 'Slice'), 1), (('Slice', 'indexes'), 1), (('copy', 'of'), 1), (('the', 'entire'), 1), (('a', 'slice'), 1), (('between', 'expressions'), 1), (('statements', 'is'), 1), (('rigidly', 'enforced,'), 1), (('as', 'Common'), 1), (('Ruby.', 'This'), 1), (('for-loops', 'Conditional'), 1), (('vs.', 'if'), 1), (('exec()', 'built-in'), 1), (('(in', 'Python'), 1), (('2,', 'exec'), 1), (('former', 'is'), 1), (('lambda', 'expressions,'), 1), (('A', 'particular'), 1), (('that', 'an'), 1), (('statement', 'such'), 1), (('functions', 'attached'), 1), (('is,', 'for'), 1), (('functions,', 'syntactic'), 1), (('for', 'Class.method(instance,'), 1), (('Python', 'methods'), 1), (('methods', 'have'), 1), (('explicit', 'self'), 1), (('data,', 'in'), 1), (('this)', 'in'), 1), (('Objective-C,', 'Ruby).'), 1), (('their', 'names'), 1), (('to', 'allow'), 1), (('allow', 'user-defined'), 1), (('by', 'native'), 1), (('comparison,', 'in'), 1), (('Type', 'constraints'), 1), (('checked', 'at'), 1), (('on', 'an'), 1), (('not', 'of'), 1), (('a', 'suitable'), 1), (('Despite', 'being'), 1), (('dynamically', 'typed,'), 1), (('strongly', 'typed,'), 1), (('that', 'are'), 1), (('example,', 'adding'), 1), (('a', 'string)'), 1), (('allows', 'programmers'), 1), (('programmers', 'to'), 1), (('their', 'own'), 1), (('are', 'constructed'), 1), (('SpamClass()', 'or'), 1), (('EggsClass()),', 'and'), 1), (('the', 'metaclass'), 1), (('(itself', 'an'), 1), (('an', 'instance'), 1), (('instance', 'of'), 1), (('allowing', 'metaprogramming'), 1), (('3.0,', 'Python'), 1), (('Python', 'had'), 1), (('had', 'two'), 1), (('kinds', 'of'), 1), (('same', 'syntax):'), 1), (('support', 'the'), 1), (('not', 'enforced'), 1), (('language,', 'but'), 1), (('catch', 'errors.'), 1), (('supports', 'a'), 1), (('(where', 'the'), 1), (('remainder', 'can'), 1), (('%', '-3'), 1), (('==', '125'), 1), (('precedence', 'rules,'), 1), (('operators', 'infix'), 1), (('unary', 'to'), 1), (('numbers', 'respectively).'), 1), (('between', 'integers'), 1), (('produces', 'floating-point'), 1), (('has', 'changed'), 1), (('significantly', 'over'), 1), (('over', 'time:'), 1), (('always', 'be'), 1), (('floating-point', 'division,'), 1), (('==', '2.5.'), 1), (('So', '7//3'), 1), (('-3,', '7.5//3'), 1), (('Adding', 'from'), 1), (('__future__', 'import'), 1), (('division', 'causes'), 1), (('to', 'use'), 1), (('terms,', '/'), 1), (('/', 'is'), 1), (('true', 'division'), 1), (('and', '//'), 1), (('floor', 'division.'), 1), (('division.', 'Rounding'), 1), (('different', 'from'), 1), (('most', 'languages,'), 1), (('instance,', 'it'), 1), (('b*(a//b)', '+'), 1), (('+', 'a%b'), 1), (('==', 'a'), 1), (('valid', 'for'), 1), (('negative', 'values'), 1), (('values', 'of'), 1), (('a.', 'However,'), 1), (('equation', 'means'), 1), (('the', 'result'), 1), (('b),', 'where'), 1), (('to', 'lie'), 1), (('the', 'interval'), 1), (('to', 'even:'), 1), (('round(2.5)', 'both'), 1), (('Versions', 'before'), 1), (('before', '3'), 1), (('round-away-from-zero:', 'round(0.5)'), 1), (('round(0.5)', 'is'), 1), (('expressions', 'with'), 1), (('with', 'multiple'), 1), (('equality', 'relations'), 1), (('relations', 'in'), 1), (('general', 'use'), 1), (('expression', 'a'), 1), (('b', 'and'), 1), (('C-derived', 'languages'), 1), (('differently:', 'in'), 1), (('<', 'b,'), 1), (('0', 'or'), 1), (('that', 'result'), 1), (('compared', 'with'), 1), (('with', 'c.'), 1), (('uses', 'arbitrary-precision'), 1), (('arbitrary-precision', 'arithmetic'), 1), (('numbers', 'to'), 1), (('several', 'rounding'), 1), (('rounding', 'modes.'), 1), (('extensive', 'mathematics'), 1), (('library', 'NumPy'), 1), (('extends', 'the'), 1), (('and', 'manipulation.'), 1), (('==', '\"Hello,'), 1), (('to', 'calculate'), 1), ((\"Python's\", 'large'), 1), (('interfaces,', 'connecting'), 1), (('arithmetic', 'with'), 1), (('covered', 'by'), 1), (('most', 'are'), 1), (('are', 'specified'), 1), (('and', 'test'), 1), (('test', 'suites.'), 1), (('suites.', 'However,'), 1), (('for', 'variant'), 1), (('implementations.', 'As'), 1), (('2024,', 'the'), 1), (('(PyPI),', 'the'), 1), (('the', 'official'), 1), (('including:', '=='), 1), (('Most', 'Python'), 1), (('include', 'a'), 1), (('a', 'read–eval–print'), 1), (('them', 'to'), 1), (('a', 'command'), 1), (('enter', 'statements'), 1), (('statements', 'sequentially'), 1), (('sequentially', 'and'), 1), (('(IDE)', 'called'), 1), (('syntax', 'highlighting.'), 1), (('highlighting.', 'As'), 1), (('environments', 'including'), 1), (('including', 'PyCharm,'), 1), (('Studio', 'Code'), 1), (('Code', 'etc,'), 1), (('browser-based', 'IDEs,'), 1), (('scientific', 'computing.'), 1), (('C', 'extensions,'), 1), (('but', 'third-party'), 1), (('older', 'C'), 1), (('C', 'versions—e.g.'), 1), (('intermediate', 'bytecode'), 1), (('and', 'native'), 1), (('many', 'platforms,'), 1), (('was', 'supported'), 1), (('Python', '3.5)'), 1), (('systems,', 'including'), 1), (('VMS.', 'Platform'), 1), (('its', 'earliest'), 1), (('1', 'and'), 1), (('supported,', 'but'), 1), (('3.7,', 'only'), 1), (('supports', 'operating'), 1), (('===', 'PyPy'), 1), (('over', 'CPython,'), 1), (('but', 'some'), 1), (('the', 'call'), 1), (('CircuitPython', 'are'), 1), (('3', 'variants'), 1), (('that', 'uses'), 1), (('speed', 'up'), 1), (('a', 'performance-oriented'), 1), (('including', 'bytecode'), 1), (('caching,', 'eager'), 1), (('coroutines,', 'a'), 1), (('method-at-a-time', 'JIT,'), 1), (('experimental', 'bytecode'), 1), (('with', 'e.g.'), 1), (('328P-based', 'Arduino,'), 1), (('ones', 'compatible'), 1), (('that', 'run'), 1), (('language', 'not'), 1), (('type', 'with'), 1), (('(similar', 'to'), 1), (('just-in-time', 'Python'), 1), (('a', 'project'), 1), (('Python', 'interpreter'), 1), (('interpreter', 'five-fold'), 1), (('five-fold', 'by'), 1), (('LLVM,', 'and'), 1), (('of', 'improving'), 1), (('thousands', 'of'), 1), (('implementations', 'suffer'), 1), (('global', 'interpreter'), 1), (('interpreter', 'lock.'), 1), (('a', 'discontinued'), 1), (('discontinued', 'just-in-time'), 1), (('with', 'CPython'), 1), (('CPython', 'and'), 1), (('code', 'at'), 1), (('It', 'implemented'), 1), (('some', 'additional'), 1), (('the', 'Symbian'), 1), (('system.', 'The'), 1), (('with', 'GTK'), 1), (('widget', 'libraries,'), 1), (('enabling', 'programs'), 1), (('programs', 'to'), 1), (('===', 'Cross-compilers'), 1), (('===', 'There'), 1), (('to', 'high-level'), 1), (('of', 'Python,'), 1), (('a', 'language'), 1), (('the', 'source'), 1), (('Brython,', 'Transcrypt'), 1), (('LLVM)', 'and'), 1), (('and', 'supports'), 1), (('multithreading.', 'Cython'), 1), (('superset', 'of)'), 1), (('via', 'direct'), 1), (('direct', 'C-level'), 1), (('Python', 'interpreter.'), 1), (('claiming', 'high'), 1), (('claim', 'to'), 1), (('Python', 'code;'), 1), (('not', 'possible'), 1), (('or', 'machine'), 1), (('code.', 'Unless'), 1), (('changed,', 'but'), 1), (('possible', 'with'), 1), (('The', 'faster'), 1), (('source', 'code'), 1), (('or', 'compiled'), 1), (('Nuitka', 'compiles'), 1), (('Numba', 'uses'), 1), (('uses', 'LLVM'), 1), (('compile', 'a'), 1), (('code.', 'Pythran'), 1), (('MyHDL', 'is'), 1), (('Python-based', 'hardware'), 1), (('language', '(HDL),'), 1), ((\"Google's\", 'Grumpy'), 1), (('in', '2017)'), 1), (('running', 'Python'), 1), (('\"Python', '3.4,'), 1), (('although', 'features'), 1), (('and', 'behaviors'), 1), (('and', 'Shed'), 1), (('Shed', 'Skin'), 1), ((\"Python's\", 'performance'), 1), (('compared', 'to'), 1), (('Language', 'Benchmarks'), 1), (('Game.', '=='), 1), (('PEP', '8.'), 1), (('PEPs', 'are'), 1), (('community', 'and'), 1), (('council.', 'Enhancement'), 1), (('the', 'development'), 1), (('reference', 'implementation.'), 1), (('mailing', 'list'), 1), (('Roundup', 'bug'), 1), (('tracker', 'hosted'), 1), (('at', 'by'), 1), (('the', 'foundation.'), 1), (('2022,', 'all'), 1), (('issues', 'and'), 1), (('took', 'place'), 1), (('self-hosted', 'source-code'), 1), (('Python', 'moved'), 1), (('to', 'GitHub'), 1), (('where', 'code'), 1), (('is', 'expected'), 1), (('needs', 'to'), 1), (('These', 'releases'), 1), (('happen', 'infrequently—version'), 1), (('released', '8'), 1), (('a', 'version'), 1), (('unlikely', 'to'), 1), (('to', 'ever'), 1), (('ever', 'happen.'), 1), (('are', 'largely'), 1), (('largely', 'compatible'), 1), (('previous', 'version'), 1), (('features.', 'The'), 1), (('to', 'happen'), 1), (('happen', 'annually.'), 1), (('annually.', 'Each'), 1), (('is', 'supported'), 1), (('its', 'release.'), 1), (('releases,', 'which'), 1), (('months', 'and'), 1), (('made', 'when'), 1), (('when', 'a'), 1), (('Security', 'vulnerabilities'), 1), (('third', 'and'), 1), (('incremented.', 'Many'), 1), (('and', 'release-candidates'), 1), (('released', 'as'), 1), (('testing', 'before'), 1), (('Although', 'there'), 1), (('often', 'delayed'), 1), (('not', 'ready.'), 1), (('the', 'large'), 1), (('large', 'unit'), 1), (('unit', 'test'), 1), (('academic', 'conference'), 1), (('language.', 'Python'), 1), (('3.12', 'dropped'), 1), (('modules,', 'and'), 1), (('the', 'future,'), 1), (('future,', 'deprecated'), 1), (('emit', 'DeprecationWarning'), 1), (('The', \"'w'\"), 1), (('of', 'ctypes'), 1), (('security', 'and'), 1), (('the', 'typing'), 1), (('the', 'fields'), 1), (('be', 'disallowed'), 1), (('API', 'include'), 1), (('pydoc', '(available'), 1), (('standard', 'library),'), 1), (('Sphinx,', 'Pdoc'), 1), (('and', 'Graphviz,'), 1), (('Naming', '=='), 1), ((\"Python's\", 'name'), 1), (('literature', 'are'), 1), (('eggs', 'instead'), 1), (('Python', 'routines.'), 1), (('that', 'something'), 1), (('to', 'Python.'), 1), (('Python.', 'Examples'), 1), (('Examples', 'of'), 1), (('this', 'prefix'), 1), (('include', 'Pygame,'), 1), (('games);', 'PyQt'), 1), (('which', 'bind'), 1), (('Qt', 'and'), 1), (('GTK', 'to'), 1), (('and', 'PyPy,'), 1), (('PyPy,', 'a'), 1), (('originally', 'written'), 1), (('Popularity', '=='), 1), (('of', 'December'), 1), (('in', 'ratings'), 1), (('a', 'year\")'), 1), (('2018,', 'and'), 1), (('to', 'have'), 1), (('so', 'four'), 1), (('times', 'as'), 1), (('2020).', 'Large'), 1), (('that', 'use'), 1), (('Google,', 'Yahoo!,'), 1), (('like', 'ILM'), 1), (('news', 'networking'), 1), (('networking', 'site'), 1), (('Reddit', 'was'), 1), (('was', 'written'), 1), (('can', 'serve'), 1), (('language', 'for'), 1), (('the', 'Apache'), 1), (('webserver.', 'With'), 1), (('Interface,', 'a'), 1), (('Django,', 'Pylons,'), 1), (('Pylons,', 'Pyramid,'), 1), (('the', 'design'), 1), (('the', 'client-side'), 1), (('computers,', 'and'), 1), (('Dropbox.', 'Libraries'), 1), (('as', 'NumPy,'), 1), (('Matplotlib', 'allow'), 1), (('allow', 'the'), 1), (('computing,', 'with'), 1), (('with', 'specialized'), 1), (('and', 'Astropy'), 1), (('algebra', 'system'), 1), (('interface', 'programmable'), 1), (('Python:', 'its'), 1), (('covers', 'many'), 1), (('many', 'aspects'), 1), (('algebra,', 'combinatorics,'), 1), (('has', 'Python'), 1), (('computer', 'vision'), 1), (('vision', 'and'), 1), (('and', 'image'), 1), (('commonly', 'used'), 1), (('intelligence', 'projects'), 1), (('projects', 'with'), 1), (('the', 'help'), 1), (('Keras,', 'Pytorch,'), 1), (('scikit-learn', 'and'), 1), (('the', 'Logic'), 1), (('ProbLog.', 'As'), 1), (('a', 'modular'), 1), (('tools,', 'Python'), 1), (('be', 'particularly'), 1), (('AI', 'applications,'), 1), (('in', 'particular,'), 1), (('their', 'use'), 1), (('structures.', 'Typical'), 1), (('answering,', 'geospatial'), 1), (('system,', 'implemented'), 1), (('uses', 'Definite'), 1), (('as', 'prompt'), 1), (('prompt', 'generators'), 1), (('for', 'text-to-text'), 1), (('GPT3', 'and'), 1), (('Stable', 'Diffusion.'), 1), (('using', 'libraries'), 1), (('FreeCAD,', '3D'), 1), (('3ds', 'Max,'), 1), (('4D,', 'Lightwave,'), 1), (('visual', 'effects'), 1), (('compositor', 'Nuke,'), 1), (('Inkscape,', 'Scribus'), 1), (('Shop', 'Pro,'), 1), (('Pro,', 'and'), 1), (('and', 'capella.'), 1), (('pretty', 'printer'), 1), (('the', 'best'), 1), (('been', 'used'), 1), (('adopted', 'as'), 1), (('as', 'first'), 1), (('three', 'available'), 1), (('Engine,', 'the'), 1), (('4', '(using'), 1), (('Python', '2.7),'), 1), (('OpenBSD', '(as'), 1), (('the', 'command'), 1), (('Ubuntu', 'uses'), 1), (('Ubiquity', 'installer,'), 1), (('Fedora', 'Linux'), 1), (('Linux', 'use'), 1), (('Anaconda', 'installer.'), 1), (('system,', 'Portage.'), 1), (('used', 'extensively'), 1), (('extensively', 'in'), 1), (('industry,', 'including'), 1), (('Sugar', 'software'), 1), (('the', 'One'), 1), (('2008,', 'is'), 1), (('The', 'Raspberry'), 1), (('project', 'has'), 1), (('Java', 'with'), 1), (('core', 'feature'), 1), (('and', 'generators'), 1), (('GDScript,', 'a'), 1), (('the', 'Godot'), 1), (('game', 'engine.'), 1), (('shares', 'the'), 1), (('to', 'bring'), 1), (('bring', 'the'), 1), (('philosophy', 'to'), 1), (('Java.', 'Julia'), 1), (('non-strict', 'superset'), 1), (('adding', 'e.g.'), 1), (('similar', 'syntax.'), 1), ((\"Ruby's\", 'creator,'), 1), (('Matsumoto,', 'has'), 1), (('said:', '\"I'), 1), (('\"I', 'wanted'), 1), (('that', 'was'), 1), (('why', 'I'), 1), (('to', 'design'), 1), (('my', 'own'), 1), (('developed', 'by'), 1), (('Apple,', 'has'), 1), (('for', 'enhanced'), 1), (('been', 'emulated'), 1), (('emulated', 'by'), 1), (('language', '(in'), 1), (('a', 'PEP)'), 1), (('Tcl,', 'Erlang,'), 1), (('==', 'See'), 1), (('History', 'of'), 1), (('languages', 'Comparison'), 1), (('===', '\"Python'), 1), (('Artificial', 'Intelligence\".'), 1), (('Intelligence\".', 'Python'), 1), (('Wiki.', '19'), 1), (('1', 'November'), 1), (('November', '2012.'), 1), (('Retrieved', '3'), 1), (('December', '2012.'), 1), (('2012.', 'Paine,'), 1), (('2005).', '\"AI'), 1), (('Python\".', 'AI'), 1), (('Expert', 'Newsletter.'), 1), (('Amzi!.', 'Archived'), 1), (('February', '2012.'), 1), (('Pypi.python.org.', 'Retrieved'), 1), (('&', 'Norvig,'), 1), (('Artificial', 'Intelligence:'), 1), (('Modern', 'Approach'), 1), (('Approach', '(3rd'), 1), (('ed.).', 'Upper'), 1), (('Further', 'reading'), 1), (('2012).', 'Think'), 1), (('Python:', 'How'), 1), (('A-Z', 'of'), 1), (('Languages:', 'Python\".'), 1), (('Computerworld.', 'Archived'), 1), (('29', 'December'), 1), (('31', 'March'), 1), (('Lutz,', 'Mark'), 1), (('ISBN', '978-0-596-15806-4.'), 1), (('978-0-596-15806-4.', 'Summerfield,'), 1), (('Mark', '(2009).'), 1), (('(2009).', 'Programming'), 1), (('(2nd', 'ed.).'), 1), (('ISBN', '978-1-4920-5632-4.'), 1), (('978-1-4920-5632-4.', '=='), 1), (('a', 'high-level,'), 1), (('supports', 'multiple'), 1), (('often', 'described'), 1), (('included\"', 'language'), 1), (('library.', 'Guido'), 1), (('first', 'released'), 1), (('released', 'it'), 1), (('in', '1991'), 1), (('not', 'completely'), 1), (('earlier', 'versions.'), 1), (('Python', '2.7.18,'), 1), (('community.', '=='), 1), (('1980s', 'by'), 1), (('&', 'Informatica'), 1), (('Netherlands', 'as'), 1), (('inspired', 'by'), 1), (('of', 'exception'), 1), (('handling', 'and'), 1), (('and', 'interfacing'), 1), (('December', '1989.'), 1), (('sole', 'responsibility'), 1), (('project,', 'as'), 1), (('lead', 'developer,'), 1), (('until', '12'), 1), (('him', 'to'), 1), ((\"project's\", 'chief'), 1), (('decision-maker', \"(he's\"), 1), ((\"(he's\", 'since'), 1), (('is', 'self-titled'), 1), (('January', '2019,'), 1), (('2019,', 'active'), 1), (('Council', 'to'), 1), (('project.', 'Python'), 1), (('2000,', 'with'), 1), (('2.7.x.', 'Releases'), 1), (('3.', 'Python'), 1), (('of', 'concern'), 1), (('that', 'a'), 1), (('existing', 'code'), 1), (('further', 'security'), 1), (('it.', 'Currently'), 1), (('were', 'fixed'), 1), (('in', 'e.g.'), 1), (('and', 'older'), 1), (('unsupported,', 'a'), 1), (('Python', 'implementation,'), 1), (('PyPy,', 'continues'), 1), (('and', '3.10),'), 1), (('meaning', '(at'), 1), (('(including', '2.7)'), 1), (('and', 'web-cache'), 1), (('2022,', 'Python'), 1), (('were', 'expedited'), 1), (('security', 'issues.'), 1), (('2022,', 'four'), 1), (('and', '3.7.14.'), 1), (('3.12', 'and'), 1), (('adds', 'syntax'), 1), (('(and', 'in'), 1), (('adds', 'some'), 1), (('language,', 'the'), 1), (('(soft)', 'keyword'), 1), (('keyword', 'type'), 1), (('(recent', 'releases'), 1), (('have', 'added'), 1), (('typing', 'support'), 1), (('3.10', 'the'), 1), (('modules', 'and'), 1), (('and', 'functionality,'), 1), (('will', 'too,'), 1), (('too,', 'see'), 1), (('below', 'in'), 1), (('Development', 'section.'), 1), (('be', 'between'), 1), (('3.10,', 'and'), 1), (('adds', 'another'), 1), (('error', 'messages,'), 1), (('changes.', 'Since'), 1), (('version', 'of'), 1), (('Python', '3.13'), 1), (('an', 'incremental'), 1), (('in', 'programs'), 1), (('garbage', 'collector,'), 1), (('collector,', 'an'), 1), (('compiler,', 'and'), 1), (('and', 'removals'), 1), (('removals', 'from'), 1), (('many', 'deprecated'), 1), (('it', 'and'), 1), (('of', 'full'), 1), (('support', '(up'), 1), (('one', 'and'), 1), (('followed', 'by'), 1), (('by', '3'), 1), (('security', 'support'), 1), (('same', 'total'), 1), (('support', 'as'), 1), (('Design', 'philosophy'), 1), (('programming', 'are'), 1), (('fully', 'supported,'), 1), (('their', 'features'), 1), (('programming', '(including'), 1), (('paradigms', 'are'), 1), (('collector', 'for'), 1), (('It', 'uses'), 1), (('variable', 'names'), 1), (('design', 'offers'), 1), (('has', 'filter,mapandreduce'), 1), (('that', 'implement'), 1), (('(PEP', '20),'), 1), (('which', 'includes'), 1), (('includes', 'aphorisms'), 1), (('than', 'implicit.'), 1), (('Readability', 'counts.'), 1), (('regularly', 'violate'), 1), (('principles', 'and'), 1), (('criticisms', 'are'), 1), (('features', 'had'), 1), (('vitriol', 'over'), 1), (('over', 'the'), 1), (('its', 'functionality'), 1), (('made', 'it'), 1), ((\"Rossum's\", 'vision'), 1), (('a', 'small'), 1), (('small', 'core'), 1), (('easily', 'extensible'), 1), (('espoused', 'the'), 1), (('for', 'a'), 1), (('a', '\"there'), 1), (('to', 'achieve'), 1), (('string', 'literal,'), 1), (('which', 'one'), 1), (('Martelli,', 'a'), 1), (('Software', 'Foundation'), 1), (('Foundation', 'and'), 1), (('wrote:', '\"To'), 1), ((\"'clever'\", 'is'), 1), (('to', 'avoid'), 1), (('avoid', 'premature'), 1), (('to', 'non-critical'), 1), (('in', 'speed'), 1), (('to', 'extension'), 1), (('extension', 'modules'), 1), (('as', 'C,'), 1), (('a', 'just-in-time'), 1), ((\"doesn't\", 'provide'), 1), (('that', 'might'), 1), (('might', 'be'), 1), (('is', 'compiled,'), 1), (('and', 'possibly'), 1), (('changed.', \"Python's\"), 1), (('its', 'name—a'), 1), (('tribute', 'to'), 1), (('the', 'terms'), 1), (('Python', 'sketch)'), 1), (('sketch)', 'in'), 1), (('often-used', '\"foo\"'), 1), (('which', 'has'), 1), (('idioms', 'well,'), 1), (('natural', 'or'), 1), (('fluency', 'in'), 1), (('conform', 'with'), 1), (('and', 'emphasis'), 1), (('reads', 'like'), 1), (('semantics', '=='), 1), (('meant', 'to'), 1), (('visually', 'uncluttered'), 1), (('semicolons', 'after'), 1), (('fewer', 'syntactic'), 1), (('and', 'special'), 1), (('than', 'C'), 1), (('===', 'Indentation'), 1), (('Indentation', '==='), 1), (('or', 'keywords,'), 1), (('a', 'decrease'), 1), (('signifies', 'the'), 1), (('Thus,', 'the'), 1), ((\"program's\", 'visual'), 1), (('structure.', 'This'), 1), (('sometimes', 'termed'), 1), (('the', 'off-side'), 1), (('use', 'indentation'), 1), (('semantic', 'meaning.'), 1), (('and', 'control'), 1), (('control', 'flow'), 1), (('sign', '='), 1), (('of', 'code,'), 1), (('contraction', 'of'), 1), (('which', 'iterates'), 1), (('iterates', 'over'), 1), (('element', 'to'), 1), (('a', 'local'), 1), (('its', 'condition'), 1), (('its', 'attached'), 1), (('by', 'except'), 1), (('a', 'finally'), 1), (('run', 'regardless'), 1), (('block', 'exits'), 1), (('raise', 'statement,'), 1), (('raise', 'a'), 1), (('caught', 'exception'), 1), (('exception', 'The'), 1), (('its', 'local'), 1), (('namespace', 'to'), 1), (('in', 'object-oriented'), 1), (('programming', 'The'), 1), (('function', 'or'), 1), (('which', 'encloses'), 1), (('encloses', 'a'), 1), (('a', 'code'), 1), (('acquiring', 'a'), 1), (('is', 'run,'), 1), (('then', 'releasing'), 1), (('or', 'opening'), 1), (('and', 'closing'), 1), (('a', 'file),'), 1), (('resource-acquisition-is-initialization', '(RAII)-like'), 1), (('break', 'statement,'), 1), (('the', 'next'), 1), (('variable', 'is'), 1), (('statement,', 'serving'), 1), (('empty', 'code'), 1), (('The', 'assert'), 1), (('that', 'should'), 1), (('generator', 'function'), 1), (('return', 'statement,'), 1), (('statements,', 'used'), 1), (('name', 'as'), 1), (('allocated', 'object.'), 1), (('object.', 'Variables'), 1), (('subsequently', 'be'), 1), (('object.', 'In'), 1), (('variable', 'name'), 1), (('a', 'generic'), 1), (('reference', 'holder'), 1), (('a', 'fixed'), 1), (('dynamic', 'typing—in'), 1), (('languages,', 'where'), 1), (('certain', 'type.'), 1), (('type.', 'Python'), 1), (('support', 'tail'), 1), (('never', 'will.'), 1), (('will.', 'However,'), 1), (('for', 'coroutine-like'), 1), (('coroutine-like', 'functionality'), 1), (('2.5,', 'generators'), 1), (('were', 'lazy'), 1), (('was', 'passed'), 1), (('3.3,', 'it'), 1), (('multiple', 'stack'), 1), (('===', 'Expressions'), 1), (('Expressions', '==='), 1), (('expressions', 'include:'), 1), (('Python:', 'floor'), 1), (('exponentiation.', 'Python'), 1), (('concatenation.', 'Python'), 1), (('of', 'times.'), 1), (('@', 'infix'), 1), (('matrix', 'multiplication.'), 1), (('multiplication.', 'The'), 1), (('3.8.', 'It'), 1), (('It', 'assigns'), 1), (('be', 'chained—for'), 1), (('b', '<='), 1), (('or,', 'and'), 1), (('operators.', 'Python'), 1), (('type', 'of'), 1), (('x', 'if'), 1), (('as', '[1,'), 1), (('2,', '3],'), 1), (('the', 'keys'), 1), (('Tuples,', 'written'), 1), (('dictionaries,', 'provided'), 1), (('provided', 'all'), 1), (('which', 'does'), 1), (('directly', 'modify'), 1), (('containing', 'the'), 1), (('given', 'the'), 1), (('(4,', '5)'), 1), (('to', 't—thereby'), 1), (('contents\"', 'of'), 1), (('tuple', 'objects.'), 1), (('Parentheses', 'are'), 1), (('where', 'multiple'), 1), (('evaluating', 'to'), 1), (('an', 'identical'), 1), (('object', 'on'), 1), (('right-hand', 'side'), 1), (('the', 'provided'), 1), (('provided', 'writable'), 1), (('when', 'iterated'), 1), (('the', 'corresponding'), 1), (('the', 'left.'), 1), (('format\"', 'operator'), 1), (('operator', '%'), 1), (('%', 'that'), 1), (('printf', 'format'), 1), (('this', 'was'), 1), (('3.6', 'added'), 1), (('\"blah\";', 'eggs'), 1), (('concatenated', 'by'), 1), (('same', 'operator'), 1), (('floats),', 'e.g.'), 1), (('\"spameggs\".', 'If'), 1), (('strings', 'contain'), 1), (('contain', 'numbers,'), 1), (('e.g.', '\"2\"'), 1), (('various', 'string'), 1), (('and', 'double'), 1), (('quotes', 'work'), 1), (('the', 'same.'), 1), (('(beginning', 'and'), 1), (('quotes),', 'which'), 1), (('the', 'string'), 1), (('with', 'r.'), 1), (('sequences', 'are'), 1), (('as', 'regular'), 1), (('C#.)', 'Python'), 1), (('array', 'slicing'), 1), (('elements', 'from'), 1), (('index.', 'The'), 1), (('third', 'slice'), 1), (('parameter,', 'called'), 1), (('or', 'stride,'), 1), (('allows', 'elements'), 1), (('example,', 'a[:]'), 1), (('copy.', 'In'), 1), (('is', 'rigidly'), 1), (('to', 'languages'), 1), (('example:', 'List'), 1), (('comprehensions', 'vs.'), 1), (('expressions', 'vs.'), 1), (('blocks', 'The'), 1), (('exec', 'is'), 1), (('a', 'statement);'), 1), (('latter', 'is'), 1), (('Statements', 'cannot'), 1), (('be', 'a'), 1), (('a', 'part'), 1), (('of', 'an'), 1), (('an', 'expression—so'), 1), (('or', 'lambda'), 1), (('expressions,', 'cannot'), 1), (('contain', 'statements.'), 1), (('1', 'cannot'), 1), (('Methods', '==='), 1), (('on', 'objects'), 1), (('are', 'functions'), 1), (('instance.method(argument)', 'is,'), 1), (('for', 'normal'), 1), (('and', 'functions,'), 1), (('self', 'parameter'), 1), (('access', 'instance'), 1), (('implicit', 'self'), 1), (('Ruby).', 'Python'), 1), (('called', 'dunder'), 1), (('methods', '(due'), 1), (('modify', 'how'), 1), (('variable', 'names.'), 1), (('type.', 'Despite'), 1), (('is', 'strongly'), 1), (('number', 'to'), 1), (('string)', 'rather'), 1), (('of', 'them.'), 1), (('to', 'define'), 1), (('define', 'their'), 1), (('classes,', 'most'), 1), (('object-oriented', 'programming.'), 1), (('programming.', 'New'), 1), (('by', 'calling'), 1), (('the', 'classes'), 1), (('metaclass', 'type'), 1), (('and', 'reflection.'), 1), (('versions', 'only'), 1), (('These', 'annotations'), 1), (('annotations', 'are'), 1), (('mypy', 'to'), 1), (('errors.', 'Mypy'), 1), (('called', 'mypyc,'), 1), (('leverages', 'type'), 1), (('for', 'optimization.'), 1), (('operations', '==='), 1), (('has', 'the'), 1), (('arithmetic', 'operators'), 1), (('operation', '%'), 1), (('**', 'for'), 1), (('a', 'matrix‑multiplication'), 1), (('operators', 'work'), 1), (('same', 'precedence'), 1), (('-', 'can'), 1), (('division', 'between'), 1), (('The', 'behavior'), 1), (('/', 'to'), 1), (('5/2', '=='), 1), (('(or', 'simply'), 1), (('division.', '/'), 1), (('before', 'version'), 1), (('classic', 'division.'), 1), (('true.', 'It'), 1), (('is', 'valid'), 1), (('both', 'positive'), 1), (('that', 'while'), 1), (('a%b', 'is,'), 1), (('interval', '[0,'), 1), (('where', 'b'), 1), (('it', 'has'), 1), (('0]', 'when'), 1), (('when', 'b'), 1), (('negative.', 'Python'), 1), (('for', 'rounding'), 1), (('rounding', 'a'), 1), (('integer.', 'For'), 1), (('uses', 'round'), 1), (('both', 'produce'), 1), (('is', '−1.0.'), 1), (('−1.0.', 'Python'), 1), (('a', 'manner'), 1), (('manner', 'that'), 1), (('is', 'consistent'), 1), (('in', 'mathematics.'), 1), (('c.', 'C-derived'), 1), (('languages', 'interpret'), 1), (('this', 'expression'), 1), (('and', 'that'), 1), (('result', 'would'), 1), (('Decimal', 'type/class'), 1), (('floating-point', 'numbers'), 1), (('a', 'pre-defined'), 1), (('precision', 'and'), 1), (('precision', 'for'), 1), (('rational', 'numbers.'), 1), (('scientific', 'scripting'), 1), (('processing', 'and'), 1), (('manipulation.', '=='), 1), (('Programming', 'examples'), 1), (('program:', 'Program'), 1), (('positive', 'integer:'), 1), (('library', 'provides'), 1), (('provides', 'tools'), 1), (('suited', 'to'), 1), (('strengths.', 'For'), 1), (('many', 'standard'), 1), (('and', 'protocols'), 1), (('are', 'supported.'), 1), (('to', 'relational'), 1), (('decimals,', 'manipulating'), 1), (('testing.', 'Some'), 1), (('library', 'are'), 1), (('by', 'specifications—for'), 1), (('Gateway', 'Interface'), 1), (('follows', 'PEP'), 1), (('specified', 'by'), 1), (('cross-platform', 'Python'), 1), (('or', 'rewriting'), 1), (('rewriting', 'for'), 1), (('17', 'March'), 1), (('Package', 'Index'), 1), (('Index', '(PyPI),'), 1), (('523,000', 'packages'), 1), (('packages', 'with'), 1), (('Development', 'environments'), 1), (('(including', 'CPython)'), 1), (('loop', '(REPL),'), 1), (('and', 'receive'), 1), (('IDLE,', 'which'), 1), (('Other', 'shells,'), 1), (('IDLE', 'and'), 1), (('and', 'IPython,'), 1), (('retention,', 'and'), 1), (('and', 'syntax'), 1), (('integrated', 'development'), 1), (('development', 'environments'), 1), (('IDEs,', 'including'), 1), (('SageMath,', 'for'), 1), (('Reference', 'implementation'), 1), (('C,', 'meeting'), 1), (('(Python', '3.11'), 1), (('C11)', 'with'), 1), (('C99', 'features.'), 1), (('includes', 'its'), 1), (('extensions', 'are'), 1), (('to', 'older'), 1), (('or', 'C++.'), 1), (('into', 'an'), 1), (('distributed', 'with'), 1), (('of', 'C'), 1), (('installer', 'deliberately'), 1), (('8;', 'Windows'), 1), (('(and', 'Apple'), 1), (('experimental', 'installer),'), 1), (('with', 'unofficial'), 1), (('portability', 'was'), 1), (('priorities.', '(During'), 1), (('were', 'supported,'), 1), (('has', 'since'), 1), (('since', 'been'), 1), (('fast,', 'compliant'), 1), (('compliant', 'interpreter'), 1), (('CPython,', 'but'), 1), (('libraries', 'written'), 1), (('C', 'cannot'), 1), (('variants', 'optimized'), 1), (('compilation', 'to'), 1), (('that', 'contains'), 1), (('optimizations,', 'including'), 1), (('Snek', 'Embedded'), 1), (('as', 'larger'), 1), (('\"is', 'Python-inspired,'), 1), (('to', 'write'), 1), (('under', 'a'), 1), (('Python', 'system,'), 1), (('system,', 'but'), 1), (('imperative', 'language'), 1), (('classes,', 'unlike'), 1), (('unlike', 'Python,'), 1), (('JavaScript,', 'except'), 1), (('===', 'Unsupported'), 1), (('Python', 'compilers'), 1), (('began', 'a'), 1), (('Unladen', 'Swallow'), 1), (('ability', 'to'), 1), (('while', 'ordinary'), 1), (('ordinary', 'implementations'), 1), (('just-in-time', 'specializing'), 1), (('specializing', 'compiler'), 1), (('compiler', 'that'), 1), (('transforms', 'bytecode'), 1), (('Series', '60'), 1), (('libraries,', 'enabling'), 1), (('target', 'device.'), 1), (('are', 'several'), 1), (('several', 'compilers/transpilers'), 1), (('with', 'either'), 1), (('source', 'language:'), 1), (('Pyjs', '(latest'), 1), (('2012)', 'compile'), 1), (('compile', 'Python'), 1), (('of', 'statically'), 1), (('Cython', 'compiles'), 1), (('compiles', '(a'), 1), (('to', 'C.'), 1), (('to', '\"human-readable,'), 1), (('maintainable,', 'and'), 1), (('with', 'few'), 1), (('can', 'then'), 1), (('Python', 'into'), 1), (('C.', 'Numba'), 1), (('(C++11).', 'RPython'), 1), (('to', 'build'), 1), (('PyPy', 'interpreter'), 1), (('The', 'Python'), 1), (('a', 'Python-based'), 1), (('hardware', 'description'), 1), (('description', 'language'), 1), (('(HDL),', 'that'), 1), (('MyHDL', 'code'), 1), (('to', 'Verilog'), 1), (('Older', 'projects'), 1), (('not', 'to'), 1), (('latest', 'syntax):'), 1), (('syntax):', \"Google's\"), 1), (('(and', 'an'), 1), (('an', 'alpha,'), 1), (('for', '\"Python'), 1), (('features', 'and'), 1), (('versions', 'may'), 1), (('be', 'included\")'), 1), (('included\")', 'on'), 1), (('the', '.NET'), 1), (('Common', 'Language'), 1), (('Language', 'Runtime.'), 1), (('in', '2013)'), 1), (('respectively.', '==='), 1), (('Performance', '==='), 1), (('implementations', 'on'), 1), (('a', 'non-numerical'), 1), (('workload', 'was'), 1), (('Development', '=='), 1), (('Python', 'Enhancement'), 1), (('Python', 'coding'), 1), (('covered', 'in'), 1), (('are', 'reviewed'), 1), (('and', 'commented'), 1), (('commented', 'on'), 1), (('on', 'by'), 1), (('Enhancement', 'of'), 1), (('language', 'corresponds'), 1), (('The', 'mailing'), 1), (('forum', 'for'), 1), ((\"language's\", 'development.'), 1), (('and', 'discussions'), 1), (('discussions', 'were'), 1), (('to', 'GitHub.'), 1), (('originally', 'took'), 1), ((\"CPython's\", 'public'), 1), (('releases', 'come'), 1), (('distinguished', 'by'), 1), (('which', 'part'), 1), (('is', 'incremented:'), 1), (('incremented:', 'Backward-incompatible'), 1), (('Backward-incompatible', 'versions,'), 1), (('infrequently—version', '3.0'), 1), (('or', '\"feature\"'), 1), (('\"feature\"', 'releases'), 1), (('incremented.', 'Starting'), 1), (('major', 'version'), 1), (('version', 'is'), 1), (('by', 'bug'), 1), (('several', 'years'), 1), (('Bugfix', 'releases,'), 1), (('sufficient', 'number'), 1), (('upstream', 'since'), 1), (('since', 'the'), 1), (('last', 'release.'), 1), (('also', 'patched'), 1), (('in', 'these'), 1), (('final', 'part'), 1), (('as', 'previews'), 1), (('for', 'testing'), 1), (('development', 'team'), 1), (('code', 'by'), 1), (('test', 'suite'), 1), (('The', 'major'), 1), (('major', 'academic'), 1), (('conference', 'on'), 1), (('also', 'special'), 1), (('mentoring', 'programs,'), 1), (('programs,', 'such'), 1), (('as', 'PyLadies.'), 1), (('PyLadies.', 'Python'), 1), (('removed', 'wstr'), 1), (('some', 'outdated'), 1), (('3.13;', 'already'), 1), (('Python', '3.16.'), 1), (('code', 'should'), 1), (('deprecated', 'and'), 1), (('and', 'http.server.CGIHTTPRequestHandler'), 1), (('high', 'potential'), 1), (('bugs.', 'Parts'), 1), (('typing', 'module'), 1), (('using', 'keyword'), 1), (('denote', 'the'), 1), (('(and', 'more)'), 1), (('documentation', 'generators'), 1), (('library),', 'Sphinx,'), 1), (('others.', '=='), 1), (('Python', 'references'), 1), (('and', 'culture;'), 1), (('culture;', 'for'), 1), (('variables', 'often'), 1), (('spam', 'and'), 1), (('The', 'official'), 1), (('also', 'contains'), 1), (('to', 'Monty'), 1), (('are', 'sometimes'), 1), (('as', '\"Pythonistas\".'), 1), (('\"Pythonistas\".', 'The'), 1), (('show', 'that'), 1), (('something', 'is'), 1), (('or', 'libraries'), 1), (('Pygame,', 'a'), 1), (('Python', '(commonly'), 1), (('PyGTK,', 'which'), 1), (('Since', '2003,'), 1), (('Community', 'Index'), 1), (('December', '2022'), 1), (('2022', 'it'), 1), (('Java).', 'It'), 1), (('It', 'was'), 1), (('(for', '\"the'), 1), (('highest', 'rise'), 1), (('done', 'so'), 1), (('CERN,', 'NASA,'), 1), (('some', 'smaller'), 1), (('written', 'mostly'), 1), (('serve', 'as'), 1), (('Apache', 'webserver.'), 1), (('standard', 'API'), 1), (('API', 'has'), 1), (('evolved', 'to'), 1), (('facilitate', 'these'), 1), (('frameworks', 'like'), 1), (('developers', 'in'), 1), (('maintenance', 'of'), 1), (('of', 'Ajax-based'), 1), (('a', 'data'), 1), (('a', 'relational'), 1), (('Libraries', 'such'), 1), (('in', 'scientific'), 1), (('domain-specific', 'functionality.'), 1), (('a', 'computer'), 1), (('a', 'notebook'), 1), (('programmable', 'in'), 1), (('library', 'covers'), 1), (('aspects', 'of'), 1), (('mathematics,', 'including'), 1), (('combinatorics,', 'numerical'), 1), (('mathematics,', 'number'), 1), (('Python', 'bindings'), 1), (('features', 'for'), 1), (('in', 'artificial'), 1), (('Logic', 'language'), 1), (('language', 'ProbLog.'), 1), (('As', 'a'), 1), (('and', 'rich'), 1), (('for', 'natural'), 1), (('The', 'Janus'), 1), (('typing,', 'and'), 1), (('data', 'structures.'), 1), (('this', 'combination'), 1), (('query', 'answering,'), 1), (('geospatial', 'reasoning,'), 1), (('reasoning,', 'and'), 1), (('Natlog', 'system,'), 1), (('Definite', 'Clause'), 1), (('Grammars', '(DCGs)'), 1), (('like', 'DALL-E'), 1), (('successfully', 'embedded'), 1), (('method', 'software'), 1), (('Softimage,', 'the'), 1), (('Esri', 'promotes'), 1), (('video', 'games,'), 1), (('been', 'adopted'), 1), (('App', 'Engine,'), 1), (('most', 'Linux'), 1), (('AmigaOS', '4'), 1), (('FreeBSD', '(as'), 1), (('package),', 'NetBSD,'), 1), (('and', 'OpenBSD'), 1), (('Many', 'Linux'), 1), (('distributions', 'use'), 1), (('Hat', 'Linux'), 1), (('Gentoo', 'Linux'), 1), (('security', 'industry,'), 1), (('per', 'Child'), 1), (('developed', 'at'), 1), (('has', 'adopted'), 1), (('main', 'user-programming'), 1), (('language.', 'LibreOffice'), 1), (('and', 'intends'), 1), (('intends', 'to'), 1), (('Python.', 'Its'), 1), (('Its', 'Python'), 1), (('a', 'core'), 1), (('since', 'Version'), 1), (('influenced', 'by'), 1), (('object', 'model.'), 1), (('document', 'lists'), 1), (('that', 'influenced'), 1), (('that', 'cross-compiles'), 1), (('cross-compiles', 'to'), 1), (('JavaScript,', 'has'), 1), (('syntax.', 'ECMAScript–JavaScript'), 1), (('borrowed', 'iterators'), 1), (('very', 'similar'), 1), (('to', 'Python,'), 1), (('built-in', 'to'), 1), (('engine.', 'Go'), 1), (('working', 'in'), 1), (('a', 'dynamic'), 1), (('same', 'syntax'), 1), (('syntax', 'for'), 1), (('Groovy', 'was'), 1), (('as', 'Python\".'), 1), (('a', 'non-strict'), 1), (('missing', 'classes,'), 1), (('struct).', 'Nim'), 1), (('syntax.', \"Ruby's\"), 1), (('Python.', \"That's\"), 1), (('blends', 'Python'), 1), (('code', 'for'), 1), (('practices', 'have'), 1), (('document', 'describing'), 1), (('PEP)', 'is'), 1), (('See', 'also'), 1), (('Comparison', 'of'), 1), (('Sources', '==='), 1), (('\"Python', 'for'), 1), (('19', 'July'), 1), (('July', '2012.'), 1), (('(August', '2005).'), 1), (('2012.', '\"PyAIML'), 1), (('0.8.5', ':'), 1), (('July', '2013.'), 1), (('Russell,', 'Stuart'), 1), (('Stuart', 'J.'), 1), (('A', 'Modern'), 1), (('(3rd', 'ed.).'), 1), (('How', 'to'), 1), (('Think', 'Like'), 1), (('a', 'Computer'), 1), (('Cambridge', 'University'), 1), (('University', 'Press.'), 1), (('ISBN', '978-0-521-72596-5.'), 1), (('978-0-521-72596-5.', 'Hamilton,'), 1), (('Hamilton,', 'Naomi'), 1), (('(5', 'August'), 1), (('\"The', 'A-Z'), 1), (('March', '2010.'), 1), (('Summerfield,', 'Mark'), 1), (('ed.).', 'Addison-Wesley'), 1), (('links', '=='), 1), (('==', 'Official'), 1), (('high-level,', 'general-purpose'), 1), (('philosophy', 'emphasizes'), 1), (('typed', 'and'), 1), (('paradigms,', 'including'), 1), (('described', 'as'), 1), (('a', '\"batteries'), 1), (('began', 'working'), 1), (('working', 'on'), 1), (('1980s', 'as'), 1), (('in', '2000.'), 1), (('completely', 'backward-compatible'), 1), (('in', '2020,'), 1), (('2020,', 'was'), 1), (('last', 'release'), 1), (('2.', 'Python'), 1), (('the', 'machine'), 1), (('History', '=='), 1), (('by', 'Guido'), 1), (('Centrum', 'Wiskunde'), 1), (('Informatica', '(CWI)'), 1), (('which', 'was'), 1), (('exception', 'handling'), 1), (('Amoeba', 'operating'), 1), (('system.', 'Its'), 1), (('announced', 'his'), 1), (('his', 'responsibilities'), 1), (('as', \"Python's\"), 1), ((\"Python's\", '\"benevolent'), 1), (('life\"', '(BDFL),'), 1), (('title', 'the'), 1), (('\"BDFL-emeritus\").', 'In'), 1), (('core', 'developers'), 1), (('the', 'project.'), 1), (('as', 'list'), 1), (('reference', 'counting,'), 1), (('its', 'major'), 1), (('2.6.x', 'and'), 1), (('include', 'the'), 1), (('was', 'initially'), 1), (('2015,', 'then'), 1), (('then', 'postponed'), 1), (('to', '2020'), 1), (('large', 'body'), 1), (('of', 'existing'), 1), (('not', 'easily'), 1), (('3.', 'No'), 1), (('for', 'it.'), 1), (('only', '3.8'), 1), (('later', 'are'), 1), (('(2023', 'security'), 1), (('3.7.17,', 'the'), 1), (('release).', 'While'), 1), (('older', 'is'), 1), (('to', 'support'), 1), (('2,', 'i.e.'), 1), (('(at', 'least'), 1), (('least', 'some)'), 1), (('updates\".', 'In'), 1), (('again', 'twice'), 1), (('twice', 'in'), 1), (('2022),', 'security'), 1), (('were', 'insecure'), 1), (('remote', 'code'), 1), (('code', 'execution'), 1), (('web-cache', 'poisoning.'), 1), (('2022,', 'it'), 1), (('series', '3.8'), 1), (('receive', 'security'), 1), (('made', 'due'), 1), (('of', 'October'), 1), (('October', '2023,'), 1), (('release,', 'and'), 1), (('are', 'the'), 1), (('the', 'only'), 1), (('support.', 'Notable'), 1), (('3.10', 'include'), 1), (('reporting.', 'Python'), 1), (('syntax', '(and'), 1), (('Python', 'since'), 1), (('exception', 'handling,'), 1), (('match', 'and'), 1), (('case', '(soft)'), 1), (('also', 'drops'), 1), (('versions', 'will'), 1), (('10', 'and'), 1), (('60%', 'faster'), 1), (('5%', 'on'), 1), (('that.', 'It'), 1), (('oldest', 'supported'), 1), (('supported', 'version'), 1), (('for', 'collection'), 1), (('C', 'API.'), 1), (('batteries,', 'and'), 1), (('classes,', 'functions'), 1), (('3.13,', 'it'), 1), (('have', '2'), 1), (('2', 'years'), 1), (('(up', 'from'), 1), (('3', 'years'), 1), (('before).', '=='), 1), (('multi-paradigm', 'programming'), 1), (('aspect-oriented', 'programming'), 1), (('via', 'extensions,'), 1), (('by', 'contract'), 1), (('garbage', 'collector'), 1), (('dynamic', 'name'), 1), (('which', 'binds'), 1), (('binds', 'method'), 1), (('and', 'variable'), 1), (('generator', 'expressions.'), 1), (('The', 'standard'), 1), (('two', 'modules'), 1), (('modules', '(itertools'), 1), (('(itertools', 'and'), 1), (('ML.', 'Its'), 1), (('20),', 'which'), 1), (('such', 'as:'), 1), (('than', 'ugly.'), 1), (('Explicit', 'is'), 1), (('implicit.', 'Simple'), 1), (('Simple', 'is'), 1), (('counts.', 'However,'), 1), (('adding', 'unnecessary'), 1), (('to', 'these'), 1), (('are', 'that'), 1), (('a', 'guideline'), 1), (('than', 'a'), 1), (('some', 'new'), 1), (('so', 'controversial'), 1), (('controversial', 'that'), 1), (('Rossum', 'resigned'), 1), (('resigned', 'as'), 1), (('for', 'Life'), 1), (('assignment', 'expression'), 1), (('expression', 'operator'), 1), (('particularly', 'popular'), 1), (('a', 'means'), 1), (('of', 'adding'), 1), (('adding', 'programmable'), 1), (('Van', \"Rossum's\"), 1), (('core', 'language'), 1), (('extensible', 'interpreter'), 1), (('ABC,', 'which'), 1), (('strive', 'for'), 1), (('In', 'contrast'), 1), (('\"there', 'is'), 1), (('than', 'one'), 1), (('Python', 'embraces'), 1), (('do', 'it.\"'), 1), (('it.\"', 'philosophy.'), 1), (('same', 'task.'), 1), (('task.', 'There'), 1), (('There', 'are,'), 1), (('no', 'certainty'), 1), (('certainty', 'as'), 1), (('as', 'to'), 1), (('programmer', 'should'), 1), (('should', 'use.'), 1), (('considered', 'a'), 1), (('developers', 'usually'), 1), (('would', 'offer'), 1), (('increases', 'in'), 1), (('of', 'clarity.'), 1), (('speed', 'can'), 1), (('be', 'improved'), 1), (('improved', 'by'), 1), (('speed-critical', 'functions'), 1), (('functions', 'to'), 1), (('C,', 'or'), 1), (('also', 'possible'), 1), (('cross-compile', 'to'), 1), (('a', 'very'), 1), (('developers', 'aim'), 1), (('to', 'use.'), 1), (('reflected', 'in'), 1), (('Monty', 'Python—and'), 1), (('tutorials', 'and'), 1), (('and', 'reference'), 1), (('materials,', 'such'), 1), (('(a', 'reference'), 1), (('A', 'common'), 1), (('of', 'meanings'), 1), (('program', 'style.'), 1), (('code', 'may'), 1), (('minimalist', 'philosophy'), 1), (('to', 'understand'), 1), (('another', 'programming'), 1), (('be', 'an'), 1), (('uncluttered', 'and'), 1), (('after', 'statements'), 1), (('but', 'rarely'), 1), (('delimit', 'blocks.'), 1), (('decrease', 'in'), 1), (('its', 'semantic'), 1), (('This', 'feature'), 1), (('Some', 'other'), 1), (('indent', 'size'), 1), (('four', 'spaces.'), 1), (('statements', 'include:'), 1), (('a', 'single'), 1), (('single', 'equals'), 1), (('equals', 'sign'), 1), (('The', 'if'), 1), (('conditionally', 'executes'), 1), (('and', 'elif'), 1), (('elif', '(a'), 1), (('(a', 'contraction'), 1), (('else-if)', 'The'), 1), (('object,', 'capturing'), 1), (('code', 'as'), 1), (('syntax', 'except*'), 1), (('exception', 'groups);'), 1), (('finally', 'block'), 1), (('of', 'how'), 1), (('specified', 'exception'), 1), (('exception', 'or'), 1), (('class', 'statement,'), 1), (('attaches', 'its'), 1), (('The', 'def'), 1), (('The', 'with'), 1), (('block', 'within'), 1), (('file),', 'allowing'), 1), (('(RAII)-like', 'behavior'), 1), (('behavior', 'and'), 1), (('and', 'replacing'), 1), (('a', 'common'), 1), (('and', 'continues'), 1), (('reference', 'from'), 1), (('is', 'referred'), 1), (('serving', 'as'), 1), (('a', 'NOP,'), 1), (('NOP,', 'syntactically'), 1), (('needed', 'to'), 1), (('create', 'an'), 1), (('check', 'for'), 1), (('for', 'conditions'), 1), (('also', 'an'), 1), (('functions', 'or'), 1), (('program', 'The'), 1), (('a', 'reference'), 1), (('a', 'separate,'), 1), (('Variables', 'may'), 1), (('may', 'subsequently'), 1), (('a', 'variable'), 1), (('holder', 'without'), 1), (('however,', 'it'), 1), (('typing—in', 'contrast'), 1), (('each', 'variable'), 1), (('may', 'contain'), 1), (('Rossum,', 'it'), 1), (('it', 'never'), 1), (('iterators;', 'data'), 1), (('From', 'Python'), 1), (('Python', '2.5'), 1), (('version', '3.3,'), 1), (('levels.', '==='), 1), (('The', '+,'), 1), (('+,', '-,'), 1), (('-,', 'and'), 1), (('for', 'mathematical'), 1), (('mathematical', 'addition,'), 1), (('and', 'multiplication'), 1), (('but', 'the'), 1), (('division', 'differs.'), 1), (('differs.', 'There'), 1), (('divisions', 'in'), 1), (('integer', 'division)'), 1), (('division)', '//'), 1), (('floating-point/division.', 'Python'), 1), (('duplicating', 'a'), 1), (('The', '@'), 1), (('operator.', 'It'), 1), (('for', 'matrix'), 1), ((':=,', 'called'), 1), (('by', 'value.'), 1), (('value.', \"Python's\"), 1), (('object', 'identities'), 1), (('reference),', 'and'), 1), (('example,', 'a'), 1), (('uses', 'and,'), 1), (('not', 'as'), 1), (('as', 'Boolean'), 1), (('more', 'general'), 1), (('implemented', 'using'), 1), (('using', 'lambda'), 1), (('one', 'expression'), 1), (('if', 'c'), 1), (('y', 'operator'), 1), (('common', 'to'), 1), (('other', 'languages).'), 1), (('languages).', 'Python'), 1), (('Python', 'makes'), 1), (('[1,', '2,'), 1), (('of', 'dictionaries'), 1), (('must', 'be'), 1), (('immutable', 'and'), 1), (('of', 'dictionaries,'), 1), (('are', 'immutable.'), 1), (('The', '+'), 1), (('to', 'concatenate'), 1), (('two', 'tuples,'), 1), (('but', 'produces'), 1), (('elements', 'of'), 1), (('initially', 'equal'), 1), (('equal', 'to'), 1), (('to', '(1,'), 1), (('\"modifying', 'the'), 1), (('while', 'conforming'), 1), (('the', 'immutable'), 1), (('in', 'unambiguous'), 1), (('sequence', 'unpacking'), 1), (('unpacking', 'where'), 1), (('anything', 'that'), 1), (('assigned', '(to'), 1), (('associated', 'in'), 1), (('that', 'forming'), 1), (('the', 'left-hand'), 1), (('sign', 'that'), 1), (('iterated', 'through'), 1), (('the', 'produced'), 1), (('produced', 'values'), 1), (('format', 'strings'), 1), (('(\"blah\",', '2)'), 1), (('eggs=2\".', 'In'), 1), (('str', 'class,'), 1), (('=', '\"blah\";'), 1), (('integers', 'and'), 1), (('and', 'floats),'), 1), (('+', '\"eggs\"'), 1), (('strings', 'rather'), 1), (('returns', '\"22\".'), 1), (('\"22\".', 'Python'), 1), (('string', 'literals:'), 1), (('in', 'Unix'), 1), (('backslash', '(\\\\)'), 1), (('String', 'interpolation'), 1), (('Triple-quoted', '(beginning'), 1), (('with', 'three'), 1), (('which', 'may'), 1), (('multiple', 'lines'), 1), (('like', 'here'), 1), (('here', 'documents'), 1), (('in', 'shells,'), 1), (('Ruby.', 'Raw'), 1), (('string', 'varieties,'), 1), (('prefixing', 'the'), 1), (('hence', 'raw'), 1), (('raw', 'strings'), 1), (('strings', 'are'), 1), (('are', 'common,'), 1), (('and', 'array'), 1), (('denoted', 'as'), 1), (('a[start:stop:step].', 'Indexes'), 1), (('are', 'zero-based,'), 1), (('take', 'elements'), 1), (('the', 'start'), 1), (('step', 'or'), 1), (('list.', 'Each'), 1), (('Each', 'element'), 1), (('element', 'of'), 1), (('enforced,', 'in'), 1), (('or', 'Ruby.'), 1), (('to', 'duplicating'), 1), (('For', 'example:'), 1), (('functions', '(in'), 1), (('statements', 'Statements'), 1), (('expression—so', 'list'), 1), (('and', 'other'), 1), (('comprehensions', 'or'), 1), (('expressions,', 'all'), 1), (('being', 'expressions,'), 1), (('particular', 'case'), 1), (('is', 'that'), 1), (('Methods', 'on'), 1), ((\"object's\", 'class;'), 1), (('syntax', 'instance.method(argument)'), 1), (('sugar', 'for'), 1), (('some', 'other'), 1), (('languages', '(e.g.,'), 1), (('Java,', 'Objective-C,'), 1), (('also', 'provides'), 1), (('and', 'type'), 1), (('===', 'Typing'), 1), (('Typing', '==='), 1), (('has', 'typed'), 1), (('objects', 'but'), 1), (('but', 'untyped'), 1), (('compile', 'time;'), 1), (('an', 'object'), 1), (('object', 'may'), 1), (('signifying', 'that'), 1), (('being', 'dynamically'), 1), (('typed,', 'Python'), 1), (('typed,', 'forbidding'), 1), (('not', 'well-defined'), 1), (('than', 'silently'), 1), (('to', 'make'), 1), (('sense', 'of'), 1), (('own', 'types'), 1), (('types', 'using'), 1), (('for', 'object-oriented'), 1), (('type', '(itself'), 1), (('Before', 'version'), 1), (('version', '3.0,'), 1), (('two', 'kinds'), 1), (('(both', 'using'), 1), (('new-style;', 'current'), 1), (('by', 'external'), 1), (('as', 'mypy'), 1), (('Mypy', 'also'), 1), (('annotations', 'for'), 1), (('optimization.', '==='), 1), (('===', 'Arithmetic'), 1), (('Arithmetic', 'operations'), 1), (('-,', '*,'), 1), (('the', 'modulo'), 1), (('modulo', 'operation'), 1), (('%', '(where'), 1), (('the', 'remainder'), 1), (('4', '%'), 1), (('==', '-2).'), 1), (('and', '9**0.5'), 1), (('@', '.'), 1), (('represent', 'positive'), 1), (('respectively).', 'The'), 1), (('integers', 'produces'), 1), (('time:', 'Current'), 1), (('Current', 'Python'), 1), (('(i.e.', 'since'), 1), (('be', 'floating-point'), 1), (('2.5.', 'The'), 1), (('division', '//'), 1), (('//', 'operator'), 1), (('operator', 'was'), 1), (('2.0', 'and'), 1), (('and', '-7.5//3'), 1), (('-3.0.', 'Adding'), 1), (('Python', '3.0'), 1), (('simply', 'division),'), 1), (('division),', 'and'), 1), (('/', 'before'), 1), (('version', '3.0'), 1), (('is', 'classic'), 1), (('it', 'means'), 1), (('+', '1'), 1), (('equation', 'b*(a//b)'), 1), (('of', 'a.'), 1), (('maintaining', 'the'), 1), (('this', 'equation'), 1), (('half-open', 'interval'), 1), (('(b,', '0]'), 1), (('a', 'round'), 1), (('round', 'function'), 1), (('For', 'tie-breaking,'), 1), (('round', 'to'), 1), (('round(1.5)', 'and'), 1), (('round(-0.5)', 'is'), 1), (('Boolean', 'expressions'), 1), (('consistent', 'with'), 1), (('mathematics.', 'For'), 1), (('<', 'b'), 1), (('<', 'c'), 1), (('tests', 'whether'), 1), (('and', 'b'), 1), (('interpret', 'this'), 1), (('expression', 'differently:'), 1), (('C,', 'the'), 1), (('1,', 'and'), 1), (('would', 'then'), 1), (('be', 'compared'), 1), (('arithmetic', 'for'), 1), (('type/class', 'in'), 1), (('decimal', 'module'), 1), (('decimal', 'floating-point'), 1), (('and', 'several'), 1), (('provides', 'arbitrary'), 1), (('for', 'rational'), 1), (('Due', 'to'), 1), (('library,', 'and'), 1), (('is', 'frequently'), 1), (('as', 'numerical'), 1), (('Program', 'to'), 1), (('calculate', 'the'), 1), (('Libraries', '=='), 1), (('many', 'tasks'), 1), (('cited', 'as'), 1), (('For', 'Internet-facing'), 1), (('applications,', 'many'), 1), (('and', 'HTTP'), 1), (('for', 'creating'), 1), (('numbers,', 'arithmetic'), 1), (('manipulating', 'regular'), 1), (('specifications—for', 'example,'), 1), (('internal', 'documentation,'), 1), (('However,', 'because'), 1), (('third-party', 'Python'), 1), (('software,', 'contains'), 1), (('read–eval–print', 'loop'), 1), (('line', 'interpreter'), 1), (('development', 'environment'), 1), (('add', 'further'), 1), (('abilities', 'such'), 1), (('auto-completion,', 'session'), 1), (('session', 'state'), 1), (('as', 'standard'), 1), (('IntelliJ', 'Idea,'), 1), (('etc,', 'there'), 1), (('are', 'web'), 1), (('PythonAnywhere,', 'a'), 1), (('IDE', 'and'), 1), (('hosting', 'environment;'), 1), (('environment;', 'and'), 1), (('and', 'Canopy'), 1), (('IDE,', 'a'), 1), (('IDE', 'emphasizing'), 1), (('implementation', '==='), 1), (('meeting', 'the'), 1), (('features.', 'CPython'), 1), (('its', 'own'), 1), (('extensions,', 'but'), 1), (('limited', 'to'), 1), (('C++.', 'CPython'), 1), (('CPython', 'compiles'), 1), (('an', 'intermediate'), 1), (('bytecode', 'which'), 1), (('then', 'executed'), 1), (('virtual', 'machine.'), 1), (('library', 'written'), 1), (('mixture', 'of'), 1), (('is', 'available'), 1), (('including', 'Windows'), 1), (('Windows', '7'), 1), (('and', '8;'), 1), (('XP', 'was'), 1), (('macOS', '(and'), 1), (('unofficial', 'support'), 1), (('(During', 'Python'), 1), (('development,', 'even'), 1), (('support', 'has'), 1), (('been', 'dropped'), 1), (('dropped', 'for'), 1), (('many', 'platforms.)'), 1), (('systems', 'with'), 1), (('with', 'multi-threading'), 1), (('brings', 'a'), 1), (('improvement', 'over'), 1), (('with', 'it.'), 1), (('that', 'implements'), 1), (('implements', 'microthreads;'), 1), (('stackless', 'version.'), 1), (('optimized', 'for'), 1), (('Lego', 'Mindstorms'), 1), (('EV3.', 'Pyston'), 1), (('Python', 'runtime'), 1), (('uses', 'just-in-time'), 1), (('to', 'speed'), 1), (('Python', 'programs.'), 1), (('inline', 'caching,'), 1), (('JIT,', 'and'), 1), (('Computing', 'Language'), 1), (('Language', '(compatible'), 1), (('8-bit', 'AVR'), 1), (('AVR', 'microcontrollers'), 1), (('as', 'well'), 1), (('larger', 'ones'), 1), (('Python-inspired,', 'but'), 1), (('not', 'Python.'), 1), (('programs', 'that'), 1), (('but', 'most'), 1), (('most', 'Python'), 1), (('programs', 'will'), 1), (('not', 'run'), 1), (('Snek.\"', 'It'), 1), (('including', 'OOP'), 1), (('OOP', '/'), 1), (('and', 'simplifying'), 1), (('32-bit', 'single-precision'), 1), (('been', 'developed,'), 1), (('Google', 'began'), 1), (('aim', 'of'), 1), (('of', 'speeding'), 1), (('the', 'LLVM,'), 1), (('and', 'of'), 1), (('its', 'multithreading'), 1), (('cores,', 'while'), 1), (('suffer', 'from'), 1), (('that', 'integrates'), 1), (('integrates', 'with'), 1), (('bytecode', 'to'), 1), (('for', 'certain'), 1), (('than', 'the'), 1), (('later.', 'PyS60'), 1), (('by', 'Nokia'), 1), (('Symbian', 'operating'), 1), (('run', 'on'), 1), (('device.', '==='), 1), (('object', 'languages,'), 1), (('language:', 'Brython,'), 1), (('Transcrypt', 'and'), 1), (('(a', 'superset'), 1), (('of)', 'Python'), 1), (('C.', 'The'), 1), (('high-performance', 'Julia'), 1), (('Despite', 'claiming'), 1), (('no', 'tool'), 1), (('arbitrary', 'Python'), 1), (('i.e.', \"it's\"), 1), ((\"it's\", 'known'), 1), (('Unless', 'semantics'), 1), (('are', 'changed,'), 1), (('or', 'no'), 1), (('no', 'changes'), 1), (('code,', 'and'), 1), (('that', 'way.'), 1), (('be', 'compiled'), 1), (('to', 'C,'), 1), (('C,', 'and'), 1), (('Python', '→'), 1), (('converts', 'MyHDL'), 1), (('or', 'VHDL'), 1), (('projects', '(or'), 1), (('Python', '3.x'), 1), (('transpiles', 'Python'), 1), (('Go.', 'IronPython'), 1), (('in', '2021,'), 1), (('2021,', 'is'), 1), (('behaviors', 'from'), 1), (('Runtime.', 'Jython'), 1), (('to', 'Java'), 1), (('allowing', 'the'), 1), (('Performance', 'comparison'), 1), (('comparison', 'of'), 1), (('of', 'various'), 1), (('(combinatorial)', 'workload'), 1), (('at', 'EuroSciPy'), 1), (('languages', 'is'), 1), (('benchmarked', 'by'), 1), (('by', 'The'), 1), (('Benchmarks', 'Game.'), 1), (('is', 'conducted'), 1), (('proposing', 'major'), 1), (('input', 'on'), 1), (('reviewed', 'and'), 1), (('the', 'steering'), 1), (('steering', 'council.'), 1), (('implementation.', 'The'), 1), (('the', \"language's\"), 1), (('originally', 'discussed'), 1), (('discussed', 'in'), 1), (('the', 'Roundup'), 1), (('hosted', 'at'), 1), (('all', 'issues'), 1), (('GitHub.', 'Development'), 1), (('Mercurial,', 'until'), 1), (('types,', 'distinguished'), 1), (('and', 'needs'), 1), (('The', 'first'), 1), (('3.0', 'was'), 1), (('new', 'features.'), 1), (('The', 'second'), 1), (('these', 'releases'), 1), (('and', 'are'), 1), (('bugs', 'have'), 1), (('vulnerabilities', 'are'), 1), (('patched', 'in'), 1), (('releases.', 'The'), 1), (('beta,', 'and'), 1), (('each', 'release,'), 1), (('release,', 'they'), 1), (('are', 'often'), 1), (('ready.', \"Python's\"), 1), (('the', 'state'), 1), (('is', 'PyCon.'), 1), (('3.12', 'removed'), 1), (('3.10', 'added'), 1), (('already', 'deprecated'), 1), (('Part', 'of'), 1), (('emit', 'a'), 1), (('already', 'has'), 1), (('potential', 'for'), 1), (('Parts', 'of'), 1), (('arguments', 'to'), 1), (('fields', 'and'), 1), (('such', '(and'), 1), (('==', 'API'), 1), (('API', 'documentation'), 1), (('documentation', 'for'), 1), (('for', 'Python'), 1), (('Python', 'API'), 1), (('(available', 'as'), 1), (('Graphviz,', 'among'), 1), (('among', 'others.'), 1), (('derived', 'from'), 1), (('Rossum', 'enjoyed'), 1), (('developing', 'the'), 1), (('frequently', 'in'), 1), (('Python', 'literature'), 1), (('the', 'traditional'), 1), (('foo', 'and'), 1), (('documentation', 'also'), 1), (('routines.', 'Users'), 1), (('Py-', 'is'), 1), (('prefix', 'in'), 1), (('libraries', 'include'), 1), (('a', 'binding'), 1), (('of', 'SDL'), 1), (('and', 'GTK'), 1), (('respectively;', 'and'), 1), (('Python', 'implementation'), 1), (('implementation', 'originally'), 1), (('has', 'consistently'), 1), (('top', 'ten'), 1), (('Programming', 'Language'), 1), (('Language', 'of'), 1), (('rise', 'in'), 1), (('ratings', 'in'), 1), (('2010,', '2018,'), 1), (('and', '2020'), 1), (('Large', 'organizations'), 1), (('organizations', 'that'), 1), (('smaller', 'entities'), 1), (('site', 'Reddit'), 1), (('Gateway', 'Interface,'), 1), (('Web', 'frameworks'), 1), (('TurboGears,', 'web2py,'), 1), (('web2py,', 'Tornado,'), 1), (('and', 'maintenance'), 1), (('of', 'complex'), 1), (('complex', 'applications.'), 1), (('SQLAlchemy', 'can'), 1), (('relational', 'database.'), 1), (('a', 'framework'), 1), (('framework', 'to'), 1), (('example)', 'by'), 1), (('the', 'effective'), 1), (('specialized', 'libraries'), 1), (('as', 'Biopython'), 1), (('SageMath', 'is'), 1), (('computer', 'algebra'), 1), (('of', 'mathematics,'), 1), (('image', 'processing.'), 1), (('projects', 'and'), 1), (('TensorFlow,', 'Keras,'), 1), (('language', 'processing.'), 1), (('processing.', 'The'), 1), (('and', 'Prolog'), 1), (('has', 'proved'), 1), (('proved', 'to'), 1), (('useful', 'for'), 1), (('reasoning', 'capablities.'), 1), (('similarites', 'between'), 1), (('in', 'part'), 1), (('simple', 'recursive'), 1), (('include', 'natural'), 1), (('handling', 'of'), 1), (('semantic', 'web'), 1), (('(DCGs)', 'as'), 1), (('generators', 'for'), 1), (('text-to-image', 'generators'), 1), (('or', 'Stable'), 1), (('scripting', 'language,'), 1), (('parametric', 'modelers'), 1), (('modelers', 'like'), 1), (('Blender,', 'Cinema'), 1), (('Maya,', 'modo,'), 1), (('modo,', 'MotionBuilder,'), 1), (('imaging', 'programs'), 1), (('like', 'GIMP,'), 1), (('Scribus', 'and'), 1), (('musical', 'notation'), 1), (('scorewriter', 'and'), 1), (('a', 'pretty'), 1), (('complex', 'structures'), 1), (('C++', 'containers.'), 1), (('several', 'video'), 1), (('first', 'of'), 1), (('the', 'other'), 1), (('being', 'Java'), 1), (('Java', 'and'), 1), (('ships', 'with'), 1), (('(using', 'Python'), 1), (('2.7),', 'FreeBSD'), 1), (('a', 'package)'), 1), (('package)', 'and'), 1), (('Linux', 'distributions'), 1), (('installer,', 'while'), 1), (('and', 'Fedora'), 1), (('installer.', 'Gentoo'), 1), (('package', 'management'), 1), (('information', 'security'), 1), (('in', 'exploit'), 1), (('exploit', 'development.'), 1), (('Most', 'of'), 1), (('One', 'Laptop'), 1), (('Child', 'XO,'), 1), (('of', '2008,'), 1), (('computer', 'project'), 1), (('adopted', 'Python'), 1), (('includes', 'Python'), 1), (('with', 'Python.'), 1), (('Python', 'Scripting'), 1), (('feature', 'since'), 1), (('Languages', 'influenced'), 1), ((\"Python's\", 'design'), 1), (('similar', 'object'), 1), (('influenced', 'it.'), 1), (('it.', 'CoffeeScript,'), 1), (('from', 'Python.'), 1), (('Godot', 'game'), 1), (('designed', 'for'), 1), (('\"speed', 'of'), 1), (('like', 'Python\"'), 1), (('and', 'shares'), 1), (('motivated', 'by'), 1), (('to', 'Java.'), 1), (('Julia', 'was'), 1), (('Python\".', 'Mojo'), 1), (('Mojo', 'is'), 1), (('Nim', 'uses'), 1), (('creator,', 'Yukihiro'), 1), (('Yukihiro', 'Matsumoto,'), 1), (('than', 'Perl,'), 1), (('I', 'decided'), 1), (('decided', 'to'), 1), (('design', 'my'), 1), (('own', 'language.\"'), 1), (('Kotlin', 'blends'), 1), (('and', 'Java'), 1), (('features,', 'minimizing'), 1), (('languages.', 'For'), 1), (('practice', 'of'), 1), (('requiring', 'a'), 1), (('issues', 'surrounding,'), 1), (('a', 'change'), 1), (('also', 'used'), 1), (('Swift.', '=='), 1), (('Python', 'syntax'), 1), (('(package', 'manager)'), 1), (('languages', '=='), 1), (('==', 'References'), 1), (('References', '=='), 1), (('for', 'Artificial'), 1), (('Python', 'Wiki.'), 1), (('2012.', 'Archived'), 1), (('on', '1'), 1), (('Retrieved', '11'), 1), (('\"PyAIML', '0.8.5'), 1), (('Package', 'Index\".'), 1), (('Norvig,', 'Peter'), 1), (('(2009).', 'Artificial'), 1), (('ISBN', '978-0-13-604259-4.'), 1), (('Think', 'Python:'), 1), (('Naomi', '(5'), 1), (('Programming', 'Languages:'), 1), (('Retrieved', '31'), 1), (('(2013).', 'Learning'), 1), (('3', '(2nd'), 1), (('Addison-Wesley', 'Professional.'), 1), (('978-0-321-68056-3.', 'Ramalho,'), 1), (('Ramalho,', 'Luciano'), 1)]\n"
          ]
        }
      ],
      "source": [
        "rdd = sc.parallelize(dataset1)\n",
        "counts = generate_ngrams(rdd, 2)\n",
        "words = counts.collect()\n",
        "print(words)\n",
        "if os.path.exists(output_dir):\n",
        "    shutil.rmtree(output_dir)\n",
        "\n",
        "counts.coalesce(1).saveAsTextFile(output_dir)"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Step10: Clean the Garbage files"
      ],
      "metadata": {
        "id": "vnVaJa7PsRuL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!mv \"/content/output.txt/part-00000\" \"/content/result.txt\""
      ],
      "metadata": {
        "id": "ZsRHEcQVsWZv"
      },
      "execution_count": 265,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!rm -r \"/content/output.txt\""
      ],
      "metadata": {
        "id": "0Qq4v1jStNTF"
      },
      "execution_count": 266,
      "outputs": []
    }
  ]
}