result.txt

(('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)