pax_global_header00006660000000000000000000000064142163574670014531gustar00rootroot0000000000000052 comment=db0638dcb22a26bec20a2c6ea3bddd8066f11ff3 setuptools-rust-1.2.0/000077500000000000000000000000001421635746700147455ustar00rootroot00000000000000setuptools-rust-1.2.0/.gitattributes000066400000000000000000000000601421635746700176340ustar00rootroot00000000000000html-py-ever/test/*.html linguist-vendored=true setuptools-rust-1.2.0/.github/000077500000000000000000000000001421635746700163055ustar00rootroot00000000000000setuptools-rust-1.2.0/.github/dependabot.yml000066400000000000000000000007261421635746700211420ustar00rootroot00000000000000version: 2 updates: - package-ecosystem: "cargo" directory: "examples/hello-world" schedule: interval: "monthly" - package-ecosystem: "cargo" directory: "examples/html-py-ever" schedule: interval: "monthly" - package-ecosystem: "cargo" directory: "examples/namespace_package" schedule: interval: "monthly" - package-ecosystem: "cargo" directory: "examples/rust_with_cffi" schedule: interval: "monthly" setuptools-rust-1.2.0/.github/workflows/000077500000000000000000000000001421635746700203425ustar00rootroot00000000000000setuptools-rust-1.2.0/.github/workflows/ci.yml000066400000000000000000000300421421635746700214570ustar00rootroot00000000000000name: CI on: push: branches: - main pull_request: concurrency: group: ${{ github.workflow }}-${{ github.ref_name }}-${{ github.event.pull_request.number || github.sha }} cancel-in-progress: true jobs: fmt: runs-on: "ubuntu-latest" steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: "3.x" - run: pip install black - run: black --check . mypy: runs-on: "ubuntu-latest" steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: "3.x" - run: pip install tox - run: tox -e mypy pytest: runs-on: "ubuntu-latest" steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: "3.x" - run: pip install tox - run: tox -e pytest build: name: ${{ matrix.python-version }} ${{ matrix.platform.os }}-${{ matrix.platform.python-architecture }} runs-on: ${{ matrix.platform.os }} strategy: # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }} matrix: python-version: ["3.7", "3.8", "3.9", "3.10", pypy-3.7, pypy-3.8] platform: [ { os: "macos-latest", python-architecture: "x64", rust-target: "x86_64-apple-darwin" }, { os: "ubuntu-latest", python-architecture: "x64", rust-target: "x86_64-unknown-linux-gnu" }, { os: "windows-latest", python-architecture: "x64", rust-target: "x86_64-pc-windows-msvc" }, { os: "windows-latest", python-architecture: "x86", rust-target: "i686-pc-windows-msvc" }, ] exclude: # No 32-bit pypy 3.7 on Windows - python-version: pypy-3.7 platform: { os: "windows-latest", python-architecture: "x86" } # No 32-bit pypy 3.8 on Windows - python-version: pypy-3.8 platform: { os: "windows-latest", python-architecture: "x86" } steps: - uses: actions/checkout@v3 - name: Set up Python ${{ matrix.python-version }} uses: actions/setup-python@v2 with: python-version: ${{ matrix.python-version }} architecture: ${{ matrix.platform.python-architecture }} - name: Install Rust toolchain uses: actions-rs/toolchain@v1 with: toolchain: stable target: ${{ matrix.platform.rust-target }} profile: minimal default: true - name: Install Rust aarch64-apple-darwin target if: matrix.platform.os == 'macos-latest' run: rustup target add aarch64-apple-darwin - name: Install test dependencies run: pip install --upgrade nox - name: Build package run: pip install -e . - name: Test examples shell: bash env: PYTHON: ${{ matrix.python-version }} run: nox -s test-examples - name: Test macOS universal2 if: matrix.platform.os == 'macos-latest' && !startsWith(matrix.python-version, 'pypy') shell: bash env: DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer MACOSX_DEPLOYMENT_TARGET: '10.9' ARCHFLAGS: -arch x86_64 -arch arm64 PYO3_CROSS_LIB_DIR: /Applications/Xcode.app/Contents/Developer/Library/Frameworks/Python3.framework/Versions/3.8/lib run: | cd examples/namespace_package pip install wheel python setup.py bdist_wheel ls -l dist/ pip install --force-reinstall dist/namespace_package*_universal2.whl cd - python -c "from namespace_package import rust; assert rust.rust_func() == 14" python -c "from namespace_package import python; assert python.python_func() == 15" - name: Test sdist vendor Rust crates shell: bash run: | cd examples/namespace_package python setup.py sdist --vendor-crates cd dist tar -zxf namespace_package-0.1.0.tar.gz cd namespace_package-0.1.0 cargo build --offline --target ${{ matrix.platform.rust-target }} test-abi3: runs-on: ${{ matrix.os }} strategy: # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }} matrix: os: [ubuntu-latest, macos-latest, windows-latest] steps: - uses: actions/checkout@master - name: Setup python uses: actions/setup-python@v2 with: python-version: 3.9 - uses: actions-rs/toolchain@v1 with: profile: minimal toolchain: stable override: true - name: Install Rust aarch64-apple-darwin target if: matrix.os == 'macos-latest' run: rustup target add aarch64-apple-darwin - name: Build package run: pip install -e . - name: Build an abi3 wheel shell: bash run: | cd examples/rust_with_cffi/ python --version pip install -U wheel python setup.py bdist_wheel --py-limited-api=cp39 ls -la dist/ env: # https://github.com/actions/setup-python/issues/26 MACOSX_DEPLOYMENT_TARGET: 10.9 # Now we switch to a differnet Python version and ensure we can install # the wheel we just built. - name: Setup python uses: actions/setup-python@v2 with: python-version: "3.10" - name: Install abi3 wheel and run tests shell: bash run: | cd examples/ pip install -U wheel python --version pip install rust_with_cffi/dist/rust_with_cffi*.whl python -c "from rust_with_cffi import rust; assert rust.rust_func() == 14" python -c "from rust_with_cffi.cffi import lib; assert lib.cffi_func() == 15" test-cross-compile: runs-on: ubuntu-latest strategy: # If one platform fails, allow the rest to keep testing if `CI-no-fail-fast` label is present fail-fast: ${{ !contains(github.event.pull_request.labels.*.name, 'CI-no-fail-fast') }} matrix: platform: [ { target: "aarch64-unknown-linux-gnu", arch: "aarch64" }, { target: "armv7-unknown-linux-gnueabihf", arch: "armv7" }, ] steps: - uses: actions/checkout@master - name: Build wheels run: | echo 'curl -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain stable source ~/.cargo/env rustup target add ${{ matrix.platform.target }} cd examples/rust_with_cffi/ python3.9 -m pip install crossenv python3.9 -m crossenv "/opt/python/cp39-cp39/bin/python3" --cc $TARGET_CC --cxx $TARGET_CXX --sysroot $TARGET_SYSROOT --env LIBRARY_PATH= --manylinux manylinux1 venv . venv/bin/activate build-pip install cffi wheel cross-expose cffi pip install wheel pip install -e ../../ python setup.py bdist_wheel --py-limited-api=cp37 ls -la dist/ ' > build-wheels.sh docker run --rm -v "$PWD":/io -w /io messense/manylinux2014-cross:${{ matrix.platform.arch }} bash build-wheels.sh - name: Install abi3 wheel and run tests uses: uraimo/run-on-arch-action@v2.0.5 with: arch: ${{ matrix.platform.arch }} distro: ubuntu20.04 dockerRunArgs: | --volume "${PWD}/examples:/examples" install: | apt-get update apt-get install -y --no-install-recommends python3 python3-dev python3-pip build-essential libffi-dev run: | cd /examples python3 --version pip3 install rust_with_cffi/dist/rust_with_cffi*.whl python3 -c "from rust_with_cffi import rust; assert rust.rust_func() == 14" python3 -c "from rust_with_cffi.cffi import lib; assert lib.cffi_func() == 15" test-cross: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Setup python uses: actions/setup-python@v2 with: python-version: 3.8 - uses: actions-rs/toolchain@v1 with: profile: minimal toolchain: stable override: true - name: Install cross run: cargo install cross - name: Build package run: pip install -e . - name: Build wheel using cross shell: bash env: CARGO: cross CARGO_BUILD_TARGET: aarch64-unknown-linux-gnu PYO3_CROSS_LIB_DIR: /opt/python/cp38-cp38/lib run: | cd examples/namespace_package docker build -t cross-pyo3:aarch64-unknown-linux-gnu . python -m pip install wheel python setup.py bdist_wheel --plat-name manylinux2014_aarch64 ls -la dist/ - uses: uraimo/run-on-arch-action@v2.1.1 name: Install built wheel with: arch: aarch64 distro: ubuntu20.04 dockerRunArgs: | --volume "${PWD}/examples/namespace_package:/io" install: | apt-get update apt-get install -y --no-install-recommends python3 python3-pip pip3 install -U pip run: | pip3 install namespace_package --no-index --find-links /io/dist/ --force-reinstall python3 -c "from namespace_package import rust; assert rust.rust_func() == 14" python3 -c "from namespace_package import python; assert python.python_func() == 15" test-zigbuild: runs-on: ubuntu-latest steps: - uses: actions/checkout@v3 - name: Setup python uses: actions/setup-python@v2 with: python-version: 3.8 - uses: actions-rs/toolchain@v1 with: profile: minimal toolchain: stable target: aarch64-unknown-linux-gnu override: true - name: Install cargo-zigbuild run: | cargo install cargo-zigbuild python3 -m pip install ziglang - name: Build package run: pip install -e . - name: Build wheel using cargo-zigbuild shell: bash env: CARGO: cargo-zigbuild CARGO_BUILD_TARGET: aarch64-unknown-linux-gnu PYO3_CROSS_LIB_DIR: /opt/python/cp38-cp38/lib run: | mkdir -p $PYO3_CROSS_LIB_DIR docker cp -L $(docker create --rm quay.io/pypa/manylinux2014_aarch64:latest):/opt/python/cp38-cp38 /opt/python cd examples/namespace_package python -m pip install wheel python setup.py bdist_wheel --plat-name manylinux2014_aarch64 ls -la dist/ - uses: uraimo/run-on-arch-action@v2.1.1 name: Install built wheel with: arch: aarch64 distro: ubuntu20.04 dockerRunArgs: | --volume "${PWD}/examples/namespace_package:/io" install: | apt-get update apt-get install -y --no-install-recommends python3 python3-pip pip3 install -U pip run: | pip3 install namespace_package --no-index --find-links /io/dist/ --force-reinstall python3 -c "from namespace_package import rust; assert rust.rust_func() == 14" python3 -c "from namespace_package import python; assert python.python_func() == 15" test-cibuildwheel: runs-on: macos-latest steps: - uses: actions/checkout@v3 - uses: actions-rs/toolchain@v1 with: profile: minimal toolchain: stable target: aarch64-apple-darwin override: true - uses: pypa/cibuildwheel@v2.3.1 env: CIBW_BUILD: cp39-* CIBW_BEFORE_BUILD: pip install -e . CIBW_ARCHS_MACOS: "x86_64 universal2 arm64" CIBW_BUILD_VERBOSITY: 1 with: package-dir: examples/namespace_package setuptools-rust-1.2.0/.github/workflows/python-publish.yml000066400000000000000000000017361421635746700240610ustar00rootroot00000000000000# This workflows will upload a Python Package using Twine when a release is created # For more information see: https://help.github.com/en/actions/language-and-framework-guides/using-python-with-github-actions#publishing-to-package-registries name: Upload Python Package on: release: types: [published] workflow_dispatch: jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 with: # Fetch all history so that setuptools_scm works correctly fetch-depth: 0 - name: Set up Python uses: actions/setup-python@v2 with: python-version: '3.x' - name: Install dependencies run: | python -m pip install --upgrade pip pip install setuptools wheel twine - name: Build and publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | python setup.py sdist bdist_wheel twine upload dist/* setuptools-rust-1.2.0/.gitignore000066400000000000000000000001631421635746700167350ustar00rootroot00000000000000*.pyc *.pyo *.so .eggs .tox dist build target .pytest_cache *.egg-info setuptools_rust/version.py pyo3 docs/_build setuptools-rust-1.2.0/.readthedocs.yaml000066400000000000000000000001511421635746700201710ustar00rootroot00000000000000version: 2 python: install: - requirements: docs/requirements.txt - method: pip path: . setuptools-rust-1.2.0/CHANGELOG.md000066400000000000000000000217041421635746700165620ustar00rootroot00000000000000# Changelog ## 1.2.0 (2022-03-22) ### Packaging - Drop support for Python 3.6. [#209](https://github.com/PyO3/setuptools-rust/pull/209) ### Added - Add support for `kebab-case` executable names. [#205](https://github.com/PyO3/setuptools-rust/pull/205) - Add support for custom cargo profiles. [#216](https://github.com/PyO3/setuptools-rust/pull/216) ### Fixed - Fix building macOS arm64 wheel with cibuildwheel. [#217](https://github.com/PyO3/setuptools-rust/pull/217) ## 1.1.2 (2021-12-05) ### Changed - Removed dependency on `tomli` to simplify installation. [#200](https://github.com/PyO3/setuptools-rust/pull/200) - Improve error messages on invalid inputs to `rust_extensions` keyword. [#203](https://github.com/PyO3/setuptools-rust/pull/203) ## 1.1.1 (2021-12-01) ### Fixed - Fix regression from `setuptools-rust` 1.1.0 which broke builds for the `x86_64-unknown-linux-musl` target. [#194](https://github.com/PyO3/setuptools-rust/pull/194) - Fix `--target` command line option being unable to take a value. [#195](https://github.com/PyO3/setuptools-rust/pull/195) - Fix regression from `setuptools-rust` 1.0.0 which broke builds on arm64 macos conda builds. [#196](https://github.com/PyO3/setuptools-rust/pull/196) - Fix regression from `setuptools-rust` 1.1.0 which incorrectly converted library extension suffixes to the "abi3" suffix when `py_limited_api` was unspecified. [#197](https://github.com/PyO3/setuptools-rust/pull/197) ## 1.1.0 (2021-11-30) ### Added - Add support for cross-compiling using [`cross`](https://github.com/rust-embedded/cross). [#185](https://github.com/PyO3/setuptools-rust/pull/185) ### Fixed - Fix incompatibility with Python 3.6.0 using default values for NamedTuple classes. [#184](https://github.com/PyO3/setuptools-rust/pull/184) - Stop forcing the `msvc` Rust toolchain for Windows environments using the `gnu` toolchain. [#187](https://github.com/PyO3/setuptools-rust/pull/187) ## 1.0.0 (2021-11-21) ### Added - Add `--target` command line option for specifying target triple. [#136](https://github.com/PyO3/setuptools-rust/pull/136) - Add new default `"auto"` setting for `RustExtension.py_limited_api`. [#137](https://github.com/PyO3/setuptools-rust/pull/137) - Support very verbose cargo build.rs output. [#140](https://github.com/PyO3/setuptools-rust/pull/140) ### Changed - Switch to `tomli` dependency. [#174](https://github.com/PyO3/setuptools-rust/pull/174) ### Removed - Remove `test_rust` command. (`python setup.py test` is deprecated.) [#129](https://github.com/PyO3/setuptools-rust/pull/129) - Remove `check_rust` command. [#131](https://github.com/PyO3/setuptools-rust/pull/131) - Move `tomlgen_rust` command to separate `setuptools-rust-tomlgen` package. [#167](https://github.com/PyO3/setuptools-rust/pull/167) ### Fixed - Use info from sysconfig when cross-compiling. [#139](https://github.com/PyO3/setuptools-rust/pull/139) - Put Rust extension module binary under `build/lib.*` directory. [#150](https://github.com/PyO3/setuptools-rust/pull/150) - Fix `Exec` binding with console scripts. [#154](https://github.com/PyO3/setuptools-rust/pull/154) ## 0.12.1 (2021-03-11) ### Fixed - Fix some files unexpectedly missing from `sdist` command output. [#125](https://github.com/PyO3/setuptools-rust/pull/125) ## 0.12.0 (2021-03-08) ### Packaging - Bump minimum Python version to Python 3.6. ### Added - Support building x86-64 wheel on arm64 macOS machine. [#114](https://github.com/PyO3/setuptools-rust/pull/114) - Add macOS universal2 wheel building support. [#115](https://github.com/PyO3/setuptools-rust/pull/115) - Add option to cargo vendor crates into sdist. [#118](https://github.com/PyO3/setuptools-rust/pull/118) ### Changed - Respect `PYO3_PYTHON` and `PYTHON_SYS_EXECUTABLE` environment variables if set. [#96](https://github.com/PyO3/setuptools-rust/pull/96) - Add runtime dependency on setuptools >= 46.1. [#102](https://github.com/PyO3/setuptools-rust/pull/102) - Append to, rather than replace, existing `RUSTFLAGS` when building. [#103](https://github.com/PyO3/setuptools-rust/pull/103) ### Fixed - Set executable bit on shared library. [#110](https://github.com/PyO3/setuptools-rust/pull/110) - Don't require optional `wheel` dependency. [#111](https://github.com/PyO3/setuptools-rust/pull/111) - Set a more reasonable LC_ID_DYLIB entry on macOS. [#119](https://github.com/PyO3/setuptools-rust/pull/119) ## 0.11.6 (2020-12-13) - Respect `CARGO_BUILD_TARGET` environment variable if set. [#90](https://github.com/PyO3/setuptools-rust/pull/90) - Add `setuptools_rust.__version__` and require setuptools >= 46.1. [#93](https://github.com/PyO3/setuptools-rust/pull/93) ## 0.11.5 (2020-11-10) - Fix support for Python 3.5. [#86](https://github.com/PyO3/setuptools-rust/pull/86) - Fix further cases of building for 32-bit Python on 64-bit Windows. [#87](https://github.com/PyO3/setuptools-rust/pull/87) ## 0.11.4 (2020-11-03) - Fix `tomlgen` functionality on Windows. [#78](https://github.com/PyO3/setuptools-rust/pull/78) - Add support for building abi3 shared objects. [#82](https://github.com/PyO3/setuptools-rust/pull/82) ## 0.11.3 (2020-08-24) - Fix building on Linux distributions that use musl (e.g. Alpine) out of the box. [#80](https://github.com/PyO3/setuptools-rust/pull/80) ## 0.11.2 (2020-08-10) - Fix support for namespace packages. [#79](https://github.com/PyO3/setuptools-rust/pull/79) ## 0.11.1 (2020-08-07) - Fix building for 32-bit Python on 64-bit Windows. [#77](https://github.com/PyO3/setuptools-rust/pull/77) ## 0.11.0 (2020-08-06) - Remove python 2 support. [#53](https://github.com/PyO3/setuptools-rust/pull/53) - Fix compatibility with `cffi`. [#68](https://github.com/PyO3/setuptools-rust/pull/68) - Add support for pyo3 `0.12`'s `PYO3_PYTHON` setting. [#71](https://github.com/PyO3/setuptools-rust/pull/71) ## 0.10.6 (2018-11-07) - Fix tomlgen\_rust generating invalid `Cargo.toml` files. - Fix tomlgen\_rust setting wrong path in `.cargo/config`. ## 0.10.5 (2018-09-09) - Added license file [#41](https://github.com/PyO3/setuptools-rust/pull/41) ## 0.10.4 (2018-09-09) - Add `html-py-ever` example ## 0.10.3 (2018-09-06) - `path` in `RustExtension` now defaults to `Cargo.toml` ## 0.10.2 (2018-08-09) - Add `rustc_flags` and `verbose` as options - Adopted black code style - Moved changelog to markdown ## 0.10.0 (2018-05-06) - This release significantly improves performance ## 0.9.2 (2018-05-11) - Fix build\_rust crashing on Cargo.toml manifests without a name key in the \[lib\] section - Fix single quotes not being handled when parsing Cargo.toml ## 0.9.1 (2018-03-22) - Remove unicode\_literals import as Python 2 `distutils` does not support Unicode ## 0.9.0 (2018-03-07) - Find inplace extensions and automatically generate `Cargo.toml` manifests \#29 ## 0.8.4 (2018-02-27) - Improve compatibility of build\_rust with build\_ext \#28 ## 0.8.3 (2017-12-05) - Ignore strip option when platform is win32 \#26 ## 0.8.2 (2017-09-08) - Fix script generation for bdist\_wheel ## 0.8.1 (2017-09-08) - Added native parameter - Fix script generation for executables ## 0.8.0 (2017-09-05) - Support multiple rust binaries \#24 ## 0.7.2 (2017-09-01) - Generate console-script for Binding.Exec \#22 - Do not run cargo check for sdist command \#18 - Remove extra python3 file extension for executables. ## 0.7.1 (2017-08-18) - Allow to strip symbols from executable or dynamic library. - Use PyO3 0.2 for example. ## 0.7.0 (2017-08-11) - Allow to build executable and pack with python package. - Use PyO3 0.1 for example. ## 0.6.4 (2017-07-31) - check command respects optional option - Don't fail when Rust isn't installed while all extensions are optional ## 0.6.3 (2017-07-31) - Fix pypi source distribution ## 0.6.2 (2017-07-31) - Add optional option to RustExtension \#16 ## 0.6.1 (2017-06-30) - Support CARGO\_TARGET\_DIR variable \#14 ## 0.6.0 (2017-06-20) - Add support for PyO3 project - Add support for no-binding mode ## 0.5.1 (2017-05-03) - Added support for "cargo test" - Fixed unbound method type error \#4 ## 0.5.0 (2017-03-26) - Added support for "cargo check" ## 0.4.2 (2017-03-15) - Added "--qbuild" option for "build\_rust" command. Set "quiet" mode for all extensions. - Added "--debug" and "--release" options for "build\_rust" command. ## 0.4.1 (2017-03-10) - Fixed cargo manifest absolute path detection ## 0.4 (2017-03-10) - Fixed bdist\_egg and bdist\_wheel support - setuptool's clean command cleans rust project as well - Use absolute path to cargo manifest - Enable debug builds for inplace builds, otherwise build release - Simplify monkey patches ## 0.3.1 (2017-03-09) - Fix compatibility with some old versions of setuptools ## 0.3 (2017-03-09) - Fixed OSX extension compilation - Use distutils exceptions for errors - Add rust version check for extension - Cleanup example project ## 0.2 (2017-03-08) - Fix bdist\_egg and bdist\_wheel commands ## 0.1 (2017-03-08) - Initial release setuptools-rust-1.2.0/LICENSE000066400000000000000000000021011421635746700157440ustar00rootroot00000000000000MIT License Copyright (c) 2017-2018 PyO3 project & contributors Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. setuptools-rust-1.2.0/MANIFEST.in000066400000000000000000000000671421635746700165060ustar00rootroot00000000000000include README.md include CHANGELOG.md include LICENSE setuptools-rust-1.2.0/README.md000066400000000000000000000066471421635746700162410ustar00rootroot00000000000000# Setuptools plugin for Rust extensions [![github actions](https://github.com/PyO3/setuptools-rust/actions/workflows/ci.yml/badge.svg)](https://github.com/PyO3/setuptools-rust/actions/workflows/ci.yml) [![pypi package](https://badge.fury.io/py/setuptools-rust.svg)](https://pypi.org/project/setuptools-rust/) [![readthedocs](https://readthedocs.org/projects/pip/badge/)](https://setuptools-rust.readthedocs.io/en/latest/) [![code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black) `setuptools-rust` is a plugin for `setuptools` to build Rust Python extensions implemented with [PyO3](https://github.com/PyO3/pyo3) or [rust-cpython](https://github.com/dgrunwald/rust-cpython). Compile and distribute Python extensions written in Rust as easily as if they were written in C. ## Setup For a complete example, see [html-py-ever](https://github.com/PyO3/setuptools-rust/tree/main/examples/html-py-ever). First, you need to create a bunch of files: ### setup.py ```python from setuptools import setup from setuptools_rust import Binding, RustExtension setup( name="hello-rust", version="1.0", rust_extensions=[RustExtension("hello_rust.hello_rust", binding=Binding.PyO3)], packages=["hello_rust"], # rust extensions are not zip safe, just like C-extensions. zip_safe=False, ) ``` For a complete reference of the options supported by the `RustExtension` class, see the [API reference](https://setuptools-rust.readthedocs.io/en/latest/reference.html). ### pyproject.toml ```toml [build-system] requires = ["setuptools", "wheel", "setuptools-rust"] ``` ### MANIFEST.in This file is required for building source distributions ```text include Cargo.toml recursive-include src * ``` ## Usage You can use same commands as for c-extensions. For example: ``` >>> python ./setup.py develop running develop running egg_info writing hello-rust.egg-info/PKG-INFO writing top-level names to hello_rust.egg-info/top_level.txt writing dependency_links to hello_rust.egg-info/dependency_links.txt reading manifest file 'hello_rust.egg-info/SOURCES.txt' writing manifest file 'hello_rust.egg-info/SOURCES.txt' running build_ext running build_rust cargo build --manifest-path extensions/Cargo.toml --features python3 Finished debug [unoptimized + debuginfo] target(s) in 0.0 secs Creating /.../lib/python3.6/site-packages/hello_rust.egg-link (link to .) Installed hello_rust Processing dependencies for hello_rust==1.0 Finished processing dependencies for hello_rust==1.0 ``` Or you can use commands like `bdist_wheel` (after installing `wheel`). See also [the notes in the documentation about building wheels](https://setuptools-rust.readthedocs.io/en/latest/building_wheels.html). Cross-compiling is also supported, using one of [`crossenv`](https://github.com/benfogle/crossenv), [`cross`](https://github.com/rust-embedded/cross) or [`cargo-zigbuild`](https://github.com/messense/cargo-zigbuild). For examples see the `test-cross-compile` and `test-cross` and `test-zigbuild` Github actions jobs in [`ci.yml`](https://github.com/PyO3/setuptools-rust/blob/main/.github/workflows/ci.yml). By default, `develop` will create a debug build, while `install` will create a release build. ## Commands - `build` - Standard build command will also build all rust extensions. - `build_rust` - Command builds all rust extensions. - `clean` - Standard clean command executes cargo clean for all rust extensions. setuptools-rust-1.2.0/docs/000077500000000000000000000000001421635746700156755ustar00rootroot00000000000000setuptools-rust-1.2.0/docs/Makefile000066400000000000000000000011721421635746700173360ustar00rootroot00000000000000# Minimal makefile for Sphinx documentation # # You can set these variables from the command line, and also # from the environment for the first two. SPHINXOPTS ?= SPHINXBUILD ?= sphinx-build SOURCEDIR = . BUILDDIR = _build # Put it first so that "make" without argument is like "make help". help: @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) .PHONY: help Makefile # Catch-all target: route all unknown targets to Sphinx using the new # "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). %: Makefile @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) setuptools-rust-1.2.0/docs/README.md000066400000000000000000000000361421635746700171530ustar00rootroot00000000000000```{include} ../README.md ``` setuptools-rust-1.2.0/docs/building_wheels.md000066400000000000000000000060721421635746700213700ustar00rootroot00000000000000# Building wheels Because `setuptools-rust` is an extension to `setuptools`, the standard `setup.py bdist_wheel` command is used to build distributable wheels. These wheels can be uploaded to PyPI using standard tools such as [twine](https://github.com/pypa/twine). `setuptools-rust` supports building for the [PEP 384](https://www.python.org/dev/peps/pep-0384/) "stable" (aka "limited") API when the `--py-limited-api` option is passed to `setup.py bdist_wheel`. If using PyO3 bindings for `RustExtension`, then the correct [`pyo3/abi3`](https://pyo3.rs/v0.14.5/features.html#abi3) sub-feature is automatically enabled. In this way, abi3 wheels can be uploaded to make package distributors' roles easier, and package users installing from source with `python setup.py install` can use optimizations specific to their Python version. This chapter of the documentation explains two possible ways to build wheels for multiple Python versions below. ## Using `cibuildwheel` [`cibuildwheel`][cibuildwheel] is a tool to build wheels for multiple platforms using Github Actions. The [`rtoml` package does this, for example](https://github.com/samuelcolvin/rtoml/blob/143ee0907bba616cbcd5cc58eefe9000fcc2b5f2/.github/workflows/ci.yml#L99-L195). ## Building manually Place a script called `build-wheels.sh` with the following contents in your project root (next to the `setup.py` file): ```{eval-rst} .. literalinclude:: ../examples/html-py-ever/build-wheels.sh :language: bash ``` This script can be used to produce wheels for multiple Python versions. ### Binary wheels on linux To build binary wheels on linux, you need to use the [manylinux docker container](https://github.com/pypa/manylinux). You will run the `build-wheels.sh` from above inside that container. First, pull the `manylinux2014` Docker image: ```bash docker pull quay.io/pypa/manylinux2014_x86_64 ``` Then use the following command to build wheels for supported Python versions: ```bash docker run --rm -v `pwd`:/io quay.io/pypa/manylinux2014_x86_64 bash /io/build-wheels.sh ``` This will create wheels in the `dist` directory: ```bash $ ls dist hello_rust-0.1.0-cp37-cp37m-linux_x86_64.whl hello_rust-0.1.0-cp37-cp37m-manylinux2014_x86_64.whl hello_rust-0.1.0-cp38-cp38-linux_x86_64.whl hello_rust-0.1.0-cp38-cp38-manylinux2014_x86_64.whl hello_rust-0.1.0-cp39-cp39-linux_x86_64.whl hello_rust-0.1.0-cp39-cp39-manylinux2014_x86_64.whl ``` It is possible to use any of the `manylinux` docker images: `manylinux1`, `manylinux2010` or `manylinux2014`. (Just replace `manylinux2014` in the above instructions with the alternative version you wish to use.) ### Binary wheels on macOS For building wheels on macOS it is sufficient to run the `bdist_wheel` command, i.e. `setup.py bdist_wheel`. To build `universal2` wheels set the `ARCHFLAGS` environment variable to contain both `x86_64` and `arm64`, for example `ARCHFLAGS="-arch x86_64 -arch arm64"`. Wheel-building solutions such as [`cibuildwheel`][cibuildwheel] set this environment variable automatically. [cibuildwheel]: https://github.com/pypa/cibuildwheel setuptools-rust-1.2.0/docs/conf.py000066400000000000000000000057461421635746700172100ustar00rootroot00000000000000# Configuration file for the Sphinx documentation builder. # # This file only contains a selection of the most common options. For a full # list see the documentation: # https://www.sphinx-doc.org/en/master/usage/configuration.html # -- Path setup -------------------------------------------------------------- # If extensions (or modules to document with autodoc) are in another directory, # add these directories to sys.path here. If the directory is relative to the # documentation root, use os.path.abspath to make it absolute, like shown here. # -- Project information ----------------------------------------------------- project = "setuptools-rust" copyright = "2021, The PyO3 Contributors" author = "The PyO3 Contributors" # -- General configuration --------------------------------------------------- # Add any Sphinx extension module names here, as strings. They can be # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom # ones. extensions = [ "sphinx.ext.autodoc", "sphinx.ext.napoleon", "sphinx_autodoc_typehints", "myst_parser", ] # Add any paths that contain templates here, relative to this directory. templates_path = ["_templates"] # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. exclude_patterns = ["_build", "Thumbs.db", ".DS_Store"] # -- Options for HTML output ------------------------------------------------- # The theme to use for HTML and HTML Help pages. See the documentation for # a list of builtin themes. # html_theme = "furo" # Add any paths that contain custom static files (such as style sheets) here, # relative to this directory. They are copied after the builtin static files, # so a file named "default.css" will overwrite the builtin "default.css". html_static_path = ["_static"] html_theme_options = {} # -- Custom HTML link transformation to make documentation links relative -- # This is necessary because the README.md (for example) has links to the latest # documentation, but we want them to be relative to the specific docs version. from sphinx.transforms import SphinxTransform DOCS_URL = "https://setuptools-rust.readthedocs.io/en/latest/" class RelativeDocLinks(SphinxTransform): default_priority = 750 def apply(self): from docutils.nodes import Text, reference baseref = lambda o: ( isinstance(o, reference) and o.get("refuri", "").startswith(DOCS_URL) ) basetext = lambda o: (isinstance(o, Text) and o.startswith(DOCS_URL)) for node in self.document.traverse(baseref): target = node["refuri"].replace(DOCS_URL, "", 1) node.replace_attr("refuri", target) for t in node.traverse(basetext): t1 = Text(t.replace(DOCS_URL, "", 1), t.rawsource) t.parent.replace(t, t1) return # end of class def setup(app): app.add_transform(RelativeDocLinks) return setuptools-rust-1.2.0/docs/index.md000066400000000000000000000002101421635746700173170ustar00rootroot00000000000000```{eval-rst} .. toctree:: :maxdepth: 2 :hidden: README.md building_wheels reference ``` ```{include} ../README.md ``` setuptools-rust-1.2.0/docs/make.bat000066400000000000000000000014331421635746700173030ustar00rootroot00000000000000@ECHO OFF pushd %~dp0 REM Command file for Sphinx documentation if "%SPHINXBUILD%" == "" ( set SPHINXBUILD=sphinx-build ) set SOURCEDIR=. set BUILDDIR=_build if "%1" == "" goto help %SPHINXBUILD% >NUL 2>NUL if errorlevel 9009 ( echo. echo.The 'sphinx-build' command was not found. Make sure you have Sphinx echo.installed, then set the SPHINXBUILD environment variable to point echo.to the full path of the 'sphinx-build' executable. Alternatively you echo.may add the Sphinx directory to PATH. echo. echo.If you don't have Sphinx installed, grab it from echo.http://sphinx-doc.org/ exit /b 1 ) %SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% goto end :help %SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% :end popd setuptools-rust-1.2.0/docs/reference.rst000066400000000000000000000002061421635746700203630ustar00rootroot00000000000000API Reference ============= .. py:module:: setuptools_rust .. autoclass:: RustExtension .. autoclass:: Binding .. autoclass:: Strip setuptools-rust-1.2.0/docs/requirements.txt000066400000000000000000000001231421635746700211550ustar00rootroot00000000000000Sphinx==4.1.2 sphinx-autodoc-typehints==1.12.0 furo==2021.8.31 myst-parser==0.15.2 setuptools-rust-1.2.0/examples/000077500000000000000000000000001421635746700165635ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/hello-world/000077500000000000000000000000001421635746700210135ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/hello-world/Cargo.lock000066400000000000000000000002331421635746700227160ustar00rootroot00000000000000# This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 3 [[package]] name = "hello-world" version = "0.1.0" setuptools-rust-1.2.0/examples/hello-world/Cargo.toml000066400000000000000000000003531421635746700227440ustar00rootroot00000000000000[package] name = "hello-world" version = "0.1.0" edition = "2018" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] [profile.release-lto] inherits = "release" lto = true setuptools-rust-1.2.0/examples/hello-world/MANIFEST.in000066400000000000000000000000531421635746700225470ustar00rootroot00000000000000include Cargo.toml recursive-include src * setuptools-rust-1.2.0/examples/hello-world/hello_world/000077500000000000000000000000001421635746700233255ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/hello-world/hello_world/__init__.py000066400000000000000000000000001421635746700254240ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/hello-world/noxfile.py000066400000000000000000000003771421635746700230400ustar00rootroot00000000000000from os.path import dirname import nox SETUPTOOLS_RUST = dirname(dirname(dirname(__file__))) @nox.session() def test(session: nox.Session): session.install(SETUPTOOLS_RUST) session.install(".") session.run("hello-world", *session.posargs) setuptools-rust-1.2.0/examples/hello-world/pytest.ini000066400000000000000000000000001421635746700230320ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/hello-world/setup.py000066400000000000000000000006721421635746700225320ustar00rootroot00000000000000from setuptools import setup from setuptools_rust import Binding, RustExtension setup( name="hello-world", version="1.0", rust_extensions=[ RustExtension( {"hello-world": "hello_world.hello-world"}, binding=Binding.Exec, script=True, args=["--profile", "release-lto"], ) ], # rust extensions are not zip safe, just like C-extensions. zip_safe=False, ) setuptools-rust-1.2.0/examples/hello-world/src/000077500000000000000000000000001421635746700216025ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/hello-world/src/main.rs000066400000000000000000000000551421635746700230740ustar00rootroot00000000000000fn main() { println!("Hello, world!"); } setuptools-rust-1.2.0/examples/html-py-ever/000077500000000000000000000000001421635746700211145ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/.github/000077500000000000000000000000001421635746700224545ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/.github/workflows/000077500000000000000000000000001421635746700245115ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/.github/workflows/upload.yml000066400000000000000000000013661421635746700265260ustar00rootroot00000000000000name: Upload Python Package on: release: types: [created] jobs: deploy: runs-on: ubuntu-latest steps: - uses: actions/checkout@v2 - name: Set up Python uses: actions/setup-python@v2 with: python-version: '3.x' - name: Install dependencies run: | python -m pip install --upgrade pip curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain=stable pip install setuptools wheel twine setuptools-rust - name: Build , Test and publish env: TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }} TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }} run: | python setup.py install --user cd test && python3 run_all.py twine upload dist/*setuptools-rust-1.2.0/examples/html-py-ever/Cargo.lock000066400000000000000000000410141421635746700230210ustar00rootroot00000000000000# This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 3 [[package]] name = "bitflags" version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "byteorder" version = "1.4.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" [[package]] name = "cfg-if" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "convert_case" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e" [[package]] name = "cssparser" version = "0.27.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "754b69d351cdc2d8ee09ae203db831e005560fc6030da058f86ad60c92a9cb0a" dependencies = [ "cssparser-macros", "dtoa-short", "itoa", "matches", "phf", "proc-macro2", "quote", "smallvec", "syn", ] [[package]] name = "cssparser-macros" version = "0.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dfae75de57f2b2e85e8768c3ea840fd159c8f33e2b6522c7835b7abac81be16e" dependencies = [ "quote", "syn", ] [[package]] name = "derive_more" version = "0.99.17" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" dependencies = [ "convert_case", "proc-macro2", "quote", "rustc_version", "syn", ] [[package]] name = "dtoa" version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "56899898ce76aaf4a0f24d914c97ea6ed976d42fec6ad33fcbb0a1103e07b2b0" [[package]] name = "dtoa-short" version = "0.3.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bde03329ae10e79ede66c9ce4dc930aa8599043b0743008548680f25b91502d6" dependencies = [ "dtoa", ] [[package]] name = "futf" version = "0.1.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df420e2e84819663797d1ec6544b13c5be84629e7bb00dc960d6917db2987843" dependencies = [ "mac", "new_debug_unreachable", ] [[package]] name = "fxhash" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" dependencies = [ "byteorder", ] [[package]] name = "getrandom" version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8fc3cb4d91f53b50155bdcfd23f6a4c39ae1969c2ae85982b135750cccaf5fce" dependencies = [ "cfg-if", "libc", "wasi", ] [[package]] name = "html-py-ever" version = "0.1.0" dependencies = [ "kuchiki", "pyo3", "tendril", ] [[package]] name = "html5ever" version = "0.25.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aafcf38a1a36118242d29b92e1b08ef84e67e4a5ed06e0a80be20e6a32bfed6b" dependencies = [ "log", "mac", "markup5ever", "proc-macro2", "quote", "syn", ] [[package]] name = "indoc" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7906a9fababaeacb774f72410e497a1d18de916322e33797bb2cd29baa23c9e" dependencies = [ "unindent", ] [[package]] name = "instant" version = "0.1.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" dependencies = [ "cfg-if", ] [[package]] name = "itoa" version = "0.4.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b71991ff56294aa922b450139ee08b3bfc70982c6b2c7562771375cf73542dd4" [[package]] name = "kuchiki" version = "0.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "1ea8e9c6e031377cff82ee3001dc8026cdf431ed4e2e6b51f98ab8c73484a358" dependencies = [ "cssparser", "html5ever", "matches", "selectors", ] [[package]] name = "lazy_static" version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" [[package]] name = "libc" version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f" [[package]] name = "lock_api" version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b" dependencies = [ "scopeguard", ] [[package]] name = "log" version = "0.4.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "51b9bbe6c47d51fc3e1a9b945965946b4c44142ab8792c50835a980d362c2710" dependencies = [ "cfg-if", ] [[package]] name = "mac" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c41e0c4fef86961ac6d6f8a82609f55f31b05e4fce149ac5710e439df7619ba4" [[package]] name = "markup5ever" version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a24f40fb03852d1cdd84330cddcaf98e9ec08a7b7768e952fad3b4cf048ec8fd" dependencies = [ "log", "phf", "phf_codegen", "string_cache", "string_cache_codegen", "tendril", ] [[package]] name = "matches" version = "0.1.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f" [[package]] name = "new_debug_unreachable" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" [[package]] name = "nodrop" version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb" [[package]] name = "once_cell" version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9" [[package]] name = "parking_lot" version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" dependencies = [ "instant", "lock_api", "parking_lot_core", ] [[package]] name = "parking_lot_core" version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216" dependencies = [ "cfg-if", "instant", "libc", "redox_syscall", "smallvec", "winapi", ] [[package]] name = "phf" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3dfb61232e34fcb633f43d12c58f83c1df82962dcdfa565a4e866ffc17dafe12" dependencies = [ "phf_macros", "phf_shared 0.8.0", "proc-macro-hack", ] [[package]] name = "phf_codegen" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cbffee61585b0411840d3ece935cce9cb6321f01c45477d30066498cd5e1a815" dependencies = [ "phf_generator", "phf_shared 0.8.0", ] [[package]] name = "phf_generator" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "17367f0cc86f2d25802b2c26ee58a7b23faeccf78a396094c13dced0d0182526" dependencies = [ "phf_shared 0.8.0", "rand", ] [[package]] name = "phf_macros" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7f6fde18ff429ffc8fe78e2bf7f8b7a5a5a6e2a8b58bc5a9ac69198bbda9189c" dependencies = [ "phf_generator", "phf_shared 0.8.0", "proc-macro-hack", "proc-macro2", "quote", "syn", ] [[package]] name = "phf_shared" version = "0.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c00cf8b9eafe68dde5e9eaa2cef8ee84a9336a47d566ec55ca16589633b65af7" dependencies = [ "siphasher", ] [[package]] name = "phf_shared" version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" dependencies = [ "siphasher", ] [[package]] name = "ppv-lite86" version = "0.2.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eb9f9e6e233e5c4a35559a617bf40a4ec447db2e84c20b55a6f83167b7e57872" [[package]] name = "precomputed-hash" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" [[package]] name = "proc-macro-hack" version = "0.5.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" [[package]] name = "proc-macro2" version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" dependencies = [ "unicode-xid", ] [[package]] name = "pyo3" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a378727d5fdcaafd15b5afe9842cff1c25fdc43f62a162ffda2263c57ad98703" dependencies = [ "cfg-if", "indoc", "libc", "parking_lot", "pyo3-build-config", "pyo3-ffi", "pyo3-macros", "unindent", ] [[package]] name = "pyo3-build-config" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fbb27a3e96edd34c13d97d0feefccc90a79270c577c66e19d95af8323823dfc" dependencies = [ "once_cell", ] [[package]] name = "pyo3-ffi" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b719fff844bcf3f911132112ec06527eb195f6a98e0c42cf97e1118929fd4ea" dependencies = [ "libc", "pyo3-build-config", ] [[package]] name = "pyo3-macros" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f795e52d3320abb349ca28b501a7112154a87f353fae1c811deecd58e99cfa9b" dependencies = [ "proc-macro2", "pyo3-macros-backend", "quote", "syn", ] [[package]] name = "pyo3-macros-backend" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39e03aa57a3bb7b96982958088df38302a139df4eef54671bc595f26556cb75b" dependencies = [ "proc-macro2", "pyo3-build-config", "quote", "syn", ] [[package]] name = "quote" version = "1.0.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4af2ec4714533fcdf07e886f17025ace8b997b9ce51204ee69b6da831c3da57" dependencies = [ "proc-macro2", ] [[package]] name = "rand" version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03" dependencies = [ "getrandom", "libc", "rand_chacha", "rand_core", "rand_hc", "rand_pcg", ] [[package]] name = "rand_chacha" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f4c8ed856279c9737206bf725bf36935d8666ead7aa69b52be55af369d193402" dependencies = [ "ppv-lite86", "rand_core", ] [[package]] name = "rand_core" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19" dependencies = [ "getrandom", ] [[package]] name = "rand_hc" version = "0.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ca3129af7b92a17112d59ad498c6f81eaf463253766b90396d39ea7a39d6613c" dependencies = [ "rand_core", ] [[package]] name = "rand_pcg" version = "0.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "16abd0c1b639e9eb4d7c50c0b8100b0d0f849be2349829c740fe8e6eb4816429" dependencies = [ "rand_core", ] [[package]] name = "redox_syscall" version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c" dependencies = [ "bitflags", ] [[package]] name = "rustc_version" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" dependencies = [ "semver", ] [[package]] name = "scopeguard" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" [[package]] name = "selectors" version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "df320f1889ac4ba6bc0cdc9c9af7af4bd64bb927bccdf32d81140dc1f9be12fe" dependencies = [ "bitflags", "cssparser", "derive_more", "fxhash", "log", "matches", "phf", "phf_codegen", "precomputed-hash", "servo_arc", "smallvec", "thin-slice", ] [[package]] name = "semver" version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a4a3381e03edd24287172047536f20cabde766e2cd3e65e6b00fb3af51c4f38d" [[package]] name = "serde" version = "1.0.136" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ce31e24b01e1e524df96f1c2fdd054405f8d7376249a5110886fb4b658484789" [[package]] name = "servo_arc" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d98238b800e0d1576d8b6e3de32827c2d74bee68bb97748dcf5071fb53965432" dependencies = [ "nodrop", "stable_deref_trait", ] [[package]] name = "siphasher" version = "0.3.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7bd3e3206899af3f8b12af284fafc038cc1dc2b41d1b89dd17297221c5d225de" [[package]] name = "smallvec" version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83" [[package]] name = "stable_deref_trait" version = "1.2.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" [[package]] name = "string_cache" version = "0.8.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "33994d0838dc2d152d17a62adf608a869b5e846b65b389af7f3dbc1de45c5b26" dependencies = [ "lazy_static", "new_debug_unreachable", "parking_lot", "phf_shared 0.10.0", "precomputed-hash", "serde", ] [[package]] name = "string_cache_codegen" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f24c8e5e19d22a726626f1a5e16fe15b132dcf21d10177fa5a45ce7962996b97" dependencies = [ "phf_generator", "phf_shared 0.8.0", "proc-macro2", "quote", ] [[package]] name = "syn" version = "1.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ea297be220d52398dcc07ce15a209fce436d361735ac1db700cab3b6cdfb9f54" dependencies = [ "proc-macro2", "quote", "unicode-xid", ] [[package]] name = "tendril" version = "0.4.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a9ef557cb397a4f0a5a3a628f06515f78563f2209e64d47055d9dc6052bf5e33" dependencies = [ "futf", "mac", "utf-8", ] [[package]] name = "thin-slice" version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8eaa81235c7058867fa8c0e7314f33dcce9c215f535d1913822a2b3f5e289f3c" [[package]] name = "unicode-xid" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" [[package]] name = "unindent" version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "514672a55d7380da379785a4d70ca8386c8883ff7eaae877be4d2081cebe73d8" [[package]] name = "utf-8" version = "0.7.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" [[package]] name = "wasi" version = "0.9.0+wasi-snapshot-preview1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "cccddf32554fecc6acb585f82a32a72e28b48f8c4c1883ddfeeeaa96f7d8e519" [[package]] name = "winapi" version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" dependencies = [ "winapi-i686-pc-windows-gnu", "winapi-x86_64-pc-windows-gnu", ] [[package]] name = "winapi-i686-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" setuptools-rust-1.2.0/examples/html-py-ever/Cargo.toml000066400000000000000000000004271421635746700230470ustar00rootroot00000000000000[package] name = "html-py-ever" version = "0.1.0" authors = ["konstin "] edition = "2018" [dependencies] kuchiki = "0.8.0" pyo3 = { version = "0.16.2", features = ["extension-module"] } tendril = "0.4.2" [lib] name = "html_py_ever" crate-type = ["cdylib"] setuptools-rust-1.2.0/examples/html-py-ever/MANIFEST.in000066400000000000000000000000531421635746700226500ustar00rootroot00000000000000include Cargo.toml recursive-include src * setuptools-rust-1.2.0/examples/html-py-ever/README.md000066400000000000000000000251531421635746700224010ustar00rootroot00000000000000# html-py-ever Demoing how to use [html5ever](https://github.com/servo/html5ever) through [kuchiki](https://github.com/kuchiki-rs/kuchiki) to speed up html parsing and css-selecting. ## Usage `parse_file` and `parse_text` return a parsed `Document`, which then lets you select elements by css selectors using the `select` method. All elements are returned as strings ## Benchmarking Run `tox -e py`. ## Example benchmark results Running on Intel(R) Core(TM) i7-10750H CPU @ 2.60GHz with Python 3.9.5 and Rust 1.55.0 **run_all.py** ``` $ ./test/run_all.py /home/david/dev/setuptools-rust/examples/html-py-ever/test/empty.html 0 0.000026s Parse py 0.000070s 2.693x Select py 0.000105s 12.221x Parse lxml 0.000209s 8.023x Select lxml 0.000151s 17.535x /home/david/dev/setuptools-rust/examples/html-py-ever/test/small.html 0 0.000032s Parse py 0.000286s 9.066x Select py 0.000080s 3.038x Parse lxml 0.000396s 12.525x Select lxml 0.000087s 3.264x /home/david/dev/setuptools-rust/examples/html-py-ever/test/rust.html 733 0.015430s Parse py 0.257859s 16.711x Select py 0.024799s 32.135x Parse lxml 0.166995s 10.822x Select lxml 0.024668s 31.966x /home/david/dev/setuptools-rust/examples/html-py-ever/test/python.html 1518 0.065441s Parse py 1.371898s 20.964x Select py 0.138580s 43.215x Parse lxml 0.917728s 14.024x Select lxml 0.146618s 45.721x /home/david/dev/setuptools-rust/examples/html-py-ever/test/monty-python.html 1400 0.007463s Parse py 0.184073s 24.664x Select py 0.015596s 29.757x Parse lxml 0.076753s 10.284x Select lxml 0.017100s 32.628x ``` **test_parsing.py** ``` ------------------------------------------------------------------------------------------------------------------------------------------------ benchmark: 10 tests ------------------------------------------------------------------------------------------------------------------------------------------------- Name (time in us) Min Max Mean StdDev Median IQR Outliers OPS Rounds Iterations ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- test_bench_parsing_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/empty.html] 2.1000 (1.0) 155.2000 (1.0) 2.7308 (1.0) 2.0262 (1.0) 2.4000 (1.0) 0.1000 (1.0) 341;2539 366,186.4074 (1.0) 18762 1 test_bench_parsing_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/small.html] 9.6000 (4.57) 559.3000 (3.60) 10.4213 (3.82) 4.6027 (2.27) 10.2000 (4.25) 0.3000 (3.00) 294;850 95,957.4914 (0.26) 24571 1 test_bench_parsing_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/empty.html] 24.1000 (11.48) 525.8000 (3.39) 30.5076 (11.17) 13.4886 (6.66) 26.6000 (11.08) 1.7000 (17.00) 919;1597 32,778.7273 (0.09) 10236 1 test_bench_parsing_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/small.html] 187.2000 (89.14) 582.8000 (3.76) 215.0146 (78.74) 35.1708 (17.36) 200.6000 (83.58) 21.8000 (218.00) 340;336 4,650.8477 (0.01) 3158 1 test_bench_parsing_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/monty-python.html] 6,668.5000 (>1000.0) 16,104.0000 (103.76) 7,878.4104 (>1000.0) 1,223.6380 (603.90) 7,504.4000 (>1000.0) 776.1000 (>1000.0) 10;9 126.9292 (0.00) 134 1 test_bench_parsing_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/rust.html] 14,551.0000 (>1000.0) 16,078.2000 (103.60) 15,117.5525 (>1000.0) 237.0122 (116.97) 15,072.3000 (>1000.0) 155.1500 (>1000.0) 11;10 66.1483 (0.00) 61 1 test_bench_parsing_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/python.html] 69,374.7000 (>1000.0) 88,828.3000 (572.35) 73,736.0067 (>1000.0) 6,102.6659 (>1000.0) 71,318.8000 (>1000.0) 3,288.9000 (>1000.0) 2;3 13.5619 (0.00) 15 1 test_bench_parsing_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/monty-python.html] 119,087.1000 (>1000.0) 140,231.5000 (903.55) 124,006.4333 (>1000.0) 8,041.2631 (>1000.0) 120,803.8000 (>1000.0) 2,573.4000 (>1000.0) 1;1 8.0641 (0.00) 6 1 test_bench_parsing_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/rust.html] 256,079.1000 (>1000.0) 283,591.4000 (>1000.0) 272,005.6800 (>1000.0) 11,993.9084 (>1000.0) 276,622.5000 (>1000.0) 20,551.0250 (>1000.0) 1;0 3.6764 (0.00) 5 1 test_bench_parsing_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/python.html] 1,388,658.5000 (>1000.0) 1,417,244.1000 (>1000.0) 1,407,207.0600 (>1000.0) 11,658.8211 (>1000.0) 1,407,273.7000 (>1000.0) 15,582.4000 (>1000.0) 1;0 0.7106 (0.00) 5 1 ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ``` **test_selector.py** ``` -------------------------------------------------------------------------------------------------------------------------------------------------------- benchmark: 10 tests -------------------------------------------------------------------------------------------------------------------------------------------------------- Name (time in ns) Min Max Mean StdDev Median IQR Outliers OPS Rounds Iterations ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- test_bench_selector_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/empty.html] 799.9997 (1.0) 682,700.0007 (11.08) 1,079.2724 (1.0) 5,056.3097 (6.85) 999.9994 (1.0) 99.9999 (>1000.0) 87;499 926,550.1666 (1.0) 53764 1 test_bench_selector_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/small.html] 899.9996 (1.12) 102,799.9997 (1.67) 1,134.4583 (1.05) 738.3883 (1.0) 1,100.0002 (1.10) 0.0009 (1.0) 664;51478 881,477.9722 (0.95) 158731 1 test_bench_selector_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/empty.html] 7,000.0006 (8.75) 61,600.0007 (1.0) 7,896.1815 (7.32) 2,197.4336 (2.98) 7,600.0006 (7.60) 300.0005 (>1000.0) 159;411 126,643.4926 (0.14) 9192 1 test_bench_selector_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/small.html] 24,600.0000 (30.75) 1,270,499.9999 (20.62) 26,831.8769 (24.86) 10,644.6522 (14.42) 26,300.0002 (26.30) 599.9991 (>1000.0) 237;871 37,269.1035 (0.04) 15083 1 test_bench_selector_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/monty-python.html] 288,299.9997 (360.38) 1,328,100.0001 (21.56) 330,258.3420 (306.00) 36,035.7334 (48.80) 323,899.9998 (323.90) 9,299.9999 (>1000.0) 148;273 3,027.9326 (0.00) 1930 1 test_bench_selector_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/rust.html] 323,400.0005 (404.25) 2,079,099.9997 (33.75) 361,308.3042 (334.77) 61,858.2904 (83.77) 354,000.0002 (354.00) 16,300.0004 (>1000.0) 39;115 2,767.7194 (0.00) 1144 1 test_bench_selector_rust[/home/david/dev/setuptools-rust/examples/html-py-ever/test/python.html] 2,952,400.0001 (>1000.0) 4,020,800.0000 (65.27) 3,093,027.3333 (>1000.0) 117,355.5598 (158.93) 3,067,149.9999 (>1000.0) 82,000.0000 (>1000.0) 26;18 323.3078 (0.00) 300 1 test_bench_selector_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/monty-python.html] 14,984,299.9999 (>1000.0) 16,412,400.0003 (266.44) 15,363,483.8710 (>1000.0) 385,910.8544 (522.64) 15,212,300.0003 (>1000.0) 228,699.9988 (>1000.0) 9;9 65.0894 (0.00) 62 1 test_bench_selector_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/rust.html] 22,151,300.0006 (>1000.0) 27,046,000.0002 (439.06) 24,152,934.1463 (>1000.0) 1,014,946.2212 (>1000.0) 23,943,899.9997 (>1000.0) 420,224.9995 (>1000.0) 9;10 41.4028 (0.00) 41 1 test_bench_selector_python[/home/david/dev/setuptools-rust/examples/html-py-ever/test/python.html] 139,399,100.0004 (>1000.0) 148,564,900.0006 (>1000.0) 143,540,675.0002 (>1000.0) 3,466,075.6279 (>1000.0) 143,609,199.9999 (>1000.0) 6,241,799.9993 (>1000.0) 4;0 6.9667 (0.00) 8 1 ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ``` ## build instructions **Requirements:** - rust-toolchain (i.e cargo, rustc) - python3-dev or python3-devel **building and installing** ``` pip install setuptools-rust setuptools wheel python3 setup.py install --user ``` github workflows example to test and upload the module to pypi [here](./.github/workflows/upload.yml) setuptools-rust-1.2.0/examples/html-py-ever/build-wheels.sh000077500000000000000000000011701421635746700240360ustar00rootroot00000000000000#!/bin/bash set -ex curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y export PATH="$HOME/.cargo/bin:$PATH" # Compile wheels for PYBIN in /opt/python/cp{37,38,39,310}*/bin; do rm -rf /io/build/ "${PYBIN}/pip" install -U setuptools setuptools-rust wheel "${PYBIN}/pip" wheel /io/ -w /io/dist/ --no-deps done # Bundle external shared libraries into the wheels for whl in /io/dist/*{cp37,cp38,cp39,cp310}*.whl; do auditwheel repair "$whl" -w /io/dist/ done # Install packages and test for PYBIN in /opt/python/cp{37,38,39,310}*/bin; do "${PYBIN}/pip" install html-py-ever -f /io/dist/ done setuptools-rust-1.2.0/examples/html-py-ever/html_py_ever/000077500000000000000000000000001421635746700236115ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/html_py_ever/__init__.py000066400000000000000000000000341421635746700257170ustar00rootroot00000000000000from .html_py_ever import * setuptools-rust-1.2.0/examples/html-py-ever/noxfile.py000066400000000000000000000004521421635746700231330ustar00rootroot00000000000000from os.path import dirname import nox SETUPTOOLS_RUST = dirname(dirname(dirname(__file__))) @nox.session() def test(session: nox.Session): session.install(SETUPTOOLS_RUST, "pytest", "pytest-benchmark", "beautifulsoup4") session.install(".") session.run("pytest", *session.posargs) setuptools-rust-1.2.0/examples/html-py-ever/pytest.ini000066400000000000000000000000001421635746700231330ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/requirements.txt000066400000000000000000000000401421635746700243720ustar00rootroot00000000000000setuptools-rust setuptools wheelsetuptools-rust-1.2.0/examples/html-py-ever/setup.cfg000066400000000000000000000015011421635746700227320ustar00rootroot00000000000000[metadata] name = html-py-ever version = 0.1.0 license = MIT url = https://github.com/PyO3/setuptools-rust/blob/main/examples/html-py-ever long_description = file: README.md long_description_content_type = text/markdown classifiers = License :: OSI Approved :: MIT License Intended Audience :: Developers Programming Language :: Python :: 3 Programming Language :: Python :: 3.6 Programming Language :: Python :: 3.7 Programming Language :: Python :: 3.8 Programming Language :: Python :: 3.9 Development Status :: 5 - Production/Stable Operating System :: POSIX Operating System :: MacOS :: MacOS X Operating System :: Microsoft :: Windows [options] packages = html_py_ever zip_safe = False setup_requires = setuptools-rust >= 0.12.1; python_requires = >=3.6 include_package_data = True setuptools-rust-1.2.0/examples/html-py-ever/setup.py000077500000000000000000000002661421635746700226350ustar00rootroot00000000000000#!/usr/bin/env python import sys from setuptools import setup from setuptools_rust import RustExtension setup( rust_extensions=[RustExtension("html_py_ever.html_py_ever")], ) setuptools-rust-1.2.0/examples/html-py-ever/src/000077500000000000000000000000001421635746700217035ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/src/lib.rs000066400000000000000000000027231421635746700230230ustar00rootroot00000000000000use pyo3::prelude::*; use pyo3::wrap_pyfunction; use std::io::Read; use std::path::Path; use tendril::stream::TendrilSink; /// A parsed html document #[pyclass(unsendable)] struct Document { node: kuchiki::NodeRef, } #[pymethods] impl Document { /// Returns the selected elements as strings fn select(&self, selector: &str) -> Vec { self.node .select(selector) .unwrap() .map(|css_match| css_match.text_contents()) .collect() } } impl Document { fn from_reader(reader: &mut impl Read) -> PyResult { let node = kuchiki::parse_html().from_utf8().read_from(reader)?; Ok(Document { node }) } fn from_file(path: &Path) -> PyResult { let node = kuchiki::parse_html().from_utf8().from_file(path)?; Ok(Document { node }) } } /// Parses the File from the specified Path into a document #[pyfunction] fn parse_file(path: &str) -> PyResult { let document = Document::from_file(Path::new(path))?; Ok(document) } /// Parses the given html test into a document #[pyfunction] fn parse_text(text: &str) -> PyResult { let document = Document::from_reader(&mut text.as_bytes())?; Ok(document) } #[pymodule] fn html_py_ever(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pyfunction!(parse_file))?; m.add_wrapped(wrap_pyfunction!(parse_text))?; m.add_class::()?; Ok(()) } setuptools-rust-1.2.0/examples/html-py-ever/src/main.rs000066400000000000000000000013241421635746700231750ustar00rootroot00000000000000//! Pure rust version for comparing with python based calls use kuchiki; use std::env; use std::path::PathBuf; use std::time::Instant; use tendril::stream::TendrilSink; fn main() { let path = PathBuf::from( env::args() .nth(1) .expect("You need to pass the file name as first argument"), ); let now = Instant::now(); let document = kuchiki::parse_html().from_utf8().from_file(&path).unwrap(); println!("{:?}", now.elapsed()); let now2 = Instant::now(); let links: Vec = document .select("a[href]") .unwrap() .map(|css_match| css_match.text_contents()) .collect(); println!("{} {:?}", links.len(), now2.elapsed()); } setuptools-rust-1.2.0/examples/html-py-ever/test/000077500000000000000000000000001421635746700220735ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/test/empty.html000066400000000000000000000000001421635746700241050ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/html-py-ever/test/monty-python.html000066400000000000000000011745451421635746700254670ustar00rootroot00000000000000 Monty Python - Wikipedia

Monty Python

From Wikipedia, the free encyclopedia
Jump to navigation Jump to search
"Pythonesque" redirects here. For the play by Roy Smiles, see Pythonesque (play).
This article is about the comedy group. For their show frequently called Monty Python, see Monty Python's Flying Circus.

Monty Python
Flyingcircus 2.jpg
The Pythons in 1969
Back row: Graham Chapman, Eric Idle, Terry Gilliam
Front row: Terry Jones, John Cleese, Michael Palin
Medium
Nationality British[1]
Years active 1969–1983
1989
1998–1999
2002
2013–2014
Genres
Notable works and roles Monty Python's Flying Circus (1969–1974)
And Now for Something Completely Different (1971)
Monty Python and the Holy Grail (1975)
Monty Python's Life of Brian (1979)
Monty Python Live at the Hollywood Bowl (1982)
Monty Python's The Meaning of Life (1983)
Monty Python Live (2014)
Members Graham Chapman (deceased)
John Cleese
Terry Gilliam
Eric Idle
Terry Jones
Michael Palin
Website MontyPython.com

Monty Python (also collectively known as The Pythons)[2][3] were a British surreal comedy group who created their sketch comedy show Monty Python's Flying Circus, which first aired on the BBC in 1969. Forty-five episodes were made over four series. The Python phenomenon developed from the television series into something larger in scope and impact, including touring stage shows, films, numerous albums, several books, and musicals. The Pythons' influence on comedy has been compared to the Beatles' influence on music.[4][5][6] Their sketch show has been referred to as "not only one of the more enduring icons of 1970s British popular culture, but also an important moment in the evolution of television comedy."[7]

Broadcast by the BBC between 1969 and 1974, Monty Python's Flying Circus was conceived, written, and performed by its members Graham Chapman, John Cleese, Terry Gilliam, Eric Idle, Terry Jones, and Michael Palin. Loosely structured as a sketch show, but with an innovative stream-of-consciousness approach, aided by Gilliam's animation, it pushed the boundaries of what was acceptable in style and content.[8][9] A self-contained comedy team responsible for both writing and performing their work, the Pythons had creative control which allowed them to experiment with form and content, discarding rules of television comedy. Following their television work, they began making films, which include Holy Grail (1975), Life of Brian (1979) and The Meaning of Life (1983). Their influence on British comedy has been apparent for years, while in North America, it has coloured the work of cult performers from the early editions of Saturday Night Live through to more recent absurdist trends in television comedy. "Pythonesque" has entered the English lexicon as a result.

In a 2005 poll of over 300 comics, comedy writers, producers and directors throughout the English-speaking world to find "The Comedian's Comedian", three of the six Pythons members were voted to be among the top 50 greatest comedians ever: Cleese at No. 2, Idle at No. 21, and Palin at No. 30.[10][11]

Before Flying Circus[edit]

Jones and Palin met at Oxford University, where they performed together with the Oxford Revue. Chapman and Cleese met at Cambridge University. Idle was also at Cambridge, but started a year after Chapman and Cleese. Cleese met Gilliam in New York City while on tour with the Cambridge University Footlights revue Cambridge Circus (originally entitled A Clump of Plinths). Chapman, Cleese, and Idle were members of the Footlights, which at that time also included the future Goodies (Tim Brooke-Taylor, Bill Oddie, and Graeme Garden), and Jonathan Lynn (co-writer of Yes Minister and Yes, Prime Minister). During Idle's presidency of the club, feminist writer Germaine Greer and broadcaster Clive James were members. Recordings of Footlights' revues (called "Smokers") at Pembroke College include sketches and performances by Cleese and Idle, which, along with tapes of Idle's performances in some of the drama society's theatrical productions, are kept in the archives of the Pembroke Players.[citation needed]

The six Python members appeared in or wrote these shows before Flying Circus:

The Frost Report is credited as first uniting the British Pythons and providing an environment in which they could develop their particular styles.[citation needed]

Following the success of Do Not Adjust Your Set, a tea-time children's programme, ITV offered Gilliam, Idle, Jones, and Palin their own late-night adult comedy series together. At the same time, Chapman and Cleese were offered a show by the BBC, which had been impressed by their work on The Frost Report and At Last the 1948 Show. Cleese was reluctant to do a two-man show for various reasons, including Chapman's supposedly difficult and erratic personality. Cleese had fond memories of working with Palin on How to Irritate People and invited him to join the team. With no studio available at ITV until summer 1970 for the late-night show, Palin agreed to join Cleese and Chapman, and suggested the involvement of his writing partner Jones and colleague Idle—who in turn wanted Gilliam to provide animations for the projected series. Much has been made of the fact that the Monty Python troupe is the result of Cleese's desire to work with Palin and the chance circumstances that brought the other four members into the fold.[12]

By contrast, according to John Cleese's autobiography,[13] the origins of Monty Python lay in the admiration that writing partners Cleese and Chapman had for the new type of comedy being done on Do Not Adjust Your Set; as a result, a meeting was initiated by Cleese between Chapman, Idle, Jones, Palin, and himself at which it was agreed to pool their writing and performing efforts and jointly seek production sponsorship.[citation needed]

Monty Python's Flying Circus[edit]

Main article: Monty Python's Flying Circus

Development of the series[edit]

The Pythons had a definite idea about what they wanted to do with the series. They were admirers of the work of Peter Cook, Alan Bennett, Jonathan Miller, and Dudley Moore on Beyond the Fringe, and had worked on Frost, which was similar in style.[14] They enjoyed Cook and Moore's sketch show Not Only... But Also. One problem the Pythons perceived with these programmes was that though the body of the sketch would be strong, the writers would often struggle to then find a punchline funny enough to end on, and this would detract from the overall sketch quality. They decided that they would simply not bother to "cap" their sketches in the traditional manner, and early episodes of the Flying Circus series make great play of this abandonment of the punchline (one scene has Cleese turn to Idle, as the sketch descends into chaos, and remark that "This is the silliest sketch I've ever been in"—they all resolve not to carry on and simply walk off the set).[15] However, as they began assembling material for the show, the Pythons watched one of their collective heroes, Spike Milligan, recording his groundbreaking series Q5 (1969). Not only was the programme more irreverent and anarchic than any previous television comedy, but Milligan also would often "give up" on sketches halfway through and wander off set (often muttering "Did I write this?"). It was clear that their new series would now seem less original, and Jones in particular became determined the Pythons should innovate.

After much debate, Jones remembered an animation Gilliam had created for Do Not Adjust Your Set called "Beware of the Elephants", which had intrigued him with its stream-of-consciousness style. Jones felt it would be a good concept to apply to the series: allowing sketches to blend into one another. Palin had been equally fascinated by another of Gilliam's efforts, entitled "Christmas Cards", and agreed that it represented "a way of doing things differently". Since Cleese, Chapman, and Idle were less concerned with the overall flow of the programme, Jones, Palin, and Gilliam became largely responsible for the presentation style of the Flying Circus series, in which disparate sketches are linked to give each episode the appearance of a single stream-of-consciousness (often using a Gilliam animation to move from the closing image of one sketch to the opening scene of another).

Writing started at 9 am and finished at 5 pm. Typically, Cleese and Chapman worked as one pair isolated from the others, as did Jones and Palin, while Idle wrote alone. After a few days, they would join together with Gilliam, critique their scripts, and exchange ideas. Their approach to writing was democratic. If the majority found an idea humorous, it was included in the show. The casting of roles for the sketches was a similarly unselfish process, since each member viewed himself primarily as a "writer", rather than an actor eager for screen time. When the themes for sketches were chosen, Gilliam had a free hand in bridging them with animations, using a camera, scissors, and airbrush.

While the show was a collaborative process, different factions within Python were responsible for elements of the team's humour. In general, the work of the Oxford-educated members (Jones and Palin) was more visual, and more fanciful conceptually (e.g., the arrival of the Spanish Inquisition in a suburban front room), while the Cambridge graduates' sketches tended to be more verbal and more aggressive (for example, Cleese and Chapman's many "confrontation" sketches, where one character intimidates or hurls abuse, or Idle's characters with bizarre verbal quirks, such as "The Man Who Speaks In Anagrams"). Cleese confirmed that "most of the sketches with heavy abuse were Graham's and mine, anything that started with a slow pan across countryside and impressive music was Mike and Terry's, and anything that got utterly involved with words and disappeared up any personal orifice was Eric's".[16] Gilliam's animations, meanwhile, ranged from the whimsical to the savage (the cartoon format allowing him to create some astonishingly violent scenes without fear of censorship).

Several names for the show were considered before Monty Python's Flying Circus was settled upon. Some were Owl Stretching Time, The Toad Elevating Moment, A Horse, a Spoon and a Bucket, Vaseline Review, and Bun, Wackett, Buzzard, Stubble and Boot. Flying Circus stuck when the BBC explained it had printed that name in its schedules and was not prepared to amend it. Many variations on the name in front of this title then came and went (popular legend holds that the BBC considered Monty Python's Flying Circus to be a ridiculous name, at which point the group threatened to change their name every week until the BBC relented). Gwen Dibley's Flying Circus was named after a woman Palin had read about in the newspaper, thinking it would be amusing if she were to discover she had her own TV show. Baron Von Took's Flying Circus was considered as an affectionate tribute to Barry Took, the man who had brought them together. Arthur Megapode's Flying Circus was suggested, then discarded. The name Baron Von Took's Flying Circus had the form of Baron Manfred von Richthofen's Flying Circus of WWI fame, and the new group was forming in a time when the Royal Guardsmen's 1966 song "Snoopy vs. the Red Baron" had peaked. The term 'flying circus' was also another name for the popular entertainment of the 1920s known as barnstorming, where multiple performers collaborated with their stunts to perform a combined set of acts.

Differing, somewhat confusing accounts are given of the origins of the Python name, although the members agree that its only "significance" was that they thought it sounded funny. In the 1998 documentary Live at Aspen during the US Comedy Arts Festival, where the troupe was awarded the AFI Star Award by the American Film Institute, the group implied that "Monty" was selected (Eric Idle's idea) as a gently mocking tribute to Field Marshal Lord Montgomery, a legendary British general of World War II; requiring a "slippery-sounding" surname, they settled on "Python". On other occasions, Idle has claimed that the name "Monty" was that of a popular and rotund fellow who drank in his local pub; people would often walk in and ask the barman, "Has Monty been in yet?", forcing the name to become stuck in his mind. The name Monty Python was later described by the BBC as being "envisaged by the team as the perfect name for a sleazy entertainment agent".[17]

Style of the show[edit]

Flying Circus popularised innovative formal techniques, such as the cold open, in which an episode began without the traditional opening titles or announcements.[18] An example of this is the "It's" man: Palin, outfitted in Robinson Crusoe garb, making a tortuous journey across various terrains, before finally approaching the camera to state, "It's ...", only to be then cut off by the title sequence and theme music.

On several occasions, the cold open lasted until mid-show, after which the regular opening titles ran. Occasionally, the Pythons tricked viewers by rolling the closing credits halfway through the show, usually continuing the joke by fading to the familiar globe logo used for BBC continuity, over which Cleese would parody the clipped tones of a BBC announcer. On one occasion, the credits ran directly after the opening titles.

Because of their dislike of finishing with punchlines, they experimented with ending the sketches by cutting abruptly to another scene or animation, walking offstage, addressing the camera (breaking the fourth wall), or introducing a totally unrelated event or character. A classic example of this approach was the use of Chapman's "anti-silliness" character of "the Colonel", who walked into several sketches and ordered them to be stopped because things were becoming "far too silly".

Cupid's foot, as used by Monty Python's Flying Circus

Another favourite way of ending sketches was to drop a cartoonish "16-ton weight" prop on one of the characters when the sketch seemed to be losing momentum, or a knight in full armour (played by Terry Gilliam) would wander on-set and hit characters over the head with a rubber chicken,[19] before cutting to the next scene. Yet another way of changing scenes was when John Cleese, usually outfitted in a dinner suit, would come in as a radio commentator and, in a rather pompous manner, make the formal and determined announcement "And now for something completely different.", which later became the title of the first Monty Python film.

The Python theme music is the Band of the Grenadier Guards' rendition of John Philip Sousa's "The Liberty Bell" which was first published in 1893.[20] Under the Berne Convention's "country of origin" concept, the composition was subject to United States copyright law which states that any works first published prior to 1923 was in the public domain due to copyright expiration.[21] This enabled Gilliam to co-opt the march for the series without having to make any royalty payments.[22]

The use of Gilliam's surreal, collage stop motion animations was another innovative intertextual element of the Python style. Many of the images Gilliam used were lifted from famous works of art, and from Victorian illustrations and engravings. The giant foot which crushes the show's title at the end of the opening credits is in fact the foot of Cupid, cut from a reproduction of the Renaissance masterpiece Venus, Cupid, Folly and Time by Bronzino. This foot, and Gilliam's style in general, are visual trademarks of the programme.

The Pythons used the British tradition of cross-dressing comedy by donning frocks and makeup and playing female roles themselves while speaking in falsetto. Jones specialised in playing the working-class housewife, with Palin and Idle in being generally more posh. The other members played female roles more sparsely. Generally speaking, female roles were played by women only when the scene specifically required that the character be sexually attractive (although sometimes they used Idle for this). The troupe later turned to Carol Cleveland, who co-starred in numerous episodes after 1970. In some episodes and later in Monty Python's Life of Brian, they took the idea one step further by playing women who impersonated men (in the stoning scene).

Many sketches are well-known and widely quoted. "Dead Parrot sketch", "The Lumberjack Song", "Spam" (which led to the coining of the term email spam),[23] "Nudge Nudge", "The Spanish Inquisition", "Upper Class Twit of the Year", "Cheese Shop", and "The Ministry of Silly Walks" are just a few examples.

Introduction to North America[edit]

The Canadian Broadcasting Corporation (CBC) added Monty Python's Flying Circus to its national September 1970 fall line-up.[24] They aired the 13 episodes of series 1, which had first run on the BBC the previous fall (October 1969 to January 1970), as well as the first six episodes of series 2 only a few weeks after they first appeared on the BBC (September to November 1970).[24] The CBC dropped the show when it returned to regular programming after the Christmas 1970 break, choosing to not place the remaining seven episodes of series 2 on the January 1971 CBC schedule.[24] Within a week, the CBC received hundreds of calls complaining of the cancellation, and more than 100 people staged a demonstration at the CBC's Montreal studios. The show eventually returned, becoming a fixture on the network during the first half of the 1970s.[24]

Time-Life Films had the rights to distribute all BBC-TV programmes in the United States; however, they decided that British comedy simply would not work in America, so it would not be worth the investment to convert the Python episodes from the European PAL standard to the American NTSC standard.

Sketches from Monty Python's Flying Circus were introduced to American audiences in August 1972, with the release of the Python film And Now for Something Completely Different, featuring sketches from series 1 and 2 of the television show. This 1972 release met limited box office success.

In the summer of 1974, Ron Devillier, the programme director for nonprofit PBS television station KERA in Dallas, Texas, started airing episodes of Monty Python's Flying Circus. Ratings shot through the roof, providing an encouraging sign to the other 100 PBS stations that had signed up to begin airing the show in October 1974—exactly five years after their BBC debut. There was also cross-promotion from FM Radio stations across the country, whose airing of tracks from the Python LPs had already introduced American audiences to this bizarre brand of comedy. The popularity on PBS resulted in the 1974 re-release of the 1972 ...Completely Different film, with much greater box office success.

The ability to show Monty Python's Flying Circus under the American NTSC standard had been made possible by the commercial actions of American television producer Greg Garrison. Garrison produced the NBC series The Dean Martin Comedy World, which ran during the summer of 1974. The concept was to show clips from comedy shows produced in other countries, including tape of the Python sketches "Bicycle Repairman" and "The Dull Life of a Stockbroker". Payment for use of these two sketches was enough to allow Time-Life Films to convert the entire Python library to NTSC standard, allowing for the sale to the PBS network stations which then brought the entire show to US audiences.

In 1975, ABC broadcast two 90-minute Monty Python specials, each with three shows, but cut out a total of 24 minutes from each, in part to make time for commercials, and in part to avoid upsetting their audience. As the judge observed in Gilliam v. American Broadcasting Companies, Inc., where Monty Python sued for damages caused by broadcast of the mutilated version, "According to the network, appellants should have anticipated that most of the excised material contained scatological references inappropriate for American television and that these scenes would be replaced with commercials, which presumably are more palatable to the American public." Monty Python won the case.[25]

With the popularity of Python throughout the rest of the 1970s and through most of the 1980s, PBS stations looked at other British comedies, leading to UK shows such as Are You Being Served? gaining a US audience, and leading, over time, to many PBS stations having a "British Comedy Night" which airs many popular UK comedies.[26]

Cleese departs; the circus closes[edit]

Having considered the possibility at the end of the second season, Cleese left the Flying Circus at the end of the third. He later explained that he felt he no longer had anything fresh to offer the show, and claimed that only two Cleese- and Chapman-penned sketches in the third series ("Dennis Moore" and the "Cheese Shop") were truly original, and that the others were bits and pieces from previous work cobbled together in slightly different contexts.[12] He was also finding Chapman, who was at that point in the full throes of alcoholism, difficult to work with. According to an interview with Idle, "It was on an Air Canada flight on the way to Toronto, when John (Cleese) turned to all of us and said 'I want out.' Why? I don't know. He gets bored more easily than the rest of us. He's a difficult man, not easy to be friendly with. He's so funny because he never wanted to be liked. That gives him a certain fascinating, arrogant freedom."[27]

The rest of the group carried on for one more "half" season before calling a halt to the programme in 1974. The name Monty Python's Flying Circus appears in the opening animation for season four, but in the end credits, the show is listed as simply "Monty Python". Although Cleese left the show, he was credited as a writer for three of the six episodes, largely concentrated in the "Michael Ellis" episode, which had begun life as one of the many drafts of the "Holy Grail" motion picture. When a new direction for "Grail" was decided upon, the subplot of Arthur and his knights wandering around a strange department store in modern times was lifted out and recycled as the aforementioned TV episode.

While the first three seasons contained 13 episodes each, the fourth ended after just six. Extremely keen to keep the now massively popular show going, the BBC had offered the troupe a full 13 episodes, but the truncated troupe (now under the unspoken 'leadership' of Terry Jones) had come to a common agreement while writing the fourth series that there was only enough material, and more importantly only enough enthusiasm, to shoot the six that were made.

Life beyond the Flying Circus[edit]

Filmography[edit]

And Now for Something Completely Different (1971)[edit]

Main article: And Now for Something Completely Different

The Pythons' first feature film was directed by Ian MacNaughton, reprising his role from the television series. It consisted of sketches from the first two seasons of the Flying Circus, reshot on a low budget (and often slightly edited) for cinema release. Material selected for the film includes: "Dead Parrot", "The Lumberjack Song", "Upper Class Twit of the Year", "Hell's Grannies", "Self-Defence Class", "How Not to Be Seen", and "Nudge Nudge". Financed by Playboy's UK executive Victor Lownes, it was intended as a way of breaking Monty Python into America, and although it was ultimately unsuccessful in this, the film did good business in the UK, this being in the era before home video would make the original material much more accessible. The group did not consider the film a success.

Monty Python and the Holy Grail (1975)[edit]

Main article: Monty Python and the Holy Grail

In 1974, between production on the third and fourth seasons, the group decided to embark on their first "proper" feature film, containing entirely new material. Monty Python and the Holy Grail was based on Arthurian legend and was directed by Jones and Gilliam. Again, the latter also contributed linking animations (and put together the opening credits). Along with the rest of the Pythons, Jones and Gilliam performed several roles in the film, but Chapman took the lead as King Arthur. Cleese returned to the group for the film, feeling that they were once again breaking new ground. Holy Grail was filmed on location, in picturesque rural areas of Scotland, with a budget of only £229,000; the money was raised in part with investments from rock groups such as Pink Floyd, Jethro Tull, and Led Zeppelin—and UK music industry entrepreneur Tony Stratton-Smith (founder and owner of the Charisma Records label, for which the Pythons recorded their comedy albums).

The backers of the film wanted to cut the famous Black Knight scene (in which the Black Knight loses his limbs in a duel), but it was eventually kept in the movie.[28]

Monty Python's Life of Brian (1979)[edit]

Main article: Monty Python's Life of Brian

Following the success of Holy Grail, reporters asked for the title of the next Python film, despite the fact that the team had not even begun to consider a third one. Eventually, Idle flippantly replied "Jesus Christ – Lust for Glory", which became the group's stock answer once they realised that it shut reporters up. However, they soon began to seriously consider a film lampooning the New Testament era in the same way Holy Grail had lampooned Arthurian legend. Despite them all sharing a distrust of organised religion, they agreed not to mock Jesus or his teachings directly. They also mentioned that they could not think of anything legitimate to make fun of about him. Instead, they decided to write a satire on credulity and hypocrisy among the followers of someone who had been mistaken for the "Messiah", but who had no desire to be followed as such. Chapman was cast in the lead role of Brian.

The focus therefore shifted to a separate individual born at the same time, in a neighbouring stable. When Jesus appears in the film (first, as a baby in the stable, and then later on the Mount, speaking the Beatitudes), he is played straight (by actor Kenneth Colley) and portrayed with respect. The comedy begins when members of the crowd mishear his statements of peace, love, and tolerance ("I think he said, 'Blessed are the cheesemakers'").

Directing duties were handled solely by Jones, having amicably agreed with Gilliam that Jones' approach to film-making was better suited for Python's general performing style. Holy Grail's production had often been stilted by their differences behind the camera. Gilliam again contributed two animated sequences (one being the opening credits) and took charge of set design. The film was shot on location in Tunisia, the finances being provided this time by former Beatle George Harrison, who together with Denis O'Brien formed the production company Hand-Made Films for the movie. Harrison had a cameo role as the "owner of the Mount".

Despite its subject matter attracting controversy, particularly upon its initial release, it has (together with its predecessor) been ranked among the greatest comedy films. A Channel 4 poll in 2005 ranked Holy Grail in sixth place, with Life of Brian at the top.[29]

Monty Python Live at the Hollywood Bowl (1982)[edit]

Main article: Monty Python Live at the Hollywood Bowl

Filmed at the Hollywood Bowl in Los Angeles during preparations for The Meaning of Life, this was a concert film (directed by Terry Hughes) in which the Pythons performed sketches from the television series in front of an audience. The released film also incorporated footage from the German television specials (the inclusion of which gives Ian MacNaughton his first on-screen credit for Python since the end of Flying Circus) and live performances of several songs from the troupe's then-current Monty Python's Contractual Obligation Album.

Monty Python's The Meaning of Life (1983)[edit]

Main article: Monty Python's The Meaning of Life

The Pythons' final film returned to something structurally closer to the style of Flying Circus. A series of sketches loosely follows the ages of man from birth to death. Directed again by Jones solo, The Meaning of Life is embellished with some of the group's most bizarre and disturbing moments, as well as various elaborate musical numbers. The film is by far their darkest work, containing a great deal of black humour, garnished by some spectacular violence (including an operation to remove a liver from a living patient without anaesthetic and the morbidly obese Mr. Creosote exploding over several restaurant patrons). At the time of its release, the Pythons confessed their aim was to offend "absolutely everyone".

Besides the opening credits and the fish sequence, Gilliam, by now an established live-action director, no longer wanted to produce any linking cartoons, offering instead to direct one sketch, "The Crimson Permanent Assurance". Under his helm, though, the segment grew so ambitious and tangential that it was cut from the movie and used as a supporting feature in its own right. (Television screenings also use it as a prologue.) This was the last project on which all six Pythons collaborated, except for the 1989 compilation Parrot Sketch Not Included, where they are all seen sitting in a closet for four seconds. This was the last time Chapman appeared on screen with the Pythons.

Secret Policeman's Ball benefit shows[edit]

Members of Python contributed their services to charitable endeavours and causes—sometimes as an ensemble, at other times as individuals. The cause that has been the most frequent and consistent beneficiary has been the human rights work of Amnesty International. Between 1976 and 1981, the troupe or its members appeared in four major fund-raisers for Amnesty—known collectively as the Secret Policeman's Ball shows—which were turned into multiple films, TV shows, videos, record albums, and books. These benefit shows and their many spin-offs raised considerable sums of money for Amnesty, raised public and media awareness of the human rights cause, and influenced many other members of the entertainment community (especially rock musicians) to become involved in political and social issues.[30] Among the many musicians who have publicly attributed their activism—and the organisation of their own benefit events—to the inspiration of the work in this field of Monty Python are U2, Bob Geldof, Pete Townshend, and Sting.[30] The shows are credited by Amnesty with helping the organisation develop public awareness in the US, where one of the spin-off films was a major success.

Cleese and Jones had an involvement (as performer, writer or director) in all four Amnesty benefit shows, Palin in three, Chapman in two, and Gilliam in one. Idle did not participate in the Amnesty shows. Notwithstanding Idle's lack of participation, the other five members (together with "Associate Pythons" Carol Cleveland and Neil Innes) all appeared together in the first Secret Policeman's Ball benefit—the 1976 A Poke in the Eye—where they performed several Python sketches. In this first show, they were collectively billed as Monty Python. (Peter Cook deputised for the errant Idle in a courtroom sketch.) In the next three shows, the participating Python members performed many Python sketches, but were billed under their individual names rather than under the collective Python banner. After a six-year break, Amnesty resumed producing Secret Policeman's Ball benefit shows in 1987 (sometimes with, and sometimes without, variants of the iconic title) and by 2006 had presented a total of 12 such shows. The shows since 1987 have featured newer generations of British comedic performers, including many who have attributed their participation in the show to their desire to emulate the Python's pioneering work for Amnesty. (Cleese and Palin made a brief cameo appearance in the 1989 Amnesty show; apart from that, the Pythons have not appeared in shows after the first four.)

Going solo[edit]

Each member has pursued various film, television, and stage projects since the break-up of the group, but often continued to work with one another. Many of these collaborations were very successful, most notably A Fish Called Wanda (1988), written by Cleese, in which he starred along with Palin. The pair also appeared in Time Bandits (1981), a film directed by Gilliam, who wrote it together with Palin. Gilliam directed Jabberwocky (1977), and also directed and co-wrote Brazil (1985), which featured Palin, and The Adventures of Baron Munchausen (1988), which featured Idle. Yellowbeard (1983) was co-written by Chapman and featured Chapman, Idle, and Cleese, as well as many other English comedians including Peter Cook, Spike Milligan, and Marty Feldman.

Palin and Jones wrote the comedic TV series Ripping Yarns (1976–79), starring Palin. Jones also appeared in the pilot episode and Cleese appeared in a nonspeaking part in the episode "Golden Gordon". Jones' film Erik the Viking also has Cleese playing a small part.

In 1996, Terry Jones wrote and directed an adaptation of Kenneth Grahame's novel The Wind in the Willows. It featured four members of Monty Python: Jones as Mr. Toad, Idle as Ratty, Cleese as Mr. Toad's lawyer, and Palin as the Sun. Gilliam was considered for the voice of the river.

In terms of numbers of productions, Cleese has the most prolific solo career, having appeared in dozens of films, several TV shows or series (including Cheers, 3rd Rock from the Sun, Q's assistant in the James Bond movies, and Will & Grace), many direct-to-video productions, some video games, and a number of commercials.[31] His BBC sitcom Fawlty Towers (written by and starring Cleese together with his then-wife Connie Booth) is the only comedy series to rank higher than the Flying Circus on the BFI TV 100's list, topping the whole poll.

Idle enjoyed critical success with Rutland Weekend Television in the mid-1970s, out of which came the Beatles parody the Rutles (responsible for the cult mockumentary All You Need Is Cash), and as an actor in Nuns on the Run (1990) with Robbie Coltrane. In 1976, Idle directed music videos for George Harrison songs "This Song" and "Crackerbox Palace", the latter of which also featured cameo appearances from Neil Innes and John Cleese. Idle has had success with Python songs: "Always Look on the Bright Side of Life" went to no. 3 in the UK singles chart in 1991. The song had been revived by Simon Mayo on BBC Radio 1, and was consequently released as a single that year. The theatrical phenomenon of the Python musical Spamalot has made Idle the most financially successful of the troupe after Python. Written by Idle (and featuring a pre-recorded cameo of Cleese as the voice of God), it has proved to be an enormous hit on Broadway, London's West End, and Las Vegas.[32] This was followed by Not the Messiah, which repurposes The Life of Brian as an oratorio. For the work's 2007 premiere at the Luminato festival in Toronto (which commissioned the work), Idle himself sang the "baritone-ish" part.

After Python reunions[edit]

Since The Meaning of Life, their last project as a team, the Pythons have often been the subject of reunion rumours.[32] The final reunion of all six members occurred during the Parrot Sketch Not Included – 20 Years of Monty Python special. The death of Chapman in 1989 (on the eve of their 20th anniversary) put an end to the speculation of any further reunions. Several occasions since 1989 have occurred when the surviving five members have gathered together for appearances—albeit not formal reunions. In 1996, Jones, Idle, Cleese, and Palin were featured in a film adaptation of The Wind in the Willows, which was later renamed Mr. Toad's Wild Ride.

In 1998 during the US Comedy Arts Festival, where the troupe was awarded the AFI Star Award by the American Film Institute, the five remaining members, along with what was purported to be Chapman's ashes, were reunited on stage for the first time in 18 years.[33] The occasion was in the form of an interview called Monty Python Live at Aspen, (hosted by Robert Klein, with an appearance by Eddie Izzard) in which the team looked back at some of their work and performed a few new sketches.

On 9 October 1999, to commemorate 30 years since the first Flying Circus television broadcast, BBC2 devoted an evening to Python programmes, including a documentary charting the history of the team, interspersed with new sketches by the Monty Python team filmed especially for the event. The program appears, with a few omissions, on the DVD The Life of Python. Idle's involvement in the special is limited, yet the final sketch marks the only time since 1989 that all surviving members of the troupe appear in one sketch, albeit not in the same room.

The surviving Pythons had agreed in principle to perform a live tour of America in 1999. Several shows were to be linked with Q&A meetings in various cities. Although all had said yes, Palin later changed his mind, much to the annoyance of Idle, who had begun work organising the tour. This led to Idle refusing to take part in the new material shot for the BBC anniversary evening.

In 2002, four of the surviving members, bar Cleese, performed "The Lumberjack Song" and "Sit on My Face" for George Harrison's memorial concert. The reunion also included regular supporting contributors Neil Innes and Carol Cleveland, with a special appearance from Tom Hanks.

In an interview to publicise the DVD release of The Meaning of Life, Cleese said a further reunion was unlikely. "It is absolutely impossible to get even a majority of us together in a room, and I'm not joking," Cleese said. He said that the problem was one of busyness rather than one of bad feelings.[34] A sketch appears on the same DVD spoofing the impossibility of a full reunion, bringing the members "together" in a deliberately unconvincing fashion with modern bluescreen/greenscreen techniques.

Idle has responded to queries about a Python reunion by adapting a line used by George Harrison in response to queries about a possible Beatles reunion. When asked in November 1989 about such a possibility, Harrison responded: "As far as I'm concerned, there won't be a Beatles reunion as long as John Lennon remains dead."[35] Idle's version of this was that he expected to see a proper Python reunion, "just as soon as Graham Chapman comes back from the dead", but added, "we're talking to his agent about terms."[36]

The Pythons Autobiography by the Pythons (2003), compiled from interviews with the surviving members, reveals that a series of disputes in 1998, over a possible sequel to Holy Grail that had been conceived by Idle, may have resulted in the group's permanent split. Cleese's feeling was that The Meaning of Life had been personally difficult and ultimately mediocre, and did not wish to be involved in another Python project for a variety of reasons (not least amongst them was the absence of Chapman, whose straight man-like central roles in the Grail and Brian films had been considered to be an essential anchoring performance). Apparently, Idle was angry with Cleese for refusing to do the film, which most of the remaining Pythons thought reasonably promising (the basic plot would have taken on a self-referential tone, featuring them in their main 'knight' guises from Holy Grail, mulling over the possibilities of reforming their posse). The book also reveals that a secondary option around this point was the possibility of revitalising the Python brand with a new stage tour, perhaps with the promise of new material. This idea had also met with Cleese's refusal, this time with the backing of other members.

March 2005 had a full, if nonperforming, reunion of the surviving cast members at the premiere of Idle's musical Spamalot, based on Monty Python and the Holy Grail. It opened in Chicago and has since played in New York on Broadway, London, and numerous other major cities across the world. In 2004, it was nominated for 14 Tony Awards and won three: Best Musical, Best Direction of a Musical for Mike Nichols, and Best Performance by a Featured Actress in a Musical for Sara Ramirez, who played the Lady of the Lake, a character specially added for the musical. Cleese played the voice of God, played in the film by Chapman.

Owing in part to the success of Spamalot, PBS announced on 13 July 2005 that it would begin to re-air the entire run of Monty Python's Flying Circus and new one-hour specials focusing on each member of the group, called Monty Python's Personal Best.[37] Each episode was written and produced by the individual being honoured, with the five remaining Pythons collaborating on Chapman's programme, the only one of the editions to take on a serious tone with its new material.

Innes in a hat
Long-time collaborator Neil Innes at the premiere of The Seventh Python in 2009

In 2009, to commemorate the 40th anniversary of the first episode of Monty Python's Flying Circus, a six-part documentary entitled Monty Python: Almost the Truth (Lawyers Cut) was released, featuring interviews with the surviving members of the team, as well as archive interviews with Graham Chapman and numerous excerpts from the television series and films.

Also in commemoration of the 40th anniversary, Idle, Palin, Jones, and Gilliam appeared in a production of Not the Messiah at the Royal Albert Hall. The European premiere was held on 23 October 2009.[38] An official 40th anniversary Monty Python reunion event took place in New York City on 15 October 2009, where the team received a Special Award from the British Academy of Film and Television Arts.[39]

In June 2011, it was announced that A Liar's Autobiography, an animated 3D movie based on the memoir of Graham Chapman, was in the making. The book A Liar's Autobiography was published in 1980 and details Chapman's journey through medical school, alcoholism, acknowledgement of his gay identity, and the tolls of surreal comedy. Asked what was true in a deliberately fanciful account by Chapman of his life, Terry Jones joked: "Nothing ... it's all a downright, absolute, blackguardly lie."

The film uses Chapman's own voice – from a reading of his autobiography shortly before he died of cancer – and entertainment channel Epix announced that the film will be released in early 2012 in both 2D and 3D formats. Produced and directed by London-based Bill Jones, Ben Timlett, and Jeff Simpson, the new film has 15 animation companies working on chapters that will range from three to 12 minutes in length, each in a different style.

John Cleese recorded dialogue which was matched with Chapman's voice. Michael Palin voiced Chapman's father and Terry Jones voiced his mother. Terry Gilliam voiced Graham's psychiatrist. They all play various other roles. Among the original Python group, only Eric Idle was not involved.[40]

On 26 January 2012, Terry Jones announced that the five surviving Pythons would reunite in a sci-fi comedy film called Absolutely Anything.[41] The film would combine computer-generated imagery and live action. It would be directed by Jones based on a script by Jones and Gavin Scott. The plot revolves around a teacher who discovers aliens (voiced by the Pythons) have given him magical powers to do "absolutely anything".[42] Eric Idle responded via Twitter that he would not, in fact, be participating,[43] although he was later added to the cast.[44]

Monty Python Live (Mostly): One Down, Five to Go[edit]

Main article: Monty Python Live (Mostly)
Members of Monty Python on stage at the O2 Arena, London, in July 2014

In 2013, the Pythons lost a legal case to Mark Forstater, the film producer of Monty Python and the Holy Grail, over royalties for the derivative work Spamalot. They owed a combined £800,000 in legal fees and back royalties to Forstater. They proposed a reunion show to pay their legal bill.[45]

On 19 November 2013, a new reunion was reported, following months of "secret talks".[46] The original plan was for a live, one-off stage show at the O2 Arena in London on 1 July 2014, with "some of Monty Python's greatest hits, with modern, topical, Pythonesque twists" according to a press release.[47][48][49] The tickets for this show went on sale in November 2013 and sold out in just 43 seconds.[50] Nine additional shows were added, all of them at the O2, the last on 20 July. They have said that their reunion was inspired by South Park creators Trey Parker and Matt Stone, who are massive Monty Python fans.[51]

Michael Palin stated that the final reunion show on 20 July would be the last time that the troupe would perform together. The event was first shown live from the UK nationwide and was titled Monty Python Live (Mostly) and was later reshown at select theatres in recorded form in August.[52][53]

Python members[edit]

Graham Chapman was originally a medical student, joining the Footlights at Cambridge. He completed his medical training and was legally entitled to practice as a doctor. Chapman is best remembered for the lead roles in Holy Grail, as King Arthur, and Life of Brian, as Brian Cohen. He died of spinal and throat cancer on 4 October 1989. At Chapman's memorial service, Cleese delivered an irreverent eulogy that included all the euphemisms for being dead from the "Dead Parrot" sketch, which they had written. Chapman's comedic fictional memoir, A Liar's Autobiography, was adapted into an animated 3D movie in 2012.

John Cleese is the oldest Python. He met his future Python writing partner, Chapman, in Cambridge. Outside of Python, he is best known for setting up the Video Arts group and for the sitcom Fawlty Towers (co-written with Connie Booth, whom Cleese met during work on Python and to whom he was married for a decade). Cleese has also co-authored several books on psychology and wrote the screenplay for the award-winning A Fish Called Wanda, in which he starred with Michael Palin.

Terry Gilliam, an American by birth, is the only member of the troupe of non-British origin.[54] He started off as an animator and strip cartoonist for Harvey Kurtzman's Help! magazine, one issue of which featured Cleese. Moving from the US to England, he animated features for Do Not Adjust Your Set and was then asked by its makers to join them on their next project: Monty Python's Flying Circus. He co-directed Monty Python and the Holy Grail and directed short segments of other Python films (for instance "The Crimson Permanent Assurance", the short film that appears before The Meaning of Life).

When Monty Python was first formed, two writing partnerships were already in place: Cleese and Chapman, Jones and Palin. That left two in their own corners: Gilliam, operating solo due to the nature of his work, and Eric Idle. Regular themes in Idle's contributions were elaborate wordplay and musical numbers. After Flying Circus, he hosted Saturday Night Live four times in the first five seasons. Idle's initially successful solo career faltered in the 1990s with the failures of his 1993 film Splitting Heirs (written, produced by, and starring him) and 1998's An Alan Smithee Film: Burn Hollywood Burn (in which he starred), which was awarded five Razzies, including 'Worst Picture of the Year'. He revived his career by returning to the source of his worldwide fame, adapting Monty Python material for other media. He also wrote the Broadway musical Spamalot, based on the Holy Grail movie. He also wrote Not the Messiah, an oratorio derived from the Life of Brian.

Terry Jones has been described by other members of the team as the "heart" of the operation. Jones had a lead role in maintaining the group's unity and creative independence. Python biographer George Perry has commented that should "[you] speak to him on subjects as diverse as fossil fuels, or Rupert Bear, or mercenaries in the Middle Ages or Modern China ... in a moment you will find yourself hopelessly out of your depth, floored by his knowledge." Many others agree that Jones is characterised by his irrepressible, good-natured enthusiasm. However, Jones' passion often led to prolonged arguments with other group members—in particular Cleese—with Jones often unwilling to back down. Since his major contributions were largely behind the scenes (direction, writing), and he often deferred to the other members of the group as an actor, Jones' importance to Python was often under-rated. However, he does have the legacy of delivering possibly the most famous line in all of Python, as Brian's mother Mandy in Life of Brian, "He's not the Messiah, he's a very naughty boy!", a line voted the funniest in film history on two occasions.[55][56]

Michael Palin attended Oxford, where he met his Python writing partner Jones. The two also wrote the series Ripping Yarns together. Palin and Jones originally wrote face-to-face, but soon found it was more productive to write apart and then come together to review what the other had written. Therefore, Jones and Palin's sketches tended to be more focused than that of the others, taking one bizarre situation, sticking to it, and building on it. After Flying Circus, Palin hosted Saturday Night Live four times in the first 10 seasons. His comedy output began to decrease in amount following the increasing success of his travel documentaries for the BBC. Palin released a book of diaries from the Python years entitled Michael Palin Diaries 1969–1979, published in 2007.

Associate Pythons[edit]

Several people have been accorded unofficial "associate Python" status over the years. Occasionally such people have been referred to as the 'seventh Python', in a style reminiscent of George Martin (or other associates of the Beatles) being dubbed "the Fifth Beatle". The two collaborators with the most meaningful and plentiful contributions have been Neil Innes and Carol Cleveland. Both were present and presented as Associate Pythons at the official Monty Python 25th-anniversary celebrations held in Los Angeles in July 1994.

Carol Cleveland in 2009

Neil Innes is the only non-Python besides Douglas Adams to be credited with writing material for Flying Circus. He appeared in sketches and the Python films, as well as performing some of his songs in Monty Python Live at the Hollywood Bowl. He was also a regular stand-in for absent team members on the rare occasions when they recreated sketches. For example, he took the place of Cleese at the Concert for George. Gilliam once noted that if anyone qualified for the title of the seventh Python, it would certainly be Innes. He was one of the creative talents in the off-beat Bonzo Dog Band. He would later portray Ron Nasty of the Rutles and write all of the Rutles' compositions for All You Need Is Cash (1978). By 2005, a falling out had occurred between Idle and Innes over additional Rutles projects, the results being Innes' critically acclaimed Rutles "reunion" album The Rutles: Archaeology and Idle's straight-to-DVD The Rutles 2: Can't Buy Me Lunch, each undertaken without the other's participation. According to an interview with Idle in the Chicago Tribune in May 2005, his attitude is that Innes and he go back "too far. And no further." Innes has remained silent on the dispute.

Carol Cleveland was the most important female performer in the Monty Python ensemble, commonly referred to as "the female Python". She was originally hired by producer/director John Howard Davies for just the first five episodes of the Flying Circus. The Pythons then pushed to make Cleveland a permanent recurring performer after producer/director Ian MacNaughton brought in several other actresses who were not as good as she was.[57] Cleveland went on to appear in about two-thirds of the episodes, as well as in all of the Python films, and in most of their stage shows, as well.

Other contributors[edit]

Cleese's first wife, Connie Booth, appeared as various characters in all four series of Flying Circus. Her most significant role was the "best girl" of the eponymous Lumberjack in "The Lumberjack Song", though this role was sometimes played by Carol Cleveland. Booth appeared in a total of six sketches and also played one-off characters in Python feature films And Now for Something Completely Different and Monty Python and the Holy Grail.

Douglas Adams was "discovered" by Chapman when a version of Footlights Revue (a 1974 BBC2 television show featuring some of Adams' early work) was performed live in London's West End. In Cleese's absence from the final TV series, the two formed a brief writing partnership, with Adams earning a writing credit in one episode for a sketch called "Patient Abuse". In the sketch, a man who had been stabbed by a nurse arrives at his doctor's office bleeding profusely from the stomach, when the doctor makes him fill in numerous senseless forms before he can administer treatment. He also had two cameo appearances in this season. Firstly, in the episode "The Light Entertainment War", Adams shows up in a surgeon's mask (as Dr. Emile Koning, according to the on-screen captions), pulling on gloves, while Palin narrates a sketch that introduces one person after another, and never actually gets started. Secondly, at the beginning of "Mr. Neutron", Adams is dressed in a "pepperpot" outfit and loads a missile onto a cart being driven by Terry Jones, who is calling out for scrap metal ("Any old iron ..."). Adams and Chapman also subsequently attempted a few non-Python projects, including Out of the Trees. He also contributed to a sketch on the soundtrack album for Monty Python and the Holy Grail.

Other than Carol Cleveland, the only other non-Python to make a significant number of appearances in the Flying Circus was Ian Davidson. He appeared in the first two series of the show, and played over 10 roles. While Davidson is primarily known as a scriptwriter, it is not known if he had any contribution toward the writing of the sketches, as he is only credited as a performer. In total, Davidson is credited as appearing in eight episodes of the show, which is more than any other male actor who was not a Python. Despite this, Davidson did not appear in any Python-related media subsequent to series 2, though footage of him was shown on the documentary Python Night – 30 Years of Monty Python.

Stand-up comedian Eddie Izzard, a devoted fan of the group, has occasionally stood in for absent members. When the BBC held a "Python Night" in 1999 to celebrate 30 years of the first broadcast of Flying Circus, the Pythons recorded some new material with Izzard standing in for Idle, who had declined to partake in person (he taped a solo contribution from the US). Izzard hosted The Life of Python (1999), a history of the group that was part of Python Night and appeared with them at a festival/tribute in Aspen, Colorado, in 1998 (released on DVD as Live at Aspen). Izzard has said that Monty Python was a significant influence on his style of comedy and Cleese has referred to him as "the lost Python".[58]

Series director of Flying Cirus, Ian MacNaughton, is also regularly associated with the group and made a few on-screen appearances in the show and in the film And Now for Something Completely Different. Apart from Neil Innes, others to contribute musically included Fred Tomlinson and the Fred Tomlinson Singers. They made appearances in songs such as "The Lumberjack Song" as a backup choir. In addition, various other contributors and performers for the Pythons included John Howard Davies, John Hughman, Lyn Ashley, Bob Raymond, John Young, Rita Davies, Stanley Mason, Maureen Flanagan, and David Ballantyne.

Timeline[edit]

Monty Python in films

Monty Python live

  • 1970 – Oh Hampstead (Benefit show at St Pancras Town Hall, London, UK)
  • 1971 – Lanchester Arts Festival '71 (Coventry, UK)
  • 1972 – Then Great Western Express Festival (Four day event at Tupholme Hall, Lincolnshire, UK)
  • 1973 – 1st UK Tours (UK)
  • 1973 – 1st Farewell Tours (Canada)
  • 1974 – Live Drury Lane (London, UK)
  • 1976 – Monty Python Live! (NY, USA)
  • 1980 – Monty Python Live at the Hollywood Bowl (LA, USA)
  • 2014 – Monty Python Live (Mostly): One Down, Five To Go (London, UK)

Monty Python reunions

  • 1989 – Parrot Sketch Not Included – 20 Years of Monty Python
  • 1998 – Live at Aspen (Aspen, USA)
  • 1999 – Python Night – 30 Years of Monty Python
  • 2002 – Concert For George (Royal Albert Hall, UK)
  • 2009 – Not the Messiah (He's a Very Naughty Boy) (Royal Albert Hall, UK)
  • 2014 – Monty Python Live (Mostly): One Down, Five To Go (London, UK)

Cultural influence[edit]

By the time of Monty Python's 25th anniversary, in 1994, the point was already being made that "the five surviving members had with the passing years begun to occupy an institutional position in the edifice of British social culture that they had once had so much fun trying to demolish".[59] A similar point is made in a 2006 book on the relationship between Monty and philosophy: "It is remarkable, after all, not only that the utterly bizarre Monty Python's Flying Circus was sponsored by the BBC in the first place, but that Monty Python itself grew into an institution of enormous cultural influence."[60]

Comedy stylists[edit]

Monty Python has been named as being influential to the comedy stylings of a great many additional people including: Sacha Baron Cohen,[62] David Cross,[63] Noel Fielding, Seth MacFarlane,[64] Seth Meyers,[65] Trey Parker,[66] Matt Stone,[66] and Vic and Bob.[67]

Places[edit]

In space
Terrestrial
  • After John Cleese spoke negatively about the town of Palmerston North in New Zealand, recommending it as a good place to commit suicide, the town renamed a compost heap "Mt. Cleese."[69]

"Pythonesque"[edit]

Amongst the more visible cultural influences of Monty Python is the inclusion of terms either directly from, or derived from, Monty Python, into the lexicon of the English language.

  • The most obvious of these is the term 'pythonesque', which has become a byword in surreal humour, and is included in standard dictionaries.[70][71] Terry Jones commented on his disappointment at the existence of such a term, claiming the initial aim of Monty Python was to create something new and impossible to categorise, and "the fact that Pythonesque is now a word in the Oxford English Dictionary shows the extent to which we failed".[72]
  • The term has been applied to animations similar to those constructed by Gilliam (e.g., the cut-out style of South Park, whose creators have often acknowledged a debt to Python, including contributing material to the aforementioned 30th-anniversary theme night).[73]
  • Good Eats creator Alton Brown cited Python as one of the influences that shaped how he created the series, as well as how he authors the script for each episode.[74] Later episodes included Gilliam-style animations to illustrate key points.

TV[edit]

The Japanese anime series, Girls und Panzer, featured the special episode, "Survival War!", which referenced the 'Spam' sketch.[75]

Things named after Monty Python[edit]

Beyond a dictionary definition, Python terms have entered the lexicon in other ways.

  • The term "spam" in reference to bulk, unsolicited email is derived from the programme's 1970 "Spam" sketch.[76]
  • The Python programming language by Guido van Rossum is named after the troupe, and Monty Python references are often found in sample code created for that language. The default integrated development environment of the programming language is named IDLE, an alternative one is named eric, both in honour of Eric Idle. Additionally, a 2001 April Fool's Day joke by van Rossum and Larry Wall involving the merger of Python with Perl was dubbed "Parrot" after the Dead Parrot sketch. The name "Parrot" was later used for a project to develop a virtual machine for running bytecode for interpreted languages such as Perl and Python. Its package index is also known as the "Cheese Shop"[77] after the sketch of the same name. There is also a python refactoring tool called bicyclerepair named after Bicycle Repair Man sketch.[78]
  • In 1985, a fossil of a previously unknown species of gigantic prehistoric snake from the Miocene was discovered in Riversleigh, Queensland, Australia. The Australian palaeontologist who discovered the fossil snake was a Monty Python fan, and he gave the snake the taxonomic name of Montypythonoides riversleighensis in honour of the Monty Python team.[79]
  • In 2006, Ben & Jerry's, known for their "celebrity flavours", introduced to the line-up "Vermonty Python", a coffee liqueur ice cream with a chocolate cookie crumb swirl and fudge cows. The name "Minty Python" had been suggested before in 1996 in a contest to select the quintessential British ice cream flavour.[80][81]
  • In 1999, in connection with the group's 30th anniversary, a beer named "Holy Grail Ale" was released by the Black Sheep Brewery in North Yorkshire.
  • The endangered Bemaraha woolly lemur (Avahi cleesei) is named after John Cleese.[82][83]
  • Geneticists discovered a mutant gene which caused mutant flies to live twice as long as normal ones. They dubbed the gene "Indy," which is an acronym for the line of dialogue: "I'm not dead yet!", from the film Monty Python and the Holy Grail.[69]
  • The band Toad the Wet Sprocket took its name from the Rock Notes[84] sketch on the comedy album, Monty Python's Contractual Obligation Album.[85]

World records[edit]

On St George's Day, 23 April 2007, the cast and creators of Spamalot gathered in Trafalgar Square under the tutelage of the two Terrys (Jones and Gilliam) to set a new record for the world's largest coconut orchestra. They led 5,567 people "clip-clopping" in time to the Python classic, "Always Look on the Bright Side of Life", for the Guinness World Records attempt.[86]

Media[edit]

Main article: Monty Python mediagraphy

Television[edit]

The show that started the Python phenomenon, see also List of Monty Python's Flying Circus episodes
Two 45-minute specials were made by WDR for West German television. The first was recorded in German, while the second was in English with German dubbing.
Six one-hour specials, each episode presenting the best of one member's work

Films[edit]

Five Monty Python productions were released as theatrical films:

A collection of sketches from the first and second TV series of Monty Python's Flying Circus re-enacted and shot for film
King Arthur and his knights embark on a low-budget search for the Holy Grail, encountering humorous obstacles along the way. Some of these turned into stand-alone sketches.
Brian is born on the first Christmas, in the stable next to Jesus'. He spends his life being mistaken for a messiah.
A videotape recording directed by Terry Hughes of a live performance of sketches, it was originally intended for a TV/video special. It was transferred to 35 mm and given a limited theatrical release in the US.
An examination of the meaning of life in a series of sketches from conception to death and beyond

Albums[edit]

Theatre[edit]

  • Monty Python's Flying Circus – Between 1974 and 1980 (Live at the Hollywood Bowl was released in 1982, but was performed in 1980), the Pythons made three sketch-based stage shows, comprising mainly material from the original television series.
  • Monty Python's Spamalot – Written by Idle directed by Mike Nichols, with music and lyrics by John Du Prez and Idle, it starred Hank Azaria, Tim Curry, and David Hyde Pierce; Spamalot is a musical adaptation of the film Monty Python and the Holy Grail. It ran in Chicago from 21 December 2004 to 23 January 2005, and began performances on Broadway on 17 March 2005. It won three Tonys.
  • Not the Messiah – the Toronto Symphony Orchestra commissioned Idle and John Du Prez to write the music and lyrics of an oratorio based on Monty Python's Life of Brian. Entitled Not the Messiah, it had its world premiere as part of Luminato, a "festival of arts and creativity" taking place 1–10 June 2007 in Toronto, Ontario, Canada. Not the Messiah was conducted by Peter Oundjian, Music Director of the Toronto Symphony Orchestra, who is Idle's cousin. It was performed by a narrator, the Toronto Symphony Orchestra, with guest soloists and choir. According to Idle, "It will be funnier than Handel, though not as good".
  • Monty Python Live: One Down, Five to Go – (1–5, 15–16, 18–20 July 2014) The Pythons have stated this is the last live reunion of the remaining members of Monty Python. Held at London's O2 arena, tickets for the first night's show sold out in 43 seconds. The set list included a mix of live performances of their most popular sketches, clips from their shows, and elaborate dance numbers. Each night featured a different celebrity "victim" of the "Blackmail" sketch.

Books[edit]

Games[edit]

See also[edit]

References[edit]

  1. ^ Gilliam was born American and obtained British citizenship in 1968. In protest at George W. Bush, he renounced his American citizenship in January 2006 and is now only a British citizen. "Kopflos am Potsdamer Platz", Der Tagesspiegel (in German), DE, 10 February 2006, archived from the original on 28 August 2007, retrieved 15 September 2007 
  2. ^ Wilmut (1980), p. 250.
  3. ^ Chapman, Graham; Gilliam, Terry; Cleese, John; Idle, Eric; Jones, Terry; Palin, Michael (2003). The Pythons. Orion. ISBN 978-0-7528-5293-5. 
  4. ^ Leopold, Todd (11 December 2003). "How Monty Python changed the world". CNN. Retrieved 30 March 2007. Python has been called 'the Beatles of comedy'. 
  5. ^ Free, David (January 2013). "The Beatles of Comedy". The Atlantic. Retrieved 23 January 2013. 
  6. ^ https://www.telegraph.co.uk/culture/comedy/comedy-news/10459252/Monty-Python-overhyped-Yes-but-theyre-still-the-Beatles-of-comedy.html
  7. ^ "Monty Python Celebrates 25th Anniversary But Nixes Reunion". Orlando Sentinel. 2 October 1996. Retrieved 31 October 2016. 
  8. ^ Wieselman, Jarrett (3 April 2012). "'Holy' Monty Python History Lesson". Entertainment Tonight. Archived from the original on 2 February 2014. Retrieved 24 April 2012. 
  9. ^ Martin, Sami K. (27 January 2012). "'Monty Python' Reunion Planned for New Movie". The Christian Post. Retrieved 24 April 2012. 
  10. ^ "Cook tops poll of comedy greats". The Guardian. 2 January 2005. 
  11. ^ "Cook voted 'comedians' comedian'". BBC News. 2 January 2005. Retrieved 21 September 2008. 
  12. ^ a b The Pythons Autobiography by the Pythons—Graham Chapman, John Cleese, Terry Gilliam, Eric Idle, Terry Jones, Michael Palin, John Chapman, David Sherlock, Bob McCabe—Thomas Dunne Books; Orion, 2003
  13. ^ So, Anyway ... by John Cleese; Crown Archetype, London, 2014
  14. ^ "The Roots of Monty Python". BFI Screenonline. Retrieved 23 January 2013
  15. ^ "The Silliest Interview We've Ever Had / The Silliest Sketch We've Ever Done". MontyPython.net. Retrieved 23 January 2013
  16. ^ Wilmut (1980), p.211
  17. ^ "BBC – Comedy – Monty Python". 
  18. ^ Museum of Broadcast Communications. "Monty Python's Flying Circus". 
  19. ^ Monty Python's Flying Circus Just The Words Volume 1, p33. Methuen, 1990
  20. ^ All Music Guide to Classical Music: The Definitive Guide to Classical Music. San Francisco, CA: Backbeat Books, 2005. Retrieved February 11, 2018
  21. ^ Copyright Term and the Public Domain in the United States – Cornell University Library Copyright Information Center. Retrieved February 11, 2018
  22. ^ Clark, Philip. "Monty Python: Sousa, two-sheds and musical subversions," The Guardian, Friday, July 11, 2014. Retrieved February 12, 2018
  23. ^ "How Spam Meat Has Survived Spam E-Mail". Archived from the original on 19 May 2012. 
  24. ^ a b c d Jamie Bradburn, with reference to Toronto Star article of 2 February 1971 (20 September 2011). "Vintage Toronto Ads: Jack of Hearts' Flying Circus". St. Joseph Media. Retrieved 21 March 2012. 
  25. ^ Lumbard (30 June 1976). "Terry GILLIAM et al., Plaintiffs-Appellants-Appellees, v. AMERICAN BROADCASTING COMPANIES, INC., Defendant-Appellee-Appellant". United States Court of Appeals, Second Circuit. 
  26. ^ David Stewart; David C. Stewart (May 1999). The PBS companion: a history of public television. TV Books. p. 216. ISBN 978-1-57500-050-3. Retrieved 29 September 2010. 
  27. ^ Richard Ouzounian, "Python still has legs", Toronto Star, 16 July 2006
  28. ^ Interview with John Cleese on Q-The Podcast with host John Ghomeshi, on 16 July 2009
  29. ^ "50 Greatest Comedy Films". Channel 4. Archived from the original on 8 July 2008. Retrieved 21 September 2008. 
  30. ^ a b Secret Policeman's Ball recruits New York's finest to Amnesty celebration. The Guardian. Retrieved 24 April 2012
  31. ^ John Cleese on IMDb ; includes prerelease items
  32. ^ a b Parker, Alan; O'Shea, Mick (1 April 2006). And Now For Something Completely Digital: The Complete Illustrated Guide to Monty Python CDs and DVDs. The Disinformation Company. p. 68. ISBN 978-1-932857-31-3. Retrieved 29 September 2010. 
  33. ^ Alleen Pace Nilsen; Don Lee Fred Nilsen (2000). Encyclopedia of 20th-century American humor. Oryx Press. p. 86. ISBN 978-1-57356-218-8. Retrieved 29 September 2010. 
  34. ^ Monty Python reunion 'unlikely', BBC News, 9 September 2003
  35. ^ "No 3-Beatle Reunion, George Harrison Says". The New York Times. Retrieved 6 March 2013. 
  36. ^ Graham Chapman; John Cleese; Terry Gilliam; Eric Idle (15 November 2005). The Pythons Autobiography by the Pythons. Macmillan. p. 328. ISBN 978-0-312-31145-2. Retrieved 29 September 2010. 
  37. ^ Exclusive new Monty Python specials slated to premiere in 2006, PBS, 13 July 2005
  38. ^ mollyblack wrote: (11 July 2009). "retrieved 6 July 2009". The Independent. UK. Retrieved 19 August 2009. 
  39. ^ "Pythons receive BAFTA Special Award". Bafta.org. 18 October 2009. Archived from the original on 8 November 2009. Retrieved 18 October 2009. 
  40. ^ "Monty Python back for 3D animated film". The Daily Telegraph. London. 28 June 2011. 
  41. ^ McNary, Dave (26 January 2012). "Pic reunites Monty Python members". Variety. 
  42. ^ "Monty Python members to star in new film 'Absolutely Anything'". CBS News. 6 February 2013. 
  43. ^ Idle, Eric [@EricIdle] (7 February 2013). "I'm not "Not in a Python film". I'm not in a Terry Jones film. If you can't see the difference then you should probably lie down for a bit" (Tweet) – via Twitter. 
  44. ^ Films, GFM. "Eric Idle". GFM Films. Retrieved 20 February 2014. 
  45. ^ "John Cleese: Monty Python reunion is happening because of my £800,000 legal bill". Daily Mirror. 23 May 2014. Retrieved 28 December 2014. Last July, the Pythons lost a royalties case to Mark Forstater, who produced 1975 film Monty Python and the Holy Grail. ... 
  46. ^ "Me do a silly walk? Not with this artificial hip says Cleese, aged 74: QUENTIN LETTS sees the wrinkly Pythons announce their last hurrah". Daily Mail. 21 November 2013. Retrieved 25 November 2013. 
  47. ^ "Monty Python to reunite for live one-off show in London". BBC News. 21 November 2013. 
  48. ^ "Monty Python reunite for one-off show: 'We can still be funny'". The Daily Telegraph. 21 November 2013. Retrieved 25 November 2013. 
  49. ^ "Is Monty Python's reunion a bit of a joke?". The Guardian. 21 November 2013. Retrieved 25 November 2013. 
  50. ^ Wilkinson, Peter (25 November 2013). "Monty Python reunion show sells out in 43 seconds". CNN. 
  51. ^ Lamden (21 November 2013). "EXCLUSIVE: South Park creators Trey Parker and Matt Stone 'brought Monty Python back together'". Archant. 
  52. ^ "Monty Python to disband after 10 London reunion shows", BBC News, 4 April 2014
  53. ^ "And now, the Holy Grail for Python fans – the reunion stage show: Thousands – some dressed as their favourite acts – descend on O2 for opening night". Daily Mail. 1 July 2014. Retrieved 2 July 2014. 
  54. ^ Morgan, David (6 October 2006). "Terry Gilliam Sounds Off, Director Of 'Brazil' Says Current Events Parallel His Cult Movie". CBS News. Archived from the original on 27 May 2008. Retrieved 21 September 2008. 
  55. ^ French, Philip; Kermode, Mark; Solomons, Jason; Ojumu, Akin; Fox, Killian (22 July 2007). "The last laugh: your favourite 50". The Observer. UK. Retrieved 21 September 2008. 
  56. ^ Womack, Sarah (19 February 2002). "Life of Brian wins the vote for film's best laughter line". The Daily Telegraph. London. Retrieved 21 September 2008. 
  57. ^ "The Pythons: Autobiography". Thomas Dunne Books. 2003. p. 152. ISBN 0-312-31144-3. Of course, Ian [MacNaughton] didn't want to use Carol, he wanted to bring in various bits of totty, so we had a string of people who weren't as good as Carol. Eventually we started pushing for Carol and said, 'We must have Carol for this.' 
  58. ^ Sweeney, Eamon (27 November 2009). "Living the dream: Eddie Izzard". The Irish Independent. Retrieved 30 May 2016. 
  59. ^ Perry, George (1999). The Life of Python. London: Pavilion Books. p. 6. ISBN 1-85793-441-5. Retrieved 24 August 2010. 
  60. ^ Hardcastle, Gary L.; Reisch, George A., eds. (2006). "'What's All This Then?' The Introduction". Monty Python and Philosophy: Nudge Nudge, Think Think!. Vol. 19 in Popular Culture and Philosophy series. Chicago: Open Court. p. 8. ISBN 978-0-8126-9593-9. Retrieved 24 August 2010.  Also ISBN 0-8126-9593-3
  61. ^ Ott, Brian L. (2008). The Small Screen: How Television Equips Us to Live in the Information Age. John Wiley & Sons. p. 103. ISBN 978-1-4051-6154-1. 
  62. ^ "Sacha Baron Cohen: The comic who is always in your face", The Observer, 7 June 2009. Retrieved 10 November 2014
  63. ^ "Profile in Comedy: David Cross – Comedy Writing". Archived from the original on 7 April 2011. 
  64. ^ Pollak, Kevin; MacFarlane, Seth (30 August 2009). "Kevin Pollak Chat Show" (Interview). Interviewed by Kevin Pollak. 
  65. ^ Gaydos, Steve (13 November 2011). "Live from New York: A Discussion with the Saturday Night Live Writers" (Interview). Interviewed by Steve Gaydos. 
  66. ^ a b WebCite query result
  67. ^ "Monty Python 'reuniting': 10 reasons it HAS to come back". Monty Python would itself go on to influence an entire generation of future comedians, from Eddie Izzard to Vic and Bob. 
  68. ^ "SpaceX's 'secret' payload? A wheel of cheese". Los Angeles Times. Retrieved 23 April 2013. 
  69. ^ a b "9 Geekiest Things Named After Monty Python [List]". thegeektwins.com. Retrieved 11 July 2017. 
  70. ^ Pythonesque "Monty Pythonesque" Check |url= value (help). Webster's New Millennium Dictionary of English (Preview Edition (v 0.9.7) ed.). Lexico Publishing Group, LLC. 23 November 2007. 
  71. ^ "Pythonesque, adj." OED Online, Oxford University Press, June 2018. Accessed 22 July 2018.
  72. ^ Jones, Terry (1998). Monty Python: Live at Aspen. 
  73. ^ "Monty Python meets South Park". BBC News. 4 October 1999. Retrieved 21 September 2008. 
  74. ^ Berman, Marc (27 September 2009). "Mr. TV: Food for Thought". Mediaweek. Archived from the original on 2 October 2009. Retrieved 27 October 2009. 
  75. ^ "YouTube: Girls Und Panzer – *pam *pam *pam". 
  76. ^ "RFC 2635 – DON\x27T SPEW A Set of Guidelines for Mass Unsolicited Mailings and Postings (spam*):". Retrieved 29 September 2010. 
  77. ^ "Python For Beginners". Python.org. Retrieved 3 March 2013. 
  78. ^ "Bicycle Repair Man, a Refactoring Tool for Python". Sourceforge.net. Retrieved 12 January 2013. 
  79. ^ Monty Python – a Brief History, BBC, 29 January 2002
  80. ^ "STAN FREBERG HERE – British Ice Cream Flavors:". Retrieved 1 October 2010. Ben & Jerry's Ice Cream has just finished a contest to select the quintessential British ice cream flavor. ... They wanted a kind of "pun" flavor along the lines of their successful American flavor, "Cherry Garcia"--hmm, my favorite. Anyhow, the winner was "Cool Brittania." ... But some of the 7500 losers might have been better. How about this, for British flavors: "Minty Python"? "Jack the Ripple"? Or how about "The Rolling Scones"? 
  81. ^ "American Scoops Up Prize For Name of Brit Ben & Jerry's". Wall Street Journal; reprinted in Orlando Sentinel. 4 July 1996. Retrieved 1 October 2010. If Britain were an ice cream, what flavor would it be? Jack the Ripple? Charles and Diana Split? Those names were floated in a contest run by Ben & Jerry's Homemade Inc. to create the quintessential British ice cream flavor, along the lines of its world-famous American flavor, Cherry Garcia. 
  82. ^ "Endangered lemurs get Fawlty name". BBC News. 11 November 2005. Retrieved 30 May 2016. 
  83. ^ "Avahi cleesei (Bemaraha Woolly Lemur, John Cleese's Avahi)". IUCNredlist.org. Retrieved 30 May 2016. 
  84. ^ "Rock Notes Script". montypython.net. Retrieved 5 October 2017. 
  85. ^ Python, Monty. "Monty Python's Contractual Obligation Album". Monty Python's Official Website. Retrieved 5 October 2017. 
  86. ^ "Spamalot cast sets coconut record". BBC. 
  87. ^ "Monty Python's Flying Circus on World of Spectrum". Worldofspectrum.org. Retrieved 19 August 2009. 
  88. ^ "Monty Python's Flying Circus – Lemon Amiga". lemonamiga.com. Retrieved 3 January 2015. 
  89. ^ "Toy Vault web site for Python-opoly. Retrieved November 20, 2008". Toyvault.com. Retrieved 19 August 2009. 
  90. ^ "Web site for Monty Python Fluxx". Fluxxgames.com. Retrieved 19 August 2009. 
  91. ^ "The Silly Walk Official Website". The Silly Walk Official Website. Boondoggle Studios. Retrieved 25 June 2014. 

Further reading[edit]

External links[edit]

Retrieved from "https://en.wikipedia.org/w/index.php?title=Monty_Python&oldid=855117411"
setuptools-rust-1.2.0/examples/html-py-ever/test/python.html000066400000000000000000065616171421635746700243300ustar00rootroot00000000000000 https://en.wikipedia.org/wiki/Python_(programming_language) 
<!DOCTYPE html>
<html class="client-nojs" lang="en" dir="ltr">
<head>
<meta charset="UTF-8"/>
<title>Python (programming language) - Wikipedia</title>
<script>document.documentElement.className = document.documentElement.className.replace( /(^|\s)client-nojs(\s|$)/, "$1client-js$2" );</script>
<script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"Python_(programming_language)","wgTitle":"Python (programming language)","wgCurRevisionId":857558405,"wgRevisionId":857558405,"wgArticleId":23862,"wgIsArticle":true,"wgIsRedirect":false,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":["CS1 errors: external links","Wikipedia semi-protected pages","All articles with unsourced statements","Articles with unsourced statements from October 2017","Wikipedia articles needing clarification from May 2018","Articles with unsourced statements from May 2018","Articles containing potentially dated statements from March 2018","All articles containing potentially dated statements","Articles containing potentially dated statements from August 2016","Articles containing potentially dated statements from January 2018","Articles with Curlie links","Wikipedia articles with BNF identifiers","Wikipedia articles with GND identifiers","Wikipedia articles with LCCN identifiers","Wikipedia articles with SUDOC identifiers","Good articles","Use dmy dates from August 2015","Programming languages","Class-based programming languages","Computational notebook","Computer science in the Netherlands","Cross-platform free software","Dutch inventions","Dynamically typed programming languages","Educational programming languages","High-level programming languages","Information technology in the Netherlands","Object-oriented programming languages","Programming languages created in 1991","Python (programming language)","Scripting languages","Text-oriented programming languages","Cross-platform software"],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgPageContentModel":"wikitext","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"Python_(programming_language)","wgRelevantArticleId":23862,"wgRequestId":"W4qT9gpAMFwAABW83HsAAAAS","wgCSPNonce":false,"wgIsProbablyEditable":false,"wgRelevantPageIsProbablyEditable":false,"wgRestrictionEdit":["autoconfirmed"],"wgRestrictionMove":[],"wgFlaggedRevsParams":{"tags":{}},"wgStableRevisionId":null,"wgCategoryTreePageCategoryOptions":"{\"mode\":0,\"hideprefix\":20,\"showcount\":true,\"namespaces\":false}","wgWikiEditorEnabledModules":[],"wgBetaFeaturesFeatures":[],"wgMediaViewerOnClick":true,"wgMediaViewerEnabledByDefault":true,"wgPopupsShouldSendModuleToUser":true,"wgPopupsConflictsWithNavPopupGadget":false,"wgVisualEditor":{"pageLanguageCode":"en","pageLanguageDir":"ltr","pageVariantFallbacks":"en","usePageImages":true,"usePageDescriptions":true},"wgMFExpandAllSectionsUserOption":true,"wgMFEnableFontChanger":true,"wgMFDisplayWikibaseDescriptions":{"search":true,"nearby":true,"watchlist":true,"tagline":false},"wgRelatedArticles":null,"wgRelatedArticlesUseCirrusSearch":true,"wgRelatedArticlesOnlyUseCirrusSearch":false,"wgULSCurrentAutonym":"English","wgNoticeProject":"wikipedia","wgCentralNoticeCookiesToDelete":[],"wgCentralNoticeCategoriesUsingLegacy":["Fundraising","fundraising"],"wgWikibaseItemId":"Q28865","wgScoreNoteLanguages":{"arabic":"العربية","catalan":"català","deutsch":"Deutsch","english":"English","espanol":"español","italiano":"italiano","nederlands":"Nederlands","norsk":"norsk","portugues":"português","suomi":"suomi","svenska":"svenska","vlaams":"West-Vlams"},"wgScoreDefaultNoteLanguage":"nederlands","wgCentralAuthMobileDomain":false,"wgCodeMirrorEnabled":true,"wgVisualEditorToolbarScrollOffset":0,"wgVisualEditorUnsupportedEditParams":["undo","undoafter","veswitched"],"wgEditSubmitButtonLabelPublish":true});mw.loader.state({"ext.gadget.charinsert-styles":"ready","ext.globalCssJs.user.styles":"ready","ext.globalCssJs.site.styles":"ready","site.styles":"ready","noscript":"ready","user.styles":"ready","ext.globalCssJs.user":"ready","ext.globalCssJs.site":"ready","user":"ready","user.options":"ready","user.tokens":"loading","ext.cite.styles":"ready","mediawiki.legacy.shared":"ready","mediawiki.legacy.commonPrint":"ready","mediawiki.toc.styles":"ready","wikibase.client.init":"ready","ext.visualEditor.desktopArticleTarget.noscript":"ready","ext.uls.interlanguage":"ready","ext.wikimediaBadges":"ready","mediawiki.skinning.interface":"ready","skins.vector.styles":"ready"});mw.loader.implement("user.tokens@1dqfd7l",function($,jQuery,require,module){/*@nomin*/mw.user.tokens.set({"editToken":"+\\","patrolToken":"+\\","watchToken":"+\\","csrfToken":"+\\"});
});mw.loader.load(["ext.cite.a11y","site","mediawiki.page.startup","mediawiki.user","mediawiki.page.ready","mediawiki.toc","mediawiki.searchSuggest","ext.gadget.teahouse","ext.gadget.ReferenceTooltips","ext.gadget.watchlist-notice","ext.gadget.DRN-wizard","ext.gadget.charinsert","ext.gadget.refToolbar","ext.gadget.extra-toolbar-buttons","ext.gadget.switcher","ext.centralauth.centralautologin","mmv.head","mmv.bootstrap.autostart","ext.popups","ext.visualEditor.desktopArticleTarget.init","ext.visualEditor.targetLoader","ext.eventLogging.subscriber","ext.wikimediaEvents","ext.navigationTiming","ext.uls.eventlogger","ext.uls.init","ext.uls.compactlinks","ext.uls.interface","ext.3d","ext.centralNotice.geoIP","ext.centralNotice.startUp","skins.vector.js"]);});</script>
<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=ext.cite.styles%7Cext.uls.interlanguage%7Cext.visualEditor.desktopArticleTarget.noscript%7Cext.wikimediaBadges%7Cmediawiki.legacy.commonPrint%2Cshared%7Cmediawiki.skinning.interface%7Cmediawiki.toc.styles%7Cskins.vector.styles%7Cwikibase.client.init&amp;only=styles&amp;skin=vector"/>
<script async="" src="/w/load.php?debug=false&amp;lang=en&amp;modules=startup&amp;only=scripts&amp;skin=vector"></script>
<meta name="ResourceLoaderDynamicStyles" content=""/>
<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=ext.gadget.charinsert-styles&amp;only=styles&amp;skin=vector"/>
<link rel="stylesheet" href="/w/load.php?debug=false&amp;lang=en&amp;modules=site.styles&amp;only=styles&amp;skin=vector"/>
<meta name="generator" content="MediaWiki 1.32.0-wmf.19"/>
<meta name="referrer" content="origin"/>
<meta name="referrer" content="origin-when-crossorigin"/>
<meta name="referrer" content="origin-when-cross-origin"/>
<link rel="alternate" href="android-app://org.wikipedia/http/en.m.wikipedia.org/wiki/Python_(programming_language)"/>
<link rel="apple-touch-icon" href="/static/apple-touch/wikipedia.png"/>
<link rel="shortcut icon" href="/static/favicon/wikipedia.ico"/>
<link rel="search" type="application/opensearchdescription+xml" href="/w/opensearch_desc.php" title="Wikipedia (en)"/>
<link rel="EditURI" type="application/rsd+xml" href="//en.wikipedia.org/w/api.php?action=rsd"/>
<link rel="license" href="//creativecommons.org/licenses/by-sa/3.0/"/>
<link rel="canonical" href="https://en.wikipedia.org/wiki/Python_(programming_language)"/>
<link rel="dns-prefetch" href="//login.wikimedia.org"/>
<link rel="dns-prefetch" href="//meta.wikimedia.org" />
<!--[if lt IE 9]><script src="/w/load.php?debug=false&amp;lang=en&amp;modules=html5shiv&amp;only=scripts&amp;skin=vector&amp;sync=1"></script><![endif]-->
</head>
<body class="mediawiki ltr sitedir-ltr mw-hide-empty-elt ns-0 ns-subject page-Python_programming_language rootpage-Python_programming_language skin-vector action-view">		<div id="mw-page-base" class="noprint"></div>
		<div id="mw-head-base" class="noprint"></div>
		<div id="content" class="mw-body" role="main">
			<a id="top"></a>
			<div id="siteNotice" class="mw-body-content"><!-- CentralNotice --></div><div class="mw-indicators mw-body-content">
<div id="mw-indicator-good-star" class="mw-indicator"><a href="/wiki/Wikipedia:Good_articles" title="This is a good article. Follow the link for more information."><img alt="This is a good article. Follow the link for more information." src="//upload.wikimedia.org/wikipedia/en/thumb/9/94/Symbol_support_vote.svg/19px-Symbol_support_vote.svg.png" width="19" height="20" srcset="//upload.wikimedia.org/wikipedia/en/thumb/9/94/Symbol_support_vote.svg/29px-Symbol_support_vote.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/9/94/Symbol_support_vote.svg/39px-Symbol_support_vote.svg.png 2x" data-file-width="180" data-file-height="185" /></a></div>
<div id="mw-indicator-pp-default" class="mw-indicator"><a href="/wiki/Wikipedia:Protection_policy#semi" title="This article is semi-protected until November 30, 2018."><img alt="Page semi-protected" src="//upload.wikimedia.org/wikipedia/commons/thumb/f/fc/Padlock-silver.svg/20px-Padlock-silver.svg.png" width="20" height="20" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/f/fc/Padlock-silver.svg/30px-Padlock-silver.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/f/fc/Padlock-silver.svg/40px-Padlock-silver.svg.png 2x" data-file-width="128" data-file-height="128" /></a></div>
</div>
<h1 id="firstHeading" class="firstHeading" lang="en">Python (programming language)</h1>			<div id="bodyContent" class="mw-body-content">
				<div id="siteSub" class="noprint">From Wikipedia, the free encyclopedia</div>				<div id="contentSub"></div>
				<div id="jump-to-nav"></div>				<a class="mw-jump-link" href="#mw-head">Jump to navigation</a>
				<a class="mw-jump-link" href="#p-search">Jump to search</a>
				<div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr"><div class="mw-parser-output"><p class="mw-empty-elt">
</p>
<table class="infobox vevent" style="width:22em"><caption class="summary">Python</caption><tbody><tr><td colspan="2" style="text-align:center">
<a href="/wiki/File:Python_logo_and_wordmark.svg" class="image"><img alt="Python logo and wordmark.svg" src="//upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/200px-Python_logo_and_wordmark.svg.png" width="200" height="59" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/300px-Python_logo_and_wordmark.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/f/f8/Python_logo_and_wordmark.svg/400px-Python_logo_and_wordmark.svg.png 2x" data-file-width="486" data-file-height="144" /></a></td></tr><tr><th scope="row"><a href="/wiki/Programming_paradigm" title="Programming paradigm">Paradigm</a></th><td>
<a href="/wiki/Object-oriented_programming" title="Object-oriented programming">Object-oriented</a>, <a href="/wiki/Imperative_programming" title="Imperative programming">imperative</a>, <a href="/wiki/Functional_programming" title="Functional programming">functional</a>, <a href="/wiki/Procedural_programming" title="Procedural programming">procedural</a>, <a href="/wiki/Reflective_programming" class="mw-redirect" title="Reflective programming">reflective</a></td></tr><tr><th scope="row"><a href="/wiki/Software_design" title="Software design">Designed&#160;by</a></th><td>
<a href="/wiki/Guido_van_Rossum" title="Guido van Rossum">Guido van Rossum</a></td></tr><tr><th scope="row"><a href="/wiki/Software_developer" title="Software developer">Developer</a></th><td class="organiser">
<a href="/wiki/Python_Software_Foundation" title="Python Software Foundation">Python Software Foundation</a></td></tr><tr><th scope="row">First&#160;appeared</th><td>
1990<span class="noprint">&#59;&#32;28&#160;years ago</span><span style="display:none">&#160;(<span class="bday dtstart published updated">1990</span>)</span><sup id="cite_ref-guttag_1-0" class="reference"><a href="#cite_note-guttag-1">&#91;1&#93;</a></sup></td></tr><tr><td colspan="2" style="text-align:center">
</td></tr><tr><th scope="row" style="white-space: nowrap;"><a href="/wiki/Software_release_life_cycle" title="Software release life cycle">Stable release</a></th><td>
<div style="margin:0px;">3.7.0 / 27&#160;June 2018<span class="noprint">&#59;&#32;2 months ago</span><span style="display:none">&#160;(<span class="bday dtstart published updated">2018-06-27</span>)</span><sup id="cite_ref-2" class="reference"><a href="#cite_note-2">&#91;2&#93;</a></sup><br />2.7.15 / 1&#160;May 2018<span class="noprint">&#59;&#32;3 months ago</span><span style="display:none">&#160;(<span class="bday dtstart published updated">2018-05-01</span>)</span><sup id="cite_ref-3" class="reference"><a href="#cite_note-3">&#91;3&#93;</a></sup>
   </div></td></tr><tr style="display:none"><td colspan="2">
</td></tr><tr><th scope="row"><a href="/wiki/Type_system" title="Type system">Typing discipline</a></th><td>
<p><a href="/wiki/Duck_typing" title="Duck typing">Duck</a>, <a href="/wiki/Dynamic_typing" class="mw-redirect" title="Dynamic typing">dynamic</a>, <a href="/wiki/Strong_typing" class="mw-redirect" title="Strong typing">strong</a>
<b>since version 3.5:</b>
</p>
<a href="/wiki/Gradual_typing" title="Gradual typing">Gradual</a><sup id="cite_ref-4" class="reference"><a href="#cite_note-4">&#91;4&#93;</a></sup></td></tr><tr><th scope="row"><a href="/wiki/Software_license" title="Software license">License</a></th><td>
<a href="/wiki/Python_Software_Foundation_License" title="Python Software Foundation License">Python Software Foundation License</a></td></tr><tr><th scope="row"><a href="/wiki/Filename_extension" title="Filename extension">Filename extensions</a></th><td>
.py, .pyc, .pyd, .pyo (prior to 3.5),<sup id="cite_ref-5" class="reference"><a href="#cite_note-5">&#91;5&#93;</a></sup> .pyw, .pyz (since 3.5)<sup id="cite_ref-6" class="reference"><a href="#cite_note-6">&#91;6&#93;</a></sup></td></tr><tr><th scope="row">Website</th><td>
<span class="url"><a rel="nofollow" class="external text" href="https://www.python.org/">www<wbr />.python<wbr />.org</a></span></td></tr><tr><th colspan="2" style="text-align:center;background-color: #eee;">Major <a href="/wiki/Programming_language_implementation" title="Programming language implementation">implementations</a></th></tr><tr><td colspan="2" style="text-align:center">
<a href="/wiki/CPython" title="CPython">CPython</a>, <a href="/wiki/IronPython" title="IronPython">IronPython</a>, <a href="/wiki/Jython" title="Jython">Jython</a>, <a href="/wiki/MicroPython" title="MicroPython">MicroPython</a>, <a href="/wiki/Numba" title="Numba">Numba</a>, <a href="/wiki/PyPy" title="PyPy">PyPy</a>, <a href="/wiki/Stackless_Python" title="Stackless Python">Stackless Python</a></td></tr><tr><th colspan="2" style="text-align:center;background-color: #eee;"><a href="/wiki/Dialect_(computing)" class="mw-redirect" title="Dialect (computing)">Dialects</a></th></tr><tr><td colspan="2" style="text-align:center">
<a href="/wiki/Cython" title="Cython">Cython</a>, <a href="/wiki/RPython" class="mw-redirect" title="RPython">RPython</a></td></tr><tr><th colspan="2" style="text-align:center;background-color: #eee;">Influenced by</th></tr><tr><td colspan="2" style="text-align:center">
<a href="/wiki/ABC_(programming_language)" title="ABC (programming language)">ABC</a>,<sup id="cite_ref-faq-created_7-0" class="reference"><a href="#cite_note-faq-created-7">&#91;7&#93;</a></sup> <a href="/wiki/ALGOL_68" title="ALGOL 68">ALGOL 68</a>,<sup id="cite_ref-98-interview_8-0" class="reference"><a href="#cite_note-98-interview-8">&#91;8&#93;</a></sup> <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a>,<sup id="cite_ref-AutoNT-1_9-0" class="reference"><a href="#cite_note-AutoNT-1-9">&#91;9&#93;</a></sup> <a href="/wiki/C%2B%2B" title="C++">C++</a>,<sup id="cite_ref-classmix_10-0" class="reference"><a href="#cite_note-classmix-10">&#91;10&#93;</a></sup> <a href="/wiki/CLU_(programming_language)" title="CLU (programming language)">CLU</a>,<sup id="cite_ref-effbot-call-by-object_11-0" class="reference"><a href="#cite_note-effbot-call-by-object-11">&#91;11&#93;</a></sup> <a href="/wiki/Dylan_(programming_language)" title="Dylan (programming language)">Dylan</a>,<sup id="cite_ref-AutoNT-2_12-0" class="reference"><a href="#cite_note-AutoNT-2-12">&#91;12&#93;</a></sup> <a href="/wiki/Haskell_(programming_language)" title="Haskell (programming language)">Haskell</a>,<sup id="cite_ref-AutoNT-3_13-0" class="reference"><a href="#cite_note-AutoNT-3-13">&#91;13&#93;</a></sup> <a href="/wiki/Icon_(programming_language)" title="Icon (programming language)">Icon</a>,<sup id="cite_ref-AutoNT-4_14-0" class="reference"><a href="#cite_note-AutoNT-4-14">&#91;14&#93;</a></sup> <a href="/wiki/Java_(programming_language)" title="Java (programming language)">Java</a>,<sup id="cite_ref-AutoNT-5_15-0" class="reference"><a href="#cite_note-AutoNT-5-15">&#91;15&#93;</a></sup> <a href="/wiki/Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a>,<sup id="cite_ref-AutoNT-6_16-0" class="reference"><a href="#cite_note-AutoNT-6-16">&#91;16&#93;</a></sup> <a href="/wiki/Modula-3" title="Modula-3">Modula-3</a>,<sup id="cite_ref-classmix_10-1" class="reference"><a href="#cite_note-classmix-10">&#91;10&#93;</a></sup> <a href="/wiki/Perl" title="Perl">Perl</a></td></tr><tr><th colspan="2" style="text-align:center;background-color: #eee;">Influenced</th></tr><tr><td colspan="2" style="text-align:center">
<a href="/wiki/Boo_(programming_language)" title="Boo (programming language)">Boo</a>, <a href="/wiki/Cobra_(programming_language)" title="Cobra (programming language)">Cobra</a>,  <a href="/wiki/CoffeeScript" title="CoffeeScript">CoffeeScript</a>,<sup id="cite_ref-17" class="reference"><a href="#cite_note-17">&#91;17&#93;</a></sup> <a href="/wiki/D_(programming_language)" title="D (programming language)">D</a>, <a href="/wiki/F_Sharp_(programming_language)" title="F Sharp (programming language)">F#</a>, <a href="/wiki/Falcon_(programming_language)" title="Falcon (programming language)">Falcon</a>, <a href="/wiki/Genie_(programming_language)" title="Genie (programming language)">Genie</a>,<sup id="cite_ref-18" class="reference"><a href="#cite_note-18">&#91;18&#93;</a></sup> <a href="/wiki/Go_(programming_language)" title="Go (programming language)">Go</a>, <a href="/wiki/Apache_Groovy" title="Apache Groovy">Apache Groovy</a>, <a href="/wiki/JavaScript" title="JavaScript">JavaScript</a>,<sup id="cite_ref-19" class="reference"><a href="#cite_note-19">&#91;19&#93;</a></sup><sup id="cite_ref-20" class="reference"><a href="#cite_note-20">&#91;20&#93;</a></sup> <a href="/wiki/Julia_(programming_language)" title="Julia (programming language)">Julia</a>,<sup id="cite_ref-Julia_21-0" class="reference"><a href="#cite_note-Julia-21">&#91;21&#93;</a></sup> <a href="/wiki/Nim_(programming_language)" title="Nim (programming language)">Nim</a>, <a href="/wiki/Ring_(programming_language)" title="Ring (programming language)">Ring</a>,<sup id="cite_ref-The_Ring_programming_language_and_other_languages_22-0" class="reference"><a href="#cite_note-The_Ring_programming_language_and_other_languages-22">&#91;22&#93;</a></sup> <a href="/wiki/Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>,<sup id="cite_ref-bini_23-0" class="reference"><a href="#cite_note-bini-23">&#91;23&#93;</a></sup> <a href="/wiki/Swift_(programming_language)" title="Swift (programming language)">Swift</a><sup id="cite_ref-lattner2014_24-0" class="reference"><a href="#cite_note-lattner2014-24">&#91;24&#93;</a></sup></td></tr><tr><td colspan="2" class="hlist" style="text-align:center;border-top: 1px solid #aaa; padding-top: 3px;">
<ul><li><a href="/wiki/File:Wikibooks-logo-en-noslogan.svg" class="image"><img alt="" src="//upload.wikimedia.org/wikipedia/commons/thumb/d/df/Wikibooks-logo-en-noslogan.svg/16px-Wikibooks-logo-en-noslogan.svg.png" width="16" height="16" class="noviewer" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/d/df/Wikibooks-logo-en-noslogan.svg/24px-Wikibooks-logo-en-noslogan.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/d/df/Wikibooks-logo-en-noslogan.svg/32px-Wikibooks-logo-en-noslogan.svg.png 2x" data-file-width="400" data-file-height="400" /></a> <a href="https://en.wikibooks.org/wiki/Python_Programming" class="extiw" title="wikibooks:Python Programming">Python Programming</a> at Wikibooks</li></ul>
</td></tr></tbody></table>
<p><b>Python</b> is an <a href="/wiki/Interpreted_language" title="Interpreted language">interpreted</a> <a href="/wiki/High-level_programming_language" title="High-level programming language">high-level programming language</a> for <a href="/wiki/General-purpose_programming_language" title="General-purpose programming language">general-purpose programming</a>. Created by <a href="/wiki/Guido_van_Rossum" title="Guido van Rossum">Guido van Rossum</a> and first released in 1991, Python has a design philosophy that emphasizes <a href="/wiki/Code_readability" class="mw-redirect" title="Code readability">code readability</a>, notably using <a href="/wiki/Significant_whitespace" class="mw-redirect" title="Significant whitespace">significant whitespace</a>. It provides constructs that enable clear programming on both small and large scales.<sup id="cite_ref-AutoNT-7_25-0" class="reference"><a href="#cite_note-AutoNT-7-25">&#91;25&#93;</a></sup> In July 2018, Van Rossum stepped down as the leader in the language community after 30 years.<sup id="cite_ref-26" class="reference"><a href="#cite_note-26">&#91;26&#93;</a></sup><sup id="cite_ref-27" class="reference"><a href="#cite_note-27">&#91;27&#93;</a></sup>
</p><p>Python features a <a href="/wiki/Dynamic_type" class="mw-redirect" title="Dynamic type">dynamic type</a> system and automatic <a href="/wiki/Memory_management" title="Memory management">memory management</a>. It supports multiple <a href="/wiki/Programming_paradigm" title="Programming paradigm">programming paradigms</a>, including <a href="/wiki/Object-oriented_programming" title="Object-oriented programming">object-oriented</a>, <a href="/wiki/Imperative_programming" title="Imperative programming">imperative</a>, <a href="/wiki/Functional_programming" title="Functional programming">functional</a> and <a href="/wiki/Procedural_programming" title="Procedural programming">procedural</a>, and has a large and comprehensive <a href="/wiki/Standard_library" title="Standard library">standard library</a>.<sup id="cite_ref-About_28-0" class="reference"><a href="#cite_note-About-28">&#91;28&#93;</a></sup>
</p><p>Python interpreters are available for many <a href="/wiki/Operating_system" title="Operating system">operating systems</a>. <a href="/wiki/CPython" title="CPython">CPython</a>, the <a href="/wiki/Reference_implementation" title="Reference implementation">reference implementation</a> of Python, is <a href="/wiki/Open_source" class="mw-redirect" title="Open source">open source</a> software<sup id="cite_ref-29" class="reference"><a href="#cite_note-29">&#91;29&#93;</a></sup> and has a community-based development model, as do nearly all of Python's other implementations. Python and CPython are managed by the non-profit <a href="/wiki/Python_Software_Foundation" title="Python Software Foundation">Python Software Foundation</a>.
</p>
<div id="toc" class="toc"><input type="checkbox" role="button" id="toctogglecheckbox" class="toctogglecheckbox" style="display:none" /><div class="toctitle" lang="en" dir="ltr"><h2>Contents</h2><span class="toctogglespan"><label class="toctogglelabel" for="toctogglecheckbox"></label></span></div>
<ul>
<li class="toclevel-1 tocsection-1"><a href="#History"><span class="tocnumber">1</span> <span class="toctext">History</span></a></li>
<li class="toclevel-1 tocsection-2"><a href="#Features_and_philosophy"><span class="tocnumber">2</span> <span class="toctext">Features and philosophy</span></a></li>
<li class="toclevel-1 tocsection-3"><a href="#Syntax_and_semantics"><span class="tocnumber">3</span> <span class="toctext">Syntax and semantics</span></a>
<ul>
<li class="toclevel-2 tocsection-4"><a href="#Indentation"><span class="tocnumber">3.1</span> <span class="toctext">Indentation</span></a></li>
<li class="toclevel-2 tocsection-5"><a href="#Statements_and_control_flow"><span class="tocnumber">3.2</span> <span class="toctext">Statements and control flow</span></a></li>
<li class="toclevel-2 tocsection-6"><a href="#Expressions"><span class="tocnumber">3.3</span> <span class="toctext">Expressions</span></a></li>
<li class="toclevel-2 tocsection-7"><a href="#Methods"><span class="tocnumber">3.4</span> <span class="toctext">Methods</span></a></li>
<li class="toclevel-2 tocsection-8"><a href="#Typing"><span class="tocnumber">3.5</span> <span class="toctext">Typing</span></a></li>
<li class="toclevel-2 tocsection-9"><a href="#Mathematics"><span class="tocnumber">3.6</span> <span class="toctext">Mathematics</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-10"><a href="#Libraries"><span class="tocnumber">4</span> <span class="toctext">Libraries</span></a></li>
<li class="toclevel-1 tocsection-11"><a href="#Development_environments"><span class="tocnumber">5</span> <span class="toctext">Development environments</span></a></li>
<li class="toclevel-1 tocsection-12"><a href="#Implementations"><span class="tocnumber">6</span> <span class="toctext">Implementations</span></a>
<ul>
<li class="toclevel-2 tocsection-13"><a href="#Reference_implementation"><span class="tocnumber">6.1</span> <span class="toctext">Reference implementation</span></a></li>
<li class="toclevel-2 tocsection-14"><a href="#Other_implementations"><span class="tocnumber">6.2</span> <span class="toctext">Other implementations</span></a></li>
<li class="toclevel-2 tocsection-15"><a href="#Unsupported_implementations"><span class="tocnumber">6.3</span> <span class="toctext">Unsupported implementations</span></a></li>
<li class="toclevel-2 tocsection-16"><a href="#Cross-compilers_to_other_languages"><span class="tocnumber">6.4</span> <span class="toctext">Cross-compilers to other languages</span></a></li>
<li class="toclevel-2 tocsection-17"><a href="#Performance"><span class="tocnumber">6.5</span> <span class="toctext">Performance</span></a></li>
</ul>
</li>
<li class="toclevel-1 tocsection-18"><a href="#Development"><span class="tocnumber">7</span> <span class="toctext">Development</span></a></li>
<li class="toclevel-1 tocsection-19"><a href="#Naming"><span class="tocnumber">8</span> <span class="toctext">Naming</span></a></li>
<li class="toclevel-1 tocsection-20"><a href="#Uses"><span class="tocnumber">9</span> <span class="toctext">Uses</span></a></li>
<li class="toclevel-1 tocsection-21"><a href="#Languages_influenced_by_Python"><span class="tocnumber">10</span> <span class="toctext">Languages influenced by Python</span></a></li>
<li class="toclevel-1 tocsection-22"><a href="#See_also"><span class="tocnumber">11</span> <span class="toctext">See also</span></a></li>
<li class="toclevel-1 tocsection-23"><a href="#References"><span class="tocnumber">12</span> <span class="toctext">References</span></a></li>
<li class="toclevel-1 tocsection-24"><a href="#Further_reading"><span class="tocnumber">13</span> <span class="toctext">Further reading</span></a></li>
<li class="toclevel-1 tocsection-25"><a href="#External_links"><span class="tocnumber">14</span> <span class="toctext">External links</span></a></li>
</ul>
</div>

<h2><span class="mw-headline" id="History">History</span></h2>
<div class="thumb tright"><div class="thumbinner" style="width:222px;"><a href="/wiki/File:Guido_van_Rossum_OSCON_2006.jpg" class="image"><img alt="" src="//upload.wikimedia.org/wikipedia/commons/thumb/6/66/Guido_van_Rossum_OSCON_2006.jpg/220px-Guido_van_Rossum_OSCON_2006.jpg" width="220" height="330" class="thumbimage" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/6/66/Guido_van_Rossum_OSCON_2006.jpg/330px-Guido_van_Rossum_OSCON_2006.jpg 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/6/66/Guido_van_Rossum_OSCON_2006.jpg/440px-Guido_van_Rossum_OSCON_2006.jpg 2x" data-file-width="2336" data-file-height="3504" /></a>  <div class="thumbcaption"><div class="magnify"><a href="/wiki/File:Guido_van_Rossum_OSCON_2006.jpg" class="internal" title="Enlarge"></a></div><a href="/wiki/Guido_van_Rossum" title="Guido van Rossum">Guido van Rossum</a>, the creator of Python</div></div></div>
<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="/wiki/History_of_Python" title="History of Python">History of Python</a></div>
<p>Python was conceived in the late 1980s,<sup id="cite_ref-venners-interview-pt-1_30-0" class="reference"><a href="#cite_note-venners-interview-pt-1-30">&#91;30&#93;</a></sup> and its implementation began in December 1989<sup id="cite_ref-timeline-of-python_31-0" class="reference"><a href="#cite_note-timeline-of-python-31">&#91;31&#93;</a></sup> by <a href="/wiki/Guido_van_Rossum" title="Guido van Rossum">Guido van Rossum</a> at <a href="/wiki/Centrum_Wiskunde_%26_Informatica" title="Centrum Wiskunde &amp; Informatica">Centrum Wiskunde &amp; Informatica</a> (CWI) in the <a href="/wiki/Netherlands" title="Netherlands">Netherlands</a> as a successor to the <a href="/wiki/ABC_(programming_language)" title="ABC (programming language)">ABC language</a> (itself inspired by <a href="/wiki/SETL" title="SETL">SETL</a>)<sup id="cite_ref-AutoNT-12_32-0" class="reference"><a href="#cite_note-AutoNT-12-32">&#91;32&#93;</a></sup> capable of <a href="/wiki/Exception_handling" title="Exception handling">exception handling</a> and interfacing with the <a href="/wiki/Amoeba_(operating_system)" title="Amoeba (operating system)">Amoeba</a> operating system.<sup id="cite_ref-faq-created_7-1" class="reference"><a href="#cite_note-faq-created-7">&#91;7&#93;</a></sup> Van Rossum remains Python's principal author. His continuing central role in Python's development is reflected in the title given to him by the Python community: <i><a href="/wiki/Benevolent_Dictator_For_Life" class="mw-redirect" title="Benevolent Dictator For Life">Benevolent Dictator For Life</a></i> (BDFL) – a post from which he gave himself permanent vacation on July 12, 2018.<sup id="cite_ref-lj-bdfl-resignation_33-0" class="reference"><a href="#cite_note-lj-bdfl-resignation-33">&#91;33&#93;</a></sup>
</p><p>On the origins of Python, Van Rossum wrote in 1996:<sup id="cite_ref-34" class="reference"><a href="#cite_note-34">&#91;34&#93;</a></sup>
</p>
<style data-mw-deduplicate="TemplateStyles:r856303468">.mw-parser-output .templatequote{overflow:hidden;margin:1em 0;padding:0 40px}.mw-parser-output .templatequote .templatequotecite{line-height:1.5em;text-align:left;padding-left:1.6em;margin-top:0}</style><blockquote class="templatequote"><p>...In December 1989, I was looking for a "hobby" programming project that would keep me occupied during the week around Christmas. My office ... would be closed, but I had a home computer, and not much else on my hands. I decided to write an interpreter for the new scripting language I had been thinking about lately: a descendant of <a href="/wiki/ABC_(programming_language)" title="ABC (programming language)">ABC</a> that would appeal to <a href="/wiki/Unix" title="Unix">Unix</a>/<a href="/wiki/C_(programming_language)" title="C (programming language)">C</a> <a href="/wiki/Hacker_(programmer_subculture)" class="mw-redirect" title="Hacker (programmer subculture)">hackers</a>. I chose Python as a working title for the project, being in a slightly irreverent mood (and a big fan of <i><a href="/wiki/Monty_Python%27s_Flying_Circus" title="Monty Python&#39;s Flying Circus">Monty Python's Flying Circus</a></i>). </p><div class="templatequotecite">—&#8201;<cite>Guido van Rossum</cite></div>
</blockquote>
<p>Python 2.0 was released on 16 October 2000 and had many major new features, including a <a href="/wiki/Cycle_detection" title="Cycle detection">cycle-detecting</a> <a href="/wiki/Garbage_collection_(computer_science)" title="Garbage collection (computer science)">garbage collector</a> and support for <a href="/wiki/Unicode" title="Unicode">Unicode</a>. With this release, the development process became more transparent and community-backed.<sup id="cite_ref-newin-2.0_35-0" class="reference"><a href="#cite_note-newin-2.0-35">&#91;35&#93;</a></sup>
</p><p>Python 3.0 (initially called Python 3000 or py3k) was released on 3 December 2008 after a long testing period. It is a major revision of the language that is not completely <a href="/wiki/Backward_compatibility" title="Backward compatibility">backward-compatible</a> with previous versions.<sup id="cite_ref-3.0-release_36-0" class="reference"><a href="#cite_note-3.0-release-36">&#91;36&#93;</a></sup> However, many of its major features have been <a href="/wiki/Backporting" title="Backporting">backported</a> to the Python 2.6.x<sup id="cite_ref-pep-3000_37-0" class="reference"><a href="#cite_note-pep-3000-37">&#91;37&#93;</a></sup> and 2.7.x version series, and releases of Python 3 include the <code>2to3</code> utility, which automates the translation of Python 2 code to Python 3.<sup id="cite_ref-38" class="reference"><a href="#cite_note-38">&#91;38&#93;</a></sup>
</p><p>Python 2.7's <a href="/wiki/End-of-life_(product)" title="End-of-life (product)">end-of-life</a> date was initially set at 2015, then postponed to 2020 out of concern that a large body of existing code could not easily be forward-ported to Python 3.<sup id="cite_ref-39" class="reference"><a href="#cite_note-39">&#91;39&#93;</a></sup><sup id="cite_ref-40" class="reference"><a href="#cite_note-40">&#91;40&#93;</a></sup> In January 2017, Google announced work on a Python 2.7 to <a href="/wiki/Go_(programming_language)" title="Go (programming language)">Go</a> <a href="/wiki/Transcompiler" class="mw-redirect" title="Transcompiler">transcompiler</a> to improve performance under concurrent workloads.<sup id="cite_ref-41" class="reference"><a href="#cite_note-41">&#91;41&#93;</a></sup>
</p>
<h2><span class="mw-headline" id="Features_and_philosophy">Features and philosophy</span></h2>
<p>Python is a <a href="/wiki/Multi-paradigm_programming_language" class="mw-redirect" title="Multi-paradigm programming language">multi-paradigm programming language</a>. <a href="/wiki/Object-oriented_programming" title="Object-oriented programming">Object-oriented programming</a> and <a href="/wiki/Structured_programming" title="Structured programming">structured programming</a> are fully supported, and many of its features support <a href="/wiki/Functional_programming" title="Functional programming">functional programming</a> and <a href="/wiki/Aspect-oriented_programming" title="Aspect-oriented programming">aspect-oriented programming</a> (including by <a href="/wiki/Metaprogramming" title="Metaprogramming">metaprogramming</a><sup id="cite_ref-AutoNT-13_42-0" class="reference"><a href="#cite_note-AutoNT-13-42">&#91;42&#93;</a></sup> and <a href="/wiki/Metaobject" title="Metaobject">metaobjects</a> (magic methods)).<sup id="cite_ref-AutoNT-14_43-0" class="reference"><a href="#cite_note-AutoNT-14-43">&#91;43&#93;</a></sup> Many other paradigms are supported via extensions, including <a href="/wiki/Design_by_contract" title="Design by contract">design by contract</a><sup id="cite_ref-AutoNT-15_44-0" class="reference"><a href="#cite_note-AutoNT-15-44">&#91;44&#93;</a></sup><sup id="cite_ref-AutoNT-16_45-0" class="reference"><a href="#cite_note-AutoNT-16-45">&#91;45&#93;</a></sup> and <a href="/wiki/Logic_programming" title="Logic programming">logic programming</a>.<sup id="cite_ref-AutoNT-17_46-0" class="reference"><a href="#cite_note-AutoNT-17-46">&#91;46&#93;</a></sup>
</p><p>Python uses <a href="/wiki/Dynamic_typing" class="mw-redirect" title="Dynamic typing">dynamic typing</a>, and a combination of <a href="/wiki/Reference_counting" title="Reference counting">reference counting</a> and a cycle-detecting garbage collector for <a href="/wiki/Memory_management" title="Memory management">memory management</a>. It also features dynamic <a href="/wiki/Name_resolution_(programming_languages)" title="Name resolution (programming languages)">name resolution</a> (<a href="/wiki/Late_binding" title="Late binding">late binding</a>), which binds method and variable names during program execution.
</p><p>Python's design offers some support for <a href="/wiki/Functional_programming" title="Functional programming">functional programming</a> in the <a href="/wiki/Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a> tradition. It has <code>filter()</code>, <code>map()</code>, and <code>reduce()</code> functions; <a href="/wiki/List_comprehension" title="List comprehension">list comprehensions</a>, <a href="/wiki/Associative_array" title="Associative array">dictionaries</a>, and sets; and <a href="/wiki/Generator_(computer_programming)" title="Generator (computer programming)">generator</a> expressions.<sup id="cite_ref-AutoNT-59_47-0" class="reference"><a href="#cite_note-AutoNT-59-47">&#91;47&#93;</a></sup> The standard library has two modules (itertools and functools) that implement functional tools borrowed from <a href="/wiki/Haskell_(programming_language)" title="Haskell (programming language)">Haskell</a> and <a href="/wiki/Standard_ML" title="Standard ML">Standard ML</a>.<sup id="cite_ref-AutoNT-18_48-0" class="reference"><a href="#cite_note-AutoNT-18-48">&#91;48&#93;</a></sup>
</p><p>The language's core philosophy is summarized in the document <i>The <a href="/wiki/Zen_of_Python" title="Zen of Python">Zen of Python</a></i> (<i>PEP 20</i>), which includes <a href="/wiki/Aphorism" title="Aphorism">aphorisms</a> such as:<sup id="cite_ref-PEP20_49-0" class="reference"><a href="#cite_note-PEP20-49">&#91;49&#93;</a></sup>
</p>
<ul><li>Beautiful is better than ugly</li>
<li>Explicit is better than implicit</li>
<li>Simple is better than complex</li>
<li>Complex is better than complicated</li>
<li>Readability counts</li></ul>
<p>Rather than having all of its functionality built into its core, Python was designed to be highly extensible. This compact modularity has made it particularly popular as a means of adding programmable interfaces to existing applications. Van Rossum's vision of a small core language with a large standard library and easily extensible interpreter stemmed from his frustrations with <a href="/wiki/ABC_(programming_language)" title="ABC (programming language)">ABC</a>, which espoused the opposite approach.<sup id="cite_ref-venners-interview-pt-1_30-1" class="reference"><a href="#cite_note-venners-interview-pt-1-30">&#91;30&#93;</a></sup>
</p><p>While offering choice in coding methodology, the Python philosophy rejects exuberant syntax (such as that of <a href="/wiki/Perl" title="Perl">Perl</a>) in favor of a simpler, less-cluttered grammar. As <a href="/wiki/Alex_Martelli" title="Alex Martelli">Alex Martelli</a> put it: "To describe something as 'clever' is <i>not</i> considered a compliment in the Python culture."<sup id="cite_ref-AutoNT-19_50-0" class="reference"><a href="#cite_note-AutoNT-19-50">&#91;50&#93;</a></sup> Python's philosophy rejects the Perl "<a href="/wiki/There_is_more_than_one_way_to_do_it" class="mw-redirect" title="There is more than one way to do it">there is more than one way to do it</a>" approach to language design in favor of "there should be one—and preferably only one—obvious way to do it".<sup id="cite_ref-PEP20_49-1" class="reference"><a href="#cite_note-PEP20-49">&#91;49&#93;</a></sup>
</p><p>Python's developers strive to avoid <a href="/wiki/Premature_optimization" class="mw-redirect" title="Premature optimization">premature optimization</a>, and reject patches to non-critical parts of CPython that would offer marginal increases in speed at the cost of clarity.<sup id="cite_ref-AutoNT-20_51-0" class="reference"><a href="#cite_note-AutoNT-20-51">&#91;51&#93;</a></sup> When speed is important, a Python programmer can move time-critical functions to extension modules written in languages such as C, or use <a href="/wiki/PyPy" title="PyPy">PyPy</a>, a <a href="/wiki/Just-in-time_compilation" title="Just-in-time compilation">just-in-time compiler</a>. <a href="/wiki/Cython" title="Cython">Cython</a> is also available, which translates a Python script into C and makes direct C-level API calls into the Python interpreter.
</p><p>An important goal of Python's developers is keeping it fun to use. This is reflected in the language's name—a tribute to the British comedy group <a href="/wiki/Monty_Python" title="Monty Python">Monty Python</a><sup id="cite_ref-AutoNT-24_52-0" class="reference"><a href="#cite_note-AutoNT-24-52">&#91;52&#93;</a></sup>—and in occasionally playful approaches to tutorials and reference materials, such as examples that refer to spam and eggs (from a <a href="/wiki/Spam_(Monty_Python)" title="Spam (Monty Python)">famous Monty Python sketch</a>) instead of the standard <a href="/wiki/Foobar" title="Foobar">foo and bar</a>.<sup id="cite_ref-53" class="reference"><a href="#cite_note-53">&#91;53&#93;</a></sup><sup id="cite_ref-54" class="reference"><a href="#cite_note-54">&#91;54&#93;</a></sup>
</p><p>A common <a href="/wiki/Neologism" title="Neologism">neologism</a> in the Python community is <i>pythonic</i>, which can have a wide range of meanings related to program style. To say that code is pythonic is to say that it uses Python idioms well, that it is natural or shows fluency in the language, that it conforms with Python's minimalist philosophy and emphasis on readability. In contrast, code that is difficult to understand or reads like a rough transcription from another programming language is called <i>unpythonic</i>.
</p><p>Users and admirers of Python, especially those considered knowledgeable or experienced, are often referred to as <i>Pythonists</i>, <i>Pythonistas</i>, and <i>Pythoneers</i>.<sup id="cite_ref-AutoNT-27_55-0" class="reference"><a href="#cite_note-AutoNT-27-55">&#91;55&#93;</a></sup><sup id="cite_ref-AutoNT-25_56-0" class="reference"><a href="#cite_note-AutoNT-25-56">&#91;56&#93;</a></sup>
</p>
<h2><span class="mw-headline" id="Syntax_and_semantics">Syntax and semantics</span></h2>
<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="/wiki/Python_syntax_and_semantics" title="Python syntax and semantics">Python syntax and semantics</a></div>
<p>Python is meant to be an easily readable language. Its formatting is visually uncluttered, and it often uses English keywords where other languages use punctuation. Unlike many other languages, it does not use <a href="/wiki/Curly_bracket_programming_language" class="mw-redirect" title="Curly bracket programming language">curly brackets</a> to delimit blocks, and semicolons after statements are optional. It has fewer syntactic exceptions and special cases than <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a> or <a href="/wiki/Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a>.<sup id="cite_ref-AutoNT-52_57-0" class="reference"><a href="#cite_note-AutoNT-52-57">&#91;57&#93;</a></sup>
</p>
<h3><span class="mw-headline" id="Indentation">Indentation</span></h3>
<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="/wiki/Python_syntax_and_semantics#Indentation" title="Python syntax and semantics">Python syntax and semantics §&#160;Indentation</a></div>
<p>Python uses <a href="/wiki/Whitespace_character" title="Whitespace character">whitespace</a> indentation, rather than <a href="/wiki/Curly_bracket_programming_language" class="mw-redirect" title="Curly bracket programming language">curly brackets</a> or keywords, to delimit <a href="/wiki/Block_(programming)" title="Block (programming)">blocks</a>. An increase in indentation comes after certain statements; a decrease in indentation signifies the end of the current block.<sup id="cite_ref-AutoNT-53_58-0" class="reference"><a href="#cite_note-AutoNT-53-58">&#91;58&#93;</a></sup> Thus, the program's visual structure accurately represents the program's semantic structure.<sup id="cite_ref-guttag_1-1" class="reference"><a href="#cite_note-guttag-1">&#91;1&#93;</a></sup> This feature is also sometimes termed the <a href="/wiki/Off-side_rule" title="Off-side rule">off-side rule</a>.
</p>
<h3><span class="mw-headline" id="Statements_and_control_flow">Statements and control flow</span></h3>
<p>Python's <a href="/wiki/Statement_(computer_science)" title="Statement (computer science)">statements</a> include (among others):
</p>
<ul><li>The assignment statement (token '=', the equals sign). This operates differently than in traditional <a href="/wiki/Imperative_programming" title="Imperative programming">imperative programming</a> languages, and this fundamental mechanism (including the nature of Python's version of <i>variables</i>) illuminates many other features of the language. Assignment in <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a>, e.g., <code>x = 2</code>, translates to "typed variable name x receives a copy of numeric value 2". The (right-hand) value is copied into an <a href="/wiki/Memory_allocation" class="mw-redirect" title="Memory allocation">allocated storage location</a> for which the (left-hand) <a href="/wiki/Variable_(computer_science)" title="Variable (computer science)">variable name</a> is the symbolic address. The memory allocated to the variable is large enough (potentially quite large) for the declared <a href="/wiki/Type_system" title="Type system">type</a>. In the simplest case of Python assignment, using the same example, <code>x = 2</code>, translates to "(generic) name x receives a <a href="/wiki/Pointer_(computer_programming)" title="Pointer (computer programming)">reference</a> to a separate, dynamically allocated <a href="/wiki/Object_(computer_science)" title="Object (computer science)">object</a> of numeric (int) type of value 2." This is termed <i>binding</i> the name to the object. Since the name's storage location doesn't <i>contain</i> the indicated value, it is improper to call it a <i>variable</i>. Names may be subsequently rebound at any time to objects of greatly varying types, including strings, procedures, complex objects with data and methods, etc. Successive assignments of a common value to multiple names, e.g., <code>x = 2</code>; <code>y = 2</code>; <code>z = 2</code> result in allocating storage to (at most) three names and one numeric object, to which all three names are bound. Since a name is a generic reference holder it is unreasonable to associate a fixed <a href="/wiki/Type_system" title="Type system">data type</a> with it. However at a given time a name will be bound to <i>some</i> object, which <b>will</b> have a type; thus there is <a href="/wiki/Dynamic_type" class="mw-redirect" title="Dynamic type">dynamic typing</a>.</li>
<li>The <code><a href="/wiki/If-then-else" class="mw-redirect" title="If-then-else">if</a></code> statement, which conditionally executes a block of code, along with <code>else</code> and <code>elif</code> (a contraction of else-if).</li>
<li>The <code><a href="/wiki/Foreach#Python" class="mw-redirect" title="Foreach">for</a></code> statement, which iterates over an iterable object, capturing each element to a local variable for use by the attached block.</li>
<li>The <code><a href="/wiki/While_loop#Python" title="While loop">while</a></code> statement, which executes a block of code as long as its condition is true.</li>
<li>The <code><a href="/wiki/Exception_handling_syntax#Python" title="Exception handling syntax">try</a></code> statement, which allows exceptions raised in its attached code block to be caught and handled by <code>except</code> clauses; it also ensures that clean-up code in a <code>finally</code> block will always be run regardless of how the block exits.</li>
<li>The <code>raise</code> statement, used to raise a specified exception or re-raise a caught exception.</li>
<li>The <code>class</code> statement, which executes a block of code and attaches its local namespace to a <a href="/wiki/Class_(computer_science)" class="mw-redirect" title="Class (computer science)">class</a>, for use in <a href="/wiki/Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a>.</li>
<li>The <code>def</code> statement, which defines a <a href="/wiki/Function_(computing)" class="mw-redirect" title="Function (computing)">function</a> or <a href="/wiki/Method_(computing)" class="mw-redirect" title="Method (computing)">method</a>.</li>
<li>The <code>with</code> statement, from Python 2.5 released on September 2006,<sup id="cite_ref-59" class="reference"><a href="#cite_note-59">&#91;59&#93;</a></sup> which encloses a code block within a context manager (for example, acquiring a <a href="/wiki/Lock_(computer_science)" title="Lock (computer science)">lock</a> before the block of code is run and releasing the lock afterwards, or opening a <a href="/wiki/Computer_file" title="Computer file">file</a> and then closing it), allowing <a href="/wiki/Resource_Acquisition_Is_Initialization" class="mw-redirect" title="Resource Acquisition Is Initialization">Resource Acquisition Is Initialization</a> (RAII)-like behavior and replaces a common try/finally idiom.<sup id="cite_ref-60" class="reference"><a href="#cite_note-60">&#91;60&#93;</a></sup></li>
<li>The <code>pass</code> statement, which serves as a <a href="/wiki/NOP" title="NOP">NOP</a>. It is syntactically needed to create an empty code block.</li>
<li>The <code><a href="/wiki/Assertion_(programming)" class="mw-redirect" title="Assertion (programming)">assert</a></code> statement, used during debugging to check for conditions that ought to apply.</li>
<li>The <code>yield</code> statement, which returns a value from a <a href="/wiki/Generator_(computer_science)#Python" class="mw-redirect" title="Generator (computer science)">generator</a> function. From Python 2.5, <code>yield</code> is also an operator. This form is used to implement <a href="/wiki/Coroutine" title="Coroutine">coroutines</a>.</li>
<li>The <code>import</code> statement, which is used to import modules whose functions or variables can be used in the current program. There are three ways of using import: <code>import &lt;module name&gt; [as &lt;alias&gt;]</code> or <code>from &lt;module name&gt; import *</code> or <code>from &lt;module name&gt; import &lt;definition 1&gt; [as &lt;alias 1&gt;], &lt;definition 2&gt; [as &lt;alias 2&gt;], ...</code>.</li>
<li>The <code>print</code> statement was changed to the <code>print()</code> function in Python 3.<sup id="cite_ref-diff_py2-3_61-0" class="reference"><a href="#cite_note-diff_py2-3-61">&#91;61&#93;</a></sup></li></ul>
<p>Python does not support <a href="/wiki/Tail_call" title="Tail call">tail call</a> optimization or <a href="/wiki/First-class_continuations" class="mw-redirect" title="First-class continuations">first-class continuations</a>, and, according to Guido van Rossum, it never will.<sup id="cite_ref-AutoNT-55_62-0" class="reference"><a href="#cite_note-AutoNT-55-62">&#91;62&#93;</a></sup><sup id="cite_ref-AutoNT-56_63-0" class="reference"><a href="#cite_note-AutoNT-56-63">&#91;63&#93;</a></sup> However, better support for <a href="/wiki/Coroutine" title="Coroutine">coroutine</a>-like functionality is provided in 2.5, by extending Python's <a href="/wiki/Generator_(computer_science)" class="mw-redirect" title="Generator (computer science)">generators</a>.<sup id="cite_ref-AutoNT-57_64-0" class="reference"><a href="#cite_note-AutoNT-57-64">&#91;64&#93;</a></sup> Before 2.5, generators were <a href="/wiki/Lazy_evaluation" title="Lazy evaluation">lazy</a> <a href="/wiki/Iterator" title="Iterator">iterators</a>; information was passed unidirectionally out of the generator. From Python 2.5, it is possible to pass information back into a generator function, and from Python 3.3, the information can be passed through multiple stack levels.<sup id="cite_ref-AutoNT-58_65-0" class="reference"><a href="#cite_note-AutoNT-58-65">&#91;65&#93;</a></sup>
</p>
<h3><span class="mw-headline" id="Expressions">Expressions</span></h3>
<p>Some Python <a href="/wiki/Expression_(computer_science)" title="Expression (computer science)">expressions</a> are similar to languages such as <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a> and <a href="/wiki/Java_(programming_language)" title="Java (programming language)">Java</a>, while some are not:
</p>
<ul><li>Addition, subtraction, and multiplication are the same, but the behavior of division differs. There are two types of divisions in Python. They are floor division and integer division.<sup id="cite_ref-66" class="reference"><a href="#cite_note-66">&#91;66&#93;</a></sup> Python also added the <code>**</code> operator for exponentiation.</li>
<li>From Python 3.5, the new <code>@</code> infix operator was introduced. It is intended to be used by libraries such as NumPy for <a href="/wiki/Matrix_multiplication" title="Matrix multiplication">matrix multiplication</a>.<sup id="cite_ref-PEP465_67-0" class="reference"><a href="#cite_note-PEP465-67">&#91;67&#93;</a></sup><sup id="cite_ref-Python3.5Changelog_68-0" class="reference"><a href="#cite_note-Python3.5Changelog-68">&#91;68&#93;</a></sup></li>
<li>In Python, <code>==</code> compares by value, versus Java, which compares numerics by value<sup id="cite_ref-69" class="reference"><a href="#cite_note-69">&#91;69&#93;</a></sup> and objects by reference.<sup id="cite_ref-70" class="reference"><a href="#cite_note-70">&#91;70&#93;</a></sup> (Value comparisons in Java on objects can be performed with the <code>equals()</code> method.) Python's <code>is</code> operator may be used to compare object identities (comparison by reference). In Python, comparisons may be chained, for example <code>a &lt;= b &lt;= c</code>.</li>
<li>Python uses the words <code>and</code>, <code>or</code>, <code>not</code> for its boolean operators rather than the symbolic <code>&amp;&amp;</code>, <code>||</code>, <code>!</code> used in Java and C.</li>
<li>Python has a type of expression termed a <i><a href="/wiki/List_comprehension#Python" title="List comprehension">list comprehension</a></i>. Python 2.4 extended list comprehensions into a more general expression termed a <i><a href="/wiki/Generator_(computer_science)" class="mw-redirect" title="Generator (computer science)">generator</a> expression</i>.<sup id="cite_ref-AutoNT-59_47-1" class="reference"><a href="#cite_note-AutoNT-59-47">&#91;47&#93;</a></sup></li>
<li><a href="/wiki/Anonymous_function" title="Anonymous function">Anonymous functions</a> are implemented using <a href="/wiki/Lambda_(programming)" class="mw-redirect" title="Lambda (programming)">lambda expressions</a>; however, these are limited in that the body can only be one expression.</li>
<li>Conditional expressions in Python are written as <code>x if c else y</code><sup id="cite_ref-AutoNT-60_71-0" class="reference"><a href="#cite_note-AutoNT-60-71">&#91;71&#93;</a></sup> (different in order of operands from the <code><a href="/wiki/%3F:" title="?:">c ? x : y</a></code> operator common to many other languages).</li>
<li>Python makes a distinction between <a href="/wiki/List_(computer_science)" class="mw-redirect" title="List (computer science)">lists</a> and <a href="/wiki/Tuple" title="Tuple">tuples</a>. Lists are written as <code>[1, 2, 3]</code>, are mutable, and cannot be used as the keys of dictionaries (dictionary keys must be <a href="/wiki/Immutable" class="mw-redirect" title="Immutable">immutable</a> in Python). Tuples are written as <code>(1, 2, 3)</code>, are immutable and thus can be used as the keys of dictionaries, provided all elements of the tuple are immutable. The <code>+</code> operator can be used to concatenate two tuples, which does not directly modify their contents, but rather produces a new tuple containing the elements of both provided tuples. Thus, given the variable <code>t</code> initially equal to <code>(1, 2, 3)</code>, executing <code>t = t + (4, 5)</code> first evaluates <code>t + (4, 5)</code>, which yields <code>(1, 2, 3, 4, 5)</code>, which is then assigned back to <code>t</code>, thereby effectively "modifying the contents" of <code>t</code>, while conforming to the immutable nature of tuple objects. Parentheses are optional for tuples in unambiguous contexts.<sup id="cite_ref-72" class="reference"><a href="#cite_note-72">&#91;72&#93;</a></sup></li>
<li>Python features <i>sequence unpacking</i> where multiple expressions, each evaluating to anything that can be assigned to (a variable, a writable property, etc.), are associated in the identical manner to that forming tuple literals and, as a whole, are put on the left hand side of the equal sign in an assignment statement. The statement expects an <i>iterable</i> object on the right hand side of the equal sign that produces the same number of values as the provided writable expressions when iterated through, and will iterate through it, assigning each of the produced values to the corresponding expression on the left.<sup class="noprint Inline-Template Template-Fact" style="white-space:nowrap;">&#91;<i><a href="/wiki/Wikipedia:Citation_needed" title="Wikipedia:Citation needed"><span title="This claim needs references to reliable sources. (October 2017)">citation needed</span></a></i>&#93;</sup></li>
<li>Python has a "string format" operator <code>%</code>. This functions analogous to <code><a href="/wiki/Printf" class="mw-redirect" title="Printf">printf</a></code> format strings in <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a>, e.g. <code>"spam=%s eggs=%d"&#160;% ("blah", 2)</code> evaluates to <code>"spam=blah eggs=2"</code>. In Python 3 and 2.6+, this was supplemented by the <code>format()</code> method of the <code>str</code> class, e.g. <code>"spam={0} eggs={1}".format("blah", 2)</code>. Python 3.6 added "f-strings": <code>blah = "blah"; eggs = 2; f'spam={blah} eggs={eggs}'</code>.<sup id="cite_ref-pep-0498_73-0" class="reference"><a href="#cite_note-pep-0498-73">&#91;73&#93;</a></sup></li>
<li>Python has various kinds of <a href="/wiki/String_literal" title="String literal">string literals</a>:
<ul><li>Strings delimited by single or double quote marks. Unlike in <a href="/wiki/Unix_shell" title="Unix shell">Unix shells</a>, <a href="/wiki/Perl" title="Perl">Perl</a> and Perl-influenced languages, single quote marks and double quote marks function identically. Both kinds of string use the backslash (<code>\</code>) as an <a href="/wiki/Escape_character" title="Escape character">escape character</a>. <a href="/wiki/String_interpolation" title="String interpolation">String interpolation</a> became available in Python 3.6 as "formatted string literals".<sup id="cite_ref-pep-0498_73-1" class="reference"><a href="#cite_note-pep-0498-73">&#91;73&#93;</a></sup></li>
<li>Triple-quoted strings, which begin and end with a series of three single or double quote marks. They may span multiple lines and function like <a href="/wiki/Here_document" title="Here document">here documents</a> in shells, Perl and <a href="/wiki/Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>.</li>
<li><a href="/wiki/Raw_string" class="mw-redirect" title="Raw string">Raw string</a> varieties, denoted by prefixing the string literal with an <code>r</code>. Escape sequences are not interpreted; hence raw strings are useful where literal backslashes are common, such as <a href="/wiki/Regular_expression" title="Regular expression">regular expressions</a> and <a href="/wiki/Microsoft_Windows" title="Microsoft Windows">Windows</a>-style paths. Compare "<code>@</code>-quoting" in <a href="/wiki/C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a>.</li></ul></li>
<li>Python has <a href="/wiki/Array_index" class="mw-redirect" title="Array index">array index</a> and <a href="/wiki/Array_slicing" title="Array slicing">array slicing</a> expressions on lists, denoted as <code>a[key]</code>, <code>a[start:stop]</code> or <code>a[start:stop:step]</code>. Indexes are <a href="/wiki/Zero-based" class="mw-redirect" title="Zero-based">zero-based</a>, and negative indexes are relative to the end. Slices take elements from the <i>start</i> index up to, but not including, the <i>stop</i> index. The third slice parameter, called <i>step</i> or <i>stride</i>, allows elements to be skipped and reversed. Slice indexes may be omitted, for example <code>a[:]</code> returns a copy of the entire list. Each element of a slice is a <a href="/wiki/Shallow_copy" class="mw-redirect" title="Shallow copy">shallow copy</a>.</li></ul>
<p>In Python, a distinction between expressions and statements is rigidly enforced, in contrast to languages such as <a href="/wiki/Common_Lisp" title="Common Lisp">Common Lisp</a>, <a href="/wiki/Scheme_(programming_language)" title="Scheme (programming language)">Scheme</a>, or <a href="/wiki/Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>. This leads to duplicating some functionality. For example:
</p>
<ul><li><a href="/wiki/List_comprehensions" class="mw-redirect" title="List comprehensions">List comprehensions</a> vs. <code>for</code>-loops</li>
<li><a href="/wiki/Conditional_(programming)" class="mw-redirect" title="Conditional (programming)">Conditional</a> expressions vs. <code>if</code> blocks</li>
<li>The <code>eval()</code> vs. <code>exec()</code> built-in functions (in Python 2, <code>exec</code> is a statement); the former is for expressions, the latter is for statements.</li></ul>
<p>Statements cannot be a part of an expression, so list and other comprehensions or <a href="/wiki/Lambda_(programming)" class="mw-redirect" title="Lambda (programming)">lambda expressions</a>, all being expressions, cannot contain statements. A particular case of this is that an assignment statement such as <code>a = 1</code> cannot form part of the conditional expression of a conditional statement. This has the advantage of avoiding a classic C error of mistaking an assignment operator <code>=</code> for an equality operator <code>==</code> in conditions: <code>if (c = 1) { ... }</code> is syntactically valid (but probably unintended) C code but <code>if c = 1: ...</code> causes a syntax error in Python.
</p>
<h3><span class="mw-headline" id="Methods">Methods</span></h3>
<p><a href="/wiki/Method_(programming)" class="mw-redirect" title="Method (programming)">Methods</a> on objects are <a href="/wiki/Function_(programming)" class="mw-redirect" title="Function (programming)">functions</a> attached to the object's class; the syntax <code>instance.method(argument)</code> is, for normal methods and functions, <a href="/wiki/Syntactic_sugar" title="Syntactic sugar">syntactic sugar</a> for <code>Class.method(instance, argument)</code>. Python methods have an explicit <code><a href="/wiki/This_(computer_programming)" title="This (computer programming)">self</a></code> parameter to access <a href="/wiki/Instance_data" class="mw-redirect" title="Instance data">instance data</a>, in contrast to the implicit <code>self</code> (or <code>this</code>) in some other object-oriented programming languages (e.g., <a href="/wiki/C%2B%2B" title="C++">C++</a>, <a href="/wiki/Java_(programming_language)" title="Java (programming language)">Java</a>, <a href="/wiki/Objective-C" title="Objective-C">Objective-C</a>, or <a href="/wiki/Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>).<sup id="cite_ref-AutoNT-61_74-0" class="reference"><a href="#cite_note-AutoNT-61-74">&#91;74&#93;</a></sup>
</p>
<h3><span class="mw-headline" id="Typing">Typing</span></h3>
<p>Python uses <a href="/wiki/Duck_typing" title="Duck typing">duck typing</a> and has typed objects but untyped variable names. Type constraints are not checked at <a href="/wiki/Compile_time" title="Compile time">compile time</a>; rather, operations on an object may fail, signifying that the given object is not of a suitable type. Despite being <a href="/wiki/Type_system#Dynamic_type_checking_and_runtime_type_information" title="Type system">dynamically typed</a>, Python is <a href="/wiki/Strongly_typed_programming_language" class="mw-redirect" title="Strongly typed programming language">strongly typed</a>, forbidding operations that are not well-defined (for example, adding a number to a string) rather than silently attempting to make sense of them.
</p><p>Python allows programmers to define their own types using <a href="/wiki/Class_(computer_science)" class="mw-redirect" title="Class (computer science)">classes</a>, which are most often used for <a href="/wiki/Object-oriented_programming" title="Object-oriented programming">object-oriented programming</a>. New <a href="/wiki/Object_(computer_science)" title="Object (computer science)">instances</a> of classes are constructed by calling the class (for example, <code>SpamClass()</code> or <code>EggsClass()</code>), and the classes are instances of the <a href="/wiki/Metaclass" title="Metaclass">metaclass</a> <code>type</code> (itself an instance of itself), allowing <a href="/wiki/Metaprogramming" title="Metaprogramming">metaprogramming</a> and <a href="/wiki/Reflection_(computer_science)" class="mw-redirect" title="Reflection (computer science)">reflection</a>.
</p><p>Before version 3.0, Python had two kinds of classes: <i>old-style</i> and <i>new-style</i>.<sup id="cite_ref-classy_75-0" class="reference"><a href="#cite_note-classy-75">&#91;75&#93;</a></sup> The syntax of both styles is the same, the difference being whether the class <code>object</code> is inherited from, directly or indirectly (all new-style classes inherit from <code>object</code> and are instances of <code>type</code>). In versions of Python 2 from Python 2.2 onwards, both kinds of classes can be used. Old-style classes were eliminated in Python 3.0.
</p><p>The long term plan is to support <a href="/wiki/Gradual_typing" title="Gradual typing">gradual typing</a><sup id="cite_ref-76" class="reference"><a href="#cite_note-76">&#91;76&#93;</a></sup> and from Python 3.5, the syntax of the language allows specifying static types but they are not checked in the default implementation, CPython. An experimental optional static type checker named <i>mypy</i> supports compile-time type checking.<sup id="cite_ref-77" class="reference"><a href="#cite_note-77">&#91;77&#93;</a></sup>
</p>
<table class="wikitable">
<caption>Summary of Python 3's built-in types
</caption>
<tbody><tr>
<th>Type
</th>
<th>mutable
</th>
<th>Description
</th>
<th>Syntax example
</th></tr>
<tr>
<td><code>bool</code>
</td>
<td>immutable
</td>
<td><a href="/wiki/Boolean_value" class="mw-redirect" title="Boolean value">Boolean value</a>
</td>
<td><code>True</code><br /><code>False</code>
</td></tr>
<tr>
<td><code>bytearray</code>
</td>
<td>mutable
</td>
<td>Sequence of <a href="/wiki/Byte" title="Byte">bytes</a>
</td>
<td><code>bytearray(b'Some ASCII')</code><br /><code>bytearray(b"Some ASCII")</code><br /><code>bytearray([119, 105, 107, 105])</code>
</td></tr>
<tr>
<td><code>bytes</code>
</td>
<td>immutable
</td>
<td>Sequence of bytes
</td>
<td><code>b'Some ASCII'</code><br /><code>b"Some ASCII"</code><br /><code>bytes([119, 105, 107, 105])</code>
</td></tr>
<tr>
<td><code>complex</code>
</td>
<td>immutable
</td>
<td><a href="/wiki/Complex_number" title="Complex number">Complex number</a> with real and imaginary parts
</td>
<td><code>3+2.7j</code>
</td></tr>
<tr>
<td><code>dict</code>
</td>
<td>mutable
</td>
<td><a href="/wiki/Associative_array" title="Associative array">Associative array</a> (or dictionary) of key and value pairs; can contain mixed types (keys and values), keys must be a hashable type
</td>
<td><code>{'key1': 1.0, 3: False}</code>
</td></tr>
<tr>
<td><code>ellipsis</code>
</td>
<td>
</td>
<td>An <a href="/wiki/Ellipsis_(programming_operator)" class="mw-redirect" title="Ellipsis (programming operator)">ellipsis</a> placeholder to be used as an index in <a href="/wiki/NumPy" title="NumPy">NumPy</a> arrays
</td>
<td><code>...</code>
</td></tr>
<tr>
<td><code>float</code>
</td>
<td>immutable
</td>
<td><a href="/wiki/Floating_point" class="mw-redirect" title="Floating point">Floating point</a> number, system-defined precision
</td>
<td><code>3.1415927</code>
</td></tr>
<tr>
<td><code>frozenset</code>
</td>
<td>immutable
</td>
<td>Unordered <a href="/wiki/Set_(computer_science)" class="mw-redirect" title="Set (computer science)">set</a>, contains no duplicates; can contain mixed types, if hashable
</td>
<td><code>frozenset([4.0, 'string', True])</code>
</td></tr>
<tr>
<td><code>int</code>
</td>
<td>immutable
</td>
<td><a href="/wiki/Integer_(computer_science)" title="Integer (computer science)">Integer</a> of unlimited magnitude<sup id="cite_ref-pep0237_78-0" class="reference"><a href="#cite_note-pep0237-78">&#91;78&#93;</a></sup>
</td>
<td><code>42</code>
</td></tr>
<tr>
<td><code>list</code>
</td>
<td>mutable
</td>
<td><a href="/wiki/List_(computer_science)" class="mw-redirect" title="List (computer science)">List</a>, can contain mixed types
</td>
<td><code>[4.0, 'string', True]</code>
</td></tr>
<tr>
<td><code>set</code>
</td>
<td>mutable
</td>
<td>Unordered <a href="/wiki/Set_(computer_science)" class="mw-redirect" title="Set (computer science)">set</a>, contains no duplicates; can contain mixed types, if hashable
</td>
<td><code>{4.0, 'string', True}</code>
</td></tr>
<tr>
<td><code>str</code>
</td>
<td><a href="/wiki/Immutable_object" title="Immutable object">immutable</a>
</td>
<td>A <a href="/wiki/Character_string" class="mw-redirect" title="Character string">character string</a>: sequence of Unicode codepoints
</td>
<td><code>'Wikipedia'</code><br /><code>"Wikipedia"</code><br /><code>"""Spanning<br />multiple<br />lines"""</code>
</td></tr>
<tr>
<td><code>tuple</code>
</td>
<td>immutable
</td>
<td>Can contain mixed types
</td>
<td><code>(4.0, 'string', True)</code>
</td></tr></tbody></table>
<h3><span class="mw-headline" id="Mathematics">Mathematics</span></h3>
<p>Python has the usual C language arithmetic operators (<code>+</code>, <code>-</code>, <code>*</code>, <code>/</code>, <code>%</code>). It also has <code>**</code> for exponentiation, e.g. <code>5**3 == 125</code> and <code>9**0.5 == 3.0</code>, and a new matrix multiply <code>@</code> operator is included in version 3.5.<sup id="cite_ref-79" class="reference"><a href="#cite_note-79">&#91;79&#93;</a></sup> Additionally, it has a unary operator (<code>~</code>), which essentially inverts all the bits of its one argument. For integers, this means <code>~x=-x-1</code>.<sup id="cite_ref-80" class="reference"><a href="#cite_note-80">&#91;80&#93;</a></sup> Other operators include bitwise shift operators <code>x &lt;&lt; y</code>, which shifts <code>x</code> to the left <code>y</code> places, the same as <code>x*(2**y) </code>, and <code>x &gt;&gt; y</code>, which shifts <code>x</code> to the right <code>y</code> places, the same as <code>x//(2**y) </code>.<sup id="cite_ref-81" class="reference"><a href="#cite_note-81">&#91;81&#93;</a></sup>
</p><p>The behavior of division has changed significantly over time:<sup id="cite_ref-pep0238_82-0" class="reference"><a href="#cite_note-pep0238-82">&#91;82&#93;</a></sup><sup class="noprint Inline-Template" style="white-space:nowrap;">&#91;<i><a href="/wiki/Wikipedia:Please_clarify" title="Wikipedia:Please clarify"><span title=" (May 2018)">why?</span></a></i>&#93;</sup>
</p>
<ul><li>Python 2.1 and earlier use the C division behavior. The <code>/</code> operator is integer division if both operands are integers, and floating-point division otherwise. Integer division rounds towards 0, e.g. <span class="nowrap"><code>7/3 == 2</code></span> and <span class="nowrap"><code>-7/3 == -2</code>.</span></li>
<li>Python 2.2 changes integer division to round towards negative infinity, e.g. <code>7/3 == 2</code> and <code>-7/3 == -3</code>. The floor division <code>//</code> operator is introduced. So <code>7//3 == 2</code>, <code>-7//3 == -3</code>, <code>7.5//3 == 2.0</code> and <code>-7.5//3 == -3.0</code>. Adding <code>from __future__ import division</code> causes a module to use Python 3.0 rules for division (see next).</li>
<li>Python 3.0 changes <code>/</code> to be always floating-point division. In Python terms, the pre-3.0 <code>/</code> is <i>classic division</i>, the version-3.0 <code>/</code> is <i>real division</i>, and <code>//</code> is <i>floor division</i>.</li></ul>
<p>Rounding towards negative infinity, though different from most languages, adds consistency. For instance, it means that the equation <code>(a + b)//b == a//b + 1</code> is always true. It also means that the equation <code>b*(a//b) + a%b == a</code> is valid for both positive and negative values of <code>a</code>. However, maintaining the validity of this equation means that while the result of <code>a%b</code> is, as expected, in the <a href="/wiki/Half-open_interval" class="mw-redirect" title="Half-open interval">half-open interval</a> [0, <i>b</i>), where <code>b</code> is a positive integer, it has to lie in the interval (<i>b</i>, 0] when <code>b</code> is negative.<sup id="cite_ref-AutoNT-62_83-0" class="reference"><a href="#cite_note-AutoNT-62-83">&#91;83&#93;</a></sup>
</p><p>Python provides a <code>round</code> function for <a href="/wiki/Rounding" title="Rounding">rounding</a> a float to the nearest integer. For <a href="/wiki/Rounding#Tie-breaking" title="Rounding">tie-breaking</a>, versions before 3 use round-away-from-zero: <code>round(0.5)</code> is 1.0, <code>round(-0.5)</code> is −1.0.<sup id="cite_ref-AutoNT-63_84-0" class="reference"><a href="#cite_note-AutoNT-63-84">&#91;84&#93;</a></sup> Python 3 uses <a href="/wiki/Round_to_even" class="mw-redirect" title="Round to even">round to even</a>: <code>round(1.5)</code> is 2, <code>round(2.5)</code> is 2.<sup id="cite_ref-AutoNT-64_85-0" class="reference"><a href="#cite_note-AutoNT-64-85">&#91;85&#93;</a></sup>
</p><p>Python allows boolean expressions with multiple equality relations in a manner that is consistent with general use in mathematics. For example, the expression <code>a &lt; b &lt; c</code> tests whether <code>a</code> is less than <code>b</code> and <code>b</code> is less than <code>c</code>.<sup id="cite_ref-AutoNT-65_86-0" class="reference"><a href="#cite_note-AutoNT-65-86">&#91;86&#93;</a></sup>  C-derived languages interpret this expression differently: in C, the expression would first evaluate <code>a &lt; b</code>, resulting in 0 or 1, and that result would then be compared with <code>c</code>.<sup id="cite_ref-CPL_87-0" class="reference"><a href="#cite_note-CPL-87">&#91;87&#93;</a></sup>
</p><p>Python has extensive built-in support for <a href="/wiki/Arbitrary_precision_arithmetic" class="mw-redirect" title="Arbitrary precision arithmetic">arbitrary precision arithmetic</a>. Integers are transparently switched from the machine-supported maximum fixed-precision (usually 32 or 64 bits), belonging to the python type <code>int</code>, to arbitrary precision, belonging to the Python type <code>long</code>, where needed. The latter have an "L" suffix in their textual representation.<sup id="cite_ref-88" class="reference"><a href="#cite_note-88">&#91;88&#93;</a></sup> (In Python 3, the distinction between the <code>int</code> and <code>long</code> types was eliminated; this behavior is now entirely contained by the <code>int</code> class.) The <code>Decimal</code> type/class in module <code>decimal</code> (since version 2.4) provides decimal floating point numbers to arbitrary precision and several rounding modes.<sup id="cite_ref-89" class="reference"><a href="#cite_note-89">&#91;89&#93;</a></sup> The <code>Fraction</code> type in module <code>fractions</code> (since version 2.6) provides arbitrary precision for rational numbers.<sup id="cite_ref-90" class="reference"><a href="#cite_note-90">&#91;90&#93;</a></sup>
</p><p>Due to Python's extensive mathematics library, and the third-party library <a href="/wiki/NumPy" title="NumPy">NumPy</a> that further extends the native capabilities, it is frequently used as a scientific scripting language to aid in problems such as numerical data processing and manipulation.<sup class="noprint Inline-Template Template-Fact" style="white-space:nowrap;">&#91;<i><a href="/wiki/Wikipedia:Citation_needed" title="Wikipedia:Citation needed"><span title="This claim needs references to reliable sources. (May 2018)">citation needed</span></a></i>&#93;</sup>
</p>
<h2><span class="mw-headline" id="Libraries">Libraries</span></h2>
<p>Python's large <a href="/wiki/Standard_library" title="Standard library">standard library</a>, commonly cited as one of its greatest strengths,<sup id="cite_ref-AutoNT-86_91-0" class="reference"><a href="#cite_note-AutoNT-86-91">&#91;91&#93;</a></sup> provides tools suited to many tasks. For Internet-facing applications, many standard formats and protocols such as <a href="/wiki/MIME" title="MIME">MIME</a> and <a href="/wiki/Hypertext_Transfer_Protocol" title="Hypertext Transfer Protocol">HTTP</a> are supported. It includes modules for creating <a href="/wiki/Graphical_user_interface" title="Graphical user interface">graphical user interfaces</a>, connecting to <a href="/wiki/Relational_database" title="Relational database">relational databases</a>, <a href="/wiki/Pseudorandom_number_generator" title="Pseudorandom number generator">generating pseudorandom numbers</a>, arithmetic with arbitrary precision decimals,<sup id="cite_ref-AutoNT-88_92-0" class="reference"><a href="#cite_note-AutoNT-88-92">&#91;92&#93;</a></sup> manipulating <a href="/wiki/Regular_expression" title="Regular expression">regular expressions</a>, and <a href="/wiki/Unit_testing" title="Unit testing">unit testing</a>.
</p><p>Some parts of the standard library are covered by specifications (for example, the <a href="/wiki/Web_Server_Gateway_Interface" title="Web Server Gateway Interface">Web Server Gateway Interface</a> (WSGI) implementation <code>wsgiref</code> follows PEP 333<sup id="cite_ref-AutoNT-89_93-0" class="reference"><a href="#cite_note-AutoNT-89-93">&#91;93&#93;</a></sup>), but most modules are not. They are specified by their code, internal documentation, and test suites (if supplied). However, because most of the standard library is cross-platform Python code, only a few modules need altering or rewriting for variant implementations.
</p><p>As of  March&#160;2018,<sup class="plainlinks noexcerpt noprint asof-tag update" style="display:none;"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Python_(programming_language)&amp;action=edit">&#91;update&#93;</a></sup> the <a href="/wiki/Python_Package_Index" title="Python Package Index">Python Package Index</a> (PyPI), the official repository for third-party Python software, contains over 130,000<sup id="cite_ref-94" class="reference"><a href="#cite_note-94">&#91;94&#93;</a></sup> packages with a wide range of functionality, including:
</p>
<ul><li>Graphical user interfaces</li>
<li>Web frameworks</li>
<li>Multimedia</li>
<li>Databases</li>
<li>Networking</li>
<li>Test frameworks</li>
<li>Automation</li>
<li>Web scraping<sup id="cite_ref-95" class="reference"><a href="#cite_note-95">&#91;95&#93;</a></sup></li>
<li>Documentation</li>
<li>System administration</li>
<li>Scientific computing</li>
<li>Text processing</li>
<li>Image processing</li></ul>
<h2><span class="mw-headline" id="Development_environments">Development environments</span></h2>
<div role="note" class="hatnote navigation-not-searchable">See also: <a href="/wiki/Comparison_of_integrated_development_environments#Python" title="Comparison of integrated development environments">Comparison of integrated development environments §&#160;Python</a></div>
<p>Most Python implementations (including CPython) include a <a href="/wiki/Read%E2%80%93eval%E2%80%93print_loop" title="Read–eval–print loop">read–eval–print loop</a> (REPL), permitting them to function as a <a href="/wiki/Command_line_interpreter" class="mw-redirect" title="Command line interpreter">command line interpreter</a> for which the user enters statements sequentially and receives results immediately.
</p><p>Other shells, including <a href="/wiki/IDLE_(Python)" class="mw-redirect" title="IDLE (Python)">IDLE</a> and <a href="/wiki/IPython" title="IPython">IPython</a>, add further abilities such as auto-completion, session state retention and <a href="/wiki/Syntax_highlighting" title="Syntax highlighting">syntax highlighting</a>.
</p><p>As well as standard desktop <a href="/wiki/Integrated_development_environment" title="Integrated development environment">integrated development environments</a> (see Wikipedia's "<a href="/wiki/Python_IDE" class="mw-redirect" title="Python IDE">Python IDE</a>" article), there are <a href="/wiki/Web_browser" title="Web browser">Web browser</a>-based IDEs; <a href="/wiki/SageMath" title="SageMath">SageMath</a> (intended for developing science and math-related Python programs); <a href="/wiki/PythonAnywhere" title="PythonAnywhere">PythonAnywhere</a>, a browser-based IDE and hosting environment; and Canopy IDE, a commercial Python IDE emphasizing scientific computing.<sup id="cite_ref-96" class="reference"><a href="#cite_note-96">&#91;96&#93;</a></sup>
</p>
<h2><span class="mw-headline" id="Implementations">Implementations</span></h2>
<div role="note" class="hatnote navigation-not-searchable">See also: <a href="/wiki/List_of_Python_software#Python_implementations" title="List of Python software">List of Python software §&#160;Python implementations</a></div>
<h3><span class="mw-headline" id="Reference_implementation">Reference implementation</span></h3>
<p><a href="/wiki/CPython" title="CPython">CPython</a> is the <a href="/wiki/Reference_implementation" title="Reference implementation">reference implementation</a> of Python. It is written in <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a>, meeting the <a href="/wiki/C89_(C_version)" class="mw-redirect" title="C89 (C version)">C89</a> standard with several select <a href="/wiki/C99" title="C99">C99</a> features.<sup id="cite_ref-AutoNT-66_97-0" class="reference"><a href="#cite_note-AutoNT-66-97">&#91;97&#93;</a></sup> It compiles Python programs into an intermediate <a href="/wiki/Bytecode" title="Bytecode">bytecode</a><sup id="cite_ref-AutoNT-67_98-0" class="reference"><a href="#cite_note-AutoNT-67-98">&#91;98&#93;</a></sup> which is then executed by its <a href="/wiki/Virtual_machine" title="Virtual machine">virtual machine</a>.<sup id="cite_ref-AutoNT-68_99-0" class="reference"><a href="#cite_note-AutoNT-68-99">&#91;99&#93;</a></sup> CPython is distributed with a large standard library written in a mixture of C and native Python. It is available for many platforms, including <a href="/wiki/Microsoft_Windows" title="Microsoft Windows">Windows</a> and most modern <a href="/wiki/Unix-like" title="Unix-like">Unix-like</a> systems. Platform portability was one of its earliest priorities.<sup id="cite_ref-AutoNT-69_100-0" class="reference"><a href="#cite_note-AutoNT-69-100">&#91;100&#93;</a></sup>
</p>
<h3><span class="mw-headline" id="Other_implementations">Other implementations</span></h3>
<p><a href="/wiki/PyPy" title="PyPy">PyPy</a> is a fast, compliant<sup id="cite_ref-AutoNT-70_101-0" class="reference"><a href="#cite_note-AutoNT-70-101">&#91;101&#93;</a></sup> interpreter of Python 2.7 and 3.5. Its <a href="/wiki/Just-in-time_compilation" title="Just-in-time compilation">just-in-time compiler</a> brings a significant speed improvement over CPython.<sup id="cite_ref-AutoNT-71_102-0" class="reference"><a href="#cite_note-AutoNT-71-102">&#91;102&#93;</a></sup>
</p><p><a href="/wiki/Stackless_Python" title="Stackless Python">Stackless Python</a> is a significant fork of CPython that implements <a href="/wiki/Microthread" title="Microthread">microthreads</a>; it does not use the C memory stack, thus allowing massively concurrent programs. PyPy also has a stackless version.<sup id="cite_ref-AutoNT-73_103-0" class="reference"><a href="#cite_note-AutoNT-73-103">&#91;103&#93;</a></sup>
</p><p><a href="/wiki/MicroPython" title="MicroPython">MicroPython</a> and <a href="/wiki/CircuitPython" title="CircuitPython">CircuitPython</a> are Python 3 variants optimised for <a href="/wiki/Microcontroller" title="Microcontroller">microcontrollers</a>.
</p>
<h3><span class="mw-headline" id="Unsupported_implementations">Unsupported implementations</span></h3>
<p>Other just-in-time Python compilers have been developed, but are now unsupported:
</p>
<ul><li>Google began a project named <a href="/wiki/Unladen_Swallow" class="mw-redirect" title="Unladen Swallow">Unladen Swallow</a> in 2009 with the aim of speeding up the Python interpreter fivefold by using the <a href="/wiki/LLVM" title="LLVM">LLVM</a>, and of improving its multithreading ability to scale to thousands of cores.<sup id="cite_ref-AutoNT-74_104-0" class="reference"><a href="#cite_note-AutoNT-74-104">&#91;104&#93;</a></sup></li>
<li><a href="/wiki/Psyco" title="Psyco">Psyco</a> is a <a href="/wiki/Just-in-time_compilation" title="Just-in-time compilation">just-in-time</a> <a href="/wiki/Run-time_algorithm_specialisation" title="Run-time algorithm specialisation">specialising</a> compiler that integrates with CPython and transforms bytecode to machine code at runtime. The emitted code is specialised for certain <a href="/wiki/Data_type" title="Data type">data types</a> and is faster than standard Python code.</li></ul>
<p>In 2005, <a href="/wiki/Nokia" title="Nokia">Nokia</a> released a Python interpreter for the <a href="/wiki/Series_60" class="mw-redirect" title="Series 60">Series 60</a> mobile phones named <a href="/wiki/PyS60" class="mw-redirect" title="PyS60">PyS60</a>. It includes many of the modules from the CPython implementations and some additional modules to integrate with the <a href="/wiki/Symbian" title="Symbian">Symbian</a> operating system. The project has been kept up-to-date to run on all variants of the S60 platform, and several third-party modules are available. The Nokia <a href="/wiki/N900" class="mw-redirect" title="N900">N900</a> also supports Python with <a href="/wiki/GTK" class="mw-redirect" title="GTK">GTK</a> widget libraries, enabling programs to be written and run on the target device.<sup id="cite_ref-105" class="reference"><a href="#cite_note-105">&#91;105&#93;</a></sup>
</p>
<h3><span class="mw-headline" id="Cross-compilers_to_other_languages">Cross-compilers to other languages</span></h3>
<p>There are several compilers to high-level <a href="/wiki/Object_language" title="Object language">object languages</a>, with either unrestricted Python, a restricted subset of Python, or a language similar to Python as the source language:
</p>
<ul><li><a href="/wiki/Jython" title="Jython">Jython</a> compiles into Java byte code, which can then be executed by every <a href="/wiki/Java_virtual_machine" title="Java virtual machine">Java virtual machine</a> implementation. This also enables the use of Java class library functions from the Python program.</li>
<li><a href="/wiki/IronPython" title="IronPython">IronPython</a> follows a similar approach in order to run Python programs on the .NET <a href="/wiki/Common_Language_Runtime" title="Common Language Runtime">Common Language Runtime</a>.</li>
<li>The <a href="/wiki/RPython" class="mw-redirect" title="RPython">RPython</a> language can be compiled to <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a>, <a href="/wiki/Java_bytecode" title="Java bytecode">Java bytecode</a>, or <a href="/wiki/Common_Intermediate_Language" title="Common Intermediate Language">Common Intermediate Language</a>, and is used to build the PyPy interpreter of Python.</li>
<li><a href="/wiki/Pyjs" title="Pyjs">Pyjs</a> compiles Python to <a href="/wiki/JavaScript" title="JavaScript">JavaScript</a>.</li>
<li><a href="/wiki/Cython" title="Cython">Cython</a> compiles Python to <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a> and <a href="/wiki/C%2B%2B" title="C++">C++</a>.</li>
<li>Pythran compiles Python to <a href="/wiki/C%2B%2B" title="C++">C++</a>.</li>
<li>Somewhat dated <a href="/wiki/Pyrex_(programming_language)" title="Pyrex (programming language)">Pyrex</a> (latest release in 2010) and <a href="/wiki/Shed_Skin" title="Shed Skin">Shed Skin</a> (latest release in 2013) compile to C and C++ respectively.</li>
<li>Google's Grumpy compiles Python to <a href="/wiki/Go_(programming_language)" title="Go (programming language)">Go</a>.</li>
<li><a href="/wiki/MyHDL" title="MyHDL">MyHDL</a> compiles Python to <a href="/wiki/VHDL" title="VHDL">VHDL</a>.</li>
<li><a href="/wiki/Nuitka" title="Nuitka">Nuitka</a> compiles Python into C++ <sup id="cite_ref-106" class="reference"><a href="#cite_note-106">&#91;106&#93;</a></sup></li></ul>
<h3><span class="mw-headline" id="Performance">Performance</span></h3>
<p>A performance comparison of various Python implementations on a non-numerical (combinatorial) workload was presented at EuroSciPy '13.<sup id="cite_ref-107" class="reference"><a href="#cite_note-107">&#91;107&#93;</a></sup>
</p>
<h2><span class="mw-headline" id="Development">Development</span></h2>
<p>Python's development is conducted largely through the <i>Python Enhancement Proposal</i> (PEP) process, the primary mechanism for proposing major new features, collecting community input on issues and documenting Python design decisions.<sup id="cite_ref-PepCite000_108-0" class="reference"><a href="#cite_note-PepCite000-108">&#91;108&#93;</a></sup> Outstanding PEPs are reviewed and commented on by the Python community and Guido Van Rossum, Python's <a href="/wiki/Benevolent_Dictator_For_Life" class="mw-redirect" title="Benevolent Dictator For Life">Benevolent Dictator For Life</a>.<sup id="cite_ref-PepCite000_108-1" class="reference"><a href="#cite_note-PepCite000-108">&#91;108&#93;</a></sup>
</p><p>Enhancement of the language corresponds with development of the CPython reference implementation. The mailing list python-dev is the primary forum for the language's development. Specific issues are discussed in the <a href="/wiki/Roundup_(issue_tracker)" title="Roundup (issue tracker)">Roundup</a> <a href="/wiki/Bug_tracker" class="mw-redirect" title="Bug tracker">bug tracker</a> maintained at python.org.<sup id="cite_ref-AutoNT-21_109-0" class="reference"><a href="#cite_note-AutoNT-21-109">&#91;109&#93;</a></sup> Development originally took place on a <a href="/wiki/Self-hosted" class="mw-redirect" title="Self-hosted">self-hosted</a> source-code repository running <a href="/wiki/Mercurial" title="Mercurial">Mercurial</a>, until Python moved to <a href="/wiki/GitHub" title="GitHub">GitHub</a> in January 2017.<sup id="cite_ref-py_dev_guide_110-0" class="reference"><a href="#cite_note-py_dev_guide-110">&#91;110&#93;</a></sup>
</p><p>CPython's public releases come in three types, distinguished by which part of the version number is incremented:
</p>
<ul><li>Backward-incompatible versions, where code is expected to break and need to be manually <a href="/wiki/Ported" class="mw-redirect" title="Ported">ported</a>. The first part of the version number is incremented. These releases happen infrequently—for example, version 3.0 was released 8 years after 2.0.</li>
<li>Major or "feature" releases, about every 18 months, are largely compatible but introduce new features. The second part of the version number is incremented. Each major version is supported by bugfixes for several years after its release.<sup id="cite_ref-release-schedule_111-0" class="reference"><a href="#cite_note-release-schedule-111">&#91;111&#93;</a></sup></li>
<li>Bugfix releases, which introduce no new features, occur about every 3 months and are made when a sufficient number of bugs have been fixed upstream since the last release. Security vulnerabilities are also patched in these releases. The third and final part of the version number is incremented.<sup id="cite_ref-AutoNT-22_112-0" class="reference"><a href="#cite_note-AutoNT-22-112">&#91;112&#93;</a></sup></li></ul>
<p>Many <a href="/wiki/Beta_release" class="mw-redirect" title="Beta release">alpha, beta, and release-candidates</a> are also released as previews and for testing before final releases. Although there is a rough schedule for each release, they are often delayed if the code is not ready. Python's development team monitors the state of the code by running the large <a href="/wiki/Unit_test" class="mw-redirect" title="Unit test">unit test</a> suite during development, and using the <a href="/wiki/BuildBot" class="mw-redirect" title="BuildBot">BuildBot</a> <a href="/wiki/Continuous_integration" title="Continuous integration">continuous integration</a> system.<sup id="cite_ref-AutoNT-23_113-0" class="reference"><a href="#cite_note-AutoNT-23-113">&#91;113&#93;</a></sup>
</p><p>The community of Python developers has also contributed over 86,000<sup id="cite_ref-114" class="reference"><a href="#cite_note-114">&#91;114&#93;</a></sup> software modules (as of  20&#160;August&#160;2016<sup class="plainlinks noexcerpt noprint asof-tag update" style="display:none;"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Python_(programming_language)&amp;action=edit">&#91;update&#93;</a></sup>) to the <a href="/wiki/Python_Package_Index" title="Python Package Index">Python Package Index</a> (PyPI), the official repository of third-party Python libraries.
</p><p>The major <a href="/wiki/Academic_conference" title="Academic conference">academic conference</a> on Python is <a href="/wiki/PyCon" class="mw-redirect" title="PyCon">PyCon</a>. There are also special Python mentoring programmes, such as <a href="/wiki/Pyladies" class="mw-redirect" title="Pyladies">Pyladies</a>.
</p>
<h2><span class="mw-headline" id="Naming">Naming</span></h2>
<p>Python's name is derived from the British comedy group <a href="/wiki/Monty_Python" title="Monty Python">Monty Python</a>, whom Python creator Guido van Rossum enjoyed while developing the language. Monty Python references appear frequently in Python code and culture;<sup id="cite_ref-tutorial-chapter1_115-0" class="reference"><a href="#cite_note-tutorial-chapter1-115">&#91;115&#93;</a></sup> for example, the <a href="/wiki/Metasyntactic_variable" title="Metasyntactic variable">metasyntactic variables</a> often used in Python literature are <a href="/wiki/Spam_(Monty_Python)" title="Spam (Monty Python)"><i>spam</i> and <i>eggs</i></a> instead of the traditional <a href="/wiki/Foobar" title="Foobar"><i>foo</i> and <i>bar</i></a>.<sup id="cite_ref-tutorial-chapter1_115-1" class="reference"><a href="#cite_note-tutorial-chapter1-115">&#91;115&#93;</a></sup><sup id="cite_ref-AutoNT-26_116-0" class="reference"><a href="#cite_note-AutoNT-26-116">&#91;116&#93;</a></sup> The official Python documentation also contains various references to Monty Python routines.<sup id="cite_ref-117" class="reference"><a href="#cite_note-117">&#91;117&#93;</a></sup><sup id="cite_ref-118" class="reference"><a href="#cite_note-118">&#91;118&#93;</a></sup>
</p><p>The prefix <i>Py-</i> is used to show that something is related to Python. Examples of the use of this prefix in names of Python applications or libraries include <a href="/wiki/Pygame" title="Pygame">Pygame</a>, a <a href="/wiki/Language_binding" title="Language binding">binding</a> of <a href="/wiki/Simple_DirectMedia_Layer" title="Simple DirectMedia Layer">SDL</a> to Python (commonly used to create games); <a href="/wiki/PyQt" title="PyQt">PyQt</a> and <a href="/wiki/PyGTK" title="PyGTK">PyGTK</a>, which bind <a href="/wiki/Qt_(software)" title="Qt (software)">Qt</a> and <a href="/wiki/GTK" class="mw-redirect" title="GTK">GTK</a> to Python respectively; and <a href="/wiki/PyPy" title="PyPy">PyPy</a>, a Python implementation originally written in Python.
</p>
<h2><span class="mw-headline" id="Uses">Uses</span></h2>
<div role="note" class="hatnote navigation-not-searchable">Main article: <a href="/wiki/List_of_Python_software" title="List of Python software">List of Python software</a></div>
<p>Since 2003, Python has consistently ranked in the top ten most popular programming languages in the <a href="/wiki/TIOBE_Programming_Community_Index" class="mw-redirect" title="TIOBE Programming Community Index">TIOBE Programming Community Index</a> where, as of  January&#160;2018<sup class="plainlinks noexcerpt noprint asof-tag update" style="display:none;"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Python_(programming_language)&amp;action=edit">&#91;update&#93;</a></sup>, it is the fourth most popular language (behind <a href="/wiki/Java_(programming_language)" title="Java (programming language)">Java</a>, <a href="/wiki/C_(programming_language)" title="C (programming language)">C</a>, and <a href="/wiki/C%2B%2B" title="C++">C++</a>).<sup id="cite_ref-119" class="reference"><a href="#cite_note-119">&#91;119&#93;</a></sup> It was selected Programming Language of the Year in 2007 and 2010.<sup id="cite_ref-AutoNT-34_120-0" class="reference"><a href="#cite_note-AutoNT-34-120">&#91;120&#93;</a></sup>
</p><p>An empirical study found that scripting languages, such as Python, are more productive than conventional languages, such as C and Java, for programming problems involving string manipulation and search in a dictionary, and determined that memory consumption was often "better than Java and not much worse than C or C++".<sup id="cite_ref-AutoNT-28_121-0" class="reference"><a href="#cite_note-AutoNT-28-121">&#91;121&#93;</a></sup>
</p><p>Large organizations that use Python include <a href="/wiki/Wikipedia" title="Wikipedia">Wikipedia</a>, <a href="/wiki/Google" title="Google">Google</a>,<sup id="cite_ref-quotes-about-python_122-0" class="reference"><a href="#cite_note-quotes-about-python-122">&#91;122&#93;</a></sup> <a href="/wiki/Yahoo!" title="Yahoo!">Yahoo!</a>,<sup id="cite_ref-AutoNT-29_123-0" class="reference"><a href="#cite_note-AutoNT-29-123">&#91;123&#93;</a></sup> <a href="/wiki/CERN" title="CERN">CERN</a>,<sup id="cite_ref-AutoNT-30_124-0" class="reference"><a href="#cite_note-AutoNT-30-124">&#91;124&#93;</a></sup> <a href="/wiki/NASA" title="NASA">NASA</a>,<sup id="cite_ref-AutoNT-31_125-0" class="reference"><a href="#cite_note-AutoNT-31-125">&#91;125&#93;</a></sup> <a href="/wiki/Facebook" title="Facebook">Facebook</a>,<sup id="cite_ref-126" class="reference"><a href="#cite_note-126">&#91;126&#93;</a></sup> <a href="/wiki/Amazon_(company)" title="Amazon (company)">Amazon</a>, <a href="/wiki/Instagram" title="Instagram">Instagram</a>, <a href="/wiki/Spotify" title="Spotify">Spotify</a><sup id="cite_ref-127" class="reference"><a href="#cite_note-127">&#91;127&#93;</a></sup> and some smaller entities like <a href="/wiki/Industrial_Light_%26_Magic" title="Industrial Light &amp; Magic">ILM</a><sup id="cite_ref-AutoNT-32_128-0" class="reference"><a href="#cite_note-AutoNT-32-128">&#91;128&#93;</a></sup> and <a href="/wiki/ITA_Software" title="ITA Software">ITA</a>.<sup id="cite_ref-AutoNT-33_129-0" class="reference"><a href="#cite_note-AutoNT-33-129">&#91;129&#93;</a></sup> The social news networking site <a href="/wiki/Reddit" title="Reddit">Reddit</a> is written entirely in Python.
</p><p>Python can serve as a <a href="/wiki/Scripting_language" title="Scripting language">scripting language</a> for <a href="/wiki/Web_application" title="Web application">web applications</a>, e.g., via <a href="/wiki/Mod_wsgi" title="Mod wsgi">mod_wsgi</a> for the <a href="/wiki/Apache_web_server" class="mw-redirect" title="Apache web server">Apache web server</a>.<sup id="cite_ref-AutoNT-35_130-0" class="reference"><a href="#cite_note-AutoNT-35-130">&#91;130&#93;</a></sup> With <a href="/wiki/Web_Server_Gateway_Interface" title="Web Server Gateway Interface">Web Server Gateway Interface</a>, a standard API has evolved to facilitate these applications. <a href="/wiki/Web_framework" title="Web framework">Web frameworks</a> like <a href="/wiki/Django_(web_framework)" title="Django (web framework)">Django</a>, <a href="/wiki/Pylons_(web_framework)" class="mw-redirect" title="Pylons (web framework)">Pylons</a>, <a href="/wiki/Pyramid_(web_framework)" class="mw-redirect" title="Pyramid (web framework)">Pyramid</a>, <a href="/wiki/TurboGears" title="TurboGears">TurboGears</a>, <a href="/wiki/Web2py" title="Web2py">web2py</a>, <a href="/wiki/Tornado_(web_server)" title="Tornado (web server)">Tornado</a>, <a href="/wiki/Flask_(web_framework)" title="Flask (web framework)">Flask</a>, <a href="/wiki/Bottle_(web_framework)" title="Bottle (web framework)">Bottle</a> and <a href="/wiki/Zope" title="Zope">Zope</a> support developers in the design and maintenance of complex applications. <a href="/wiki/Pyjs" title="Pyjs">Pyjs</a> and <a href="/wiki/IronPython" title="IronPython">IronPython</a> can be used to develop the client-side of Ajax-based applications. <a href="/wiki/SQLAlchemy" title="SQLAlchemy">SQLAlchemy</a> can be used as <a href="/wiki/Data_mapper_pattern" title="Data mapper pattern">data mapper</a> to a relational database. <a href="/wiki/Twisted_(software)" title="Twisted (software)">Twisted</a> is a framework to program communications between computers, and is used (for example) by <a href="/wiki/Dropbox_(service)" title="Dropbox (service)">Dropbox</a>.
</p><p>Libraries such as <a href="/wiki/NumPy" title="NumPy">NumPy</a>, <a href="/wiki/SciPy" title="SciPy">SciPy</a> and <a href="/wiki/Matplotlib" title="Matplotlib">Matplotlib</a> allow the effective use of Python in scientific computing,<sup id="cite_ref-cise_131-0" class="reference"><a href="#cite_note-cise-131">&#91;131&#93;</a></sup><sup id="cite_ref-millman_132-0" class="reference"><a href="#cite_note-millman-132">&#91;132&#93;</a></sup> with specialized libraries such as <a href="/wiki/Biopython" title="Biopython">Biopython</a> and <a href="/wiki/Astropy" title="Astropy">Astropy</a> providing domain-specific functionality. <a href="/wiki/SageMath" title="SageMath">SageMath</a> is a <a href="/wiki/Mathematical_software" title="Mathematical software">mathematical software</a> with a "<a href="/w/index.php?title=Electronic_Notebook&amp;action=edit&amp;redlink=1" class="new" title="Electronic Notebook (page does not exist)">notebook</a>" programmable in Python: its library covers many aspects of <a href="/wiki/Mathematics" title="Mathematics">mathematics</a>, including <a href="/wiki/Algebra" title="Algebra">algebra</a>, <a href="/wiki/Combinatorics" title="Combinatorics">combinatorics</a>, <a href="/wiki/Numerical_mathematics" class="mw-redirect" title="Numerical mathematics">numerical mathematics</a>, <a href="/wiki/Number_theory" title="Number theory">number theory</a>, and <a href="/wiki/Calculus" title="Calculus">calculus</a>.
</p><p>Python has been successfully embedded in many software products as a scripting language, including in <a href="/wiki/Finite_element_method" title="Finite element method">finite element method</a> software such as <a href="/wiki/Abaqus" title="Abaqus">Abaqus</a>, 3D parametric modeler like <a href="/wiki/FreeCAD" title="FreeCAD">FreeCAD</a>, 3D animation packages such as <a href="/wiki/3ds_Max" class="mw-redirect" title="3ds Max">3ds Max</a>, <a href="/wiki/Blender_(software)" title="Blender (software)">Blender</a>, <a href="/wiki/Cinema_4D" title="Cinema 4D">Cinema 4D</a>, <a href="/wiki/Lightwave" class="mw-redirect" title="Lightwave">Lightwave</a>, <a href="/wiki/Houdini_(software)" title="Houdini (software)">Houdini</a>, <a href="/wiki/Maya_(software)" class="mw-redirect" title="Maya (software)">Maya</a>, <a href="/wiki/Modo_(software)" title="Modo (software)">modo</a>, <a href="/wiki/MotionBuilder" class="mw-redirect" title="MotionBuilder">MotionBuilder</a>, <a href="/wiki/Autodesk_Softimage" title="Autodesk Softimage">Softimage</a>, the visual effects compositor <a href="/wiki/Nuke_(software)" title="Nuke (software)">Nuke</a>, 2D imaging programs like <a href="/wiki/GIMP" title="GIMP">GIMP</a>,<sup id="cite_ref-133" class="reference"><a href="#cite_note-133">&#91;133&#93;</a></sup> <a href="/wiki/Inkscape" title="Inkscape">Inkscape</a>, <a href="/wiki/Scribus" title="Scribus">Scribus</a> and <a href="/wiki/Paint_Shop_Pro" class="mw-redirect" title="Paint Shop Pro">Paint Shop Pro</a>,<sup id="cite_ref-AutoNT-38_134-0" class="reference"><a href="#cite_note-AutoNT-38-134">&#91;134&#93;</a></sup> and <a href="/wiki/Musical_notation" title="Musical notation">musical notation</a> programs like <a href="/wiki/Scorewriter" title="Scorewriter">scorewriter</a> and <a href="/wiki/Capella_(notation_program)" title="Capella (notation program)">capella</a>. <a href="/wiki/GNU_Debugger" title="GNU Debugger">GNU Debugger</a> uses Python as a <a href="/wiki/Prettyprint" title="Prettyprint">pretty printer</a> to show complex structures such as C++ containers. <a href="/wiki/Esri" title="Esri">Esri</a> promotes Python as the best choice for writing scripts in <a href="/wiki/ArcGIS" title="ArcGIS">ArcGIS</a>.<sup id="cite_ref-AutoNT-39_135-0" class="reference"><a href="#cite_note-AutoNT-39-135">&#91;135&#93;</a></sup> It has also been used in several video games,<sup id="cite_ref-AutoNT-40_136-0" class="reference"><a href="#cite_note-AutoNT-40-136">&#91;136&#93;</a></sup><sup id="cite_ref-AutoNT-41_137-0" class="reference"><a href="#cite_note-AutoNT-41-137">&#91;137&#93;</a></sup> and has been adopted as first of the three available <a href="/wiki/Programming_language" title="Programming language">programming languages</a> in <a href="/wiki/Google_App_Engine" title="Google App Engine">Google App Engine</a>, the other two being <a href="/wiki/Java_(software_platform)" title="Java (software platform)">Java</a> and <a href="/wiki/Go_(programming_language)" title="Go (programming language)">Go</a>.<sup id="cite_ref-AutoNT-42_138-0" class="reference"><a href="#cite_note-AutoNT-42-138">&#91;138&#93;</a></sup> Python is also used in <a href="/wiki/Algorithmic_trading" title="Algorithmic trading">algorithmic trading</a> and quantitative finance.<sup id="cite_ref-139" class="reference"><a href="#cite_note-139">&#91;139&#93;</a></sup> Python can also be implemented in APIs of online brokerages that run on other languages by using wrappers.<sup id="cite_ref-140" class="reference"><a href="#cite_note-140">&#91;140&#93;</a></sup>
</p><p>Python has been used in <a href="/wiki/Artificial_intelligence" title="Artificial intelligence">artificial intelligence</a> projects.<sup id="cite_ref-AutoNT-43_141-0" class="reference"><a href="#cite_note-AutoNT-43-141">&#91;141&#93;</a></sup><sup id="cite_ref-AutoNT-44_142-0" class="reference"><a href="#cite_note-AutoNT-44-142">&#91;142&#93;</a></sup><sup id="cite_ref-AutoNT-45_143-0" class="reference"><a href="#cite_note-AutoNT-45-143">&#91;143&#93;</a></sup><sup id="cite_ref-AutoNT-46_144-0" class="reference"><a href="#cite_note-AutoNT-46-144">&#91;144&#93;</a></sup> As a scripting language with <a href="/wiki/Modular_programming" title="Modular programming">modular architecture</a>, simple syntax and rich text processing tools, Python is often used for <a href="/wiki/Natural_language_processing" title="Natural language processing">natural language processing</a>.<sup id="cite_ref-AutoNT-47_145-0" class="reference"><a href="#cite_note-AutoNT-47-145">&#91;145&#93;</a></sup>
</p><p>Many operating systems include Python as a standard component. It ships with most <a href="/wiki/Linux_distribution" title="Linux distribution">Linux distributions</a>, <a href="/wiki/AmigaOS_4" title="AmigaOS 4">AmigaOS 4</a>, <a href="/wiki/FreeBSD" title="FreeBSD">FreeBSD</a>, <a href="/wiki/NetBSD" title="NetBSD">NetBSD</a>, <a href="/wiki/OpenBSD" title="OpenBSD">OpenBSD</a> and <a href="/wiki/MacOS" title="MacOS">macOS</a>, and can be used from the command line (terminal). Many Linux distributions use installers written in Python: <a href="/wiki/Ubuntu_(operating_system)" title="Ubuntu (operating system)">Ubuntu</a> uses the <a href="/wiki/Ubiquity_(software)" title="Ubiquity (software)">Ubiquity</a> installer, while <a href="/wiki/Red_Hat_Linux" title="Red Hat Linux">Red Hat Linux</a> and <a href="/wiki/Fedora_(operating_system)" title="Fedora (operating system)">Fedora</a> use the <a href="/wiki/Anaconda_(installer)" title="Anaconda (installer)">Anaconda</a> installer. <a href="/wiki/Gentoo_Linux" title="Gentoo Linux">Gentoo Linux</a> uses Python in its <a href="/wiki/Package_management_system" class="mw-redirect" title="Package management system">package management system</a>, <a href="/wiki/Portage_(software)" title="Portage (software)">Portage</a>.
</p><p>Python is used extensively in the <a href="/wiki/Information_security" title="Information security">information security</a> industry, including in exploit development.<sup id="cite_ref-AutoNT-49_146-0" class="reference"><a href="#cite_note-AutoNT-49-146">&#91;146&#93;</a></sup><sup id="cite_ref-AutoNT-50_147-0" class="reference"><a href="#cite_note-AutoNT-50-147">&#91;147&#93;</a></sup>
</p><p>Most of the <a href="/wiki/Sugar_(software)" title="Sugar (software)">Sugar</a> software for the <a href="/wiki/One_Laptop_per_Child" title="One Laptop per Child">One Laptop per Child</a> XO, now developed at <a href="/wiki/Sugar_Labs" title="Sugar Labs">Sugar Labs</a>, is written in Python.<sup id="cite_ref-AutoNT-51_148-0" class="reference"><a href="#cite_note-AutoNT-51-148">&#91;148&#93;</a></sup>
</p><p>The <a href="/wiki/Raspberry_Pi" title="Raspberry Pi">Raspberry Pi</a> <a href="/wiki/Single-board_computer" title="Single-board computer">single-board computer</a> project has adopted Python as its main user-programming language.
</p><p><a href="/wiki/LibreOffice" title="LibreOffice">LibreOffice</a> includes Python, and intends to replace Java with Python. Its Python Scripting Provider is a core feature<sup id="cite_ref-149" class="reference"><a href="#cite_note-149">&#91;149&#93;</a></sup> since Version 4.0 from 7 February 2013.
</p>
<h2><span class="mw-headline" id="Languages_influenced_by_Python">Languages influenced by Python</span></h2>
<p>Python's design and philosophy have influenced many other programming languages:
</p>
<ul><li><a href="/wiki/Boo_(programming_language)" title="Boo (programming language)">Boo</a> uses indentation, a similar syntax, and a similar object model.<sup id="cite_ref-AutoNT-90_150-0" class="reference"><a href="#cite_note-AutoNT-90-150">&#91;150&#93;</a></sup></li>
<li><a href="/wiki/Cobra_(programming_language)" title="Cobra (programming language)">Cobra</a> uses indentation and a similar syntax, and its "Acknowledgements" document lists Python first among languages that influenced it.<sup id="cite_ref-AutoNT-91_151-0" class="reference"><a href="#cite_note-AutoNT-91-151">&#91;151&#93;</a></sup> However, Cobra directly supports <a href="/wiki/Design_by_contract" title="Design by contract">design-by-contract</a>, <a href="/wiki/Unit_testing" title="Unit testing">unit tests</a>, and optional <a href="/wiki/Static_typing" class="mw-redirect" title="Static typing">static typing</a>.<sup id="cite_ref-AutoNT-92_152-0" class="reference"><a href="#cite_note-AutoNT-92-152">&#91;152&#93;</a></sup></li>
<li><a href="/wiki/CoffeeScript" title="CoffeeScript">CoffeeScript</a>, a programming language that cross-compiles to JavaScript, has Python-inspired syntax.</li>
<li><a href="/wiki/ECMAScript" title="ECMAScript">ECMAScript</a> borrowed <a href="/wiki/Iterator" title="Iterator">iterators</a> and <a href="/wiki/Generator_(computer_science)" class="mw-redirect" title="Generator (computer science)">generators</a> from Python.<sup id="cite_ref-AutoNT-93_153-0" class="reference"><a href="#cite_note-AutoNT-93-153">&#91;153&#93;</a></sup></li>
<li><a href="/wiki/Go_(programming_language)" title="Go (programming language)">Go</a> is designed for the "speed of working in a dynamic language like Python"<sup id="cite_ref-AutoNT-94_154-0" class="reference"><a href="#cite_note-AutoNT-94-154">&#91;154&#93;</a></sup> and shares the same syntax for slicing arrays.</li>
<li><a href="/wiki/Groovy_(programming_language)" class="mw-redirect" title="Groovy (programming language)">Groovy</a> was motivated by the desire to bring the Python design philosophy to <a href="/wiki/Java_(programming_language)" title="Java (programming language)">Java</a>.<sup id="cite_ref-AutoNT-95_155-0" class="reference"><a href="#cite_note-AutoNT-95-155">&#91;155&#93;</a></sup></li>
<li><a href="/wiki/Julia_(programming_language)" title="Julia (programming language)">Julia</a> was designed "with <a href="/wiki/Hygienic_macro" title="Hygienic macro">true macros</a> [.. and to be] as usable for general programming as Python [and] should be as fast as C".<sup id="cite_ref-Julia_21-1" class="reference"><a href="#cite_note-Julia-21">&#91;21&#93;</a></sup> Calling to or from Julia is possible; to with PyCall.jl and a Python package pyjulia allows calling, in the other direction, from Python.</li>
<li><a href="/wiki/Kotlin_(programming_language)" title="Kotlin (programming language)">Kotlin</a> is a functional programming language with an interactive shell similar to python. However, Kotlin is strongly typed with access to standard Java libraries.<sup id="cite_ref-156" class="reference"><a href="#cite_note-156">&#91;156&#93;</a></sup></li>
<li><a href="/wiki/Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a>'s creator, <a href="/wiki/Yukihiro_Matsumoto" title="Yukihiro Matsumoto">Yukihiro Matsumoto</a>, has said: "I wanted a scripting language that was more powerful than Perl, and more object-oriented than Python. That's why I decided to design my own language."<sup id="cite_ref-linuxdevcenter_157-0" class="reference"><a href="#cite_note-linuxdevcenter-157">&#91;157&#93;</a></sup></li>
<li><a href="/wiki/Swift_(programming_language)" title="Swift (programming language)">Swift</a>, a programming language developed by Apple, has some Python-inspired syntax.<sup id="cite_ref-158" class="reference"><a href="#cite_note-158">&#91;158&#93;</a></sup></li>
<li><a href="/wiki/Gdscript" class="mw-redirect" title="Gdscript">GDScript</a>, dynamically typed programming language used to create video-games. It is extremely similar to Python with a few minor differences.</li></ul>
<p>Python's development practices have also been emulated by other languages. For example, the practice of requiring a document describing the rationale for, and issues surrounding, a change to the language (in Python, a PEP) is also used in <a href="/wiki/Tcl" title="Tcl">Tcl</a><sup id="cite_ref-AutoNT-99_159-0" class="reference"><a href="#cite_note-AutoNT-99-159">&#91;159&#93;</a></sup> and <a href="/wiki/Erlang_(programming_language)" title="Erlang (programming language)">Erlang</a>.<sup id="cite_ref-AutoNT-100_160-0" class="reference"><a href="#cite_note-AutoNT-100-160">&#91;160&#93;</a></sup>
</p><p>Python received TIOBE's Programming Language of the Year awards in 2007 and 2010. The award is given to the language with the greatest growth in popularity over the year, as measured by the <a href="/wiki/TIOBE_index" title="TIOBE index">TIOBE index</a>.<sup id="cite_ref-AutoNT-101_161-0" class="reference"><a href="#cite_note-AutoNT-101-161">&#91;161&#93;</a></sup>
</p>
<h2><span class="mw-headline" id="See_also">See also</span></h2>
<div role="navigation" aria-label="Portals" class="noprint portal plainlist tright" style="margin:0.5em 0 0.5em 1em;border:solid #aaa 1px">
<ul style="display:table;box-sizing:border-box;padding:0.1em;max-width:175px;background:#f9f9f9;font-size:85%;line-height:110%;font-style:italic;font-weight:bold">
<li style="display:table-row"><span style="display:table-cell;padding:0.2em;vertical-align:middle;text-align:center"><img alt="" src="//upload.wikimedia.org/wikipedia/commons/thumb/3/31/Free_and_open-source_software_logo_%282009%29.svg/28px-Free_and_open-source_software_logo_%282009%29.svg.png" width="28" height="28" class="noviewer" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/3/31/Free_and_open-source_software_logo_%282009%29.svg/42px-Free_and_open-source_software_logo_%282009%29.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/3/31/Free_and_open-source_software_logo_%282009%29.svg/56px-Free_and_open-source_software_logo_%282009%29.svg.png 2x" data-file-width="512" data-file-height="512" /></span><span style="display:table-cell;padding:0.2em 0.2em 0.2em 0.3em;vertical-align:middle"><a href="/wiki/Portal:Free_software" class="mw-redirect" title="Portal:Free software">Free software portal</a></span></li>
<li style="display:table-row"><span style="display:table-cell;padding:0.2em;vertical-align:middle;text-align:center"><img alt="" src="//upload.wikimedia.org/wikipedia/en/thumb/f/fd/Portal-puzzle.svg/32px-Portal-puzzle.svg.png" width="32" height="28" class="noviewer" srcset="//upload.wikimedia.org/wikipedia/en/thumb/f/fd/Portal-puzzle.svg/48px-Portal-puzzle.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/f/fd/Portal-puzzle.svg/64px-Portal-puzzle.svg.png 2x" data-file-width="32" data-file-height="28" /></span><span style="display:table-cell;padding:0.2em 0.2em 0.2em 0.3em;vertical-align:middle"><a href="/wiki/Portal:Python_programming" class="mw-redirect" title="Portal:Python programming">Python programming portal</a></span></li></ul></div>
<ul><li><a href="/wiki/History_of_Python" title="History of Python">History of Python</a></li>
<li><a href="/wiki/List_of_integrated_development_environments_for_Python" class="mw-redirect" title="List of integrated development environments for Python">Comparison of integrated development environments for Python</a></li>
<li><a href="/wiki/Comparison_of_programming_languages" title="Comparison of programming languages">Comparison of programming languages</a></li>
<li><a href="/wiki/List_of_programming_languages" title="List of programming languages">List of programming languages</a></li>
<li><a href="/wiki/Pip_(package_manager)" title="Pip (package manager)">pip (package manager)</a></li>
<li><a href="/wiki/Off-side_rule" title="Off-side rule">Off-side rule</a></li></ul>
<h2><span class="mw-headline" id="References">References</span></h2>
<div class="reflist columns references-column-width" style="-moz-column-width: 30em; -webkit-column-width: 30em; column-width: 30em; list-style-type: decimal;">
<ol class="references">
<li id="cite_note-guttag-1"><span class="mw-cite-backlink">^ <a href="#cite_ref-guttag_1-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-guttag_1-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation book">Guttag, John V. (2016-08-12). <i>Introduction to Computation and Programming Using Python: With Application to Understanding Data</i>. MIT Press. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-262-52962-4" title="Special:BookSources/978-0-262-52962-4">978-0-262-52962-4</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Introduction+to+Computation+and+Programming+Using+Python%3A+With+Application+to+Understanding+Data&amp;rft.pub=MIT+Press&amp;rft.date=2016-08-12&amp;rft.isbn=978-0-262-52962-4&amp;rft.aulast=Guttag&amp;rft.aufirst=John+V.&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-2"><span class="mw-cite-backlink"><b><a href="#cite_ref-2">^</a></b></span> <span class="reference-text"><cite class="citation web">Deily, Ned (28 March 2018). <a rel="nofollow" class="external text" href="https://www.python.org/downloads/release/python-370/?hn">"Python 3.7.0 is now available"</a>. <i>Python Insider</i>. The Python Core Developers<span class="reference-accessdate">. Retrieved <span class="nowrap">29 March</span> 2018</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Insider&amp;rft.atitle=Python+3.7.0+is+now+available&amp;rft.date=2018-03-28&amp;rft.aulast=Deily&amp;rft.aufirst=Ned&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdownloads%2Frelease%2Fpython-370%2F%3Fhn&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-3"><span class="mw-cite-backlink"><b><a href="#cite_ref-3">^</a></b></span> <span class="reference-text"><cite class="citation web">Peterson, Benjamin (1 May 2018). <a rel="nofollow" class="external text" href="https://blog.python.org/2018/05/python-2715-released.html">"Python 2.7.15 released"</a>. <i>Python Insider</i>. The Python Core Developers<span class="reference-accessdate">. Retrieved <span class="nowrap">1 May</span> 2018</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Insider&amp;rft.atitle=Python+2.7.15+released&amp;rft.date=2018-05-01&amp;rft.aulast=Peterson&amp;rft.aufirst=Benjamin&amp;rft_id=https%3A%2F%2Fblog.python.org%2F2018%2F05%2Fpython-2715-released.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-4"><span class="mw-cite-backlink"><b><a href="#cite_ref-4">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0483/">"PEP 483 -- The Theory of Type Hints"</a>. <i>Python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python.org&amp;rft.atitle=PEP+483+--+The+Theory+of+Type+Hints&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0483%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-5"><span class="mw-cite-backlink"><b><a href="#cite_ref-5">^</a></b></span> <span class="reference-text">File extension .pyo was removed in Python 3.5. See <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0488/">PEP 0488</a></span>
</li>
<li id="cite_note-6"><span class="mw-cite-backlink"><b><a href="#cite_ref-6">^</a></b></span> <span class="reference-text"><cite class="citation web">Holth, Moore (30 March 2014). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0441/">"PEP 0441 -- Improving Python ZIP Application Support"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">12 November</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=PEP+0441+--+Improving+Python+ZIP+Application+Support&amp;rft.date=2014-03-30&amp;rft.aulast=Holth&amp;rft.aufirst=Moore&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0441%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-faq-created-7"><span class="mw-cite-backlink">^ <a href="#cite_ref-faq-created_7-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-faq-created_7-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/faq/general.html#why-was-python-created-in-the-first-place">"Why was Python created in the first place?"</a>. <i>General Python FAQ</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">22 March</span> 2007</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=General+Python+FAQ&amp;rft.atitle=Why+was+Python+created+in+the+first+place%3F&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Ffaq%2Fgeneral.html%23why-was-python-created-in-the-first-place&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-98-interview-8"><span class="mw-cite-backlink"><b><a href="#cite_ref-98-interview_8-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Kuchling, Andrew M. (22 December 2006). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20070501105422/http://www.amk.ca/python/writing/gvr-interview">"Interview with Guido van Rossum (July 1998)"</a>. <i>amk.ca</i>. Archived from <a rel="nofollow" class="external text" href="http://www.amk.ca/python/writing/gvr-interview">the original</a> on 1 May 2007<span class="reference-accessdate">. Retrieved <span class="nowrap">12 March</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=amk.ca&amp;rft.atitle=Interview+with+Guido+van+Rossum+%28July+1998%29&amp;rft.date=2006-12-22&amp;rft.aulast=Kuchling&amp;rft.aufirst=Andrew+M.&amp;rft_id=http%3A%2F%2Fwww.amk.ca%2Fpython%2Fwriting%2Fgvr-interview&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-1-9"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-1_9-0">^</a></b></span> <span class="reference-text"><cite class="citation journal">van Rossum, Guido (1993). <a rel="nofollow" class="external text" href="http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.38.2023">"An Introduction to Python for UNIX/C Programmers"</a>. <i>Proceedings of the NLUUG najaarsconferentie (Dutch UNIX users group)</i>. <q>even though the design of C is far from ideal, its influence on Python is considerable.</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=Proceedings+of+the+NLUUG+najaarsconferentie+%28Dutch+UNIX+users+group%29&amp;rft.atitle=An+Introduction+to+Python+for+UNIX%2FC+Programmers&amp;rft.date=1993&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=http%3A%2F%2Fciteseerx.ist.psu.edu%2Fviewdoc%2Fsummary%3Fdoi%3D10.1.1.38.2023&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-classmix-10"><span class="mw-cite-backlink">^ <a href="#cite_ref-classmix_10-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-classmix_10-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/tutorial/classes.html">"Classes"</a>. <i>The Python Tutorial</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">20 February</span> 2012</span>. <q>It is a mixture of the class mechanisms found in C++ and Modula-3</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=The+Python+Tutorial&amp;rft.atitle=Classes&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Ftutorial%2Fclasses.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-effbot-call-by-object-11"><span class="mw-cite-backlink"><b><a href="#cite_ref-effbot-call-by-object_11-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Lundh, Fredrik. <a rel="nofollow" class="external text" href="http://effbot.org/zone/call-by-object.htm">"Call By Object"</a>. <i>effbot.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">21 November</span> 2017</span>. <q>replace "CLU" with "Python", "record" with "instance", and "procedure" with "function or method", and you get a pretty accurate description of Python's object model.</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=effbot.org&amp;rft.atitle=Call+By+Object&amp;rft.aulast=Lundh&amp;rft.aufirst=Fredrik&amp;rft_id=http%3A%2F%2Feffbot.org%2Fzone%2Fcall-by-object.htm&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-2-12"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-2_12-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Simionato, Michele. <a rel="nofollow" class="external text" href="https://www.python.org/download/releases/2.3/mro/">"The Python 2.3 Method Resolution Order"</a>. Python Software Foundation. <q>The C3 method itself has nothing to do with Python, since it was invented by people working on Dylan and it is described in a paper intended for lispers</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=The+Python+2.3+Method+Resolution+Order&amp;rft.pub=Python+Software+Foundation&amp;rft.aulast=Simionato&amp;rft.aufirst=Michele&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdownload%2Freleases%2F2.3%2Fmro%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-3-13"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-3_13-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Kuchling, A. M. <a rel="nofollow" class="external text" href="https://docs.python.org/howto/functional.html">"Functional Programming HOWTO"</a>. <i>Python v2.7.2 documentation</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">9 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+v2.7.2+documentation&amp;rft.atitle=Functional+Programming+HOWTO&amp;rft.aulast=Kuchling&amp;rft.aufirst=A.+M.&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Fhowto%2Ffunctional.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-4-14"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-4_14-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Schemenauer, Neil; Peters, Tim; Hetland, Magnus Lie (18 May 2001). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0255/">"PEP 255&#160;– Simple Generators"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">9 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+255+%E2%80%93+Simple+Generators&amp;rft.date=2001-05-18&amp;rft.aulast=Schemenauer&amp;rft.aufirst=Neil&amp;rft.au=Peters%2C+Tim&amp;rft.au=Hetland%2C+Magnus+Lie&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0255%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-5-15"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-5_15-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Smith, Kevin D.; Jewett, Jim J.; Montanaro, Skip; Baxter, Anthony (2 September 2004). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0318/">"PEP 318&#160;– Decorators for Functions and Methods"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+318+%E2%80%93+Decorators+for+Functions+and+Methods&amp;rft.date=2004-09-02&amp;rft.aulast=Smith&amp;rft.aufirst=Kevin+D.&amp;rft.au=Jewett%2C+Jim+J.&amp;rft.au=Montanaro%2C+Skip&amp;rft.au=Baxter%2C+Anthony&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0318%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-6-16"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-6_16-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3.2/tutorial/controlflow.html">"More Control Flow Tools"</a>. <i>Python 3 documentation</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 July</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+3+documentation&amp;rft.atitle=More+Control+Flow+Tools&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3.2%2Ftutorial%2Fcontrolflow.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-17"><span class="mw-cite-backlink"><b><a href="#cite_ref-17">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://coffeescript.org/">"CoffeeScript borrows chained comparisons from Python"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=CoffeeScript+borrows+chained+comparisons+from+Python&amp;rft_id=https%3A%2F%2Fcoffeescript.org%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-18"><span class="mw-cite-backlink"><b><a href="#cite_ref-18">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://wiki.gnome.org/action/show/Projects/Genie">"Genie Language - A brief guide"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">28 December</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Genie+Language+-+A+brief+guide&amp;rft_id=https%3A%2F%2Fwiki.gnome.org%2Faction%2Fshow%2FProjects%2FGenie&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-19"><span class="mw-cite-backlink"><b><a href="#cite_ref-19">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.2ality.com/2013/02/javascript-influences.html">"Perl and Python influences in JavaScript"</a>. <i>www.2ality.com</i>. 24 February 2013<span class="reference-accessdate">. Retrieved <span class="nowrap">15 May</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=www.2ality.com&amp;rft.atitle=Perl+and+Python+influences+in+JavaScript&amp;rft.date=2013-02-24&amp;rft_id=http%3A%2F%2Fwww.2ality.com%2F2013%2F02%2Fjavascript-influences.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-20"><span class="mw-cite-backlink"><b><a href="#cite_ref-20">^</a></b></span> <span class="reference-text"><cite class="citation web">Rauschmayer, Axel. <a rel="nofollow" class="external text" href="http://speakingjs.com/es5/ch03.html">"Chapter 3: The Nature of JavaScript; Influences"</a>. <i>O'Reilly, Speaking JavaScript</i><span class="reference-accessdate">. Retrieved <span class="nowrap">15 May</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=O%27Reilly%2C+Speaking+JavaScript&amp;rft.atitle=Chapter+3%3A+The+Nature+of+JavaScript%3B+Influences&amp;rft.aulast=Rauschmayer&amp;rft.aufirst=Axel&amp;rft_id=http%3A%2F%2Fspeakingjs.com%2Fes5%2Fch03.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-Julia-21"><span class="mw-cite-backlink">^ <a href="#cite_ref-Julia_21-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-Julia_21-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://julialang.org/blog/2012/02/why-we-created-julia">"Why We Created Julia"</a>. <i>Julia website</i>. February 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">5 June</span> 2014</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Julia+website&amp;rft.atitle=Why+We+Created+Julia&amp;rft.date=2012-02&amp;rft_id=http%3A%2F%2Fjulialang.org%2Fblog%2F2012%2F02%2Fwhy-we-created-julia&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-The_Ring_programming_language_and_other_languages-22"><span class="mw-cite-backlink"><b><a href="#cite_ref-The_Ring_programming_language_and_other_languages_22-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Ring Team (4 December 2017). <a rel="nofollow" class="external text" href="http://ring-lang.sourceforge.net/doc1.6/introduction.html#ring-and-other-languages">"Ring and other languages"</a>. <i>ring-lang.net</i>. <a href="/w/index.php?title=Ring-lang&amp;action=edit&amp;redlink=1" class="new" title="Ring-lang (page does not exist)">ring-lang</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=ring-lang.net&amp;rft.atitle=Ring+and+other+languages&amp;rft.date=2017-12-04&amp;rft.au=Ring+Team&amp;rft_id=http%3A%2F%2Fring-lang.sourceforge.net%2Fdoc1.6%2Fintroduction.html%23ring-and-other-languages&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-bini-23"><span class="mw-cite-backlink"><b><a href="#cite_ref-bini_23-0">^</a></b></span> <span class="reference-text"><cite class="citation book">Bini, Ola (2007). <i>Practical JRuby on Rails Web 2.0 Projects: bringing Ruby on Rails to the Java platform</i>. Berkeley: APress. p.&#160;3. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-1-59059-881-8" title="Special:BookSources/978-1-59059-881-8">978-1-59059-881-8</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Practical+JRuby+on+Rails+Web+2.0+Projects%3A+bringing+Ruby+on+Rails+to+the+Java+platform&amp;rft.place=Berkeley&amp;rft.pages=3&amp;rft.pub=APress&amp;rft.date=2007&amp;rft.isbn=978-1-59059-881-8&amp;rft.aulast=Bini&amp;rft.aufirst=Ola&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-lattner2014-24"><span class="mw-cite-backlink"><b><a href="#cite_ref-lattner2014_24-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Lattner, Chris (3 June 2014). <a rel="nofollow" class="external text" href="http://nondot.org/sabre/">"Chris Lattner's Homepage"</a>. Chris Lattner<span class="reference-accessdate">. Retrieved <span class="nowrap">3 June</span> 2014</span>. <q>The Swift language is the product of tireless effort from a team of language experts, documentation gurus, compiler optimization ninjas, and an incredibly important internal dogfooding group who provided feedback to help refine and battle-test ideas. Of course, it also greatly benefited from the experiences hard-won by many other languages in the field, drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Chris+Lattner%27s+Homepage&amp;rft.pub=Chris+Lattner&amp;rft.date=2014-06-03&amp;rft.aulast=Lattner&amp;rft.aufirst=Chris&amp;rft_id=http%3A%2F%2Fnondot.org%2Fsabre%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-7-25"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-7_25-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Kuhlman, Dave. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20120623165941/http://cutter.rexx.com/~dkuhlman/python_book_01.html">"A Python Book: Beginning Python, Advanced Python, and Python Exercises"</a>. Archived from <a rel="nofollow" class="external text" href="http://cutter.rexx.com/~dkuhlman/python_book_01.html">the original</a> on 23 June 2012.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=A+Python+Book%3A+Beginning+Python%2C+Advanced+Python%2C+and+Python+Exercises&amp;rft.aulast=Kuhlman&amp;rft.aufirst=Dave&amp;rft_id=http%3A%2F%2Fcutter.rexx.com%2F~dkuhlman%2Fpython_book_01.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-26"><span class="mw-cite-backlink"><b><a href="#cite_ref-26">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.linuxjournal.com/content/guido-van-rossum-stepping-down-role-pythons-benevolent-dictator-life">"Guido van Rossum Stepping Down from Role as Python's Benevolent Dictator For Life | Linux Journal"</a>. <i>www.linuxjournal.com</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=www.linuxjournal.com&amp;rft.atitle=Guido+van+Rossum+Stepping+Down+from+Role+as+Python%27s+Benevolent+Dictator+For+Life+%7C+Linux+Journal&amp;rft_id=https%3A%2F%2Fwww.linuxjournal.com%2Fcontent%2Fguido-van-rossum-stepping-down-role-pythons-benevolent-dictator-life&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-27"><span class="mw-cite-backlink"><b><a href="#cite_ref-27">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.theinquirer.net/inquirer/news/3035842/python-boss-guido-van-rossum-steps-down-after-30-years">"Python boss Guido van Rossum steps down after 30 years | TheINQUIRER"</a>. <i><a rel="nofollow" class="external free" href="http://www.theinquirer.net">http://www.theinquirer.net</a></i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=http%3A%2F%2Fwww.theinquirer.net&amp;rft.atitle=Python+boss+Guido+van+Rossum+steps+down+after+30+years+%7C+TheINQUIRER&amp;rft_id=https%3A%2F%2Fwww.theinquirer.net%2Finquirer%2Fnews%2F3035842%2Fpython-boss-guido-van-rossum-steps-down-after-30-years&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span> <span style="font-size:100%" class="error citation-comment">External link in <code style="color:inherit; border:inherit; padding:inherit;">&#124;website=</code> (<a href="/wiki/Help:CS1_errors#param_has_ext_link" title="Help:CS1 errors">help</a>)</span></span>
</li>
<li id="cite_note-About-28"><span class="mw-cite-backlink"><b><a href="#cite_ref-About_28-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/about">"About Python"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 April</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=About+Python&amp;rft.pub=Python+Software+Foundation&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fabout&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span>, second section "Fans of Python use the phrase "batteries included" to describe the standard library, which covers everything from asynchronous processing to zip files."</span>
</li>
<li id="cite_note-29"><span class="mw-cite-backlink"><b><a href="#cite_ref-29">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3/license.html">"History and License"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">5 December</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=History+and+License&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3%2Flicense.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span> "All Python releases are Open Source"</span>
</li>
<li id="cite_note-venners-interview-pt-1-30"><span class="mw-cite-backlink">^ <a href="#cite_ref-venners-interview-pt-1_30-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-venners-interview-pt-1_30-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web">Venners, Bill (13 January 2003). <a rel="nofollow" class="external text" href="http://www.artima.com/intv/pythonP.html">"The Making of Python"</a>. <i>Artima Developer</i>. Artima<span class="reference-accessdate">. Retrieved <span class="nowrap">22 March</span> 2007</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Artima+Developer&amp;rft.atitle=The+Making+of+Python&amp;rft.date=2003-01-13&amp;rft.aulast=Venners&amp;rft.aufirst=Bill&amp;rft_id=http%3A%2F%2Fwww.artima.com%2Fintv%2FpythonP.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-timeline-of-python-31"><span class="mw-cite-backlink"><b><a href="#cite_ref-timeline-of-python_31-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido (20 January 2009). <a rel="nofollow" class="external text" href="http://python-history.blogspot.com/2009/01/brief-timeline-of-python.html">"A Brief Timeline of Python"</a>. <i>The History of Python</i>. Google<span class="reference-accessdate">. Retrieved <span class="nowrap">20 January</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=The+History+of+Python&amp;rft.atitle=A+Brief+Timeline+of+Python&amp;rft.date=2009-01-20&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=http%3A%2F%2Fpython-history.blogspot.com%2F2009%2F01%2Fbrief-timeline-of-python.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-12-32"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-12_32-0">^</a></b></span> <span class="reference-text"><cite class="citation mailinglist"><a href="/wiki/Guido_van_Rossum" title="Guido van Rossum">van Rossum, Guido</a> (29 August 2000). <a rel="nofollow" class="external text" href="http://mail.python.org/pipermail/python-dev/2000-August/008881.html">"SETL (was: Lukewarm about range literals)"</a>. <i>Python-Dev</i> (Mailing list)<span class="reference-accessdate">. Retrieved <span class="nowrap">13 March</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=SETL+%28was%3A+Lukewarm+about+range+literals%29&amp;rft.date=2000-08-29&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=http%3A%2F%2Fmail.python.org%2Fpipermail%2Fpython-dev%2F2000-August%2F008881.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-lj-bdfl-resignation-33"><span class="mw-cite-backlink"><b><a href="#cite_ref-lj-bdfl-resignation_33-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Fairchild, Carlie (12 July 2018). <a rel="nofollow" class="external text" href="https://www.linuxjournal.com/content/guido-van-rossum-stepping-down-role-pythons-benevolent-dictator-life">"Guido van Rossum Stepping Down from Role as Python's Benevolent Dictator For Life"</a>. Linux Journal<span class="reference-accessdate">. Retrieved <span class="nowrap">13 July</span> 2018</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Guido+van+Rossum+Stepping+Down+from+Role+as+Python%27s+Benevolent+Dictator+For+Life&amp;rft.pub=Linux+Journal&amp;rft.date=2018-07-12&amp;rft.aulast=Fairchild&amp;rft.aufirst=Carlie&amp;rft_id=https%3A%2F%2Fwww.linuxjournal.com%2Fcontent%2Fguido-van-rossum-stepping-down-role-pythons-benevolent-dictator-life&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-34"><span class="mw-cite-backlink"><b><a href="#cite_ref-34">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido (1996). <a rel="nofollow" class="external text" href="https://www.python.org/doc/essays/foreword/">"Foreword for "Programming Python" (1st ed.)"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">10 July</span> 2014</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Foreword+for+%22Programming+Python%22+%281st+ed.%29&amp;rft.date=1996&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdoc%2Fessays%2Fforeword%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-newin-2.0-35"><span class="mw-cite-backlink"><b><a href="#cite_ref-newin-2.0_35-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Kuchling, A. M.; Zadka, Moshe (16 October 2000). <a rel="nofollow" class="external text" href="https://docs.python.org/whatsnew/2.0.html">"What's New in Python 2.0"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=What%27s+New+in+Python+2.0&amp;rft.pub=Python+Software+Foundation&amp;rft.date=2000-10-16&amp;rft.aulast=Kuchling&amp;rft.aufirst=A.+M.&amp;rft.au=Zadka%2C+Moshe&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Fwhatsnew%2F2.0.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-3.0-release-36"><span class="mw-cite-backlink"><b><a href="#cite_ref-3.0-release_36-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/download/releases/3.0/">"Python 3.0 Release"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">8 July</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+3.0+Release&amp;rft.pub=Python+Software+Foundation&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdownload%2Freleases%2F3.0%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-pep-3000-37"><span class="mw-cite-backlink"><b><a href="#cite_ref-pep-3000_37-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido (5 April 2006). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-3000/">"PEP 3000&#160;– Python 3000"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">27 June</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+3000+%E2%80%93+Python+3000&amp;rft.date=2006-04-05&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-3000%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-38"><span class="mw-cite-backlink"><b><a href="#cite_ref-38">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3/library/2to3.html">"Automated Python 2 to 3 code translation — Python Documentation"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2018</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Automated+Python+2+to+3+code+translation+%E2%80%94+Python+Documentation&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3%2Flibrary%2F2to3.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-39"><span class="mw-cite-backlink"><b><a href="#cite_ref-39">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://legacy.python.org/dev/peps/pep-0373/">"PEP 373 -- Python 2.7 Release Schedule"</a>. <i>python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">9 January</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=PEP+373+--+Python+2.7+Release+Schedule&amp;rft_id=https%3A%2F%2Flegacy.python.org%2Fdev%2Fpeps%2Fpep-0373%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-40"><span class="mw-cite-backlink"><b><a href="#cite_ref-40">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0466/">"PEP 466 -- Network Security Enhancements for Python 2.7.x"</a>. <i>python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">9 January</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=PEP+466+--+Network+Security+Enhancements+for+Python+2.7.x&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0466%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-41"><span class="mw-cite-backlink"><b><a href="#cite_ref-41">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://opensource.googleblog.com/2017/01/grumpy-go-running-python.html">"Google Open Source Blog: Grumpy: Go running Python!"</a>. 4 January 2017<span class="reference-accessdate">. Retrieved <span class="nowrap">7 March</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Google+Open+Source+Blog%3A+Grumpy%3A+Go+running+Python%21&amp;rft.date=2017-01-04&amp;rft_id=https%3A%2F%2Fopensource.googleblog.com%2F2017%2F01%2Fgrumpy-go-running-python.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-13-42"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-13_42-0">^</a></b></span> <span class="reference-text"><cite class="citation web">The Cain Gang Ltd. <a rel="nofollow" class="external text" href="https://www.webcitation.org/5lubkaJRc?url=http://www.python.org/community/pycon/dc2004/papers/24/metaclasses-pycon.pdf">"Python Metaclasses: Who? Why? When?"</a> <span style="font-size:85%;">(PDF)</span>. Archived from <a rel="nofollow" class="external text" href="https://www.python.org/community/pycon/dc2004/papers/24/metaclasses-pycon.pdf">the original</a> <span style="font-size:85%;">(PDF)</span> on 10 December 2009<span class="reference-accessdate">. Retrieved <span class="nowrap">27 June</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+Metaclasses%3A+Who%3F+Why%3F+When%3F&amp;rft.au=The+Cain+Gang+Ltd.&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fcommunity%2Fpycon%2Fdc2004%2Fpapers%2F24%2Fmetaclasses-pycon.pdf&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-14-43"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-14_43-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3.0/reference/datamodel.html#special-method-names">"3.3. Special method names"</a>. <i>The Python Language Reference</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">27 June</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=The+Python+Language+Reference&amp;rft.atitle=3.3.+Special+method+names&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3.0%2Freference%2Fdatamodel.html%23special-method-names&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-15-44"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-15_44-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.nongnu.org/pydbc/">"PyDBC: method preconditions, method postconditions and class invariants for Python"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">24 September</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=PyDBC%3A+method+preconditions%2C+method+postconditions+and+class+invariants+for+Python&amp;rft_id=http%3A%2F%2Fwww.nongnu.org%2Fpydbc%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-16-45"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-16_45-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.wayforward.net/pycontract/">"Contracts for Python"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">24 September</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Contracts+for+Python&amp;rft_id=http%3A%2F%2Fwww.wayforward.net%2Fpycontract%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-17-46"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-17_46-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://sites.google.com/site/pydatalog/">"PyDatalog"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">22 July</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=PyDatalog&amp;rft_id=https%3A%2F%2Fsites.google.com%2Fsite%2Fpydatalog%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-59-47"><span class="mw-cite-backlink">^ <a href="#cite_ref-AutoNT-59_47-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-AutoNT-59_47-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web">Hettinger, Raymond (30 January 2002). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0289/">"PEP 289&#160;– Generator Expressions"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">19 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+289+%E2%80%93+Generator+Expressions&amp;rft.date=2002-01-30&amp;rft.aulast=Hettinger&amp;rft.aufirst=Raymond&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0289%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-18-48"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-18_48-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3/library/itertools.html">"6.5 itertools&#160;– Functions creating iterators for efficient looping"</a>. Docs.python.org<span class="reference-accessdate">. Retrieved <span class="nowrap">22 November</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=6.5+itertools+%E2%80%93+Functions+creating+iterators+for+efficient+looping&amp;rft.pub=Docs.python.org&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3%2Flibrary%2Fitertools.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-PEP20-49"><span class="mw-cite-backlink">^ <a href="#cite_ref-PEP20_49-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-PEP20_49-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web">Peters, Tim (19 August 2004). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0020/">"PEP 20&#160;– The Zen of Python"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+20+%E2%80%93+The+Zen+of+Python&amp;rft.date=2004-08-19&amp;rft.aulast=Peters&amp;rft.aufirst=Tim&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0020%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-19-50"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-19_50-0">^</a></b></span> <span class="reference-text"><cite class="citation book">Martelli, Alex; Ravenscroft, Anna; Ascher, David (2005). <a rel="nofollow" class="external text" href="http://shop.oreilly.com/product/9780596007973.do"><i>Python Cookbook, 2nd Edition</i></a>. <a href="/wiki/O%27Reilly_Media" title="O&#39;Reilly Media">O'Reilly Media</a>. p.&#160;230. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-596-00797-3" title="Special:BookSources/978-0-596-00797-3">978-0-596-00797-3</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Python+Cookbook%2C+2nd+Edition&amp;rft.pages=230&amp;rft.pub=O%27Reilly+Media&amp;rft.date=2005&amp;rft.isbn=978-0-596-00797-3&amp;rft.aulast=Martelli&amp;rft.aufirst=Alex&amp;rft.au=Ravenscroft%2C+Anna&amp;rft.au=Ascher%2C+David&amp;rft_id=http%3A%2F%2Fshop.oreilly.com%2Fproduct%2F9780596007973.do&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-20-51"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-20_51-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://ebeab.com/2014/01/21/python-culture/">"Python Culture"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+Culture&amp;rft_id=http%3A%2F%2Febeab.com%2F2014%2F01%2F21%2Fpython-culture%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-24-52"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-24_52-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/2/faq/general.html#why-is-it-called-python">"General Python FAQ"</a>. <i>Python v2.7.3 documentation</i>. Docs.python.org<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+v2.7.3+documentation&amp;rft.atitle=General+Python+FAQ&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F2%2Ffaq%2Fgeneral.html%23why-is-it-called-python&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-53"><span class="mw-cite-backlink"><b><a href="#cite_ref-53">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://insidetech.monster.com/training/articles/8114-15-ways-python-is-a-powerful-force-on-the-web">"15 Ways Python Is a Powerful Force on the Web"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=15+Ways+Python+Is+a+Powerful+Force+on+the+Web&amp;rft_id=https%3A%2F%2Finsidetech.monster.com%2Ftraining%2Farticles%2F8114-15-ways-python-is-a-powerful-force-on-the-web&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-54"><span class="mw-cite-backlink"><b><a href="#cite_ref-54">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/2/library/pprint.html">"pprint - Data pretty printer - Python Documentation"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=pprint+-+Data+pretty+printer+-+Python+Documentation&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F2%2Flibrary%2Fpprint.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-27-55"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-27_55-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Goodger, David. <a rel="nofollow" class="external text" href="http://python.net/~goodger/projects/pycon/2007/idiomatic/handout.html">"Code Like a Pythonista: Idiomatic Python"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Code+Like+a+Pythonista%3A+Idiomatic+Python&amp;rft.aulast=Goodger&amp;rft.aufirst=David&amp;rft_id=http%3A%2F%2Fpython.net%2F~goodger%2Fprojects%2Fpycon%2F2007%2Fidiomatic%2Fhandout.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-25-56"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-25_56-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://python.net/crew/mwh/hacks/objectthink.html">"How to think like a Pythonista"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=How+to+think+like+a+Pythonista&amp;rft_id=http%3A%2F%2Fpython.net%2Fcrew%2Fmwh%2Fhacks%2Fobjectthink.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-52-57"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-52_57-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/faq/general.html#is-python-a-good-language-for-beginning-programmers">"Is Python a good language for beginning programmers?"</a>. <i>General Python FAQ</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">21 March</span> 2007</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=General+Python+FAQ&amp;rft.atitle=Is+Python+a+good+language+for+beginning+programmers%3F&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Ffaq%2Fgeneral.html%23is-python-a-good-language-for-beginning-programmers&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-53-58"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-53_58-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.secnetix.de/~olli/Python/block_indentation.hawk">"Myths about indentation in Python"</a>. Secnetix.de<span class="reference-accessdate">. Retrieved <span class="nowrap">19 April</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Myths+about+indentation+in+Python&amp;rft.pub=Secnetix.de&amp;rft_id=http%3A%2F%2Fwww.secnetix.de%2F~olli%2FPython%2Fblock_indentation.hawk&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-59"><span class="mw-cite-backlink"><b><a href="#cite_ref-59">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/download/releases/2.5/">"Python 2.5 Release"</a>. <i>Python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python.org&amp;rft.atitle=Python+2.5+Release&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdownload%2Freleases%2F2.5%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-60"><span class="mw-cite-backlink"><b><a href="#cite_ref-60">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/download/releases/2.5/highlights/">"Highlights: Python 2.5"</a>. <i>Python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python.org&amp;rft.atitle=Highlights%3A+Python+2.5&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdownload%2Freleases%2F2.5%2Fhighlights%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-diff_py2-3-61"><span class="mw-cite-backlink"><b><a href="#cite_ref-diff_py2-3_61-0">^</a></b></span> <span class="reference-text"><cite class="citation book">Sweigart, Al (2010). "Appendix A: Differences Between Python 2 and 3". <a rel="nofollow" class="external text" href="https://inventwithpython.com/appendixa.html"><i>Invent Your Own Computer Games with Python</i></a> (2 ed.). <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-9821060-1-3" title="Special:BookSources/978-0-9821060-1-3">978-0-9821060-1-3</a><span class="reference-accessdate">. Retrieved <span class="nowrap">20 February</span> 2014</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=bookitem&amp;rft.atitle=Appendix+A%3A+Differences+Between+Python+2+and+3&amp;rft.btitle=Invent+Your+Own+Computer+Games+with+Python&amp;rft.edition=2&amp;rft.date=2010&amp;rft.isbn=978-0-9821060-1-3&amp;rft.aulast=Sweigart&amp;rft.aufirst=Al&amp;rft_id=https%3A%2F%2Finventwithpython.com%2Fappendixa.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-55-62"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-55_62-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido (22 April 2009). <a rel="nofollow" class="external text" href="http://neopythonic.blogspot.be/2009/04/tail-recursion-elimination.html">"Tail Recursion Elimination"</a>. Neopythonic.blogspot.be<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Tail+Recursion+Elimination&amp;rft.pub=Neopythonic.blogspot.be&amp;rft.date=2009-04-22&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=http%3A%2F%2Fneopythonic.blogspot.be%2F2009%2F04%2Ftail-recursion-elimination.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-56-63"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-56_63-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido (9 February 2006). <a rel="nofollow" class="external text" href="http://www.artima.com/weblogs/viewpost.jsp?thread=147358">"Language Design Is Not Just Solving Puzzles"</a>. <i>Artima forums</i>. Artima<span class="reference-accessdate">. Retrieved <span class="nowrap">21 March</span> 2007</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Artima+forums&amp;rft.atitle=Language+Design+Is+Not+Just+Solving+Puzzles&amp;rft.date=2006-02-09&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=http%3A%2F%2Fwww.artima.com%2Fweblogs%2Fviewpost.jsp%3Fthread%3D147358&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-57-64"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-57_64-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido; Eby, Phillip J. (10 May 2005). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0342/">"PEP 342&#160;– Coroutines via Enhanced Generators"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">19 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+342+%E2%80%93+Coroutines+via+Enhanced+Generators&amp;rft.date=2005-05-10&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft.au=Eby%2C+Phillip+J.&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0342%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-58-65"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-58_65-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0380/">"PEP 380"</a>. Python.org<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=PEP+380&amp;rft.pub=Python.org&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0380%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-66"><span class="mw-cite-backlink"><b><a href="#cite_ref-66">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org">"division"</a>. <i>python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=division&amp;rft_id=https%3A%2F%2Fdocs.python.org&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-PEP465-67"><span class="mw-cite-backlink"><b><a href="#cite_ref-PEP465_67-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0465/">"PEP 0465 -- A dedicated infix operator for matrix multiplication"</a>. <i>python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">1 January</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=PEP+0465+--+A+dedicated+infix+operator+for+matrix+multiplication&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0465%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-Python3.5Changelog-68"><span class="mw-cite-backlink"><b><a href="#cite_ref-Python3.5Changelog_68-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/downloads/release/python-351/">"Python 3.5.1 Release and Changelog"</a>. <i>python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">1 January</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=Python+3.5.1+Release+and+Changelog&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdownloads%2Frelease%2Fpython-351%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-69"><span class="mw-cite-backlink"><b><a href="#cite_ref-69">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.21.1">"Chapter 15. Expressions - 15.21.1. Numerical Equality Operators == and&#160;!="</a>. <a href="/wiki/Oracle_Corporation" title="Oracle Corporation">Oracle Corporation</a><span class="reference-accessdate">. Retrieved <span class="nowrap">28 August</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Chapter+15.+Expressions+-+15.21.1.+Numerical+Equality+Operators+%3D%3D+and+%21%3D&amp;rft.pub=Oracle+Corporation&amp;rft_id=https%3A%2F%2Fdocs.oracle.com%2Fjavase%2Fspecs%2Fjls%2Fse8%2Fhtml%2Fjls-15.html%23jls-15.21.1&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-70"><span class="mw-cite-backlink"><b><a href="#cite_ref-70">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.oracle.com/javase/specs/jls/se8/html/jls-15.html#jls-15.21.3">"Chapter 15. Expressions - 15.21.3. Reference Equality Operators == and&#160;!="</a>. Oracle Corporation<span class="reference-accessdate">. Retrieved <span class="nowrap">28 August</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Chapter+15.+Expressions+-+15.21.3.+Reference+Equality+Operators+%3D%3D+and+%21%3D&amp;rft.pub=Oracle+Corporation&amp;rft_id=https%3A%2F%2Fdocs.oracle.com%2Fjavase%2Fspecs%2Fjls%2Fse8%2Fhtml%2Fjls-15.html%23jls-15.21.3&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-60-71"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-60_71-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido; Hettinger, Raymond (7 February 2003). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0308/">"PEP 308&#160;– Conditional Expressions"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">13 July</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+308+%E2%80%93+Conditional+Expressions&amp;rft.date=2003-02-07&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft.au=Hettinger%2C+Raymond&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0308%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-72"><span class="mw-cite-backlink"><b><a href="#cite_ref-72">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3/library/stdtypes.html#tuple">"4. Built-in Types &#8212; Python 3.6.3rc1 documentation"</a>. <i>python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">1 October</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=4.+Built-in+Types+%26%238212%3B+Python+3.6.3rc1+documentation&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3%2Flibrary%2Fstdtypes.html%23tuple&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-pep-0498-73"><span class="mw-cite-backlink">^ <a href="#cite_ref-pep-0498_73-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-pep-0498_73-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0498/">"PEP 498 -- Literal String Interpolation"</a>. <i>python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">8 March</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=PEP+498+--+Literal+String+Interpolation&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0498%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-61-74"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-61_74-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/faq/design.html#why-must-self-be-used-explicitly-in-method-definitions-and-calls">"Why must 'self' be used explicitly in method definitions and calls?"</a>. <i>Design and History FAQ</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">19 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Design+and+History+FAQ&amp;rft.atitle=Why+must+%27self%27+be+used+explicitly+in+method+definitions+and+calls%3F&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Ffaq%2Fdesign.html%23why-must-self-be-used-explicitly-in-method-definitions-and-calls&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-classy-75"><span class="mw-cite-backlink"><b><a href="#cite_ref-classy_75-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/reference/datamodel.html#new-style-and-classic-classes">"The Python Language Reference, section 3.3. New-style and classic classes, for release 2.7.1"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">12 January</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=The+Python+Language+Reference%2C+section+3.3.+New-style+and+classic+classes%2C+for+release+2.7.1&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Freference%2Fdatamodel.html%23new-style-and-classic-classes&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-76"><span class="mw-cite-backlink"><b><a href="#cite_ref-76">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://lwn.net/Articles/627418/">"Type hinting for Python"</a>. LWN.net. 24 December 2014<span class="reference-accessdate">. Retrieved <span class="nowrap">5 May</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Type+hinting+for+Python&amp;rft.pub=LWN.net&amp;rft.date=2014-12-24&amp;rft_id=https%3A%2F%2Flwn.net%2FArticles%2F627418%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-77"><span class="mw-cite-backlink"><b><a href="#cite_ref-77">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://mypy-lang.org/">"mypy - Optional Static Typing for Python"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">28 January</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=mypy+-+Optional+Static+Typing+for+Python&amp;rft_id=http%3A%2F%2Fmypy-lang.org%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-pep0237-78"><span class="mw-cite-backlink"><b><a href="#cite_ref-pep0237_78-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Zadka, Moshe; van Rossum, Guido (11 March 2001). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0237/">"PEP 237&#160;– Unifying Long Integers and Integers"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 September</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+237+%E2%80%93+Unifying+Long+Integers+and+Integers&amp;rft.date=2001-03-11&amp;rft.aulast=Zadka&amp;rft.aufirst=Moshe&amp;rft.au=van+Rossum%2C+Guido&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0237%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-79"><span class="mw-cite-backlink"><b><a href="#cite_ref-79">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://legacy.python.org/dev/peps/pep-0465/">"PEP 465 -- A dedicated infix operator for matrix multiplication"</a>. <i>python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=PEP+465+--+A+dedicated+infix+operator+for+matrix+multiplication&amp;rft_id=https%3A%2F%2Flegacy.python.org%2Fdev%2Fpeps%2Fpep-0465%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-80"><span class="mw-cite-backlink"><b><a href="#cite_ref-80">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://stackoverflow.com/questions/8305199/the-tilde-operator-in-python">"The tilde operator in Python - Stackoverflow"</a>. <i>stackoverflow.com</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=stackoverflow.com&amp;rft.atitle=The+tilde+operator+in+Python+-+Stackoverflow&amp;rft_id=https%3A%2F%2Fstackoverflow.com%2Fquestions%2F8305199%2Fthe-tilde-operator-in-python&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-81"><span class="mw-cite-backlink"><b><a href="#cite_ref-81">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://wiki.python.org/moin/BitwiseOperators">"BitwiseOperators - Python Wiki"</a>. <i>wiki.python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=wiki.python.org&amp;rft.atitle=BitwiseOperators+-+Python+Wiki&amp;rft_id=https%3A%2F%2Fwiki.python.org%2Fmoin%2FBitwiseOperators&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-pep0238-82"><span class="mw-cite-backlink"><b><a href="#cite_ref-pep0238_82-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Zadka, Moshe; van Rossum, Guido (11 March 2001). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0238/">"PEP 238&#160;– Changing the Division Operator"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">23 October</span> 2013</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+238+%E2%80%93+Changing+the+Division+Operator&amp;rft.date=2001-03-11&amp;rft.aulast=Zadka&amp;rft.aufirst=Moshe&amp;rft.au=van+Rossum%2C+Guido&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0238%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-62-83"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-62_83-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://python-history.blogspot.com/2010/08/why-pythons-integer-division-floors.html">"Why Python's Integer Division Floors"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">25 August</span> 2010</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Why+Python%27s+Integer+Division+Floors&amp;rft_id=http%3A%2F%2Fpython-history.blogspot.com%2F2010%2F08%2Fwhy-pythons-integer-division-floors.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-63-84"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-63_84-0">^</a></b></span> <span class="reference-text"><cite class="citation"><a rel="nofollow" class="external text" href="https://docs.python.org/library/functions.html#round">"round"</a>, <i>The Python standard library, release 2.7, §2: Built-in functions</i><span class="reference-accessdate">, retrieved <span class="nowrap">14 August</span> 2011</span></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=The+Python+standard+library%2C+release+2.7%2C+%C2%A72%3A+Built-in+functions&amp;rft.atitle=round&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Flibrary%2Ffunctions.html%23round&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-64-85"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-64_85-0">^</a></b></span> <span class="reference-text"><cite class="citation"><a rel="nofollow" class="external text" href="https://docs.python.org/py3k/library/functions.html#round">"round"</a>, <i>The Python standard library, release 3.2, §2: Built-in functions</i><span class="reference-accessdate">, retrieved <span class="nowrap">14 August</span> 2011</span></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=The+Python+standard+library%2C+release+3.2%2C+%C2%A72%3A+Built-in+functions&amp;rft.atitle=round&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Fpy3k%2Flibrary%2Ffunctions.html%23round&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-65-86"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-65_86-0">^</a></b></span> <span class="reference-text"><cite class="citation book">Beazley, David M. (2009). <i>Python Essential Reference</i> (4th ed.). p.&#160;66.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Python+Essential+Reference&amp;rft.pages=66&amp;rft.edition=4th&amp;rft.date=2009&amp;rft.aulast=Beazley&amp;rft.aufirst=David+M.&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-CPL-87"><span class="mw-cite-backlink"><b><a href="#cite_ref-CPL_87-0">^</a></b></span> <span class="reference-text"><cite class="citation book">Kernighan, Brian W.; Ritchie, Dennis M. (1988). <a class="external text" href="https://en.wikipedia.org/wiki/The_C_Programming_Language"><i>The C Programming Language</i></a> (2nd ed.). p.&#160;206.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=The+C+Programming+Language&amp;rft.pages=206&amp;rft.edition=2nd&amp;rft.date=1988&amp;rft.aulast=Kernighan&amp;rft.aufirst=Brian+W.&amp;rft.au=Ritchie%2C+Dennis+M.&amp;rft_id=https%3A%2F%2Fen.wikipedia.org%2Fwiki%2FThe_C_Programming_Language&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-88"><span class="mw-cite-backlink"><b><a href="#cite_ref-88">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/2.7/library/stdtypes.html">"Built-in Type"</a>. <i>docs.python.org</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=docs.python.org&amp;rft.atitle=Built-in+Type&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F2.7%2Flibrary%2Fstdtypes.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-89"><span class="mw-cite-backlink"><b><a href="#cite_ref-89">^</a></b></span> <span class="reference-text"><cite class="citation web">Batista, Facundo. <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0327/">"PEP 0327 -- Decimal Data Type"</a>. <i>Python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">26 September</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python.org&amp;rft.atitle=PEP+0327+--+Decimal+Data+Type&amp;rft.aulast=Batista&amp;rft.aufirst=Facundo&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0327%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-90"><span class="mw-cite-backlink"><b><a href="#cite_ref-90">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/2.6/whatsnew/2.6.html">"What's New in Python 2.6 — Python v2.6.9 documentation"</a>. <i>docs.python.org</i><span class="reference-accessdate">. Retrieved <span class="nowrap">26 September</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=docs.python.org&amp;rft.atitle=What%E2%80%99s+New+in+Python+2.6+%E2%80%94+Python+v2.6.9+documentation&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F2.6%2Fwhatsnew%2F2.6.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-86-91"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-86_91-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Piotrowski, Przemyslaw (July 2006). <a rel="nofollow" class="external text" href="http://www.oracle.com/technetwork/articles/piotrowski-pythoncore-084049.html">"Build a Rapid Web Development Environment for Python Server Pages and Oracle"</a>. <i>Oracle Technology Network</i>. Oracle<span class="reference-accessdate">. Retrieved <span class="nowrap">12 March</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Oracle+Technology+Network&amp;rft.atitle=Build+a+Rapid+Web+Development+Environment+for+Python+Server+Pages+and+Oracle&amp;rft.date=2006-07&amp;rft.aulast=Piotrowski&amp;rft.aufirst=Przemyslaw&amp;rft_id=http%3A%2F%2Fwww.oracle.com%2Ftechnetwork%2Farticles%2Fpiotrowski-pythoncore-084049.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-88-92"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-88_92-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Batista, Facundo (17 October 2003). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0327/">"PEP 327&#160;– Decimal Data Type"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+327+%E2%80%93+Decimal+Data+Type&amp;rft.date=2003-10-17&amp;rft.aulast=Batista&amp;rft.aufirst=Facundo&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0327%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-89-93"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-89_93-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Eby, Phillip J. (7 December 2003). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0333/">"PEP 333&#160;– Python Web Server Gateway Interface v1.0"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">19 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+333+%E2%80%93+Python+Web+Server+Gateway+Interface+v1.0&amp;rft.date=2003-12-07&amp;rft.aulast=Eby&amp;rft.aufirst=Phillip+J.&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0333%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-94"><span class="mw-cite-backlink"><b><a href="#cite_ref-94">^</a></b></span> <span class="reference-text"><cite class="citation web">Debill, Erik. <a rel="nofollow" class="external text" href="http://www.modulecounts.com/">"Module Counts"</a>. <i>ModuleCounts</i><span class="reference-accessdate">. Retrieved <span class="nowrap">20 September</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=ModuleCounts&amp;rft.atitle=Module+Counts&amp;rft.aulast=Debill&amp;rft.aufirst=Erik&amp;rft_id=http%3A%2F%2Fwww.modulecounts.com%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-95"><span class="mw-cite-backlink"><b><a href="#cite_ref-95">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://likegeeks.com/python-web-scraping/">"20+ Python Web Scraping Examples (Beautiful Soup &amp; Selenium) - Like Geeks"</a>. <i>likegeeks.com</i>. 5 December 2017<span class="reference-accessdate">. Retrieved <span class="nowrap">12 March</span> 2018</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=likegeeks.com&amp;rft.atitle=20%2B+Python+Web+Scraping+Examples+%28Beautiful+Soup+%26+Selenium%29+-+Like+Geeks&amp;rft.date=2017-12-05&amp;rft_id=https%3A%2F%2Flikegeeks.com%2Fpython-web-scraping%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-96"><span class="mw-cite-backlink"><b><a href="#cite_ref-96">^</a></b></span> <span class="reference-text"><cite class="citation web">Enthought, Canopy. <a rel="nofollow" class="external text" href="https://www.enthought.com/products/canopy/">"Canopy"</a>. <i>www.enthought.com</i><span class="reference-accessdate">. Retrieved <span class="nowrap">20 August</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=www.enthought.com&amp;rft.atitle=Canopy&amp;rft.aulast=Enthought&amp;rft.aufirst=Canopy&amp;rft_id=https%3A%2F%2Fwww.enthought.com%2Fproducts%2Fcanopy%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-66-97"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-66_97-0">^</a></b></span> <span class="reference-text"><cite class="citation web">van Rossum, Guido (5 June 2001). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0007/">"PEP 7&#160;– Style Guide for C Code"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+7+%E2%80%93+Style+Guide+for+C+Code&amp;rft.date=2001-06-05&amp;rft.aulast=van+Rossum&amp;rft.aufirst=Guido&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0007%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-67-98"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-67_98-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/3/library/dis.html#python-bytecode-instructions">"CPython byte code"</a>. Docs.python.org<span class="reference-accessdate">. Retrieved <span class="nowrap">16 February</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=CPython+byte+code&amp;rft.pub=Docs.python.org&amp;rft_id=https%3A%2F%2Fdocs.python.org%2F3%2Flibrary%2Fdis.html%23python-bytecode-instructions&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-68-99"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-68_99-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.troeger.eu/teaching/pythonvm08.pdf">"Python 2.5 internals"</a> <span style="font-size:85%;">(PDF)</span><span class="reference-accessdate">. Retrieved <span class="nowrap">19 April</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+2.5+internals&amp;rft_id=http%3A%2F%2Fwww.troeger.eu%2Fteaching%2Fpythonvm08.pdf&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-69-100"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-69_100-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.oreilly.com/pub/a/oreilly/frank/rossum_1099.html">"An Interview with Guido van Rossum"</a>. Oreilly.com<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=An+Interview+with+Guido+van+Rossum&amp;rft.pub=Oreilly.com&amp;rft_id=http%3A%2F%2Fwww.oreilly.com%2Fpub%2Fa%2Foreilly%2Ffrank%2Frossum_1099.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-70-101"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-70_101-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://pypy.org/compat.html">"PyPy compatibility"</a>. Pypy.org<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=PyPy+compatibility&amp;rft.pub=Pypy.org&amp;rft_id=http%3A%2F%2Fpypy.org%2Fcompat.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-71-102"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-71_102-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://speed.pypy.org/">"speed comparison between CPython and Pypy"</a>. Speed.pypy.org<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=speed+comparison+between+CPython+and+Pypy&amp;rft.pub=Speed.pypy.org&amp;rft_id=http%3A%2F%2Fspeed.pypy.org%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-73-103"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-73_103-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://doc.pypy.org/en/latest/stackless.html">"Application-level Stackless features — PyPy 2.0.2 documentation"</a>. Doc.pypy.org<span class="reference-accessdate">. Retrieved <span class="nowrap">17 July</span> 2013</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Application-level+Stackless+features+%E2%80%94+PyPy+2.0.2+documentation&amp;rft.pub=Doc.pypy.org&amp;rft_id=http%3A%2F%2Fdoc.pypy.org%2Fen%2Flatest%2Fstackless.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-74-104"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-74_104-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://code.google.com/p/unladen-swallow/wiki/ProjectPlan">"Plans for optimizing Python"</a>. <i>Google Project Hosting</i>. Google. 15 December 2009<span class="reference-accessdate">. Retrieved <span class="nowrap">24 September</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Google+Project+Hosting&amp;rft.atitle=Plans+for+optimizing+Python&amp;rft.date=2009-12-15&amp;rft_id=https%3A%2F%2Fcode.google.com%2Fp%2Funladen-swallow%2Fwiki%2FProjectPlan&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-105"><span class="mw-cite-backlink"><b><a href="#cite_ref-105">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.stochasticgeometry.ie/2010/04/29/python-on-the-nokia-n900/">"Python on the Nokia N900"</a>. <i>Stochastic Geometry</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Stochastic+Geometry&amp;rft.atitle=Python+on+the+Nokia+N900&amp;rft_id=http%3A%2F%2Fwww.stochasticgeometry.ie%2F2010%2F04%2F29%2Fpython-on-the-nokia-n900%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-106"><span class="mw-cite-backlink"><b><a href="#cite_ref-106">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://nuitka.net/">"Nuitka Home | Nuitka Home"</a>. <i>nuitka.net</i><span class="reference-accessdate">. Retrieved <span class="nowrap">18 August</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=nuitka.net&amp;rft.atitle=Nuitka+Home+%7C+Nuitka+Home&amp;rft_id=http%3A%2F%2Fnuitka.net%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-107"><span class="mw-cite-backlink"><b><a href="#cite_ref-107">^</a></b></span> <span class="reference-text"><cite class="citation conference">Murri, Riccardo (2013). <i>Performance of Python runtimes on a non-numeric scientific code</i>. European Conference on Python in Science (EuroSciPy). <a href="/wiki/ArXiv" title="ArXiv">arXiv</a>:<span class="plainlinks"><a rel="nofollow" class="external text" href="//arxiv.org/abs/1404.6388">1404.6388</a>&#8239;<img alt="Freely accessible" src="//upload.wikimedia.org/wikipedia/commons/thumb/6/65/Lock-green.svg/9px-Lock-green.svg.png" title="Freely accessible" width="9" height="14" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/6/65/Lock-green.svg/14px-Lock-green.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/6/65/Lock-green.svg/18px-Lock-green.svg.png 2x" data-file-width="512" data-file-height="813" /></span>. <a href="/wiki/Bibcode" title="Bibcode">Bibcode</a>:<a rel="nofollow" class="external text" href="http://adsabs.harvard.edu/abs/2014arXiv1404.6388M">2014arXiv1404.6388M</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=conference&amp;rft.btitle=Performance+of+Python+runtimes+on+a+non-numeric+scientific+code&amp;rft.date=2013&amp;rft_id=info%3Aarxiv%2F1404.6388&amp;rft_id=info%3Abibcode%2F2014arXiv1404.6388M&amp;rft.aulast=Murri&amp;rft.aufirst=Riccardo&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-PepCite000-108"><span class="mw-cite-backlink">^ <a href="#cite_ref-PepCite000_108-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-PepCite000_108-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web">Warsaw, Barry; Hylton, Jeremy; Goodger, David (13 June 2000). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0001/">"PEP 1&#160;– PEP Purpose and Guidelines"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">19 April</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+1+%E2%80%93+PEP+Purpose+and+Guidelines&amp;rft.date=2000-06-13&amp;rft.aulast=Warsaw&amp;rft.aufirst=Barry&amp;rft.au=Hylton%2C+Jeremy&amp;rft.au=Goodger%2C+David&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0001%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-21-109"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-21_109-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Cannon, Brett. <a rel="nofollow" class="external text" href="https://web.archive.org/web/20090601134342/http://www.python.org/dev/intro/">"Guido, Some Guys, and a Mailing List: How Python is Developed"</a>. <i>python.org</i>. Python Software Foundation. Archived from <a rel="nofollow" class="external text" href="https://www.python.org/dev/intro/">the original</a> on 1 June 2009<span class="reference-accessdate">. Retrieved <span class="nowrap">27 June</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=python.org&amp;rft.atitle=Guido%2C+Some+Guys%2C+and+a+Mailing+List%3A+How+Python+is+Developed&amp;rft.aulast=Cannon&amp;rft.aufirst=Brett&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fintro%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-py_dev_guide-110"><span class="mw-cite-backlink"><b><a href="#cite_ref-py_dev_guide_110-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/devguide/">"Python Developer's Guide"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+Developer%27s+Guide&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Fdevguide%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-release-schedule-111"><span class="mw-cite-backlink"><b><a href="#cite_ref-release-schedule_111-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Norwitz, Neal (8 April 2002). <a rel="nofollow" class="external text" href="https://mail.python.org/pipermail/python-dev/2002-April/022739.html">"&#91;Python-Dev&#93; Release Schedules (was Stability &amp; change)"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">27 June</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=%26%2391%3BPython-Dev%26%2393%3B+Release+Schedules+%28was+Stability+%26+change%29&amp;rft.date=2002-04-08&amp;rft.aulast=Norwitz&amp;rft.aufirst=Neal&amp;rft_id=https%3A%2F%2Fmail.python.org%2Fpipermail%2Fpython-dev%2F2002-April%2F022739.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-22-112"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-22_112-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Aahz; Baxter, Anthony (15 March 2001). <a rel="nofollow" class="external text" href="https://www.python.org/dev/peps/pep-0006/">"PEP 6&#160;– Bug Fix Releases"</a>. <i>Python Enhancement Proposals</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">27 June</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Enhancement+Proposals&amp;rft.atitle=PEP+6+%E2%80%93+Bug+Fix+Releases&amp;rft.date=2001-03-15&amp;rft.au=Aahz&amp;rft.au=Baxter%2C+Anthony&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fpeps%2Fpep-0006%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-23-113"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-23_113-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/dev/buildbot/">"Python Buildbot"</a>. <i>Python Developer’s Guide</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 September</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Python+Developer%E2%80%99s+Guide&amp;rft.atitle=Python+Buildbot&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fdev%2Fbuildbot%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-114"><span class="mw-cite-backlink"><b><a href="#cite_ref-114">^</a></b></span> <span class="reference-text"><cite class="citation web">DeBill, Erik. <a rel="nofollow" class="external text" href="http://www.modulecounts.com/#">"Module Counts"</a>. <i>www.modulecounts.com</i><span class="reference-accessdate">. Retrieved <span class="nowrap">20 August</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=www.modulecounts.com&amp;rft.atitle=Module+Counts&amp;rft.aulast=DeBill&amp;rft.aufirst=Erik&amp;rft_id=http%3A%2F%2Fwww.modulecounts.com%2F%23&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-tutorial-chapter1-115"><span class="mw-cite-backlink">^ <a href="#cite_ref-tutorial-chapter1_115-0"><sup><i><b>a</b></i></sup></a> <a href="#cite_ref-tutorial-chapter1_115-1"><sup><i><b>b</b></i></sup></a></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://docs.python.org/tutorial/appetite.html">"Whetting Your Appetite"</a>. <i>The Python Tutorial</i>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">20 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=The+Python+Tutorial&amp;rft.atitle=Whetting+Your+Appetite&amp;rft_id=https%3A%2F%2Fdocs.python.org%2Ftutorial%2Fappetite.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-26-116"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-26_116-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://stackoverflow.com/questions/5033906/in-python-should-i-use-else-after-a-return-in-an-if-block">"In Python, should I use else after a return in an if block?"</a>. <i><a href="/wiki/Stack_Overflow" title="Stack Overflow">Stack Overflow</a></i>. Stack Exchange. 17 February 2011<span class="reference-accessdate">. Retrieved <span class="nowrap">6 May</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Stack+Overflow&amp;rft.atitle=In+Python%2C+should+I+use+else+after+a+return+in+an+if+block%3F&amp;rft.date=2011-02-17&amp;rft_id=https%3A%2F%2Fstackoverflow.com%2Fquestions%2F5033906%2Fin-python-should-i-use-else-after-a-return-in-an-if-block&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-117"><span class="mw-cite-backlink"><b><a href="#cite_ref-117">^</a></b></span> <span class="reference-text"><cite class="citation book">Lutz, Mark (2009). <a rel="nofollow" class="external text" href="https://books.google.com/books?id=1HxWGezDZcgC&amp;pg=PA17"><i>Learning Python: Powerful Object-Oriented Programming</i></a>. O'Reilly Media, Inc. p.&#160;17. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/9781449379322" title="Special:BookSources/9781449379322">9781449379322</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Learning+Python%3A+Powerful+Object-Oriented+Programming&amp;rft.pages=17&amp;rft.pub=O%27Reilly+Media%2C+Inc.&amp;rft.date=2009&amp;rft.isbn=9781449379322&amp;rft.aulast=Lutz&amp;rft.aufirst=Mark&amp;rft_id=https%3A%2F%2Fbooks.google.com%2Fbooks%3Fid%3D1HxWGezDZcgC%26pg%3DPA17&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-118"><span class="mw-cite-backlink"><b><a href="#cite_ref-118">^</a></b></span> <span class="reference-text"><cite class="citation book">Fehily, Chris (2002). <a rel="nofollow" class="external text" href="https://books.google.com/books?id=carqdIdfVlYC&amp;pg=PR15"><i>Python</i></a>. Peachpit Press. p.&#160;xv. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/9780201748840" title="Special:BookSources/9780201748840">9780201748840</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Python&amp;rft.pages=xv&amp;rft.pub=Peachpit+Press&amp;rft.date=2002&amp;rft.isbn=9780201748840&amp;rft.aulast=Fehily&amp;rft.aufirst=Chris&amp;rft_id=https%3A%2F%2Fbooks.google.com%2Fbooks%3Fid%3DcarqdIdfVlYC%26pg%3DPR15&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-119"><span class="mw-cite-backlink"><b><a href="#cite_ref-119">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.tiobe.com/tiobe-index/">"TIOBE Index"</a>. TIOBE - The Software Quality Company<span class="reference-accessdate">. Retrieved <span class="nowrap">7 March</span> 2017</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=TIOBE+Index&amp;rft.pub=TIOBE+-+The+Software+Quality+Company&amp;rft_id=http%3A%2F%2Fwww.tiobe.com%2Ftiobe-index%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-34-120"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-34_120-0">^</a></b></span> <span class="reference-text"><cite class="citation web">TIOBE Software Index (2015). <a rel="nofollow" class="external text" href="http://www.tiobe.com/index.php/paperinfo/tpci/Python.html">"TIOBE Programming Community Index Python"</a><span class="reference-accessdate">. Retrieved <span class="nowrap">10 September</span> 2015</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=TIOBE+Programming+Community+Index+Python&amp;rft.date=2015&amp;rft.au=TIOBE+Software+Index&amp;rft_id=http%3A%2F%2Fwww.tiobe.com%2Findex.php%2Fpaperinfo%2Ftpci%2FPython.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-28-121"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-28_121-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Prechelt, Lutz (14 March 2000). <a rel="nofollow" class="external text" href="http://page.mi.fu-berlin.de/prechelt/Biblio/jccpprt_computer2000.pdf">"An empirical comparison of C, C++, Java, Perl, Python, Rexx, and Tcl"</a> <span style="font-size:85%;">(PDF)</span><span class="reference-accessdate">. Retrieved <span class="nowrap">30 August</span> 2013</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=An+empirical+comparison+of+C%2C+C%2B%2B%2C+Java%2C+Perl%2C+Python%2C+Rexx%2C+and+Tcl&amp;rft.date=2000-03-14&amp;rft.aulast=Prechelt&amp;rft.aufirst=Lutz&amp;rft_id=http%3A%2F%2Fpage.mi.fu-berlin.de%2Fprechelt%2FBiblio%2Fjccpprt_computer2000.pdf&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-quotes-about-python-122"><span class="mw-cite-backlink"><b><a href="#cite_ref-quotes-about-python_122-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.python.org/about/quotes/">"Quotes about Python"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">8 January</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Quotes+about+Python&amp;rft.pub=Python+Software+Foundation&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fabout%2Fquotes%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-29-123"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-29_123-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://wiki.python.org/moin/OrganizationsUsingPython">"Organizations Using Python"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">15 January</span> 2009</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Organizations+Using+Python&amp;rft.pub=Python+Software+Foundation&amp;rft_id=https%3A%2F%2Fwiki.python.org%2Fmoin%2FOrganizationsUsingPython&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-30-124"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-30_124-0">^</a></b></span> <span class="reference-text"><cite class="citation journal"><a rel="nofollow" class="external text" href="http://cdsweb.cern.ch/journal/CERNBulletin/2006/31/News%20Articles/974627?ln=en">"Python&#160;: the holy grail of programming"</a>. <i>CERN Bulletin</i>. CERN Publications (31/2006). 31 July 2006<span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=CERN+Bulletin&amp;rft.atitle=Python+%3A+the+holy+grail+of+programming&amp;rft.issue=31%2F2006&amp;rft.date=2006-07-31&amp;rft_id=http%3A%2F%2Fcdsweb.cern.ch%2Fjournal%2FCERNBulletin%2F2006%2F31%2FNews%2520Articles%2F974627%3Fln%3Den&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-31-125"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-31_125-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Shafer, Daniel G. (17 January 2003). <a rel="nofollow" class="external text" href="https://www.python.org/about/success/usa/">"Python Streamlines Space Shuttle Mission Design"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+Streamlines+Space+Shuttle+Mission+Design&amp;rft.pub=Python+Software+Foundation&amp;rft.date=2003-01-17&amp;rft.aulast=Shafer&amp;rft.aufirst=Daniel+G.&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fabout%2Fsuccess%2Fusa%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-126"><span class="mw-cite-backlink"><b><a href="#cite_ref-126">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://developers.facebook.com/blog/post/301">"Tornado: Facebook's Real-Time Web Framework for Python - Facebook for Developers"</a>. <i>Facebook for Developers</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2018-06-19</span></span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Facebook+for+Developers&amp;rft.atitle=Tornado%3A+Facebook%27s+Real-Time+Web+Framework+for+Python+-+Facebook+for+Developers&amp;rft_id=https%3A%2F%2Fdevelopers.facebook.com%2Fblog%2Fpost%2F301&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-127"><span class="mw-cite-backlink"><b><a href="#cite_ref-127">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://labs.spotify.com/2013/03/20/how-we-use-python-at-spotify/">"How we use Python at Spotify"</a>. <i>Spotify Labs</i><span class="reference-accessdate">. Retrieved <span class="nowrap">2018-07-25</span></span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Spotify+Labs&amp;rft.atitle=How+we+use+Python+at+Spotify&amp;rft_id=https%3A%2F%2Flabs.spotify.com%2F2013%2F03%2F20%2Fhow-we-use-python-at-spotify%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-32-128"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-32_128-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Fortenberry, Tim (17 January 2003). <a rel="nofollow" class="external text" href="https://www.python.org/about/success/ilm/">"Industrial Light &amp; Magic Runs on Python"</a>. Python Software Foundation<span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Industrial+Light+%26+Magic+Runs+on+Python&amp;rft.pub=Python+Software+Foundation&amp;rft.date=2003-01-17&amp;rft.aulast=Fortenberry&amp;rft.aufirst=Tim&amp;rft_id=https%3A%2F%2Fwww.python.org%2Fabout%2Fsuccess%2Film%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-33-129"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-33_129-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Taft, Darryl K. (5 March 2007). <a rel="nofollow" class="external text" href="http://www.eweek.com/c/a/Application-Development/Python-Slithers-into-Systems/">"Python Slithers into Systems"</a>. <i>eWeek.com</i>. Ziff Davis Holdings<span class="reference-accessdate">. Retrieved <span class="nowrap">24 September</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=eWeek.com&amp;rft.atitle=Python+Slithers+into+Systems&amp;rft.date=2007-03-05&amp;rft.aulast=Taft&amp;rft.aufirst=Darryl+K.&amp;rft_id=http%3A%2F%2Fwww.eweek.com%2Fc%2Fa%2FApplication-Development%2FPython-Slithers-into-Systems%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-35-130"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-35_130-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://w3techs.com/technologies/details/pl-python/all/all">"Usage statistics and market share of Python for websites"</a>. 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">18 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Usage+statistics+and+market+share+of+Python+for+websites&amp;rft.date=2012&amp;rft_id=http%3A%2F%2Fw3techs.com%2Ftechnologies%2Fdetails%2Fpl-python%2Fall%2Fall&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-cise-131"><span class="mw-cite-backlink"><b><a href="#cite_ref-cise_131-0">^</a></b></span> <span class="reference-text"><cite class="citation journal">Oliphant, Travis (2007). <a rel="nofollow" class="external text" href="https://www.h2desk.com/blog/python-scientific-computing/">"Python for Scientific Computing"</a>. <i>Computing in Science and Engineering</i>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=Computing+in+Science+and+Engineering&amp;rft.atitle=Python+for+Scientific+Computing&amp;rft.date=2007&amp;rft.aulast=Oliphant&amp;rft.aufirst=Travis&amp;rft_id=https%3A%2F%2Fwww.h2desk.com%2Fblog%2Fpython-scientific-computing%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-millman-132"><span class="mw-cite-backlink"><b><a href="#cite_ref-millman_132-0">^</a></b></span> <span class="reference-text"><cite class="citation journal">Millman, K. Jarrod; Aivazis, Michael (2011). <a rel="nofollow" class="external text" href="http://www.computer.org/csdl/mags/cs/2011/02/mcs2011020009.html">"Python for Scientists and Engineers"</a>. <i>Computing in Science and Engineering</i>. <b>13</b> (2): 9–12.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=Computing+in+Science+and+Engineering&amp;rft.atitle=Python+for+Scientists+and+Engineers&amp;rft.volume=13&amp;rft.issue=2&amp;rft.pages=9-12&amp;rft.date=2011&amp;rft.aulast=Millman&amp;rft.aufirst=K.+Jarrod&amp;rft.au=Aivazis%2C+Michael&amp;rft_id=http%3A%2F%2Fwww.computer.org%2Fcsdl%2Fmags%2Fcs%2F2011%2F02%2Fmcs2011020009.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-133"><span class="mw-cite-backlink"><b><a href="#cite_ref-133">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20130717070814/http://gimp-win.sourceforge.net/faq.html">"Installers for GIMP for Windows - Frequently Asked Questions"</a>. 26 July 2013. Archived from <a rel="nofollow" class="external text" href="http://gimp-win.sourceforge.net/faq.html">the original</a> on 17 July 2013<span class="reference-accessdate">. Retrieved <span class="nowrap">26 July</span> 2013</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Installers+for+GIMP+for+Windows+-+Frequently+Asked+Questions&amp;rft.date=2013-07-26&amp;rft_id=http%3A%2F%2Fgimp-win.sourceforge.net%2Ffaq.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-38-134"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-38_134-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20080319061519/http://www.jasc.com/support/customercare/articles/psp9components.asp">"jasc psp9components"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.jasc.com/support/customercare/articles/psp9components.asp">the original</a> on 19 March 2008.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=jasc+psp9components&amp;rft_id=http%3A%2F%2Fwww.jasc.com%2Fsupport%2Fcustomercare%2Farticles%2Fpsp9components.asp&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-39-135"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-39_135-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://webhelp.esri.com/arcgisdesktop/9.2/index.cfm?TopicName=About_getting_started_with_writing_geoprocessing_scripts">"About getting started with writing geoprocessing scripts"</a>. <i>ArcGIS Desktop Help 9.2</i>. Environmental Systems Research Institute. 17 November 2006<span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=ArcGIS+Desktop+Help+9.2&amp;rft.atitle=About+getting+started+with+writing+geoprocessing+scripts&amp;rft.date=2006-11-17&amp;rft_id=http%3A%2F%2Fwebhelp.esri.com%2Farcgisdesktop%2F9.2%2Findex.cfm%3FTopicName%3DAbout_getting_started_with_writing_geoprocessing_scripts&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-40-136"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-40_136-0">^</a></b></span> <span class="reference-text"><cite class="citation web">CCP porkbelly (24 August 2010). <a rel="nofollow" class="external text" href="http://community.eveonline.com/news/dev-blogs/stackless-python-2.7/">"Stackless Python 2.7"</a>. <i>EVE Community Dev Blogs</i>. <a href="/wiki/CCP_Games" title="CCP Games">CCP Games</a>. <q>As you may know, EVE has at its core the programming language known as Stackless Python.</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=EVE+Community+Dev+Blogs&amp;rft.atitle=Stackless+Python+2.7&amp;rft.date=2010-08-24&amp;rft.au=CCP+porkbelly&amp;rft_id=http%3A%2F%2Fcommunity.eveonline.com%2Fnews%2Fdev-blogs%2Fstackless-python-2.7%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-41-137"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-41_137-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Caudill, Barry (20 September 2005). <a rel="nofollow" class="external text" href="https://www.webcitation.org/5ru5VItfv?url=http://www.2kgames.com/civ4/blog_03.htm">"Modding Sid Meier's Civilization IV"</a>. <i>Sid Meier's Civilization IV Developer Blog</i>. <a href="/wiki/Firaxis_Games" title="Firaxis Games">Firaxis Games</a>. Archived from <a rel="nofollow" class="external text" href="http://www.2kgames.com/civ4/blog_03.htm">the original</a> on 11 August 2010. <q>we created three levels of tools ... The next level offers Python and XML support, letting modders with more experience manipulate the game world and everything in it.</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Sid+Meier%27s+Civilization+IV+Developer+Blog&amp;rft.atitle=Modding+Sid+Meier%27s+Civilization+IV&amp;rft.date=2005-09-20&amp;rft.aulast=Caudill&amp;rft.aufirst=Barry&amp;rft_id=http%3A%2F%2Fwww.2kgames.com%2Fciv4%2Fblog_03.htm&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-42-138"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-42_138-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://www.webcitation.org/5ru5FHxfV?url=http://code.google.com/apis/documents/docs/1.0/developers_guide_python.html">"Python Language Guide (v1.0)"</a>. <i>Google Documents List Data API v1.0</i>. Google. Archived from <a rel="nofollow" class="external text" href="https://code.google.com/apis/documents/docs/1.0/developers_guide_python.html">the original</a> on 11 August 2010.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Google+Documents+List+Data+API+v1.0&amp;rft.atitle=Python+Language+Guide+%28v1.0%29&amp;rft_id=https%3A%2F%2Fcode.google.com%2Fapis%2Fdocuments%2Fdocs%2F1.0%2Fdevelopers_guide_python.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-139"><span class="mw-cite-backlink"><b><a href="#cite_ref-139">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.quantinsti.com/blog/python-best-programming-language-algorithmic-trading/">"Python - Best Programming Language for Algorithmic Trading Systems"</a>. 9 March 2016<span class="reference-accessdate">. Retrieved <span class="nowrap">3 October</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+-+Best+Programming+Language+for+Algorithmic+Trading+Systems&amp;rft.date=2016-03-09&amp;rft_id=http%3A%2F%2Fwww.quantinsti.com%2Fblog%2Fpython-best-programming-language-algorithmic-trading%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-140"><span class="mw-cite-backlink"><b><a href="#cite_ref-140">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.quantinsti.com/blog/ibpy-tutorial-implement-python-interactive-brokers-api/">"Trading with Interactive Brokers using Python: An IBPy Tutorial"</a>. 19 September 2016<span class="reference-accessdate">. Retrieved <span class="nowrap">3 October</span> 2016</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Trading+with+Interactive+Brokers+using+Python%3A+An+IBPy+Tutorial&amp;rft.date=2016-09-19&amp;rft_id=http%3A%2F%2Fwww.quantinsti.com%2Fblog%2Fibpy-tutorial-implement-python-interactive-brokers-api%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-43-141"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-43_141-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20121101045354/http://wiki.python.org/moin/PythonForArtificialIntelligence">"Python for Artificial Intelligence"</a>. Wiki.python.org. 19 July 2012. Archived from <a rel="nofollow" class="external text" href="https://wiki.python.org/moin/PythonForArtificialIntelligence">the original</a> on 1 November 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Python+for+Artificial+Intelligence&amp;rft.pub=Wiki.python.org&amp;rft.date=2012-07-19&amp;rft_id=https%3A%2F%2Fwiki.python.org%2Fmoin%2FPythonForArtificialIntelligence&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-44-142"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-44_142-0">^</a></b></span> <span class="reference-text"><cite class="citation journal">Paine, Jocelyn, ed. (August 2005). <a rel="nofollow" class="external text" href="http://www.ainewsletter.com/newsletters/aix_0508.htm#python_ai_ai">"AI in Python"</a>. <i>AI Expert Newsletter</i>. Amzi!<span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=AI+Expert+Newsletter&amp;rft.atitle=AI+in+Python&amp;rft.date=2005-08&amp;rft_id=http%3A%2F%2Fwww.ainewsletter.com%2Fnewsletters%2Faix_0508.htm%23python_ai_ai&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-45-143"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-45_143-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://pypi.python.org/pypi/PyAIML">"PyAIML 0.8.5&#160;: Python Package Index"</a>. Pypi.python.org<span class="reference-accessdate">. Retrieved <span class="nowrap">17 July</span> 2013</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=PyAIML+0.8.5+%3A+Python+Package+Index&amp;rft.pub=Pypi.python.org&amp;rft_id=https%3A%2F%2Fpypi.python.org%2Fpypi%2FPyAIML&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-46-144"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-46_144-0">^</a></b></span> <span class="reference-text"><cite class="citation book"><a href="/wiki/Stuart_J._Russell" title="Stuart J. Russell">Russell, Stuart J.</a> &amp; <a href="/wiki/Peter_Norvig" title="Peter Norvig">Norvig, Peter</a> (2009). <a rel="nofollow" class="external text" href="http://aima.cs.berkeley.edu/"><i>Artificial Intelligence: A Modern Approach</i></a> (3rd ed.). Upper Saddle River, NJ: Prentice Hall. p.&#160;1062. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-13-604259-4" title="Special:BookSources/978-0-13-604259-4">978-0-13-604259-4</a><span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Artificial+Intelligence%3A+A+Modern+Approach&amp;rft.place=Upper+Saddle+River%2C+NJ&amp;rft.pages=1062&amp;rft.edition=3rd&amp;rft.pub=Prentice+Hall&amp;rft.date=2009&amp;rft.isbn=978-0-13-604259-4&amp;rft.aulast=Russell&amp;rft.aufirst=Stuart+J.&amp;rft.au=Norvig%2C+Peter&amp;rft_id=http%3A%2F%2Faima.cs.berkeley.edu%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-47-145"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-47_145-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.nltk.org">"Natural Language Toolkit"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Natural+Language+Toolkit&amp;rft_id=http%3A%2F%2Fwww.nltk.org&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-49-146"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-49_146-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20090216134332/http://immunitysec.com/products-immdbg.shtml">"Immunity: Knowing You're Secure"</a>. Archived from <a rel="nofollow" class="external text" href="http://www.immunitysec.com/products-immdbg.shtml">the original</a> on 16 February 2009.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Immunity%3A+Knowing+You%27re+Secure&amp;rft_id=http%3A%2F%2Fwww.immunitysec.com%2Fproducts-immdbg.shtml&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-50-147"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-50_147-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://oss.coresecurity.com/">"Corelabs site"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Corelabs+site&amp;rft_id=http%3A%2F%2Foss.coresecurity.com%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-51-148"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-51_148-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://sugarlabs.org/go/Sugar">"What is Sugar?"</a>. Sugar Labs<span class="reference-accessdate">. Retrieved <span class="nowrap">11 February</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=What+is+Sugar%3F&amp;rft.pub=Sugar+Labs&amp;rft_id=http%3A%2F%2Fsugarlabs.org%2Fgo%2FSugar&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-149"><span class="mw-cite-backlink"><b><a href="#cite_ref-149">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.libreoffice.org/download/4-0-new-features-and-fixes/">"4.0 New Features and Fixes"</a>. <i>LibreOffice.org</i>. <a href="/wiki/The_Document_Foundation" title="The Document Foundation">The Document Foundation</a>. 2013<span class="reference-accessdate">. Retrieved <span class="nowrap">25 February</span> 2013</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=LibreOffice.org&amp;rft.atitle=4.0+New+Features+and+Fixes&amp;rft.date=2013&amp;rft_id=http%3A%2F%2Fwww.libreoffice.org%2Fdownload%2F4-0-new-features-and-fixes%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-90-150"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-90_150-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20081211062108/http://boo.codehaus.org/Gotchas+for+Python+Users">"Gotchas for Python Users"</a>. <i>boo.codehaus.org</i>. Codehaus Foundation. Archived from <a rel="nofollow" class="external text" href="http://boo.codehaus.org/Gotchas+for+Python+Users">the original</a> on 11 December 2008<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=boo.codehaus.org&amp;rft.atitle=Gotchas+for+Python+Users&amp;rft_id=http%3A%2F%2Fboo.codehaus.org%2FGotchas%2Bfor%2BPython%2BUsers&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-91-151"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-91_151-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Esterbrook, Charles. <a rel="nofollow" class="external text" href="http://cobra-language.com/docs/acknowledgements/">"Acknowledgements"</a>. <i>cobra-language.com</i>. Cobra Language<span class="reference-accessdate">. Retrieved <span class="nowrap">7 April</span> 2010</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=cobra-language.com&amp;rft.atitle=Acknowledgements&amp;rft.aulast=Esterbrook&amp;rft.aufirst=Charles&amp;rft_id=http%3A%2F%2Fcobra-language.com%2Fdocs%2Facknowledgements%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-92-152"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-92_152-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Esterbrook, Charles. <a rel="nofollow" class="external text" href="http://cobra-language.com/docs/python/">"Comparison to Python"</a>. <i>cobra-language.com</i>. Cobra Language<span class="reference-accessdate">. Retrieved <span class="nowrap">7 April</span> 2010</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=cobra-language.com&amp;rft.atitle=Comparison+to+Python&amp;rft.aulast=Esterbrook&amp;rft.aufirst=Charles&amp;rft_id=http%3A%2F%2Fcobra-language.com%2Fdocs%2Fpython%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-93-153"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-93_153-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://web.archive.org/web/20071020082650/http://wiki.ecmascript.org/doku.php?id=proposals:iterators_and_generators">"Proposals: iterators and generators &#91;ES4 Wiki&#93;"</a>. wiki.ecmascript.org. Archived from <a rel="nofollow" class="external text" href="http://wiki.ecmascript.org/doku.php?id=proposals:iterators_and_generators">the original</a> on 20 October 2007<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Proposals%3A+iterators+and+generators+%5BES4+Wiki%26%2393%3B&amp;rft.pub=wiki.ecmascript.org&amp;rft_id=http%3A%2F%2Fwiki.ecmascript.org%2Fdoku.php%3Fid%3Dproposals%3Aiterators_and_generators&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-94-154"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-94_154-0">^</a></b></span> <span class="reference-text"><cite class="citation news">Kincaid, Jason (10 November 2009). <a rel="nofollow" class="external text" href="https://techcrunch.com/2009/11/10/google-go-language/">"Google's Go: A New Programming Language That's Python Meets C++"</a>. TechCrunch<span class="reference-accessdate">. Retrieved <span class="nowrap">29 January</span> 2010</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.atitle=Google%E2%80%99s+Go%3A+A+New+Programming+Language+That%E2%80%99s+Python+Meets+C%2B%2B&amp;rft.date=2009-11-10&amp;rft.aulast=Kincaid&amp;rft.aufirst=Jason&amp;rft_id=https%3A%2F%2Ftechcrunch.com%2F2009%2F11%2F10%2Fgoogle-go-language%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-95-155"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-95_155-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Strachan, James (29 August 2003). <a rel="nofollow" class="external text" href="http://radio.weblogs.com/0112098/2003/08/29.html">"Groovy&#160;– the birth of a new dynamic language for the Java platform"</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Groovy+%E2%80%93+the+birth+of+a+new+dynamic+language+for+the+Java+platform&amp;rft.date=2003-08-29&amp;rft.aulast=Strachan&amp;rft.aufirst=James&amp;rft_id=http%3A%2F%2Fradio.weblogs.com%2F0112098%2F2003%2F08%2F29.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-156"><span class="mw-cite-backlink"><b><a href="#cite_ref-156">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="https://kotlinlang.org/docs/tutorials/command-line.html">"Working with the Command Line Compiler - Kotlin Programming Language"</a>. <i>Kotlin</i><span class="reference-accessdate">. Retrieved <span class="nowrap">12 March</span> 2018</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=Kotlin&amp;rft.atitle=Working+with+the+Command+Line+Compiler+-+Kotlin+Programming+Language&amp;rft_id=https%3A%2F%2Fkotlinlang.org%2Fdocs%2Ftutorials%2Fcommand-line.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-linuxdevcenter-157"><span class="mw-cite-backlink"><b><a href="#cite_ref-linuxdevcenter_157-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.linuxdevcenter.com/pub/a/linux/2001/11/29/ruby.html">"An Interview with the Creator of Ruby"</a>. Linuxdevcenter.com<span class="reference-accessdate">. Retrieved <span class="nowrap">3 December</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=An+Interview+with+the+Creator+of+Ruby&amp;rft.pub=Linuxdevcenter.com&amp;rft_id=http%3A%2F%2Fwww.linuxdevcenter.com%2Fpub%2Fa%2Flinux%2F2001%2F11%2F29%2Fruby.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-158"><span class="mw-cite-backlink"><b><a href="#cite_ref-158">^</a></b></span> <span class="reference-text"><cite class="citation web"><a href="/wiki/Chris_Lattner" title="Chris Lattner">Lattner, Chris</a> (3 June 2014). <a rel="nofollow" class="external text" href="http://nondot.org/sabre">"Chris Lattner's Homepage"</a>. Chris Lattner<span class="reference-accessdate">. Retrieved <span class="nowrap">3 June</span> 2014</span>. <q>I started work on the Swift Programming Language in July of 2010. I implemented much of the basic language structure, with only a few people knowing of its existence. A few other (amazing) people started contributing in earnest late in 2011, and it became a major focus for the Apple Developer Tools group in July 2013 [...] drawing ideas from Objective-C, Rust, Haskell, Ruby, Python, C#, CLU, and far too many others to list.</q></cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=Chris+Lattner%27s+Homepage&amp;rft.pub=Chris+Lattner&amp;rft.date=2014-06-03&amp;rft.aulast=Lattner&amp;rft.aufirst=Chris&amp;rft_id=http%3A%2F%2Fnondot.org%2Fsabre&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-99-159"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-99_159-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Kupries, Andreas; Fellows, Donal K. (14 September 2000). <a rel="nofollow" class="external text" href="http://www.tcl.tk/cgi-bin/tct/tip/3.html">"TIP #3: TIP Format"</a>. <i>tcl.tk</i>. Tcl Developer Xchange<span class="reference-accessdate">. Retrieved <span class="nowrap">24 November</span> 2008</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=unknown&amp;rft.jtitle=tcl.tk&amp;rft.atitle=TIP+%233%3A+TIP+Format&amp;rft.date=2000-09-14&amp;rft.aulast=Kupries&amp;rft.aufirst=Andreas&amp;rft.au=Fellows%2C+Donal+K.&amp;rft_id=http%3A%2F%2Fwww.tcl.tk%2Fcgi-bin%2Ftct%2Ftip%2F3.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-100-160"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-100_160-0">^</a></b></span> <span class="reference-text"><cite class="citation web">Gustafsson, Per; Niskanen, Raimo (29 January 2007). <a rel="nofollow" class="external text" href="http://www.erlang.org/eeps/eep-0001.html">"EEP 1: EEP Purpose and Guidelines"</a>. erlang.org<span class="reference-accessdate">. Retrieved <span class="nowrap">19 April</span> 2011</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=EEP+1%3A+EEP+Purpose+and+Guidelines&amp;rft.pub=erlang.org&amp;rft.date=2007-01-29&amp;rft.aulast=Gustafsson&amp;rft.aufirst=Per&amp;rft.au=Niskanen%2C+Raimo&amp;rft_id=http%3A%2F%2Fwww.erlang.org%2Feeps%2Feep-0001.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
<li id="cite_note-AutoNT-101-161"><span class="mw-cite-backlink"><b><a href="#cite_ref-AutoNT-101_161-0">^</a></b></span> <span class="reference-text"><cite class="citation web"><a rel="nofollow" class="external text" href="http://www.tiobe.com/index.php/content/paperinfo/tpci/">"TIOBE Programming Community Index for March 2012"</a>. TIOBE Software. March 2012<span class="reference-accessdate">. Retrieved <span class="nowrap">25 March</span> 2012</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=unknown&amp;rft.btitle=TIOBE+Programming+Community+Index+for+March+2012&amp;rft.pub=TIOBE+Software&amp;rft.date=2012-03&amp;rft_id=http%3A%2F%2Fwww.tiobe.com%2Findex.php%2Fcontent%2Fpaperinfo%2Ftpci%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></span>
</li>
</ol></div>
<h2><span class="mw-headline" id="Further_reading">Further reading</span></h2>
<ul><li><cite class="citation book">Downey, Allen B. (May 2012). <a rel="nofollow" class="external text" href="http://www.greenteapress.com/thinkpython/html/"><i>Think Python: How to Think Like a Computer Scientist</i></a> (Version 1.6.6 ed.). <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-521-72596-5" title="Special:BookSources/978-0-521-72596-5">978-0-521-72596-5</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Think+Python%3A+How+to+Think+Like+a+Computer+Scientist&amp;rft.edition=Version+1.6.6&amp;rft.date=2012-05&amp;rft.isbn=978-0-521-72596-5&amp;rft.aulast=Downey&amp;rft.aufirst=Allen+B.&amp;rft_id=http%3A%2F%2Fwww.greenteapress.com%2Fthinkpython%2Fhtml%2F&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></li>
<li><cite class="citation news">Hamilton, Naomi (5 August 2008). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20081229095320/http://www.computerworld.com.au/index.php/id%3B66665771">"The A-Z of Programming Languages: Python"</a>. <i>Computerworld</i>. Archived from <a rel="nofollow" class="external text" href="http://www.computerworld.com.au/index.php/id;66665771">the original</a> on 29 December 2008<span class="reference-accessdate">. Retrieved <span class="nowrap">31 March</span> 2010</span>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Ajournal&amp;rft.genre=article&amp;rft.jtitle=Computerworld&amp;rft.atitle=The+A-Z+of+Programming+Languages%3A+Python&amp;rft.date=2008-08-05&amp;rft.aulast=Hamilton&amp;rft.aufirst=Naomi&amp;rft_id=http%3A%2F%2Fwww.computerworld.com.au%2Findex.php%2Fid%3B66665771&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></li>
<li><cite class="citation book">Lutz, Mark (2013). <a rel="nofollow" class="external text" href="http://shop.oreilly.com/product/0636920028154.do"><i>Learning Python</i></a> (5th ed.). O'Reilly Media. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-596-15806-4" title="Special:BookSources/978-0-596-15806-4">978-0-596-15806-4</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Learning+Python&amp;rft.edition=5th&amp;rft.pub=O%27Reilly+Media&amp;rft.date=2013&amp;rft.isbn=978-0-596-15806-4&amp;rft.aulast=Lutz&amp;rft.aufirst=Mark&amp;rft_id=http%3A%2F%2Fshop.oreilly.com%2Fproduct%2F0636920028154.do&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></li>
<li><cite class="citation book">Pilgrim, Mark (2004). <a rel="nofollow" class="external text" href="http://diveintopython.net"><i>Dive Into Python</i></a>. Apress. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-1-59059-356-1" title="Special:BookSources/978-1-59059-356-1">978-1-59059-356-1</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Dive+Into+Python&amp;rft.pub=Apress&amp;rft.date=2004&amp;rft.isbn=978-1-59059-356-1&amp;rft.aulast=Pilgrim&amp;rft.aufirst=Mark&amp;rft_id=http%3A%2F%2Fdiveintopython.net&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></li>
<li><cite class="citation book">Pilgrim, Mark (2009). <a rel="nofollow" class="external text" href="https://web.archive.org/web/20111017050617/http://www.diveintopython3.net/"><i>Dive Into Python 3</i></a>. Apress. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-1-4302-2415-0" title="Special:BookSources/978-1-4302-2415-0">978-1-4302-2415-0</a>. Archived from <a rel="nofollow" class="external text" href="http://diveintopython3.net">the original</a> on 2011-10-17.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Dive+Into+Python+3&amp;rft.pub=Apress&amp;rft.date=2009&amp;rft.isbn=978-1-4302-2415-0&amp;rft.aulast=Pilgrim&amp;rft.aufirst=Mark&amp;rft_id=http%3A%2F%2Fdiveintopython3.net&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></li>
<li><cite class="citation book">Summerfield, Mark (2009). <a rel="nofollow" class="external text" href="http://www.qtrac.eu/py3book.html"><i>Programming in Python 3</i></a> (2nd ed.). Addison-Wesley Professional. <a href="/wiki/International_Standard_Book_Number" title="International Standard Book Number">ISBN</a>&#160;<a href="/wiki/Special:BookSources/978-0-321-68056-3" title="Special:BookSources/978-0-321-68056-3">978-0-321-68056-3</a>.</cite><span title="ctx_ver=Z39.88-2004&amp;rft_val_fmt=info%3Aofi%2Ffmt%3Akev%3Amtx%3Abook&amp;rft.genre=book&amp;rft.btitle=Programming+in+Python+3&amp;rft.edition=2nd&amp;rft.pub=Addison-Wesley+Professional&amp;rft.date=2009&amp;rft.isbn=978-0-321-68056-3&amp;rft.aulast=Summerfield&amp;rft.aufirst=Mark&amp;rft_id=http%3A%2F%2Fwww.qtrac.eu%2Fpy3book.html&amp;rfr_id=info%3Asid%2Fen.wikipedia.org%3APython+%28programming+language%29" class="Z3988"><span style="display:none;">&#160;</span></span></li></ul>
<h2><span class="mw-headline" id="External_links">External links</span></h2>
<div role="navigation" aria-labelledby="sister-projects" class="metadata plainlinks plainlist mbox-small" style="border:1px solid #aaa; padding:0.75em; background:#f9f9f9;">
    <div style="padding-bottom: 0.75em; text-align: center;">Find more about<b style="display:block;">Python (programming language)</b>at Wikipedia's <a href="/wiki/Wikipedia:Wikimedia_sister_projects" title="Wikipedia:Wikimedia sister projects"><span id="sister-projects">sister projects</span></a>
    </div>
    <ul style="border-top:1px solid #aaa; padding-top: 0.75em;">
        <li style="min-height: 31px;"><span style="display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;"><img alt="" src="//upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/20px-Commons-logo.svg.png" width="20" height="27" style="vertical-align: middle" srcset="//upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/30px-Commons-logo.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/40px-Commons-logo.svg.png 2x" data-file-width="1024" data-file-height="1376" /></span><span style="display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;"><a href="https://commons.wikimedia.org/wiki/Category:Python_(programming_language)" class="extiw" title="c:Category:Python (programming language)">Media</a> from Wikimedia Commons</span>
            </li><li style="min-height: 31px;"><span style="display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;"><img alt="" src="//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikiquote-logo.svg/23px-Wikiquote-logo.svg.png" width="23" height="27" style="vertical-align: middle" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikiquote-logo.svg/35px-Wikiquote-logo.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikiquote-logo.svg/46px-Wikiquote-logo.svg.png 2x" data-file-width="300" data-file-height="355" /></span><span style="display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;"><a href="https://en.wikiquote.org/wiki/Python" class="extiw" title="q:Python">Quotations</a> from Wikiquote</span>
            </li><li style="min-height: 31px;"><span style="display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;"><img alt="" src="//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikibooks-logo.svg/27px-Wikibooks-logo.svg.png" width="27" height="27" style="vertical-align: middle" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikibooks-logo.svg/41px-Wikibooks-logo.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikibooks-logo.svg/54px-Wikibooks-logo.svg.png 2x" data-file-width="300" data-file-height="300" /></span><span style="display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;"><a href="https://en.wikibooks.org/wiki/Python_Programming" class="extiw" title="b:Python Programming">Textbooks</a> from Wikibooks</span>
            </li><li style="min-height: 31px;"><span style="display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;"><img alt="" src="//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Wikiversity-logo-en.svg/27px-Wikiversity-logo-en.svg.png" width="27" height="24" style="vertical-align: middle" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Wikiversity-logo-en.svg/41px-Wikiversity-logo-en.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Wikiversity-logo-en.svg/54px-Wikiversity-logo-en.svg.png 2x" data-file-width="1000" data-file-height="900" /></span><span style="display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;"><a href="https://en.wikiversity.org/wiki/Python" class="extiw" title="v:Python">Learning resources</a> from Wikiversity</span>
            </li>
    </ul>
</div>
<ul><li><span class="official-website"><span class="url"><a rel="nofollow" class="external text" href="https://www.python.org/">Official website</a></span></span> <a href="https://www.wikidata.org/wiki/Q28865#P856" title="Edit this at Wikidata"><img alt="Edit this at Wikidata" src="//upload.wikimedia.org/wikipedia/commons/thumb/7/73/Blue_pencil.svg/10px-Blue_pencil.svg.png" width="10" height="10" style="vertical-align: text-top" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/7/73/Blue_pencil.svg/15px-Blue_pencil.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/7/73/Blue_pencil.svg/20px-Blue_pencil.svg.png 2x" data-file-width="600" data-file-height="600" /></a></li>
<li><a rel="nofollow" class="external text" href="https://curlie.org/Computers/Programming/Languages/Python">Python</a> at Curlie (based on <a href="/wiki/DMOZ" title="DMOZ">DMOZ</a>)</li></ul>
<div role="navigation" class="navbox" aria-labelledby="Programming_languages" style="padding:3px"><table class="nowraplinks hlist collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div class="plainlinks hlist navbar mini"><ul><li class="nv-view"><a href="/wiki/Template:Programming_languages" title="Template:Programming languages"><abbr title="View this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">v</abbr></a></li><li class="nv-talk"><a href="/wiki/Template_talk:Programming_languages" title="Template talk:Programming languages"><abbr title="Discuss this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">t</abbr></a></li><li class="nv-edit"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Template:Programming_languages&amp;action=edit"><abbr title="Edit this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">e</abbr></a></li></ul></div><div id="Programming_languages" style="font-size:114%;margin:0 4em"><a href="/wiki/Programming_language" title="Programming language">Programming languages</a></div></th></tr><tr><td class="navbox-abovebelow" colspan="2"><div id="*_Comparison&amp;#10;*_Timeline&amp;#10;*_History">
<ul><li><a href="/wiki/Comparison_of_programming_languages" title="Comparison of programming languages">Comparison</a></li>
<li><a href="/wiki/Timeline_of_programming_languages" title="Timeline of programming languages">Timeline</a></li>
<li><a href="/wiki/History_of_programming_languages" title="History of programming languages">History</a></li></ul>
</div></td></tr><tr><td colspan="2" class="navbox-list navbox-odd" style="width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/APL_(programming_language)" title="APL (programming language)">APL</a></li>
<li><a href="/wiki/Assembly_language" title="Assembly language">Assembly</a></li>
<li><a href="/wiki/BASIC" title="BASIC">BASIC</a></li>
<li><a href="/wiki/C_(programming_language)" title="C (programming language)">C</a></li>
<li><a href="/wiki/C%2B%2B" title="C++">C++</a></li>
<li><a href="/wiki/C_Sharp_(programming_language)" title="C Sharp (programming language)">C#</a></li>
<li><a href="/wiki/COBOL" title="COBOL">COBOL</a></li>
<li><a href="/wiki/Fortran" title="Fortran">Fortran</a></li>
<li><a href="/wiki/Go_(programming_language)" title="Go (programming language)">Go</a></li>
<li><a href="/wiki/Apache_Groovy" title="Apache Groovy">Groovy</a></li>
<li><a href="/wiki/Haskell_(programming_language)" title="Haskell (programming language)">Haskell</a></li>
<li><a href="/wiki/Java_(programming_language)" title="Java (programming language)">Java</a></li>
<li><a href="/wiki/JavaScript" title="JavaScript">JavaScript</a> (JS)</li>
<li><a href="/wiki/Kotlin_(programming_language)" title="Kotlin (programming language)">Kotlin</a></li>
<li><a href="/wiki/Lisp_(programming_language)" title="Lisp (programming language)">Lisp</a></li>
<li><a href="/wiki/Lua_(programming_language)" title="Lua (programming language)">Lua</a></li>
<li><a href="/wiki/Objective-C" title="Objective-C">Objective-C</a></li>
<li><a href="/wiki/Pascal_(programming_language)" title="Pascal (programming language)">Pascal</a></li>
<li><a href="/wiki/Perl" title="Perl">Perl</a></li>
<li><a href="/wiki/PHP" title="PHP">PHP</a></li>
<li><a class="mw-selflink selflink">Python</a></li>
<li><a href="/wiki/Ruby_(programming_language)" title="Ruby (programming language)">Ruby</a></li>
<li><a href="/wiki/Rust_(programming_language)" title="Rust (programming language)">Rust</a></li>
<li><a href="/wiki/Shell_script" title="Shell script">Shell</a></li>
<li><a href="/wiki/Smalltalk" title="Smalltalk">Smalltalk</a></li>
<li><a href="/wiki/Swift_(programming_language)" title="Swift (programming language)">Swift</a></li>
<li><a href="/wiki/Visual_Basic_.NET" title="Visual Basic .NET">Visual Basic .NET</a> (VB.NET)</li>
<li><i><a href="/wiki/List_of_programming_languages" title="List of programming languages">more...</a></i></li></ul>
</div></td></tr><tr><td class="navbox-abovebelow" colspan="2"><div>
<ul><li><img alt="Category" src="//upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/16px-Folder_Hexagonal_Icon.svg.png" title="Category" width="16" height="14" srcset="//upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/24px-Folder_Hexagonal_Icon.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/32px-Folder_Hexagonal_Icon.svg.png 2x" data-file-width="36" data-file-height="31" /> <b><a href="/wiki/Category:Programming_languages" title="Category:Programming languages">Category</a></b></li>
<li><img alt="List-Class article" src="//upload.wikimedia.org/wikipedia/en/thumb/d/db/Symbol_list_class.svg/16px-Symbol_list_class.svg.png" title="List-Class article" width="16" height="16" srcset="//upload.wikimedia.org/wikipedia/en/thumb/d/db/Symbol_list_class.svg/23px-Symbol_list_class.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/d/db/Symbol_list_class.svg/31px-Symbol_list_class.svg.png 2x" data-file-width="180" data-file-height="185" /> <b>Lists</b>
<ul><li><a href="/wiki/List_of_programming_languages" title="List of programming languages">Alphabetical</a></li>
<li><a href="/wiki/List_of_programming_languages_by_type" title="List of programming languages by type">Categorical</a></li>
<li><a href="/wiki/Generational_list_of_programming_languages" title="Generational list of programming languages">Generational</a></li>
<li><a href="/wiki/Non-English-based_programming_languages" title="Non-English-based programming languages">Non-English-based</a></li></ul></li></ul>
</div></td></tr></tbody></table></div>
<div role="navigation" class="navbox" aria-labelledby="Python" style="padding:3px"><table class="nowraplinks collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="3"><div class="plainlinks hlist navbar mini"><ul><li class="nv-view"><a href="/wiki/Template:Python_(programming_language)" title="Template:Python (programming language)"><abbr title="View this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">v</abbr></a></li><li class="nv-talk"><a href="/wiki/Template_talk:Python_(programming_language)" title="Template talk:Python (programming language)"><abbr title="Discuss this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">t</abbr></a></li><li class="nv-edit"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Template:Python_(programming_language)&amp;action=edit"><abbr title="Edit this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">e</abbr></a></li></ul></div><div id="Python" style="font-size:114%;margin:0 4em"><a class="mw-selflink selflink">Python</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="/wiki/Programming_language_implementation" title="Programming language implementation">Implementations</a></th><td class="navbox-list navbox-odd hlist" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/CircuitPython" title="CircuitPython">CircuitPython</a></li>
<li><a href="/wiki/CLPython" title="CLPython">CLPython</a></li>
<li><a href="/wiki/CPython" title="CPython">CPython</a></li>
<li><a href="/wiki/Cython" title="Cython">Cython</a></li>
<li><a href="/wiki/MicroPython" title="MicroPython">MicroPython</a></li>
<li><a href="/wiki/Numba" title="Numba">Numba</a></li>
<li><a href="/wiki/IronPython" title="IronPython">IronPython</a></li>
<li><a href="/wiki/Jython" title="Jython">Jython</a></li>
<li><a href="/wiki/Psyco" title="Psyco">Psyco</a></li>
<li><a href="/wiki/PyPy" title="PyPy">PyPy</a></li>
<li><a href="/wiki/Python_for_S60" title="Python for S60">Python for S60</a></li>
<li><a href="/wiki/Shed_Skin" title="Shed Skin">Shed Skin</a></li>
<li><a href="/wiki/Stackless_Python" title="Stackless Python">Stackless Python</a></li>
<li><a href="/wiki/Unladen_Swallow" class="mw-redirect" title="Unladen Swallow">Unladen Swallow</a></li>
<li><i><a href="/wiki/List_of_Python_software#Python_implementations" title="List of Python software">more</a>...</i></li></ul>
</div></td><td class="navbox-image" rowspan="3" style="width:1px;padding:0px 0px 0px 2px"><div><a href="/wiki/File:Python-logo-notext.svg" class="image"><img alt="Python-logo-notext.svg" src="//upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Python-logo-notext.svg/55px-Python-logo-notext.svg.png" width="55" height="55" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Python-logo-notext.svg/83px-Python-logo-notext.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Python-logo-notext.svg/110px-Python-logo-notext.svg.png 2x" data-file-width="110" data-file-height="110" /></a></div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="/wiki/Integrated_development_environment" title="Integrated development environment">IDE</a></th><td class="navbox-list navbox-even hlist" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Comparison_of_integrated_development_environments#Python" title="Comparison of integrated development environments">Boa</a></li>
<li><a href="/wiki/Eric_Python_IDE" class="mw-redirect" title="Eric Python IDE">Eric Python IDE</a></li>
<li><a href="/wiki/IDLE_(Python)" class="mw-redirect" title="IDLE (Python)">IDLE</a></li>
<li><a href="/wiki/PyCharm" title="PyCharm">PyCharm</a></li>
<li><a href="/wiki/PyDev" title="PyDev">PyDev</a></li>
<li><a href="/wiki/Stani%27s_Python_Editor" title="Stani&#39;s Python Editor">SPE</a></li>
<li><a href="/wiki/Ninja-IDE" title="Ninja-IDE">Ninja-IDE</a></li>
<li><i><a href="/wiki/List_of_integrated_development_environments_for_Python#Python" class="mw-redirect" title="List of integrated development environments for Python">more</a>...</i></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Topics</th><td class="navbox-list navbox-odd hlist" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Web_Server_Gateway_Interface" title="Web Server Gateway Interface">WSGI</a></li></ul>
</div></td></tr><tr><td class="navbox-abovebelow hlist" colspan="3"><div>
<ul><li><a href="/wiki/List_of_Python_software" title="List of Python software">software (list)</a></li>
<li><a href="/wiki/Python_Software_Foundation" title="Python Software Foundation">Python Software Foundation</a></li>
<li><a href="/wiki/Python_Conference" title="Python Conference">PyCon</a></li></ul>
</div></td></tr></tbody></table></div>
<div role="navigation" class="navbox" aria-labelledby="Python_web_frameworks" style="padding:3px"><table class="nowraplinks collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div class="plainlinks hlist navbar mini"><ul><li class="nv-view"><a href="/wiki/Template:Python_web_frameworks" title="Template:Python web frameworks"><abbr title="View this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">v</abbr></a></li><li class="nv-talk"><a href="/wiki/Template_talk:Python_web_frameworks" title="Template talk:Python web frameworks"><abbr title="Discuss this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">t</abbr></a></li><li class="nv-edit"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Template:Python_web_frameworks&amp;action=edit"><abbr title="Edit this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">e</abbr></a></li></ul></div><div id="Python_web_frameworks" style="font-size:114%;margin:0 4em"><a class="mw-selflink selflink">Python</a> <a href="/wiki/Web_framework" title="Web framework">web frameworks</a></div></th></tr><tr><td colspan="2" class="navbox-list navbox-odd hlist" style="width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Zope#BlueBream" title="Zope">BlueBream</a></li>
<li><a href="/wiki/Bottle_(web_framework)" title="Bottle (web framework)">Bottle</a></li>
<li><a href="/wiki/CherryPy" title="CherryPy">CherryPy</a></li>
<li><a href="/wiki/Django_(web_framework)" title="Django (web framework)">Django</a></li>
<li><a href="/wiki/Flask_(web_framework)" title="Flask (web framework)">Flask</a></li>
<li><a href="/wiki/Grok_(web_framework)" title="Grok (web framework)">Grok</a></li>
<li><a href="/wiki/Nagare_(web_framework)" title="Nagare (web framework)">Nagare</a></li>
<li><a href="/wiki/Nevow" title="Nevow">Nevow</a></li>
<li><a href="/wiki/Pyjs" title="Pyjs">Pyjs</a></li>
<li><a href="/wiki/Pylons_project#Pylons_Framework" title="Pylons project">Pylons</a></li>
<li><a href="/wiki/Pylons_project#Pyramid" title="Pylons project">Pyramid</a></li>
<li><a href="/wiki/Quixote_(web_framework)" title="Quixote (web framework)">Quixote</a></li>
<li><a href="/wiki/Spyce_(software)" title="Spyce (software)">Spyce</a></li>
<li><a href="/wiki/TACTIC_(web_framework)" title="TACTIC (web framework)">TACTIC</a></li>
<li><a href="/wiki/Tornado_(web_server)" title="Tornado (web server)">Tornado</a></li>
<li><a href="/wiki/TurboGears" title="TurboGears">TurboGears</a></li>
<li><a href="/wiki/Twisted_(software)" title="Twisted (software)">TwistedWeb</a></li>
<li><a href="/wiki/Webware_for_Python" title="Webware for Python">Webware</a></li>
<li><a href="/wiki/Web2py" title="Web2py">web2py</a></li>
<li><a href="/wiki/Zope#Zope_2" title="Zope">Zope 2</a></li>
<li><i><a href="/wiki/Category:Python_web_frameworks" title="Category:Python web frameworks">more</a></i>...</li></ul>
</div></td></tr></tbody></table></div>
<div role="navigation" class="navbox" aria-labelledby="Free_and_open-source_software" style="padding:3px"><table class="nowraplinks hlist collapsible autocollapse navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th scope="col" class="navbox-title" colspan="2"><div class="plainlinks hlist navbar mini"><ul><li class="nv-view"><a href="/wiki/Template:FOSS" title="Template:FOSS"><abbr title="View this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">v</abbr></a></li><li class="nv-talk"><a href="/wiki/Template_talk:FOSS" title="Template talk:FOSS"><abbr title="Discuss this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">t</abbr></a></li><li class="nv-edit"><a class="external text" href="//en.wikipedia.org/w/index.php?title=Template:FOSS&amp;action=edit"><abbr title="Edit this template" style=";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;">e</abbr></a></li></ul></div><div id="Free_and_open-source_software" style="font-size:114%;margin:0 4em"><a href="/wiki/Free_and_open-source_software" title="Free and open-source software">Free and open-source software</a></div></th></tr><tr><th scope="row" class="navbox-group" style="width:1%">General</th><td class="navbox-list navbox-odd" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Alternative_terms_for_free_software" title="Alternative terms for free software">Alternative terms for free software</a></li>
<li><a href="/wiki/Comparison_of_open-source_and_closed-source_software" title="Comparison of open-source and closed-source software">Comparison of open-source and closed-source software</a></li>
<li><a href="/wiki/Comparison_of_source_code_hosting_facilities" title="Comparison of source code hosting facilities">Comparison of source code hosting facilities</a></li>
<li><a href="/wiki/Free_software" title="Free software">Free software</a></li>
<li><a href="/wiki/List_of_free_software_project_directories" title="List of free software project directories">Free software project directories</a></li>
<li><a href="/wiki/Gratis_versus_libre" title="Gratis versus libre">Gratis versus libre</a></li>
<li><a href="/wiki/Long-term_support" title="Long-term support">Long-term support</a></li>
<li><a href="/wiki/Open-source_software" title="Open-source software">Open-source software</a></li>
<li><a href="/wiki/Open-source_software_development" title="Open-source software development">Open-source software development</a></li>
<li><a href="/wiki/Outline_of_free_software" title="Outline of free software">Outline</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="/wiki/List_of_free_and_open-source_software_packages" title="List of free and open-source software packages">Software<br />packages</a></th><td class="navbox-list navbox-even" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Comparison_of_free_software_for_audio" title="Comparison of free software for audio">Audio</a></li>
<li><a href="/wiki/List_of_open-source_bioinformatics_software" title="List of open-source bioinformatics software">Bioinformatics</a></li>
<li><a href="/wiki/List_of_open-source_codecs" title="List of open-source codecs">Codecs</a></li>
<li><a href="/wiki/List_of_collaborative_software#Open_source_software" title="List of collaborative software">Collaboration</a></li>
<li><a href="/wiki/Comparison_of_open-source_configuration_management_software" title="Comparison of open-source configuration management software">Configuration management</a></li>
<li><a href="/wiki/Device_driver#Open_drivers" title="Device driver">Device drivers</a>
<ul><li><a href="/wiki/Free_and_open-source_graphics_device_driver" title="Free and open-source graphics device driver">Graphics</a></li>
<li><a href="/wiki/Comparison_of_open-source_wireless_drivers" title="Comparison of open-source wireless drivers">Wireless</a></li></ul></li>
<li><a href="/wiki/Comparison_of_free_geophysics_software" title="Comparison of free geophysics software">Geophysics</a></li>
<li><a href="/wiki/List_of_open-source_health_software" title="List of open-source health software">Health</a></li>
<li><a href="/wiki/List_of_open-source_software_for_mathematics" title="List of open-source software for mathematics">Mathematics</a></li>
<li><a href="/wiki/Comparison_of_open-source_operating_systems" title="Comparison of open-source operating systems">Operating systems</a></li>
<li><a href="/wiki/Comparison_of_open-source_programming_language_licensing" title="Comparison of open-source programming language licensing">Programming languages</a></li>
<li><a href="/wiki/List_of_open-source_routing_platforms" title="List of open-source routing platforms">Routing</a></li>
<li><a href="/wiki/List_of_statistical_packages#Open-source_statistical_packages" title="List of statistical packages">Statistics</a></li>
<li><a href="/wiki/List_of_free_television_software" title="List of free television software">Television</a></li>
<li><a href="/wiki/List_of_open-source_video_games" title="List of open-source video games">Video games</a></li>
<li><a href="/wiki/List_of_free_software_web_applications" title="List of free software web applications">Web applications</a>
<ul><li><a href="/wiki/List_of_content_management_systems#Open_source_software" title="List of content management systems">Content management systems</a></li>
<li><a href="/wiki/Comparison_of_shopping_cart_software" title="Comparison of shopping cart software">E-commerce</a></li></ul></li>
<li><a href="/wiki/List_of_word_processors#Free_and_open-source_software" title="List of word processors">Word processors</a></li>
<li><a href="/wiki/List_of_free_and_open-source_Android_applications" title="List of free and open-source Android applications">Android apps</a></li>
<li><a href="/wiki/List_of_free_and_open-source_iOS_applications" title="List of free and open-source iOS applications">iOS apps</a></li>
<li><a href="/wiki/List_of_commercial_open-source_applications_and_services" title="List of commercial open-source applications and services">Commercial</a></li>
<li><a href="/wiki/List_of_trademarked_open-source_software" title="List of trademarked open-source software">Trademarked</a></li>
<li><a href="/wiki/List_of_formerly_proprietary_software" title="List of formerly proprietary software">Formerly proprietary</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Community</th><td class="navbox-list navbox-odd" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Free_software_movement" title="Free software movement">Free software movement</a></li>
<li><a href="/wiki/History_of_free_and_open-source_software" title="History of free and open-source software">History</a></li>
<li><a href="/wiki/Open-source_software_movement" title="Open-source software movement">Open-source software movement</a></li>
<li><a href="/wiki/List_of_free_and_open-source_software_organizations" title="List of free and open-source software organizations">Organizations</a></li>
<li><a href="/wiki/List_of_free-software_events" title="List of free-software events">Events</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%"><a href="/wiki/Free_software_license" title="Free software license">Licenses</a></th><td class="navbox-list navbox-even" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Academic_Free_License" title="Academic Free License">AFL</a></li>
<li><a href="/wiki/Apache_License" title="Apache License">Apache</a></li>
<li><a href="/wiki/Apple_Public_Source_License" title="Apple Public Source License">APSL</a></li>
<li><a href="/wiki/Artistic_License" title="Artistic License">Artistic</a></li>
<li><a href="/wiki/Beerware" title="Beerware">Beerware</a></li>
<li><a href="/wiki/Boost_Software_License" class="mw-redirect" title="Boost Software License">Boost</a></li>
<li><a href="/wiki/BSD_licenses" title="BSD licenses">BSD</a></li>
<li><a href="/wiki/Creative_Commons_license#Zero_/_public_domain" title="Creative Commons license">CC0</a></li>
<li><a href="/wiki/Common_Development_and_Distribution_License" title="Common Development and Distribution License">CDDL</a></li>
<li><a href="/wiki/Eclipse_Public_License" title="Eclipse Public License">EPL</a></li>
<li><a href="/wiki/Free_Software_Foundation" title="Free Software Foundation">Free Software Foundation</a>
<ul><li><a href="/wiki/GNU_General_Public_License" title="GNU General Public License">GNU GPL</a></li>
<li><a href="/wiki/GNU_Lesser_General_Public_License" title="GNU Lesser General Public License">GNU LGPL</a></li></ul></li>
<li><a href="/wiki/ISC_license" title="ISC license">ISC</a></li>
<li><a href="/wiki/MIT_License" title="MIT License">MIT</a></li>
<li><a href="/wiki/Mozilla_Public_License" title="Mozilla Public License">MPL</a></li>
<li><a href="/wiki/Source-available_software#Open_Source_licenses" title="Source-available software">Ms-PL/RL</a></li>
<li><a href="/wiki/Python_License" title="Python License">Python</a></li>
<li><a href="/wiki/Python_Software_Foundation_License" title="Python Software Foundation License">Python Software Foundation License</a></li>
<li><a href="/wiki/Sleepycat_License" title="Sleepycat License">Sleepycat</a></li>
<li><a href="/wiki/Unlicense" title="Unlicense">Unlicense</a></li>
<li><a href="/wiki/WTFPL" title="WTFPL">WTFPL</a></li>
<li><a href="/wiki/Zlib_License" title="Zlib License">zlib</a></li></ul>
</div><table class="nowraplinks navbox-subgroup" style="border-spacing:0"><tbody><tr><th id="Types_and_standards" scope="row" class="navbox-group" style="width:1%">Types and<br /> standards</th><td class="navbox-list navbox-odd" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Comparison_of_free_and_open-source_software_licenses" title="Comparison of free and open-source software licenses">Comparison of free and open-source software licenses</a></li>
<li><a href="/wiki/Contributor_License_Agreement" title="Contributor License Agreement">Contributor License Agreement</a></li>
<li><a href="/wiki/Copyleft" title="Copyleft">Copyleft</a></li>
<li><a href="/wiki/Debian_Free_Software_Guidelines" title="Debian Free Software Guidelines">Debian Free Software Guidelines</a></li>
<li><a href="/wiki/Definition_of_Free_Cultural_Works" title="Definition of Free Cultural Works">Definition of Free Cultural Works</a></li>
<li><a href="/wiki/Free_license" title="Free license">Free license</a></li>
<li><a href="/wiki/The_Free_Software_Definition" title="The Free Software Definition">The Free Software Definition</a></li>
<li><a href="/wiki/The_Open_Source_Definition" title="The Open Source Definition">The Open Source Definition</a></li>
<li><a href="/wiki/Open-source_license" title="Open-source license">Open-source license</a></li>
<li><a href="/wiki/Permissive_software_licence" title="Permissive software licence">Permissive software licence</a></li>
<li><a href="/wiki/Public_domain" title="Public domain">Public domain</a></li>
<li><a href="/wiki/Viral_license" title="Viral license">Viral license</a></li></ul>
</div></td></tr></tbody></table><div>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Challenges</th><td class="navbox-list navbox-even" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Binary_blob" title="Binary blob">Binary blob</a></li>
<li><a href="/wiki/Digital_rights_management" title="Digital rights management">Digital rights management</a></li>
<li><a href="/wiki/Hardware_restriction" title="Hardware restriction">Hardware restrictions</a></li>
<li><a href="/wiki/License_proliferation" title="License proliferation">License proliferation</a></li>
<li><a href="/wiki/Mozilla_software_rebranded_by_Debian" title="Mozilla software rebranded by Debian">Mozilla software rebranding</a></li>
<li><a href="/wiki/Proprietary_software" title="Proprietary software">Proprietary software</a></li>
<li><a href="/wiki/SCO%E2%80%93Linux_disputes" title="SCO–Linux disputes">SCO/Linux controversies</a></li>
<li><a href="/wiki/UEFI_Secure_Boot#Secure_boot" class="mw-redirect" title="UEFI Secure Boot">Secure boot</a></li>
<li><a href="/wiki/Software_patents_and_free_software" title="Software patents and free software">Software patents</a></li>
<li><a href="/wiki/Open-source_software_security" title="Open-source software security">Software security</a></li>
<li><a href="/wiki/Trusted_Computing" title="Trusted Computing">Trusted Computing</a></li></ul>
</div></td></tr><tr><th scope="row" class="navbox-group" style="width:1%">Related topics</th><td class="navbox-list navbox-odd" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><a href="/wiki/Fork_(software_development)" title="Fork (software development)">Forking</a></li>
<li><i><a href="/wiki/GNU_Manifesto" title="GNU Manifesto">GNU Manifesto</a></i></li>
<li><a href="/wiki/Microsoft_Open_Specification_Promise" title="Microsoft Open Specification Promise">Microsoft Open Specification Promise</a></li>
<li><a href="/wiki/Open-core_model" title="Open-core model">Open-core model</a></li>
<li><a href="/wiki/Open-source_hardware" title="Open-source hardware">Open-source hardware</a></li>
<li><a href="/wiki/Shared_Source_Initiative" title="Shared Source Initiative">Shared Source Initiative</a></li>
<li><a href="/wiki/Source-available_software" title="Source-available software">Source-available software</a></li>
<li><i><a href="/wiki/The_Cathedral_and_the_Bazaar" title="The Cathedral and the Bazaar">The Cathedral and the Bazaar</a></i></li>
<li><i><a href="/wiki/Revolution_OS" title="Revolution OS">Revolution OS</a></i></li></ul>
</div></td></tr><tr><td class="navbox-abovebelow" colspan="2" style="font-weight:bold"><div>
<ul><li><img alt="Wikipedia book" src="//upload.wikimedia.org/wikipedia/commons/thumb/8/89/Symbol_book_class2.svg/16px-Symbol_book_class2.svg.png" title="Wikipedia book" width="16" height="16" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/8/89/Symbol_book_class2.svg/23px-Symbol_book_class2.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/8/89/Symbol_book_class2.svg/31px-Symbol_book_class2.svg.png 2x" data-file-width="180" data-file-height="185" /> <a href="/wiki/Book:Free_and_Open_Source_Software" title="Book:Free and Open Source Software">Book</a></li>
<li><img alt="Category" src="//upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/16px-Folder_Hexagonal_Icon.svg.png" title="Category" width="16" height="14" srcset="//upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/24px-Folder_Hexagonal_Icon.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/32px-Folder_Hexagonal_Icon.svg.png 2x" data-file-width="36" data-file-height="31" /> <a href="/wiki/Category:Free_software" title="Category:Free software">Category</a></li>
<li><img alt="Commons page" src="//upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/12px-Commons-logo.svg.png" title="Commons page" width="12" height="16" srcset="//upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/18px-Commons-logo.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/24px-Commons-logo.svg.png 2x" data-file-width="1024" data-file-height="1376" /> <a href="https://commons.wikimedia.org/wiki/Category:Free_software" class="extiw" title="commons:Category:Free software">Commons</a></li>
<li><img alt="Portal" src="//upload.wikimedia.org/wikipedia/en/thumb/f/fd/Portal-puzzle.svg/16px-Portal-puzzle.svg.png" title="Portal" width="16" height="14" srcset="//upload.wikimedia.org/wikipedia/en/thumb/f/fd/Portal-puzzle.svg/24px-Portal-puzzle.svg.png 1.5x, //upload.wikimedia.org/wikipedia/en/thumb/f/fd/Portal-puzzle.svg/32px-Portal-puzzle.svg.png 2x" data-file-width="32" data-file-height="28" /> <a href="/wiki/Portal:Free_and_open-source_software" title="Portal:Free and open-source software">Portal</a></li></ul>
</div></td></tr></tbody></table></div>
<div role="navigation" class="navbox" aria-labelledby="Authority_control_frameless_&amp;#124;text-top_&amp;#124;10px_&amp;#124;alt=Edit_this_at_Wikidata_&amp;#124;link=https&amp;#58;//www.wikidata.org/wiki/Q28865&amp;#124;Edit_this_at_Wikidata" style="padding:3px"><table class="nowraplinks hlist navbox-inner" style="border-spacing:0;background:transparent;color:inherit"><tbody><tr><th id="Authority_control_frameless_&amp;#124;text-top_&amp;#124;10px_&amp;#124;alt=Edit_this_at_Wikidata_&amp;#124;link=https&amp;#58;//www.wikidata.org/wiki/Q28865&amp;#124;Edit_this_at_Wikidata" scope="row" class="navbox-group" style="width:1%"><a href="/wiki/Help:Authority_control" title="Help:Authority control">Authority control</a> <a href="https://www.wikidata.org/wiki/Q28865" title="Edit this at Wikidata"><img alt="Edit this at Wikidata" src="//upload.wikimedia.org/wikipedia/commons/thumb/7/73/Blue_pencil.svg/10px-Blue_pencil.svg.png" width="10" height="10" style="vertical-align: text-top" srcset="//upload.wikimedia.org/wikipedia/commons/thumb/7/73/Blue_pencil.svg/15px-Blue_pencil.svg.png 1.5x, //upload.wikimedia.org/wikipedia/commons/thumb/7/73/Blue_pencil.svg/20px-Blue_pencil.svg.png 2x" data-file-width="600" data-file-height="600" /></a></th><td class="navbox-list navbox-odd" style="text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px"><div style="padding:0em 0.25em">
<ul><li><span class="nowrap"><a href="/wiki/Biblioth%C3%A8que_nationale_de_France" title="Bibliothèque nationale de France">BNF</a>: <span class="uid"><a rel="nofollow" class="external text" href="http://catalogue.bnf.fr/ark:/12148/cb13560465c">cb13560465c</a> <a rel="nofollow" class="external text" href="http://data.bnf.fr/ark:/12148/cb13560465c">(data)</a></span></span></li>
<li><span class="nowrap"><a href="/wiki/Integrated_Authority_File" title="Integrated Authority File">GND</a>: <span class="uid"><a rel="nofollow" class="external text" href="https://d-nb.info/gnd/4434275-5">4434275-5</a></span></span></li>
<li><span class="nowrap"><a href="/wiki/Library_of_Congress_Control_Number" title="Library of Congress Control Number">LCCN</a>: <span class="uid"><a rel="nofollow" class="external text" href="http://id.loc.gov/authorities/subjects/sh96008834">sh96008834</a></span></span></li>
<li><span class="nowrap"><a href="/wiki/Syst%C3%A8me_universitaire_de_documentation" title="Système universitaire de documentation">SUDOC</a>: <span class="uid"><a rel="nofollow" class="external text" href="https://www.idref.fr/051626225">051626225</a></span></span></li></ul>
</div></td></tr></tbody></table></div>
<p class="mw-empty-elt">

</p>
<!--
NewPP limit report
Parsed by mw1339
Cached time: 20180901132603
Cache expiry: 86400
Dynamic content: true
CPU time usage: 1.668 seconds
Real time usage: 1.834 seconds
Preprocessor visited node count: 9297/1000000
Preprocessor generated node count: 0/1500000
Post‐expand include size: 325244/2097152 bytes
Template argument size: 13445/2097152 bytes
Highest expansion depth: 21/40
Expensive parser function count: 16/500
Unstrip recursion depth: 0/20
Unstrip post‐expand size: 168432/5000000 bytes
Number of Wikibase entities loaded: 1/400
Lua time usage: 0.849/10.000 seconds
Lua memory usage: 7.26 MB/50 MB
-->
<!--
Transclusion expansion time report (%,ms,calls,template)
100.00% 1501.115      1 -total
 62.25%  934.404      1 Template:Reflist
 37.80%  567.419    141 Template:Cite_web
  7.01%  105.275      2 Template:Infobox
  6.87%  103.198     14 Template:Cite_book
  6.53%   97.954      1 Template:Infobox_programming_language
  3.86%   57.928      1 Template:Official_website
  3.13%   46.924      3 Template:Fix
  3.03%   45.504      5 Template:Navbox
  2.88%   43.261      1 Template:Pp-protected
-->
</div>
<!-- Saved in parser cache with key enwiki:pcache:idhash:23862-0!canonical and timestamp 20180901132603 and revision id 857558405
 -->
<noscript><img src="//en.wikipedia.org/wiki/Special:CentralAutoLogin/start?type=1x1" alt="" title="" width="1" height="1" style="border: none; position: absolute;" /></noscript></div>					<div class="printfooter">
						Retrieved from "<a dir="ltr" href="https://en.wikipedia.org/w/index.php?title=Python_(programming_language)&amp;oldid=857558405">https://en.wikipedia.org/w/index.php?title=Python_(programming_language)&amp;oldid=857558405</a>"					</div>
				<div id="catlinks" class="catlinks" data-mw="interface"><div id="mw-normal-catlinks" class="mw-normal-catlinks"><a href="/wiki/Help:Category" title="Help:Category">Categories</a>: <ul><li><a href="/wiki/Category:Programming_languages" title="Category:Programming languages">Programming languages</a></li><li><a href="/wiki/Category:Class-based_programming_languages" title="Category:Class-based programming languages">Class-based programming languages</a></li><li><a href="/wiki/Category:Computational_notebook" title="Category:Computational notebook">Computational notebook</a></li><li><a href="/wiki/Category:Computer_science_in_the_Netherlands" title="Category:Computer science in the Netherlands">Computer science in the Netherlands</a></li><li><a href="/wiki/Category:Cross-platform_free_software" title="Category:Cross-platform free software">Cross-platform free software</a></li><li><a href="/wiki/Category:Dutch_inventions" title="Category:Dutch inventions">Dutch inventions</a></li><li><a href="/wiki/Category:Dynamically_typed_programming_languages" title="Category:Dynamically typed programming languages">Dynamically typed programming languages</a></li><li><a href="/wiki/Category:Educational_programming_languages" title="Category:Educational programming languages">Educational programming languages</a></li><li><a href="/wiki/Category:High-level_programming_languages" title="Category:High-level programming languages">High-level programming languages</a></li><li><a href="/wiki/Category:Information_technology_in_the_Netherlands" title="Category:Information technology in the Netherlands">Information technology in the Netherlands</a></li><li><a href="/wiki/Category:Object-oriented_programming_languages" title="Category:Object-oriented programming languages">Object-oriented programming languages</a></li><li><a href="/wiki/Category:Programming_languages_created_in_1991" title="Category:Programming languages created in 1991">Programming languages created in 1991</a></li><li><a href="/wiki/Category:Python_(programming_language)" title="Category:Python (programming language)">Python (programming language)</a></li><li><a href="/wiki/Category:Scripting_languages" title="Category:Scripting languages">Scripting languages</a></li><li><a href="/wiki/Category:Text-oriented_programming_languages" title="Category:Text-oriented programming languages">Text-oriented programming languages</a></li><li><a href="/wiki/Category:Cross-platform_software" title="Category:Cross-platform software">Cross-platform software</a></li></ul></div><div id="mw-hidden-catlinks" class="mw-hidden-catlinks mw-hidden-cats-hidden">Hidden categories: <ul><li><a href="/wiki/Category:CS1_errors:_external_links" title="Category:CS1 errors: external links">CS1 errors: external links</a></li><li><a href="/wiki/Category:Wikipedia_semi-protected_pages" title="Category:Wikipedia semi-protected pages">Wikipedia semi-protected pages</a></li><li><a href="/wiki/Category:All_articles_with_unsourced_statements" title="Category:All articles with unsourced statements">All articles with unsourced statements</a></li><li><a href="/wiki/Category:Articles_with_unsourced_statements_from_October_2017" title="Category:Articles with unsourced statements from October 2017">Articles with unsourced statements from October 2017</a></li><li><a href="/wiki/Category:Wikipedia_articles_needing_clarification_from_May_2018" title="Category:Wikipedia articles needing clarification from May 2018">Wikipedia articles needing clarification from May 2018</a></li><li><a href="/wiki/Category:Articles_with_unsourced_statements_from_May_2018" title="Category:Articles with unsourced statements from May 2018">Articles with unsourced statements from May 2018</a></li><li><a href="/wiki/Category:Articles_containing_potentially_dated_statements_from_March_2018" title="Category:Articles containing potentially dated statements from March 2018">Articles containing potentially dated statements from March 2018</a></li><li><a href="/wiki/Category:All_articles_containing_potentially_dated_statements" title="Category:All articles containing potentially dated statements">All articles containing potentially dated statements</a></li><li><a href="/wiki/Category:Articles_containing_potentially_dated_statements_from_August_2016" title="Category:Articles containing potentially dated statements from August 2016">Articles containing potentially dated statements from August 2016</a></li><li><a href="/wiki/Category:Articles_containing_potentially_dated_statements_from_January_2018" title="Category:Articles containing potentially dated statements from January 2018">Articles containing potentially dated statements from January 2018</a></li><li><a href="/wiki/Category:Articles_with_Curlie_links" title="Category:Articles with Curlie links">Articles with Curlie links</a></li><li><a href="/wiki/Category:Wikipedia_articles_with_BNF_identifiers" title="Category:Wikipedia articles with BNF identifiers">Wikipedia articles with BNF identifiers</a></li><li><a href="/wiki/Category:Wikipedia_articles_with_GND_identifiers" title="Category:Wikipedia articles with GND identifiers">Wikipedia articles with GND identifiers</a></li><li><a href="/wiki/Category:Wikipedia_articles_with_LCCN_identifiers" title="Category:Wikipedia articles with LCCN identifiers">Wikipedia articles with LCCN identifiers</a></li><li><a href="/wiki/Category:Wikipedia_articles_with_SUDOC_identifiers" title="Category:Wikipedia articles with SUDOC identifiers">Wikipedia articles with SUDOC identifiers</a></li><li><a href="/wiki/Category:Good_articles" title="Category:Good articles">Good articles</a></li><li><a href="/wiki/Category:Use_dmy_dates_from_August_2015" title="Category:Use dmy dates from August 2015">Use dmy dates from August 2015</a></li></ul></div></div>				<div class="visualClear"></div>
							</div>
		</div>
		<div id="mw-navigation">
			<h2>Navigation menu</h2>
			<div id="mw-head">
									<div id="p-personal" role="navigation" class="" aria-labelledby="p-personal-label">
						<h3 id="p-personal-label">Personal tools</h3>
						<ul>
							<li id="pt-anonuserpage">Not logged in</li><li id="pt-anontalk"><a href="/wiki/Special:MyTalk" title="Discussion about edits from this IP address [n]" accesskey="n">Talk</a></li><li id="pt-anoncontribs"><a href="/wiki/Special:MyContributions" title="A list of edits made from this IP address [y]" accesskey="y">Contributions</a></li><li id="pt-createaccount"><a href="/w/index.php?title=Special:CreateAccount&amp;returnto=Python+%28programming+language%29" title="You are encouraged to create an account and log in; however, it is not mandatory">Create account</a></li><li id="pt-login"><a href="/w/index.php?title=Special:UserLogin&amp;returnto=Python+%28programming+language%29" title="You&#039;re encouraged to log in; however, it&#039;s not mandatory. [o]" accesskey="o">Log in</a></li>						</ul>
					</div>
									<div id="left-navigation">
										<div id="p-namespaces" role="navigation" class="vectorTabs" aria-labelledby="p-namespaces-label">
						<h3 id="p-namespaces-label">Namespaces</h3>
						<ul>
							<li id="ca-nstab-main" class="selected"><span><a href="/wiki/Python_(programming_language)" title="View the content page [c]" accesskey="c">Article</a></span></li><li id="ca-talk"><span><a href="/wiki/Talk:Python_(programming_language)" rel="discussion" title="Discussion about the content page [t]" accesskey="t">Talk</a></span></li>						</ul>
					</div>
										<div id="p-variants" role="navigation" class="vectorMenu emptyPortlet" aria-labelledby="p-variants-label">
												<input type="checkbox" class="vectorMenuCheckbox" aria-labelledby="p-variants-label" />
						<h3 id="p-variants-label">
							<span>Variants</span>
						</h3>
						<div class="menu">
							<ul>
															</ul>
						</div>
					</div>
									</div>
				<div id="right-navigation">
										<div id="p-views" role="navigation" class="vectorTabs" aria-labelledby="p-views-label">
						<h3 id="p-views-label">Views</h3>
						<ul>
							<li id="ca-view" class="collapsible selected"><span><a href="/wiki/Python_(programming_language)">Read</a></span></li><li id="ca-viewsource" class="collapsible"><span><a href="/w/index.php?title=Python_(programming_language)&amp;action=edit" title="This page is protected.&#10;You can view its source [e]" accesskey="e">View source</a></span></li><li id="ca-history" class="collapsible"><span><a href="/w/index.php?title=Python_(programming_language)&amp;action=history" title="Past revisions of this page [h]" accesskey="h">View history</a></span></li>						</ul>
					</div>
										<div id="p-cactions" role="navigation" class="vectorMenu emptyPortlet" aria-labelledby="p-cactions-label">
						<input type="checkbox" class="vectorMenuCheckbox" aria-labelledby="p-cactions-label" />
						<h3 id="p-cactions-label"><span>More</span></h3>
						<div class="menu">
							<ul>
															</ul>
						</div>
					</div>
										<div id="p-search" role="search">
						<h3>
							<label for="searchInput">Search</label>
						</h3>
						<form action="/w/index.php" id="searchform">
							<div id="simpleSearch">
								<input type="search" name="search" placeholder="Search Wikipedia" title="Search Wikipedia [f]" accesskey="f" id="searchInput"/><input type="hidden" value="Special:Search" name="title"/><input type="submit" name="fulltext" value="Search" title="Search Wikipedia for this text" id="mw-searchButton" class="searchButton mw-fallbackSearchButton"/><input type="submit" name="go" value="Go" title="Go to a page with this exact name if it exists" id="searchButton" class="searchButton"/>							</div>
						</form>
					</div>
									</div>
			</div>
			<div id="mw-panel">
				<div id="p-logo" role="banner"><a class="mw-wiki-logo" href="/wiki/Main_Page"  title="Visit the main page"></a></div>
						<div class="portal" role="navigation" id="p-navigation" aria-labelledby="p-navigation-label">
			<h3 id="p-navigation-label">Navigation</h3>
			<div class="body">
								<ul>
					<li id="n-mainpage-description"><a href="/wiki/Main_Page" title="Visit the main page [z]" accesskey="z">Main page</a></li><li id="n-contents"><a href="/wiki/Portal:Contents" title="Guides to browsing Wikipedia">Contents</a></li><li id="n-featuredcontent"><a href="/wiki/Portal:Featured_content" title="Featured content – the best of Wikipedia">Featured content</a></li><li id="n-currentevents"><a href="/wiki/Portal:Current_events" title="Find background information on current events">Current events</a></li><li id="n-randompage"><a href="/wiki/Special:Random" title="Load a random article [x]" accesskey="x">Random article</a></li><li id="n-sitesupport"><a href="https://donate.wikimedia.org/wiki/Special:FundraiserRedirector?utm_source=donate&amp;utm_medium=sidebar&amp;utm_campaign=C13_en.wikipedia.org&amp;uselang=en" title="Support us">Donate to Wikipedia</a></li><li id="n-shoplink"><a href="//shop.wikimedia.org" title="Visit the Wikipedia store">Wikipedia store</a></li>				</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id="p-interaction" aria-labelledby="p-interaction-label">
			<h3 id="p-interaction-label">Interaction</h3>
			<div class="body">
								<ul>
					<li id="n-help"><a href="/wiki/Help:Contents" title="Guidance on how to use and edit Wikipedia">Help</a></li><li id="n-aboutsite"><a href="/wiki/Wikipedia:About" title="Find out about Wikipedia">About Wikipedia</a></li><li id="n-portal"><a href="/wiki/Wikipedia:Community_portal" title="About the project, what you can do, where to find things">Community portal</a></li><li id="n-recentchanges"><a href="/wiki/Special:RecentChanges" title="A list of recent changes in the wiki [r]" accesskey="r">Recent changes</a></li><li id="n-contactpage"><a href="//en.wikipedia.org/wiki/Wikipedia:Contact_us" title="How to contact Wikipedia">Contact page</a></li>				</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id="p-tb" aria-labelledby="p-tb-label">
			<h3 id="p-tb-label">Tools</h3>
			<div class="body">
								<ul>
					<li id="t-whatlinkshere"><a href="/wiki/Special:WhatLinksHere/Python_(programming_language)" title="List of all English Wikipedia pages containing links to this page [j]" accesskey="j">What links here</a></li><li id="t-recentchangeslinked"><a href="/wiki/Special:RecentChangesLinked/Python_(programming_language)" rel="nofollow" title="Recent changes in pages linked from this page [k]" accesskey="k">Related changes</a></li><li id="t-upload"><a href="/wiki/Wikipedia:File_Upload_Wizard" title="Upload files [u]" accesskey="u">Upload file</a></li><li id="t-specialpages"><a href="/wiki/Special:SpecialPages" title="A list of all special pages [q]" accesskey="q">Special pages</a></li><li id="t-permalink"><a href="/w/index.php?title=Python_(programming_language)&amp;oldid=857558405" title="Permanent link to this revision of the page">Permanent link</a></li><li id="t-info"><a href="/w/index.php?title=Python_(programming_language)&amp;action=info" title="More information about this page">Page information</a></li><li id="t-wikibase"><a href="https://www.wikidata.org/wiki/Special:EntityPage/Q28865" title="Link to connected data repository item [g]" accesskey="g">Wikidata item</a></li><li id="t-cite"><a href="/w/index.php?title=Special:CiteThisPage&amp;page=Python_%28programming_language%29&amp;id=857558405" title="Information on how to cite this page">Cite this page</a></li>				</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id="p-coll-print_export" aria-labelledby="p-coll-print_export-label">
			<h3 id="p-coll-print_export-label">Print/export</h3>
			<div class="body">
								<ul>
					<li id="coll-create_a_book"><a href="/w/index.php?title=Special:Book&amp;bookcmd=book_creator&amp;referer=Python+%28programming+language%29">Create a book</a></li><li id="coll-download-as-rdf2latex"><a href="/w/index.php?title=Special:ElectronPdf&amp;page=Python+%28programming+language%29&amp;action=show-download-screen">Download as PDF</a></li><li id="t-print"><a href="/w/index.php?title=Python_(programming_language)&amp;printable=yes" title="Printable version of this page [p]" accesskey="p">Printable version</a></li>				</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id="p-wikibase-otherprojects" aria-labelledby="p-wikibase-otherprojects-label">
			<h3 id="p-wikibase-otherprojects-label">In other projects</h3>
			<div class="body">
								<ul>
					<li class="wb-otherproject-link wb-otherproject-commons"><a href="https://commons.wikimedia.org/wiki/Category:Python_(programming_language)" hreflang="en">Wikimedia Commons</a></li><li class="wb-otherproject-link wb-otherproject-wikibooks"><a href="https://en.wikibooks.org/wiki/Python_Programming" hreflang="en">Wikibooks</a></li><li class="wb-otherproject-link wb-otherproject-wikiquote"><a href="https://en.wikiquote.org/wiki/Python" hreflang="en">Wikiquote</a></li><li class="wb-otherproject-link wb-otherproject-wikiversity"><a href="https://en.wikiversity.org/wiki/Python" hreflang="en">Wikiversity</a></li>				</ul>
							</div>
		</div>
			<div class="portal" role="navigation" id="p-lang" aria-labelledby="p-lang-label">
			<h3 id="p-lang-label">Languages</h3>
			<div class="body">
								<ul>
					<li class="interlanguage-link interwiki-af"><a href="https://af.wikipedia.org/wiki/Python_(programmeertaal)" title="Python (programmeertaal) – Afrikaans" lang="af" hreflang="af" class="interlanguage-link-target">Afrikaans</a></li><li class="interlanguage-link interwiki-als"><a href="https://als.wikipedia.org/wiki/Python_(Programmiersprache)" title="Python (Programmiersprache) – Alemannisch" lang="als" hreflang="als" class="interlanguage-link-target">Alemannisch</a></li><li class="interlanguage-link interwiki-ar"><a href="https://ar.wikipedia.org/wiki/%D8%A8%D8%A7%D9%8A%D8%AB%D9%88%D9%86" title="بايثون – Arabic" lang="ar" hreflang="ar" class="interlanguage-link-target">العربية</a></li><li class="interlanguage-link interwiki-an"><a href="https://an.wikipedia.org/wiki/Python" title="Python – Aragonese" lang="an" hreflang="an" class="interlanguage-link-target">Aragonés</a></li><li class="interlanguage-link interwiki-as"><a href="https://as.wikipedia.org/wiki/%E0%A6%AA%E0%A6%BE%E0%A6%87%E0%A6%A5%E0%A6%A8" title="পাইথন – Assamese" lang="as" hreflang="as" class="interlanguage-link-target">অসমীয়া</a></li><li class="interlanguage-link interwiki-ast"><a href="https://ast.wikipedia.org/wiki/Python" title="Python – Asturian" lang="ast" hreflang="ast" class="interlanguage-link-target">Asturianu</a></li><li class="interlanguage-link interwiki-az"><a href="https://az.wikipedia.org/wiki/Python_(proqramla%C5%9Fd%C4%B1rma_dili)" title="Python (proqramlaşdırma dili) – Azerbaijani" lang="az" hreflang="az" class="interlanguage-link-target">Azərbaycanca</a></li><li class="interlanguage-link interwiki-azb"><a href="https://azb.wikipedia.org/wiki/%D9%BE%D8%A7%DB%8C%D8%AA%D9%88%D9%86" title="پایتون – South Azerbaijani" lang="azb" hreflang="azb" class="interlanguage-link-target">تۆرکجه</a></li><li class="interlanguage-link interwiki-bn"><a href="https://bn.wikipedia.org/wiki/%E0%A6%AA%E0%A6%BE%E0%A6%87%E0%A6%A5%E0%A6%A8_(%E0%A6%AA%E0%A7%8D%E0%A6%B0%E0%A7%8B%E0%A6%97%E0%A7%8D%E0%A6%B0%E0%A6%BE%E0%A6%AE%E0%A6%BF%E0%A6%82_%E0%A6%AD%E0%A6%BE%E0%A6%B7%E0%A6%BE)" title="পাইথন (প্রোগ্রামিং ভাষা) – Bangla" lang="bn" hreflang="bn" class="interlanguage-link-target">বাংলা</a></li><li class="interlanguage-link interwiki-zh-min-nan"><a href="https://zh-min-nan.wikipedia.org/wiki/Python" title="Python – Chinese (Min Nan)" lang="zh-min-nan" hreflang="zh-min-nan" class="interlanguage-link-target">Bân-lâm-gú</a></li><li class="interlanguage-link interwiki-be"><a href="https://be.wikipedia.org/wiki/Python_(%D0%BC%D0%BE%D0%B2%D0%B0_%D0%BF%D1%80%D0%B0%D0%B3%D1%80%D0%B0%D0%BC%D0%B0%D0%B2%D0%B0%D0%BD%D0%BD%D1%8F)" title="Python (мова праграмавання) – Belarusian" lang="be" hreflang="be" class="interlanguage-link-target">Беларуская</a></li><li class="interlanguage-link interwiki-bg"><a href="https://bg.wikipedia.org/wiki/Python" title="Python – Bulgarian" lang="bg" hreflang="bg" class="interlanguage-link-target">Български</a></li><li class="interlanguage-link interwiki-bs"><a href="https://bs.wikipedia.org/wiki/Python_(programski_jezik)" title="Python (programski jezik) – Bosnian" lang="bs" hreflang="bs" class="interlanguage-link-target">Bosanski</a></li><li class="interlanguage-link interwiki-ca"><a href="https://ca.wikipedia.org/wiki/Python" title="Python – Catalan" lang="ca" hreflang="ca" class="interlanguage-link-target">Català</a></li><li class="interlanguage-link interwiki-ceb"><a href="https://ceb.wikipedia.org/wiki/Python_(programming_language)" title="Python (programming language) – Cebuano" lang="ceb" hreflang="ceb" class="interlanguage-link-target">Cebuano</a></li><li class="interlanguage-link interwiki-cs"><a href="https://cs.wikipedia.org/wiki/Python" title="Python – Czech" lang="cs" hreflang="cs" class="interlanguage-link-target">Čeština</a></li><li class="interlanguage-link interwiki-da"><a href="https://da.wikipedia.org/wiki/Python_(programmeringssprog)" title="Python (programmeringssprog) – Danish" lang="da" hreflang="da" class="interlanguage-link-target">Dansk</a></li><li class="interlanguage-link interwiki-de badge-Q17437798 badge-goodarticle" title="good article"><a href="https://de.wikipedia.org/wiki/Python_(Programmiersprache)" title="Python (Programmiersprache) – German" lang="de" hreflang="de" class="interlanguage-link-target">Deutsch</a></li><li class="interlanguage-link interwiki-et"><a href="https://et.wikipedia.org/wiki/Python_(programmeerimiskeel)" title="Python (programmeerimiskeel) – Estonian" lang="et" hreflang="et" class="interlanguage-link-target">Eesti</a></li><li class="interlanguage-link interwiki-el"><a href="https://el.wikipedia.org/wiki/Python" title="Python – Greek" lang="el" hreflang="el" class="interlanguage-link-target">Ελληνικά</a></li><li class="interlanguage-link interwiki-es"><a href="https://es.wikipedia.org/wiki/Python" title="Python – Spanish" lang="es" hreflang="es" class="interlanguage-link-target">Español</a></li><li class="interlanguage-link interwiki-eo"><a href="https://eo.wikipedia.org/wiki/Python_(programlingvo)" title="Python (programlingvo) – Esperanto" lang="eo" hreflang="eo" class="interlanguage-link-target">Esperanto</a></li><li class="interlanguage-link interwiki-eu"><a href="https://eu.wikipedia.org/wiki/Python_(informatika)" title="Python (informatika) – Basque" lang="eu" hreflang="eu" class="interlanguage-link-target">Euskara</a></li><li class="interlanguage-link interwiki-fa"><a href="https://fa.wikipedia.org/wiki/%D9%BE%D8%A7%DB%8C%D8%AA%D9%88%D9%86_(%D8%B2%D8%A8%D8%A7%D9%86_%D8%A8%D8%B1%D9%86%D8%A7%D9%85%D9%87%E2%80%8C%D9%86%D9%88%DB%8C%D8%B3%DB%8C)" title="پایتون (زبان برنامه‌نویسی) – Persian" lang="fa" hreflang="fa" class="interlanguage-link-target">فارسی</a></li><li class="interlanguage-link interwiki-fr"><a href="https://fr.wikipedia.org/wiki/Python_(langage)" title="Python (langage) – French" lang="fr" hreflang="fr" class="interlanguage-link-target">Français</a></li><li class="interlanguage-link interwiki-gl"><a href="https://gl.wikipedia.org/wiki/Python" title="Python – Galician" lang="gl" hreflang="gl" class="interlanguage-link-target">Galego</a></li><li class="interlanguage-link interwiki-gu"><a href="https://gu.wikipedia.org/wiki/%E0%AA%AA%E0%AA%BE%E0%AA%AF%E0%AA%A5%E0%AB%8B%E0%AA%A8(%E0%AA%AA%E0%AB%8D%E0%AA%B0%E0%AB%8B%E0%AA%97%E0%AB%8D%E0%AA%B0%E0%AA%BE%E0%AA%AE%E0%AA%BF%E0%AA%82%E0%AA%97_%E0%AA%AD%E0%AA%BE%E0%AA%B7%E0%AA%BE)" title="પાયથોન(પ્રોગ્રામિંગ ભાષા) – Gujarati" lang="gu" hreflang="gu" class="interlanguage-link-target">ગુજરાતી</a></li><li class="interlanguage-link interwiki-ko"><a href="https://ko.wikipedia.org/wiki/%ED%8C%8C%EC%9D%B4%EC%8D%AC" title="파이썬 – Korean" lang="ko" hreflang="ko" class="interlanguage-link-target">한국어</a></li><li class="interlanguage-link interwiki-hy"><a href="https://hy.wikipedia.org/wiki/Python" title="Python – Armenian" lang="hy" hreflang="hy" class="interlanguage-link-target">Հայերեն</a></li><li class="interlanguage-link interwiki-hi"><a href="https://hi.wikipedia.org/wiki/%E0%A4%AA%E0%A4%BE%E0%A4%87%E0%A4%A5%E0%A4%A8" title="पाइथन – Hindi" lang="hi" hreflang="hi" class="interlanguage-link-target">हिन्दी</a></li><li class="interlanguage-link interwiki-hr"><a href="https://hr.wikipedia.org/wiki/Python_(programski_jezik)" title="Python (programski jezik) – Croatian" lang="hr" hreflang="hr" class="interlanguage-link-target">Hrvatski</a></li><li class="interlanguage-link interwiki-id"><a href="https://id.wikipedia.org/wiki/Python_(bahasa_pemrograman)" title="Python (bahasa pemrograman) – Indonesian" lang="id" hreflang="id" class="interlanguage-link-target">Bahasa Indonesia</a></li><li class="interlanguage-link interwiki-ia"><a href="https://ia.wikipedia.org/wiki/Python_(linguage_de_programmation)" title="Python (linguage de programmation) – Interlingua" lang="ia" hreflang="ia" class="interlanguage-link-target">Interlingua</a></li><li class="interlanguage-link interwiki-is"><a href="https://is.wikipedia.org/wiki/Python_(forritunarm%C3%A1l)" title="Python (forritunarmál) – Icelandic" lang="is" hreflang="is" class="interlanguage-link-target">Íslenska</a></li><li class="interlanguage-link interwiki-it"><a href="https://it.wikipedia.org/wiki/Python" title="Python – Italian" lang="it" hreflang="it" class="interlanguage-link-target">Italiano</a></li><li class="interlanguage-link interwiki-he"><a href="https://he.wikipedia.org/wiki/%D7%A4%D7%99%D7%99%D7%AA%D7%95%D7%9F" title="פייתון – Hebrew" lang="he" hreflang="he" class="interlanguage-link-target">עברית</a></li><li class="interlanguage-link interwiki-ka"><a href="https://ka.wikipedia.org/wiki/%E1%83%9E%E1%83%98%E1%83%97%E1%83%9D%E1%83%9C%E1%83%98_(%E1%83%9E%E1%83%A0%E1%83%9D%E1%83%92%E1%83%A0%E1%83%90%E1%83%9B%E1%83%98%E1%83%A0%E1%83%94%E1%83%91%E1%83%98%E1%83%A1_%E1%83%94%E1%83%9C%E1%83%90)" title="პითონი (პროგრამირების ენა) – Georgian" lang="ka" hreflang="ka" class="interlanguage-link-target">ქართული</a></li><li class="interlanguage-link interwiki-kk"><a href="https://kk.wikipedia.org/wiki/Python" title="Python – Kazakh" lang="kk" hreflang="kk" class="interlanguage-link-target">Қазақша</a></li><li class="interlanguage-link interwiki-ky"><a href="https://ky.wikipedia.org/wiki/Python" title="Python – Kyrgyz" lang="ky" hreflang="ky" class="interlanguage-link-target">Кыргызча</a></li><li class="interlanguage-link interwiki-la"><a href="https://la.wikipedia.org/wiki/Python_(lingua_programmandi)" title="Python (lingua programmandi) – Latin" lang="la" hreflang="la" class="interlanguage-link-target">Latina</a></li><li class="interlanguage-link interwiki-lv"><a href="https://lv.wikipedia.org/wiki/Python" title="Python – Latvian" lang="lv" hreflang="lv" class="interlanguage-link-target">Latviešu</a></li><li class="interlanguage-link interwiki-lt"><a href="https://lt.wikipedia.org/wiki/Python" title="Python – Lithuanian" lang="lt" hreflang="lt" class="interlanguage-link-target">Lietuvių</a></li><li class="interlanguage-link interwiki-jbo"><a href="https://jbo.wikipedia.org/wiki/paiton" title="paiton – Lojban" lang="jbo" hreflang="jbo" class="interlanguage-link-target">La .lojban.</a></li><li class="interlanguage-link interwiki-lmo"><a href="https://lmo.wikipedia.org/wiki/Python" title="Python – Lombard" lang="lmo" hreflang="lmo" class="interlanguage-link-target">Lumbaart</a></li><li class="interlanguage-link interwiki-hu"><a href="https://hu.wikipedia.org/wiki/Python_(programoz%C3%A1si_nyelv)" title="Python (programozási nyelv) – Hungarian" lang="hu" hreflang="hu" class="interlanguage-link-target">Magyar</a></li><li class="interlanguage-link interwiki-mk"><a href="https://mk.wikipedia.org/wiki/%D0%9F%D0%B0%D1%98%D1%82%D0%BE%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D1%81%D0%BA%D0%B8_%D1%98%D0%B0%D0%B7%D0%B8%D0%BA)" title="Пајтон (програмски јазик) – Macedonian" lang="mk" hreflang="mk" class="interlanguage-link-target">Македонски</a></li><li class="interlanguage-link interwiki-ml"><a href="https://ml.wikipedia.org/wiki/%E0%B4%AA%E0%B5%88%E0%B4%A4%E0%B5%8D%E0%B4%A4%E0%B5%BA_(%E0%B4%AA%E0%B5%8D%E0%B4%B0%E0%B5%8B%E0%B4%97%E0%B5%8D%E0%B4%B0%E0%B4%BE%E0%B4%AE%E0%B4%BF%E0%B4%99%E0%B5%8D%E0%B4%99%E0%B5%8D_%E0%B4%AD%E0%B4%BE%E0%B4%B7)" title="പൈത്തൺ (പ്രോഗ്രാമിങ്ങ് ഭാഷ) – Malayalam" lang="ml" hreflang="ml" class="interlanguage-link-target">മലയാളം</a></li><li class="interlanguage-link interwiki-mr"><a href="https://mr.wikipedia.org/wiki/%E0%A4%AA%E0%A4%BE%E0%A4%AF%E0%A4%A5%E0%A5%89%E0%A4%A8" title="पायथॉन – Marathi" lang="mr" hreflang="mr" class="interlanguage-link-target">मराठी</a></li><li class="interlanguage-link interwiki-ms"><a href="https://ms.wikipedia.org/wiki/Python" title="Python – Malay" lang="ms" hreflang="ms" class="interlanguage-link-target">Bahasa Melayu</a></li><li class="interlanguage-link interwiki-mn"><a href="https://mn.wikipedia.org/wiki/Python" title="Python – Mongolian" lang="mn" hreflang="mn" class="interlanguage-link-target">Монгол</a></li><li class="interlanguage-link interwiki-my"><a href="https://my.wikipedia.org/wiki/Python_(programming_language)" title="Python (programming language) – Burmese" lang="my" hreflang="my" class="interlanguage-link-target">မြန်မာဘာသာ</a></li><li class="interlanguage-link interwiki-nl"><a href="https://nl.wikipedia.org/wiki/Python_(programmeertaal)" title="Python (programmeertaal) – Dutch" lang="nl" hreflang="nl" class="interlanguage-link-target">Nederlands</a></li><li class="interlanguage-link interwiki-ne"><a href="https://ne.wikipedia.org/wiki/%E0%A4%AA%E0%A4%BE%E0%A4%87%E0%A4%A5%E0%A4%A8_%E0%A4%AA%E0%A5%8D%E0%A4%B0%E0%A5%8B%E0%A4%97%E0%A5%8D%E0%A4%B0%E0%A4%BE%E0%A4%AE%E0%A4%BF%E0%A4%99%E0%A5%8D%E0%A4%97_%E0%A4%AD%E0%A4%BE%E0%A4%B7%E0%A4%BE" title="पाइथन प्रोग्रामिङ्ग भाषा – Nepali" lang="ne" hreflang="ne" class="interlanguage-link-target">नेपाली</a></li><li class="interlanguage-link interwiki-ja"><a href="https://ja.wikipedia.org/wiki/Python" title="Python – Japanese" lang="ja" hreflang="ja" class="interlanguage-link-target">日本語</a></li><li class="interlanguage-link interwiki-no"><a href="https://no.wikipedia.org/wiki/Python" title="Python – Norwegian" lang="no" hreflang="no" class="interlanguage-link-target">Norsk</a></li><li class="interlanguage-link interwiki-nn"><a href="https://nn.wikipedia.org/wiki/Python" title="Python – Norwegian Nynorsk" lang="nn" hreflang="nn" class="interlanguage-link-target">Norsk nynorsk</a></li><li class="interlanguage-link interwiki-or"><a href="https://or.wikipedia.org/wiki/%E0%AC%AA%E0%AC%BE%E0%AC%87%E0%AC%A5%E0%AC%A8%E0%AD%8D_(%E0%AC%AA%E0%AD%8D%E0%AC%B0%E0%AD%8B%E0%AC%97%E0%AD%8D%E0%AC%B0%E0%AC%BE%E0%AC%AE%E0%AC%BF%E0%AC%82_%E0%AC%AD%E0%AC%BE%E0%AC%B7%E0%AC%BE)" title="ପାଇଥନ୍ (ପ୍ରୋଗ୍ରାମିଂ ଭାଷା) – Odia" lang="or" hreflang="or" class="interlanguage-link-target">ଓଡ଼ିଆ</a></li><li class="interlanguage-link interwiki-uz"><a href="https://uz.wikipedia.org/wiki/Python" title="Python – Uzbek" lang="uz" hreflang="uz" class="interlanguage-link-target">Oʻzbekcha/ўзбекча</a></li><li class="interlanguage-link interwiki-pnb"><a href="https://pnb.wikipedia.org/wiki/%D9%BE%D8%A7%D8%A6%DB%8C%D8%AA%DA%BE%D9%86_(%DA%A9%D9%85%D9%BE%DB%8C%D9%88%D9%B9%D8%B1_%D8%A8%D9%88%D9%84%DB%8C)" title="پائیتھن (کمپیوٹر بولی) – Western Punjabi" lang="pnb" hreflang="pnb" class="interlanguage-link-target">پنجابی</a></li><li class="interlanguage-link interwiki-km"><a href="https://km.wikipedia.org/wiki/%E1%9E%95%E1%9E%B6%E1%9E%99%E1%9E%90%E1%9E%BB%E1%9E%93" title="ផាយថុន – Khmer" lang="km" hreflang="km" class="interlanguage-link-target">ភាសាខ្មែរ</a></li><li class="interlanguage-link interwiki-nds"><a href="https://nds.wikipedia.org/wiki/Python_(Programmeerspraak)" title="Python (Programmeerspraak) – Low German" lang="nds" hreflang="nds" class="interlanguage-link-target">Plattdüütsch</a></li><li class="interlanguage-link interwiki-pl"><a href="https://pl.wikipedia.org/wiki/Python" title="Python – Polish" lang="pl" hreflang="pl" class="interlanguage-link-target">Polski</a></li><li class="interlanguage-link interwiki-pt"><a href="https://pt.wikipedia.org/wiki/Python" title="Python – Portuguese" lang="pt" hreflang="pt" class="interlanguage-link-target">Português</a></li><li class="interlanguage-link interwiki-ro"><a href="https://ro.wikipedia.org/wiki/Python" title="Python – Romanian" lang="ro" hreflang="ro" class="interlanguage-link-target">Română</a></li><li class="interlanguage-link interwiki-ru badge-Q17437796 badge-featuredarticle" title="featured article"><a href="https://ru.wikipedia.org/wiki/Python" title="Python – Russian" lang="ru" hreflang="ru" class="interlanguage-link-target">Русский</a></li><li class="interlanguage-link interwiki-sco"><a href="https://sco.wikipedia.org/wiki/Python_(programmin_leid)" title="Python (programmin leid) – Scots" lang="sco" hreflang="sco" class="interlanguage-link-target">Scots</a></li><li class="interlanguage-link interwiki-sq"><a href="https://sq.wikipedia.org/wiki/Python" title="Python – Albanian" lang="sq" hreflang="sq" class="interlanguage-link-target">Shqip</a></li><li class="interlanguage-link interwiki-si"><a href="https://si.wikipedia.org/wiki/%E0%B6%B4%E0%B6%BA%E0%B7%92%E0%B6%AD%E0%B6%B1%E0%B7%8A" title="පයිතන් – Sinhala" lang="si" hreflang="si" class="interlanguage-link-target">සිංහල</a></li><li class="interlanguage-link interwiki-simple"><a href="https://simple.wikipedia.org/wiki/Python_(programming_language)" title="Python (programming language) – Simple English" lang="simple" hreflang="simple" class="interlanguage-link-target">Simple English</a></li><li class="interlanguage-link interwiki-sk"><a href="https://sk.wikipedia.org/wiki/Python_(programovac%C3%AD_jazyk)" title="Python (programovací jazyk) – Slovak" lang="sk" hreflang="sk" class="interlanguage-link-target">Slovenčina</a></li><li class="interlanguage-link interwiki-sl"><a href="https://sl.wikipedia.org/wiki/Python_(programski_jezik)" title="Python (programski jezik) – Slovenian" lang="sl" hreflang="sl" class="interlanguage-link-target">Slovenščina</a></li><li class="interlanguage-link interwiki-ckb"><a href="https://ckb.wikipedia.org/wiki/%D9%BE%D8%A7%DB%8C%D8%AA%D9%86_(%D8%B2%D9%85%D8%A7%D9%86%DB%8C_%D8%A8%DB%95%D8%B1%D9%86%D8%A7%D9%85%DB%95%D8%B3%D8%A7%D8%B2%DB%8C)" title="پایتن (زمانی بەرنامەسازی) – Central Kurdish" lang="ckb" hreflang="ckb" class="interlanguage-link-target">کوردی</a></li><li class="interlanguage-link interwiki-sr"><a href="https://sr.wikipedia.org/wiki/%D0%9F%D0%B0%D1%98%D1%82%D0%BE%D0%BD_(%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D1%81%D0%BA%D0%B8_%D1%98%D0%B5%D0%B7%D0%B8%D0%BA)" title="Пајтон (програмски језик) – Serbian" lang="sr" hreflang="sr" class="interlanguage-link-target">Српски / srpski</a></li><li class="interlanguage-link interwiki-sh"><a href="https://sh.wikipedia.org/wiki/Python_programski_jezik" title="Python programski jezik – Serbo-Croatian" lang="sh" hreflang="sh" class="interlanguage-link-target">Srpskohrvatski / српскохрватски</a></li><li class="interlanguage-link interwiki-fi"><a href="https://fi.wikipedia.org/wiki/Python_(ohjelmointikieli)" title="Python (ohjelmointikieli) – Finnish" lang="fi" hreflang="fi" class="interlanguage-link-target">Suomi</a></li><li class="interlanguage-link interwiki-sv"><a href="https://sv.wikipedia.org/wiki/Python_(programspr%C3%A5k)" title="Python (programspråk) – Swedish" lang="sv" hreflang="sv" class="interlanguage-link-target">Svenska</a></li><li class="interlanguage-link interwiki-tl"><a href="https://tl.wikipedia.org/wiki/Python_(wikang_pamprograma)" title="Python (wikang pamprograma) – Tagalog" lang="tl" hreflang="tl" class="interlanguage-link-target">Tagalog</a></li><li class="interlanguage-link interwiki-ta"><a href="https://ta.wikipedia.org/wiki/%E0%AE%AA%E0%AF%88%E0%AE%A4%E0%AF%8D%E0%AE%A4%E0%AE%BE%E0%AE%A9%E0%AF%8D" title="பைத்தான் – Tamil" lang="ta" hreflang="ta" class="interlanguage-link-target">தமிழ்</a></li><li class="interlanguage-link interwiki-te"><a href="https://te.wikipedia.org/wiki/%E0%B0%AA%E0%B1%88%E0%B0%A5%E0%B0%BE%E0%B0%A8%E0%B1%8D_(%E0%B0%95%E0%B0%82%E0%B0%AA%E0%B1%8D%E0%B0%AF%E0%B1%82%E0%B0%9F%E0%B0%B0%E0%B1%8D_%E0%B0%AD%E0%B0%BE%E0%B0%B7)" title="పైథాన్ (కంప్యూటర్ భాష) – Telugu" lang="te" hreflang="te" class="interlanguage-link-target">తెలుగు</a></li><li class="interlanguage-link interwiki-th"><a href="https://th.wikipedia.org/wiki/%E0%B8%A0%E0%B8%B2%E0%B8%A9%E0%B8%B2%E0%B9%84%E0%B8%9E%E0%B8%97%E0%B8%AD%E0%B8%99" title="ภาษาไพทอน – Thai" lang="th" hreflang="th" class="interlanguage-link-target">ไทย</a></li><li class="interlanguage-link interwiki-tg"><a href="https://tg.wikipedia.org/wiki/Python" title="Python – Tajik" lang="tg" hreflang="tg" class="interlanguage-link-target">Тоҷикӣ</a></li><li class="interlanguage-link interwiki-tr"><a href="https://tr.wikipedia.org/wiki/Python_(programlama_dili)" title="Python (programlama dili) – Turkish" lang="tr" hreflang="tr" class="interlanguage-link-target">Türkçe</a></li><li class="interlanguage-link interwiki-bug"><a href="https://bug.wikipedia.org/wiki/Python" title="Python – Buginese" lang="bug" hreflang="bug" class="interlanguage-link-target">ᨅᨔ ᨕᨘᨁᨗ</a></li><li class="interlanguage-link interwiki-uk"><a href="https://uk.wikipedia.org/wiki/Python" title="Python – Ukrainian" lang="uk" hreflang="uk" class="interlanguage-link-target">Українська</a></li><li class="interlanguage-link interwiki-ur"><a href="https://ur.wikipedia.org/wiki/%D9%BE%D8%A7%D8%A6%DB%8C%D8%AA%DA%BE%D9%86_(%D9%BE%D8%B1%D9%88%DA%AF%D8%B1%D8%A7%D9%85%D9%86%DA%AF_%D8%B2%D8%A8%D8%A7%D9%86)" title="پائیتھن (پروگرامنگ زبان) – Urdu" lang="ur" hreflang="ur" class="interlanguage-link-target">اردو</a></li><li class="interlanguage-link interwiki-vi"><a href="https://vi.wikipedia.org/wiki/Python_(ng%C3%B4n_ng%E1%BB%AF_l%E1%BA%ADp_tr%C3%ACnh)" title="Python (ngôn ngữ lập trình) – Vietnamese" lang="vi" hreflang="vi" class="interlanguage-link-target">Tiếng Việt</a></li><li class="interlanguage-link interwiki-wuu"><a href="https://wuu.wikipedia.org/wiki/Python" title="Python – Wu Chinese" lang="wuu" hreflang="wuu" class="interlanguage-link-target">吴语</a></li><li class="interlanguage-link interwiki-zh-yue"><a href="https://zh-yue.wikipedia.org/wiki/Python" title="Python – Cantonese" lang="zh-yue" hreflang="zh-yue" class="interlanguage-link-target">粵語</a></li><li class="interlanguage-link interwiki-zh"><a href="https://zh.wikipedia.org/wiki/Python" title="Python – Chinese" lang="zh" hreflang="zh" class="interlanguage-link-target">中文</a></li>				</ul>
				<div class="after-portlet after-portlet-lang"><span class="wb-langlinks-edit wb-langlinks-link"><a href="https://www.wikidata.org/wiki/Special:EntityPage/Q28865#sitelinks-wikipedia" title="Edit interlanguage links" class="wbc-editpage">Edit links</a></span></div>			</div>
		</div>
				</div>
		</div>
				<div id="footer" role="contentinfo">
						<ul id="footer-info">
								<li id="footer-info-lastmod"> This page was last edited on 1 September 2018, at 13:26<span class="anonymous-show"> (UTC)</span>.</li>
								<li id="footer-info-copyright">Text is available under the <a rel="license" href="//en.wikipedia.org/wiki/Wikipedia:Text_of_Creative_Commons_Attribution-ShareAlike_3.0_Unported_License">Creative Commons Attribution-ShareAlike License</a><a rel="license" href="//creativecommons.org/licenses/by-sa/3.0/" style="display:none;"></a>;
additional terms may apply.  By using this site, you agree to the <a href="//wikimediafoundation.org/wiki/Terms_of_Use">Terms of Use</a> and <a href="//wikimediafoundation.org/wiki/Privacy_policy">Privacy Policy</a>. Wikipedia® is a registered trademark of the <a href="//www.wikimediafoundation.org/">Wikimedia Foundation, Inc.</a>, a non-profit organization.</li>
							</ul>
						<ul id="footer-places">
								<li id="footer-places-privacy"><a href="https://foundation.wikimedia.org/wiki/Privacy_policy" class="extiw" title="wmf:Privacy policy">Privacy policy</a></li>
								<li id="footer-places-about"><a href="/wiki/Wikipedia:About" title="Wikipedia:About">About Wikipedia</a></li>
								<li id="footer-places-disclaimer"><a href="/wiki/Wikipedia:General_disclaimer" title="Wikipedia:General disclaimer">Disclaimers</a></li>
								<li id="footer-places-contact"><a href="//en.wikipedia.org/wiki/Wikipedia:Contact_us">Contact Wikipedia</a></li>
								<li id="footer-places-developers"><a href="https://www.mediawiki.org/wiki/Special:MyLanguage/How_to_contribute">Developers</a></li>
								<li id="footer-places-cookiestatement"><a href="https://foundation.wikimedia.org/wiki/Cookie_statement">Cookie statement</a></li>
								<li id="footer-places-mobileview"><a href="//en.m.wikipedia.org/w/index.php?title=Python_(programming_language)&amp;mobileaction=toggle_view_mobile" class="noprint stopMobileRedirectToggle">Mobile view</a></li>
							</ul>
										<ul id="footer-icons" class="noprint">
										<li id="footer-copyrightico">
						<a href="https://wikimediafoundation.org/"><img src="/static/images/wikimedia-button.png" srcset="/static/images/wikimedia-button-1.5x.png 1.5x, /static/images/wikimedia-button-2x.png 2x" width="88" height="31" alt="Wikimedia Foundation"/></a>					</li>
										<li id="footer-poweredbyico">
						<a href="//www.mediawiki.org/"><img src="/static/images/poweredby_mediawiki_88x31.png" alt="Powered by MediaWiki" srcset="/static/images/poweredby_mediawiki_132x47.png 1.5x, /static/images/poweredby_mediawiki_176x62.png 2x" width="88" height="31"/></a>					</li>
									</ul>
						<div style="clear: both;"></div>
		</div>

<script>(window.RLQ=window.RLQ||[]).push(function(){mw.config.set({"wgPageParseReport":{"limitreport":{"cputime":"1.668","walltime":"1.834","ppvisitednodes":{"value":9297,"limit":1000000},"ppgeneratednodes":{"value":0,"limit":1500000},"postexpandincludesize":{"value":325244,"limit":2097152},"templateargumentsize":{"value":13445,"limit":2097152},"expansiondepth":{"value":21,"limit":40},"expensivefunctioncount":{"value":16,"limit":500},"unstrip-depth":{"value":0,"limit":20},"unstrip-size":{"value":168432,"limit":5000000},"entityaccesscount":{"value":1,"limit":400},"timingprofile":["100.00% 1501.115      1 -total"," 62.25%  934.404      1 Template:Reflist"," 37.80%  567.419    141 Template:Cite_web","  7.01%  105.275      2 Template:Infobox","  6.87%  103.198     14 Template:Cite_book","  6.53%   97.954      1 Template:Infobox_programming_language","  3.86%   57.928      1 Template:Official_website","  3.13%   46.924      3 Template:Fix","  3.03%   45.504      5 Template:Navbox","  2.88%   43.261      1 Template:Pp-protected"]},"scribunto":{"limitreport-timeusage":{"value":"0.849","limit":"10.000"},"limitreport-memusage":{"value":7617187,"limit":52428800}},"cachereport":{"origin":"mw1339","timestamp":"20180901132603","ttl":86400,"transientcontent":true}}});mw.config.set({"wgBackendResponseTime":99,"wgHostname":"mw1257"});});</script>
	</body>
</html>
setuptools-rust-1.2.0/examples/html-py-ever/test/run_all.py000077500000000000000000000034331421635746700241070ustar00rootroot00000000000000#!/usr/bin/env python3 import os from glob import glob from time import perf_counter from typing import Tuple import html_py_ever from bs4 import BeautifulSoup try: import lxml HAVE_LXML = True except ImportError: HAVE_LXML = False def rust(filename: str) -> Tuple[int, float, float]: start_load = perf_counter() doc = html_py_ever.parse_file(filename) end_load = perf_counter() start_search = perf_counter() links = doc.select("a[href]") end_search = perf_counter() return len(links), end_load - start_load, end_search - start_search def python(filename: str, parser: str) -> Tuple[int, float, float]: start_load = perf_counter() with open(filename, encoding="utf8") as fp: soup = BeautifulSoup(fp, parser) end_load = perf_counter() start_search = perf_counter() links = soup.select("a[href]") end_search = perf_counter() return len(links), end_load - start_load, end_search - start_search def main(): files_glob = os.path.abspath(os.path.join(os.path.dirname(__file__), "*.html")) for filename in glob(files_glob): count_rs, parse_rs, select_rs = rust(filename) count_py, parse_py, select_py = python(filename, "html.parser") assert count_rs == count_py print(f"{filename} {count_rs} {parse_rs:6f}s") print(f"Parse py {parse_py:6f}s {parse_py/parse_rs:6.3f}x") print(f"Select py {select_py:6f}s {select_py/select_rs:6.3f}x") if HAVE_LXML: count_lxml, parse_lxml, select_lxml = python(filename, "lxml") assert count_rs == count_lxml print(f"Parse lxml {parse_lxml:6f}s {parse_lxml/parse_rs:6.3f}x") print(f"Select lxml {select_lxml:6f}s {select_lxml/select_rs:6.3f}x") if __name__ == "__main__": main() setuptools-rust-1.2.0/examples/html-py-ever/test/rust.html000066400000000000000000025116301421635746700237660ustar00rootroot00000000000000 Rust - Wikidata

Rust (Q575650)

From Wikidata
Jump to navigation Jump to search
systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety
  • Rust language
  • Rustlang
edit
Language Label Description Also known as
English
Rust
systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety
  • Rust language
  • Rustlang

Statements

named after
Pucciniales
0 references
influenced by
Alef
1 reference
reference URL
https://doc.rust-lang.org/reference/influences.html
retrieved
28 January 2018
title
Appendix: Influences - The Rust Reference (English)
C++
0 references
C♯
0 references
Camlp4
0 references
Common Lisp
0 references
Cyclone
0 references
Erlang
0 references
Haskell
0 references
Hermes
0 references
Limbo
0 references
Napier88
0 references
Newsqueak
0 references
OCaml
0 references
Racket
0 references
NIL
0 references
Ruby
0 references
Sather
0 references
Scheme
0 references
Standard ML
0 references
Swift
0 references
Python
0 references
Clean
0 references
C
0 references
software version
0.7
publication date
3 July 2013
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/0.7
publication date
3 July 2013
title
Release 0.7 (English)
retrieved
23 July 2018
0.8
publication date
27 September 2013
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/0.8
publication date
27 September 2013
title
Release 0.8 (English)
retrieved
23 July 2018
0.9
publication date
9 January 2014
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/0.9
publication date
9 January 2014
title
Release 0.9 (English)
retrieved
23 July 2018
0.10
publication date
3 April 2014
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/0.10
publication date
3 April 2014
title
Release 0.10 (English)
retrieved
23 July 2018
0.11.0
publication date
2 July 2014
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/0.11.0
publication date
2 July 2014
title
Release 0.11.0 (English)
retrieved
23 July 2018
0.12.0
publication date
9 October 2014
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/0.12.0
publication date
9 October 2014
title
Release 0.12.0 (English)
retrieved
23 July 2018
1.22.0
publication date
22 November 2017
version type
stable version
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/1.22.0
publication date
22 November 2017
title
Release 1.22.0 (English)
retrieved
23 July 2018
1.23.0
publication date
4 January 2018
version type
stable version
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/1.23.0
publication date
4 January 2018
title
Release 1.23.0 (English)
retrieved
23 July 2018
1.24.0
publication date
15 February 2018
version type
stable version
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/1.24.0
publication date
15 February 2018
title
Release 1.24.0 (English)
retrieved
23 July 2018
1.25.0
publication date
29 March 2018
version type
stable version
1 reference
reference URL
https://github.com/rust-lang/rust/releases/tag/1.25.0
publication date
29 March 2018
title
Release 1.25.0 (English)
retrieved
23 July 2018
Twitter hashtag
rustlang
0 references
file extension
rs
media type
text/x-rust
0 references
rlib
0 references
different from
Rust
0 references

Identifiers

Free Software Directory entry
Rust
1 reference
retrieved
5 October 2016
GND ID
1078438080
0 references
Twitter username
rustlang
number of subscribers
29,546
1 reference
retrieved
10 May 2018
Arch Linux package
rust
0 references
GitHub username
rust-lang
0 references
Ubuntu package
rustc
0 references
Fedora package
rust
0 references
subreddit
rust
0 references
 

Sitelinks

edit
edit
edit
    edit
      edit
        edit
          edit
            edit
              edit
                Retrieved from "https://www.wikidata.org/w/index.php?title=Q575650&oldid=720139361"
                setuptools-rust-1.2.0/examples/html-py-ever/test/small.html000066400000000000000000000001731421635746700240720ustar00rootroot00000000000000 Title setuptools-rust-1.2.0/examples/html-py-ever/test/test_parsing.py000077500000000000000000000013351421635746700251540ustar00rootroot00000000000000#!/usr/bin/env python from glob import glob import os import html_py_ever import pytest from bs4 import BeautifulSoup from html_py_ever import Document HTML_FILES = glob(os.path.join(os.path.dirname(__file__), "*.html")) def rust(filename: str) -> Document: return html_py_ever.parse_file(filename) def python(filename: str) -> BeautifulSoup: with open(filename, encoding="utf8") as fp: soup = BeautifulSoup(fp, "html.parser") return soup @pytest.mark.parametrize("filename", HTML_FILES) def test_bench_parsing_rust(benchmark, filename): benchmark(rust, filename) @pytest.mark.parametrize("filename", HTML_FILES) def test_bench_parsing_python(benchmark, filename): benchmark(python, filename) setuptools-rust-1.2.0/examples/html-py-ever/test/test_selector.py000077500000000000000000000011551421635746700253310ustar00rootroot00000000000000#!/usr/bin/env python from glob import glob import os import html_py_ever import pytest from bs4 import BeautifulSoup HTML_FILES = glob(os.path.join(os.path.dirname(__file__), "*.html")) @pytest.mark.parametrize("filename", HTML_FILES) def test_bench_selector_rust(benchmark, filename): document = html_py_ever.parse_file(filename) benchmark(document.select, "a[href]") @pytest.mark.parametrize("filename", HTML_FILES) def test_bench_selector_python(benchmark, filename): with open(filename, encoding="utf8") as fp: soup = BeautifulSoup(fp, "html.parser") benchmark(soup.select, "a[href]") setuptools-rust-1.2.0/examples/namespace_package/000077500000000000000000000000001421635746700221725ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/.cargo/000077500000000000000000000000001421635746700233435ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/.cargo/config.toml000066400000000000000000000003401421635746700255020ustar00rootroot00000000000000[target.x86_64-apple-darwin] rustflags = [ "-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup", ] [target.aarch64-apple-darwin] rustflags = [ "-C", "link-arg=-undefined", "-C", "link-arg=dynamic_lookup", ] setuptools-rust-1.2.0/examples/namespace_package/Cargo.lock000066400000000000000000000134561421635746700241100ustar00rootroot00000000000000# This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 3 [[package]] name = "bitflags" version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "cfg-if" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "indoc" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7906a9fababaeacb774f72410e497a1d18de916322e33797bb2cd29baa23c9e" dependencies = [ "unindent", ] [[package]] name = "instant" version = "0.1.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" dependencies = [ "cfg-if", ] [[package]] name = "libc" version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f" [[package]] name = "lock_api" version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b" dependencies = [ "scopeguard", ] [[package]] name = "namespace_package_rust" version = "0.1.0" dependencies = [ "pyo3", ] [[package]] name = "once_cell" version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9" [[package]] name = "parking_lot" version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" dependencies = [ "instant", "lock_api", "parking_lot_core", ] [[package]] name = "parking_lot_core" version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216" dependencies = [ "cfg-if", "instant", "libc", "redox_syscall", "smallvec", "winapi", ] [[package]] name = "proc-macro2" version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" dependencies = [ "unicode-xid", ] [[package]] name = "pyo3" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a378727d5fdcaafd15b5afe9842cff1c25fdc43f62a162ffda2263c57ad98703" dependencies = [ "cfg-if", "indoc", "libc", "parking_lot", "pyo3-build-config", "pyo3-ffi", "pyo3-macros", "unindent", ] [[package]] name = "pyo3-build-config" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fbb27a3e96edd34c13d97d0feefccc90a79270c577c66e19d95af8323823dfc" dependencies = [ "once_cell", ] [[package]] name = "pyo3-ffi" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b719fff844bcf3f911132112ec06527eb195f6a98e0c42cf97e1118929fd4ea" dependencies = [ "libc", "pyo3-build-config", ] [[package]] name = "pyo3-macros" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f795e52d3320abb349ca28b501a7112154a87f353fae1c811deecd58e99cfa9b" dependencies = [ "proc-macro2", "pyo3-macros-backend", "quote", "syn", ] [[package]] name = "pyo3-macros-backend" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39e03aa57a3bb7b96982958088df38302a139df4eef54671bc595f26556cb75b" dependencies = [ "proc-macro2", "pyo3-build-config", "quote", "syn", ] [[package]] name = "quote" version = "1.0.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4af2ec4714533fcdf07e886f17025ace8b997b9ce51204ee69b6da831c3da57" dependencies = [ "proc-macro2", ] [[package]] name = "redox_syscall" version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c" dependencies = [ "bitflags", ] [[package]] name = "scopeguard" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" [[package]] name = "smallvec" version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83" [[package]] name = "syn" version = "1.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ea297be220d52398dcc07ce15a209fce436d361735ac1db700cab3b6cdfb9f54" dependencies = [ "proc-macro2", "quote", "unicode-xid", ] [[package]] name = "unicode-xid" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" [[package]] name = "unindent" version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "514672a55d7380da379785a4d70ca8386c8883ff7eaae877be4d2081cebe73d8" [[package]] name = "winapi" version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" dependencies = [ "winapi-i686-pc-windows-gnu", "winapi-x86_64-pc-windows-gnu", ] [[package]] name = "winapi-i686-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" setuptools-rust-1.2.0/examples/namespace_package/Cargo.toml000066400000000000000000000002731421635746700241240ustar00rootroot00000000000000[package] name = "namespace_package_rust" version = "0.1.0" edition = "2018" [lib] crate-type = ["cdylib"] [dependencies] pyo3 = { version = "0.16.2", features = ["extension-module"] } setuptools-rust-1.2.0/examples/namespace_package/Cross.toml000066400000000000000000000002551421635746700241620ustar00rootroot00000000000000[target.aarch64-unknown-linux-gnu] image = "cross-pyo3:aarch64-unknown-linux-gnu" [build.env] passthrough = [ "RUST_BACKTRACE", "RUST_LOG", "PYO3_CROSS_LIB_DIR", ] setuptools-rust-1.2.0/examples/namespace_package/Dockerfile000066400000000000000000000006551421635746700241720ustar00rootroot00000000000000FROM quay.io/pypa/manylinux2014_aarch64 AS manylinux FROM ghcr.io/cross-rs/aarch64-unknown-linux-gnu:edge RUN curl -L https://github.com/indygreg/python-build-standalone/releases/download/20220318/cpython-3.8.13+20220318-x86_64-unknown-linux-gnu-install_only.tar.gz | tar -xz -C /usr/local ENV PATH=/usr/local/python/bin:$PATH COPY --from=manylinux /opt/_internal /opt/_internal COPY --from=manylinux /opt/python /opt/python setuptools-rust-1.2.0/examples/namespace_package/MANIFEST.in000066400000000000000000000000531421635746700237260ustar00rootroot00000000000000include Cargo.toml recursive-include src * setuptools-rust-1.2.0/examples/namespace_package/namespace_package/000077500000000000000000000000001421635746700256015ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/namespace_package/python/000077500000000000000000000000001421635746700271225ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/namespace_package/python/__init__.py000066400000000000000000000000411421635746700312260ustar00rootroot00000000000000def python_func(): return 15 setuptools-rust-1.2.0/examples/namespace_package/noxfile.py000066400000000000000000000004041421635746700242060ustar00rootroot00000000000000from os.path import dirname import nox SETUPTOOLS_RUST = dirname(dirname(dirname(__file__))) @nox.session() def test(session: nox.Session): session.install(SETUPTOOLS_RUST, "pytest") session.install(".") session.run("pytest", *session.posargs) setuptools-rust-1.2.0/examples/namespace_package/pytest.ini000066400000000000000000000000001421635746700242110ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/setup.py000066400000000000000000000007001421635746700237010ustar00rootroot00000000000000from setuptools import setup, find_namespace_packages from setuptools_rust import Binding, RustExtension setup( name="namespace_package", version="0.1.0", packages=find_namespace_packages(include=["namespace_package.*"]), zip_safe=False, rust_extensions=[ RustExtension( "namespace_package.rust", path="Cargo.toml", binding=Binding.PyO3, debug=False, ) ], ) setuptools-rust-1.2.0/examples/namespace_package/src/000077500000000000000000000000001421635746700227615ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/src/lib.rs000066400000000000000000000004141421635746700240740ustar00rootroot00000000000000use pyo3::prelude::*; use pyo3::wrap_pyfunction; #[pyfunction] fn rust_func() -> usize { 14 } /// A Python module implemented in Rust. #[pymodule] fn rust(py: Python, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pyfunction!(rust_func))?; Ok(()) } setuptools-rust-1.2.0/examples/namespace_package/tests/000077500000000000000000000000001421635746700233345ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/namespace_package/tests/test_namespace_package.py000066400000000000000000000002311421635746700303500ustar00rootroot00000000000000from namespace_package import rust, python def test_rust(): assert rust.rust_func() == 14 def test_cffi(): assert python.python_func() == 15 setuptools-rust-1.2.0/examples/rust_with_cffi/000077500000000000000000000000001421635746700216025ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/rust_with_cffi/Cargo.lock000066400000000000000000000134461421635746700235170ustar00rootroot00000000000000# This file is automatically @generated by Cargo. # It is not intended for manual editing. version = 3 [[package]] name = "bitflags" version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" [[package]] name = "cfg-if" version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" [[package]] name = "indoc" version = "1.0.4" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e7906a9fababaeacb774f72410e497a1d18de916322e33797bb2cd29baa23c9e" dependencies = [ "unindent", ] [[package]] name = "instant" version = "0.1.12" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" dependencies = [ "cfg-if", ] [[package]] name = "libc" version = "0.2.121" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "efaa7b300f3b5fe8eb6bf21ce3895e1751d9665086af2d64b42f19701015ff4f" [[package]] name = "lock_api" version = "0.4.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "88943dd7ef4a2e5a4bfa2753aaab3013e34ce2533d1996fb18ef591e315e2b3b" dependencies = [ "scopeguard", ] [[package]] name = "once_cell" version = "1.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "87f3e037eac156d1775da914196f0f37741a274155e34a0b7e427c35d2a2ecb9" [[package]] name = "parking_lot" version = "0.11.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7d17b78036a60663b797adeaee46f5c9dfebb86948d1255007a1d6be0271ff99" dependencies = [ "instant", "lock_api", "parking_lot_core", ] [[package]] name = "parking_lot_core" version = "0.8.5" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d76e8e1493bcac0d2766c42737f34458f1c8c50c0d23bcb24ea953affb273216" dependencies = [ "cfg-if", "instant", "libc", "redox_syscall", "smallvec", "winapi", ] [[package]] name = "proc-macro2" version = "1.0.36" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c7342d5883fbccae1cc37a2353b09c87c9b0f3afd73f5fb9bba687a1f733b029" dependencies = [ "unicode-xid", ] [[package]] name = "pyo3" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "a378727d5fdcaafd15b5afe9842cff1c25fdc43f62a162ffda2263c57ad98703" dependencies = [ "cfg-if", "indoc", "libc", "parking_lot", "pyo3-build-config", "pyo3-ffi", "pyo3-macros", "unindent", ] [[package]] name = "pyo3-build-config" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "4fbb27a3e96edd34c13d97d0feefccc90a79270c577c66e19d95af8323823dfc" dependencies = [ "once_cell", ] [[package]] name = "pyo3-ffi" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7b719fff844bcf3f911132112ec06527eb195f6a98e0c42cf97e1118929fd4ea" dependencies = [ "libc", "pyo3-build-config", ] [[package]] name = "pyo3-macros" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f795e52d3320abb349ca28b501a7112154a87f353fae1c811deecd58e99cfa9b" dependencies = [ "proc-macro2", "pyo3-macros-backend", "quote", "syn", ] [[package]] name = "pyo3-macros-backend" version = "0.16.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "39e03aa57a3bb7b96982958088df38302a139df4eef54671bc595f26556cb75b" dependencies = [ "proc-macro2", "pyo3-build-config", "quote", "syn", ] [[package]] name = "quote" version = "1.0.16" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b4af2ec4714533fcdf07e886f17025ace8b997b9ce51204ee69b6da831c3da57" dependencies = [ "proc-macro2", ] [[package]] name = "redox_syscall" version = "0.2.11" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8380fe0152551244f0747b1bf41737e0f8a74f97a14ccefd1148187271634f3c" dependencies = [ "bitflags", ] [[package]] name = "rust_with_cffi" version = "0.1.0" dependencies = [ "pyo3", ] [[package]] name = "scopeguard" version = "1.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd" [[package]] name = "smallvec" version = "1.8.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f2dd574626839106c320a323308629dcb1acfc96e32a8cba364ddc61ac23ee83" [[package]] name = "syn" version = "1.0.89" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ea297be220d52398dcc07ce15a209fce436d361735ac1db700cab3b6cdfb9f54" dependencies = [ "proc-macro2", "quote", "unicode-xid", ] [[package]] name = "unicode-xid" version = "0.2.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8ccb82d61f80a663efe1f787a51b16b5a51e3314d6ac365b08639f52387b33f3" [[package]] name = "unindent" version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "514672a55d7380da379785a4d70ca8386c8883ff7eaae877be4d2081cebe73d8" [[package]] name = "winapi" version = "0.3.9" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" dependencies = [ "winapi-i686-pc-windows-gnu", "winapi-x86_64-pc-windows-gnu", ] [[package]] name = "winapi-i686-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" [[package]] name = "winapi-x86_64-pc-windows-gnu" version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" setuptools-rust-1.2.0/examples/rust_with_cffi/Cargo.toml000066400000000000000000000003751421635746700235370ustar00rootroot00000000000000[package] name = "rust_with_cffi" version = "0.1.0" authors = ["Alex Gaynor "] edition = "2018" [dependencies] pyo3 = { version = "0.16.2", features = ["extension-module"] } [lib] name = "rust_with_cffi" crate-type = ["cdylib"] setuptools-rust-1.2.0/examples/rust_with_cffi/MANIFEST.in000066400000000000000000000001021421635746700233310ustar00rootroot00000000000000include Cargo.toml include cffi_module.py recursive-include src * setuptools-rust-1.2.0/examples/rust_with_cffi/cffi_module.py000066400000000000000000000002521421635746700244270ustar00rootroot00000000000000import cffi ffi = cffi.FFI() ffi.cdef( """ int cffi_func(void); """ ) ffi.set_source( "rust_with_cffi.cffi", """ int cffi_func(void) { return 15; } """, ) setuptools-rust-1.2.0/examples/rust_with_cffi/noxfile.py000066400000000000000000000004141421635746700236170ustar00rootroot00000000000000from os.path import dirname import nox SETUPTOOLS_RUST = dirname(dirname(dirname(__file__))) @nox.session() def test(session: nox.Session): session.install(SETUPTOOLS_RUST, "pytest", "cffi") session.install(".") session.run("pytest", *session.posargs) setuptools-rust-1.2.0/examples/rust_with_cffi/pytest.ini000066400000000000000000000000001421635746700236210ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/rust_with_cffi/rust_with_cffi/000077500000000000000000000000001421635746700246215ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/rust_with_cffi/rust_with_cffi/__init__.py000066400000000000000000000000001421635746700267200ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/rust_with_cffi/setup.py000066400000000000000000000014261421635746700233170ustar00rootroot00000000000000#!/usr/bin/env python import platform import sys from setuptools import setup from setuptools_rust import RustExtension setup( name="rust-with-cffi", version="0.1.0", classifiers=[ "License :: OSI Approved :: MIT License", "Development Status :: 3 - Alpha", "Intended Audience :: Developers", "Programming Language :: Python", "Programming Language :: Rust", "Operating System :: POSIX", "Operating System :: MacOS :: MacOS X", ], packages=["rust_with_cffi"], rust_extensions=[ RustExtension("rust_with_cffi.rust", py_limited_api="auto"), ], cffi_modules=["cffi_module.py:ffi"], install_requires=["cffi"], setup_requires=["cffi"], include_package_data=True, zip_safe=False, ) setuptools-rust-1.2.0/examples/rust_with_cffi/src/000077500000000000000000000000001421635746700223715ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/rust_with_cffi/src/lib.rs000066400000000000000000000003701421635746700235050ustar00rootroot00000000000000use pyo3::prelude::*; use pyo3::wrap_pyfunction; #[pyfunction] fn rust_func() -> PyResult { return Ok(14); } #[pymodule] fn rust(_py: Python<'_>, m: &PyModule) -> PyResult<()> { m.add_wrapped(wrap_pyfunction!(rust_func))?; Ok(()) }setuptools-rust-1.2.0/examples/rust_with_cffi/tests/000077500000000000000000000000001421635746700227445ustar00rootroot00000000000000setuptools-rust-1.2.0/examples/rust_with_cffi/tests/test_rust_with_cffi.py000066400000000000000000000002551421635746700273760ustar00rootroot00000000000000from rust_with_cffi import rust from rust_with_cffi.cffi import lib def test_rust(): assert rust.rust_func() == 14 def test_cffi(): assert lib.cffi_func() == 15 setuptools-rust-1.2.0/mypy.ini000066400000000000000000000006601421635746700164460ustar00rootroot00000000000000# We have to manually ignore types for some packages. It would be great if # interested users want to add these types to typeshed! [mypy] show_error_codes = True disallow_untyped_defs = True disallow_any_unimported = True no_implicit_optional = True check_untyped_defs = True warn_return_any = True warn_unused_ignores = True [mypy-semantic_version.*] ignore_missing_imports = True [mypy-wheel.*] ignore_missing_imports = True setuptools-rust-1.2.0/noxfile.py000066400000000000000000000003601421635746700167620ustar00rootroot00000000000000from glob import glob import nox @nox.session(name="test-examples", venv_backend="none") def test_examples(session: nox.Session): for example in glob("examples/*/noxfile.py"): session.run("nox", "-f", example, external=True) setuptools-rust-1.2.0/pyproject.toml000066400000000000000000000004411421635746700176600ustar00rootroot00000000000000[build-system] requires = ["setuptools>=46.1", "setuptools_scm[toml]>=3.4.3"] build-backend = "setuptools.build_meta" [tool.setuptools_scm] write_to = "setuptools_rust/version.py" [tool.isort] profile = "black" [tool.pytest.ini_options] minversion = "6.0" addopts = "--doctest-modules" setuptools-rust-1.2.0/setup.cfg000066400000000000000000000024601421635746700165700ustar00rootroot00000000000000[metadata] name = setuptools-rust version = attr: setuptools_rust.__version__ author = Nikolay Kim author_email = fafhrd91@gmail.com license = MIT description = Setuptools Rust extension plugin keywords = distutils, setuptools, rust url = https://github.com/PyO3/setuptools-rust long_description = file: README.md long_description_content_type = text/markdown classifiers = Topic :: Software Development :: Version Control License :: OSI Approved :: MIT License Intended Audience :: Developers Programming Language :: Python :: 3 Programming Language :: Python :: 3.6 Programming Language :: Python :: 3.7 Programming Language :: Python :: 3.8 Programming Language :: Python :: 3.9 Development Status :: 5 - Production/Stable Operating System :: POSIX Operating System :: MacOS :: MacOS X Operating System :: Microsoft :: Windows [options] packages = setuptools_rust zip_safe = True install_requires = setuptools>=46.1; semantic_version>=2.8.2,<3; typing_extensions>=3.7.4.3 setup_requires = setuptools>=46.1; setuptools_scm>=6.3.2 python_requires = >=3.7 [options.entry_points] distutils.commands = clean_rust=setuptools_rust:clean_rust build_rust=setuptools_rust:build_rust distutils.setup_keywords = rust_extensions=setuptools_rust.setuptools_ext:rust_extensions setuptools-rust-1.2.0/setup.py000077500000000000000000000001341421635746700164600ustar00rootroot00000000000000#!/usr/bin/env python from setuptools import setup if __name__ == "__main__": setup() setuptools-rust-1.2.0/setuptools_rust/000077500000000000000000000000001421635746700202435ustar00rootroot00000000000000setuptools-rust-1.2.0/setuptools_rust/__init__.py000066400000000000000000000003521421635746700223540ustar00rootroot00000000000000from .build import build_rust from .clean import clean_rust from .extension import Binding, RustExtension, Strip from .version import version as __version__ __all__ = ("Binding", "RustExtension", "Strip", "build_rust", "clean_rust") setuptools-rust-1.2.0/setuptools_rust/build.py000066400000000000000000000630221421635746700217170ustar00rootroot00000000000000import glob import os import platform import shutil import subprocess import sys import sysconfig from distutils import log from distutils.command.build import build as CommandBuild from distutils.errors import ( CompileError, DistutilsExecError, DistutilsFileError, DistutilsPlatformError, ) from distutils.sysconfig import get_config_var from typing import Dict, List, NamedTuple, Optional, cast from setuptools.command.build_ext import build_ext as CommandBuildExt from setuptools.command.build_ext import get_abi3_suffix from typing_extensions import Literal from .command import RustCommand from .extension import RustExtension, Strip from .utils import ( PyLimitedApi, binding_features, get_rust_target_info, get_rust_target_list, split_platform_and_extension, ) class build_rust(RustCommand): """Command for building Rust crates via cargo.""" description = "build Rust extensions (compile/link to build directory)" user_options = [ ( "inplace", "i", "ignore build-lib and put compiled extensions into the source " + "directory alongside your pure Python modules", ), ("debug", "d", "Force debug to true for all Rust extensions "), ("release", "r", "Force debug to false for all Rust extensions "), ("qbuild", None, "Force enable quiet option for all Rust extensions "), ( "build-temp", "t", "directory for temporary files (cargo 'target' directory) ", ), ("target=", None, "Build for the target triple"), ] boolean_options = ["inplace", "debug", "release", "qbuild"] plat_name: Optional[str] def initialize_options(self) -> None: super().initialize_options() self.inplace = None self.debug = None self.release = None self.qbuild = None self.build_temp = None self.plat_name = None self.target = os.getenv("CARGO_BUILD_TARGET") self.cargo = os.getenv("CARGO", "cargo") def finalize_options(self) -> None: super().finalize_options() if self.plat_name is None: self.plat_name = cast( CommandBuild, self.get_finalized_command("build") ).plat_name assert isinstance(self.plat_name, str) # Inherit settings from the `build_ext` command self.set_undefined_options( "build_ext", ("build_temp", "build_temp"), ("debug", "debug"), ("inplace", "inplace"), ) def run_for_extension(self, ext: RustExtension) -> None: assert self.plat_name is not None arch_flags = os.getenv("ARCHFLAGS") universal2 = False if self.plat_name.startswith("macosx-") and arch_flags: universal2 = "x86_64" in arch_flags and "arm64" in arch_flags if not universal2 and not self.target: if "arm64" in arch_flags: self.target = "aarch64-apple-darwin" elif "x86_64" in arch_flags: self.target = "x86_64-apple-darwin" if universal2: arm64_dylib_paths = self.build_extension(ext, "aarch64-apple-darwin") x86_64_dylib_paths = self.build_extension(ext, "x86_64-apple-darwin") dylib_paths = [] for (target_fname, arm64_dylib), (_, x86_64_dylib) in zip( arm64_dylib_paths, x86_64_dylib_paths ): fat_dylib_path = arm64_dylib.replace("aarch64-apple-darwin/", "") create_universal2_binary(fat_dylib_path, [arm64_dylib, x86_64_dylib]) dylib_paths.append(_BuiltModule(target_fname, fat_dylib_path)) else: dylib_paths = self.build_extension(ext, self.target) self.install_extension(ext, dylib_paths) def build_extension( self, ext: RustExtension, forced_target_triple: Optional[str] ) -> List["_BuiltModule"]: target_info = self._detect_rust_target(forced_target_triple) if target_info is not None: target_triple = target_info.triple cross_lib = target_info.cross_lib linker = target_info.linker # We're ignoring target_info.linker_args for now because we're not # sure if they will always do the right thing. Might help with some # of the OS-specific logic if it does. else: target_triple = None cross_lib = None linker = None rustc_cfgs = _get_rustc_cfgs(target_triple) env = _prepare_build_environment(cross_lib) if not os.path.exists(ext.path): raise DistutilsFileError( f"can't find Rust extension project file: {ext.path}" ) # Find where to put the temporary build files created by `cargo` target_dir = _base_cargo_target_dir(ext) if target_triple is not None: target_dir = os.path.join(target_dir, target_triple) quiet = self.qbuild or ext.quiet debug = self._is_debug_build(ext) cargo_args = self._cargo_args( ext=ext, target_triple=target_triple, release=not debug, quiet=quiet ) if ext._uses_exec_binding(): command = [self.cargo, "build", "--manifest-path", ext.path, *cargo_args] else: rustc_args = [ "--crate-type", "cdylib", ] if ext.rustc_flags is not None: rustc_args.extend(ext.rustc_flags) if linker is not None: rustc_args.extend(["-C", "linker=" + linker]) # OSX requires special linker arguments if sys.platform == "darwin": ext_basename = os.path.basename(self.get_dylib_ext_path(ext, ext.name)) rustc_args.extend( [ "-C", f"link-args=-undefined dynamic_lookup -Wl,-install_name,@rpath/{ext_basename}", ] ) if ext.native: rustc_args.extend(["-C", "target-cpu=native"]) # Tell musl targets not to statically link libc. See # https://github.com/rust-lang/rust/issues/59302 for details. if rustc_cfgs.get("target_env") == "musl": # This must go in the env otherwise rustc will refuse to build # the cdylib, see https://github.com/rust-lang/cargo/issues/10143 MUSL_FLAGS = "-C target-feature=-crt-static" rustflags = env.get("RUSTFLAGS") if rustflags is not None: env["RUSTFLAGS"] = f"{rustflags} {MUSL_FLAGS}" else: env["RUSTFLAGS"] = MUSL_FLAGS # Include this in the command-line anyway, so that when verbose # logging enabled the user will see that this flag is in use. rustc_args.extend(MUSL_FLAGS.split()) command = [ self.cargo, "rustc", "--lib", "--manifest-path", ext.path, *cargo_args, "--", *rustc_args, ] if not quiet: print(" ".join(command), file=sys.stderr) # Execute cargo try: output = subprocess.check_output(command, env=env, encoding="latin-1") except subprocess.CalledProcessError as e: raise CompileError(f"cargo failed with code: {e.returncode}\n{e.output}") except OSError: raise DistutilsExecError( "Unable to execute 'cargo' - this package " "requires Rust to be installed and cargo to be on the PATH" ) if not quiet: if output: print(output, file=sys.stderr) # Find the shared library that cargo hopefully produced and copy # it into the build directory as if it were produced by build_ext. profile = ext.get_cargo_profile() if profile: # https://doc.rust-lang.org/cargo/reference/profiles.html if profile in {"dev", "test"}: profile_dir = "debug" elif profile == "bench": profile_dir = "release" else: profile_dir = profile else: profile_dir = "debug" if debug else "release" artifacts_dir = os.path.join(target_dir, profile_dir) dylib_paths = [] if ext._uses_exec_binding(): for name, dest in ext.target.items(): if not name: name = dest.split(".")[-1] exe = sysconfig.get_config_var("EXE") if exe is not None: name += exe path = os.path.join(artifacts_dir, name) if os.access(path, os.X_OK): dylib_paths.append(_BuiltModule(dest, path)) else: raise DistutilsExecError( "Rust build failed; " f"unable to find executable '{name}' in '{artifacts_dir}'" ) else: if sys.platform == "win32" or sys.platform == "cygwin": dylib_ext = "dll" elif sys.platform == "darwin": dylib_ext = "dylib" else: dylib_ext = "so" wildcard_so = "*{}.{}".format(ext.get_lib_name(), dylib_ext) try: dylib_paths.append( _BuiltModule( ext.name, next(glob.iglob(os.path.join(artifacts_dir, wildcard_so))), ) ) except StopIteration: raise DistutilsExecError( f"Rust build failed; unable to find any {wildcard_so} in {artifacts_dir}" ) return dylib_paths def install_extension( self, ext: RustExtension, dylib_paths: List["_BuiltModule"] ) -> None: debug_build = ext.debug if ext.debug is not None else self.inplace debug_build = self.debug if self.debug is not None else debug_build if self.release: debug_build = False # Ask build_ext where the shared library would go if it had built it, # then copy it there. build_ext = cast(CommandBuildExt, self.get_finalized_command("build_ext")) build_ext.inplace = self.inplace for module_name, dylib_path in dylib_paths: if not module_name: module_name = os.path.basename( os.path.splitext(os.path.basename(dylib_path)[3:])[0] ) if ext._uses_exec_binding(): ext_path = build_ext.get_ext_fullpath(module_name) # remove extensions ext_path, _, _ = split_platform_and_extension(ext_path) # Add expected extension exe = sysconfig.get_config_var("EXE") if exe is not None: ext_path += exe os.makedirs(os.path.dirname(ext_path), exist_ok=True) ext.install_script(module_name.split(".")[-1], ext_path) else: ext_path = self.get_dylib_ext_path(ext, module_name) os.makedirs(os.path.dirname(ext_path), exist_ok=True) log.info("Copying rust artifact from %s to %s", dylib_path, ext_path) shutil.copyfile(dylib_path, ext_path) if sys.platform != "win32" and not debug_build: args = [] if ext.strip == Strip.All: args.append("-x") elif ext.strip == Strip.Debug: args.append("-S") if args: args.insert(0, "strip") args.append(ext_path) try: output = subprocess.check_output(args) except subprocess.CalledProcessError: pass # executables, win32(cygwin)-dll's, and shared libraries on # Unix-like operating systems need X bits mode = os.stat(ext_path).st_mode mode |= (mode & 0o444) >> 2 # copy R bits to X os.chmod(ext_path, mode) def get_dylib_ext_path(self, ext: RustExtension, target_fname: str) -> str: assert self.plat_name is not None build_ext = cast(CommandBuildExt, self.get_finalized_command("build_ext")) ext_path: str = build_ext.get_ext_fullpath(target_fname) if _is_py_limited_api(ext.py_limited_api, self._py_limited_api()): abi3_suffix = get_abi3_suffix() if abi3_suffix is not None: so_ext = get_config_var("EXT_SUFFIX") assert isinstance(so_ext, str) ext_path = ext_path[: -len(so_ext)] + get_abi3_suffix() if ".abi3." in ext_path: return ext_path # Examples: linux_x86_64, linux_i686, manylinux2014_aarch64, manylinux_2_24_armv7l plat_name = self.plat_name.lower().replace("-", "_").replace(".", "_") if not plat_name.startswith(("linux", "manylinux")): return ext_path arch_parts = [] arch_found = False for item in plat_name.split("_"): if item.startswith(("linux", "manylinux")): continue if item.isdigit() and not arch_found: # manylinux_2_24_armv7l arch should be armv7l continue arch_found = True arch_parts.append(item) target_arch = "_".join(arch_parts) host_platform = sysconfig.get_platform() host_arch = host_platform.rsplit("-", 1)[1] # Remove incorrect platform tag if we are cross compiling if target_arch and host_arch != target_arch: ext_path, _, extension = split_platform_and_extension(ext_path) # rust.so, removed platform tag ext_path += extension return ext_path def _py_limited_api(self) -> PyLimitedApi: bdist_wheel = self.distribution.get_command_obj("bdist_wheel", create=False) if bdist_wheel is None: # wheel package is not installed, not building a limited-api wheel return False else: from wheel.bdist_wheel import bdist_wheel as CommandBdistWheel bdist_wheel_command = cast(CommandBdistWheel, bdist_wheel) # type: ignore[no-any-unimported] bdist_wheel_command.ensure_finalized() return cast(PyLimitedApi, bdist_wheel_command.py_limited_api) def _detect_rust_target( self, forced_target_triple: Optional[str] ) -> Optional["_TargetInfo"]: cross_compile_info = _detect_unix_cross_compile_info() if cross_compile_info is not None: cross_target_info = cross_compile_info.to_target_info() if forced_target_triple is not None: if ( cross_target_info is not None and not cross_target_info.is_compatible_with(forced_target_triple) ): self.warn( f"Forced Rust target `{forced_target_triple}` is not " f"compatible with deduced Rust target " f"`{cross_target_info.triple}` - the built package " f" may not import successfully once installed." ) # Forcing the target in a cross-compile environment; use # the cross-compile information in combination with the # forced target return _TargetInfo( forced_target_triple, cross_compile_info.cross_lib, cross_compile_info.linker, cross_compile_info.linker_args, ) elif cross_target_info is not None: return cross_target_info else: raise DistutilsPlatformError( "Don't know the correct rust target for system type " f"{cross_compile_info.host_type}. Please set the " "CARGO_BUILD_TARGET environment variable." ) elif forced_target_triple is not None: return _TargetInfo.for_triple(forced_target_triple) else: # Automatic target detection can be overridden via the CARGO_BUILD_TARGET # environment variable or --target command line option return self._detect_local_rust_target() def _detect_local_rust_target(self) -> Optional["_TargetInfo"]: """Attempts to infer the correct Rust target from build environment for some edge cases.""" assert self.plat_name is not None # If we are on a 64-bit machine, but running a 32-bit Python, then # we'll target a 32-bit Rust build. if self.plat_name == "win32": if _get_rustc_cfgs(None).get("target_env") == "gnu": return _TargetInfo.for_triple("i686-pc-windows-gnu") return _TargetInfo.for_triple("i686-pc-windows-msvc") elif self.plat_name == "win-amd64": if _get_rustc_cfgs(None).get("target_env") == "gnu": return _TargetInfo.for_triple("x86_64-pc-windows-gnu") return _TargetInfo.for_triple("x86_64-pc-windows-msvc") elif self.plat_name.startswith("macosx-") and platform.machine() == "x86_64": # x86_64 or arm64 macOS targeting x86_64 return _TargetInfo.for_triple("x86_64-apple-darwin") else: return None def _is_debug_build(self, ext: RustExtension) -> bool: if self.release: return False elif self.debug is not None: return self.debug elif ext.debug is not None: return ext.debug else: return bool(self.inplace) def _cargo_args( self, ext: RustExtension, target_triple: Optional[str], release: bool, quiet: bool, ) -> List[str]: args = [] if target_triple is not None: args.extend(["--target", target_triple]) if release: profile = ext.get_cargo_profile() if not profile: args.append("--release") if quiet: args.append("-q") elif self.verbose: # cargo only have -vv verbose_level = "v" * min(self.verbose, 2) args.append(f"-{verbose_level}") features = { *ext.features, *binding_features(ext, py_limited_api=self._py_limited_api()), } if features: args.extend(["--features", " ".join(features)]) if ext.args is not None: args.extend(ext.args) return args def create_universal2_binary(output_path: str, input_paths: List[str]) -> None: # Try lipo first command = ["lipo", "-create", "-output", output_path, *input_paths] try: subprocess.check_output(command) except subprocess.CalledProcessError as e: output = e.output if isinstance(output, bytes): output = e.output.decode("latin-1").strip() raise CompileError("lipo failed with code: %d\n%s" % (e.returncode, output)) except OSError: # lipo not found, try using the fat-macho library try: from fat_macho import FatWriter except ImportError: raise DistutilsExecError( "failed to locate `lipo` or import `fat_macho.FatWriter`. " "Try installing with `pip install fat-macho` " ) fat = FatWriter() for input_path in input_paths: with open(input_path, "rb") as f: fat.add(f.read()) fat.write_to(output_path) class _BuiltModule(NamedTuple): """ Attributes: - module_name: dotted python import path of the module - path: the location the module has been installed at """ module_name: str path: str class _TargetInfo(NamedTuple): triple: str cross_lib: Optional[str] linker: Optional[str] linker_args: Optional[str] @staticmethod def for_triple(triple: str) -> "_TargetInfo": return _TargetInfo(triple, None, None, None) def is_compatible_with(self, target: str) -> bool: if self.triple == target: return True # the vendor field can be ignored, so x86_64-pc-linux-gnu is compatible # with x86_64-unknown-linux-gnu if _replace_vendor_with_unknown(self.triple) == target: return True return False class _CrossCompileInfo(NamedTuple): host_type: str cross_lib: Optional[str] linker: Optional[str] linker_args: Optional[str] def to_target_info(self) -> Optional[_TargetInfo]: """Maps this cross compile info to target info. Returns None if the corresponding target information could not be deduced. """ # hopefully an exact match targets = get_rust_target_list() if self.host_type in targets: return _TargetInfo( self.host_type, self.cross_lib, self.linker, self.linker_args ) # the vendor field can be ignored, so x86_64-pc-linux-gnu is compatible # with x86_64-unknown-linux-gnu without_vendor = _replace_vendor_with_unknown(self.host_type) if without_vendor is not None and without_vendor in targets: return _TargetInfo( without_vendor, self.cross_lib, self.linker, self.linker_args ) return None def _detect_unix_cross_compile_info() -> Optional["_CrossCompileInfo"]: # See https://github.com/PyO3/setuptools-rust/issues/138 # This is to support cross compiling on *NIX, where plat_name isn't # necessarily the same as the system we are running on. *NIX systems # have more detailed information available in sysconfig. We need that # because plat_name doesn't give us information on e.g., glibc vs musl. host_type = sysconfig.get_config_var("HOST_GNU_TYPE") build_type = sysconfig.get_config_var("BUILD_GNU_TYPE") if not host_type or host_type == build_type: # not *NIX, or not cross compiling return None if "apple-darwin" in host_type and (build_type and "apple-darwin" in build_type): # On macos and the build and host differ. This is probably an arm # Python which was built on x86_64. Don't try to handle this for now. # (See https://github.com/PyO3/setuptools-rust/issues/192) return None stdlib = sysconfig.get_path("stdlib") assert stdlib is not None cross_lib = os.path.dirname(stdlib) bldshared = sysconfig.get_config_var("BLDSHARED") if not bldshared: linker = None linker_args = None else: [linker, linker_args] = bldshared.split(maxsplit=1) return _CrossCompileInfo(host_type, cross_lib, linker, linker_args) _RustcCfgs = Dict[str, Optional[str]] def _get_rustc_cfgs(target_triple: Optional[str]) -> _RustcCfgs: cfgs: _RustcCfgs = {} for entry in get_rust_target_info(target_triple): maybe_split = entry.split("=", maxsplit=1) if len(maybe_split) == 2: cfgs[maybe_split[0]] = maybe_split[1].strip('"') else: assert len(maybe_split) == 1 cfgs[maybe_split[0]] = None return cfgs def _replace_vendor_with_unknown(target: str) -> Optional[str]: """Replaces vendor in the target triple with unknown. Returns None if the target is not made of 4 parts. """ components = target.split("-") if len(components) != 4: return None components[1] = "unknown" return "-".join(components) def _prepare_build_environment(cross_lib: Optional[str]) -> Dict[str, str]: """Prepares environment variables to use when executing cargo build.""" # Make sure that if pythonXX-sys is used, it builds against the current # executing python interpreter. bindir = os.path.dirname(sys.executable) env = os.environ.copy() env.update( { # disables rust's pkg-config seeking for specified packages, # which causes pythonXX-sys to fall back to detecting the # interpreter from the path. "PATH": os.path.join(bindir, os.environ.get("PATH", "")), "PYTHON_SYS_EXECUTABLE": os.environ.get( "PYTHON_SYS_EXECUTABLE", sys.executable ), "PYO3_PYTHON": os.environ.get("PYO3_PYTHON", sys.executable), } ) if cross_lib: env.setdefault("PYO3_CROSS_LIB_DIR", cross_lib) return env def _base_cargo_target_dir(ext: RustExtension) -> str: """Returns the root target directory cargo will use. If --target is passed to cargo in the command line, the target directory will have the target appended as a child. """ target_directory = ext._metadata()["target_directory"] assert isinstance( target_directory, str ), "expected cargo metadata to contain a string target directory" return target_directory def _is_py_limited_api( ext_setting: Literal["auto", True, False], wheel_setting: Optional[PyLimitedApi], ) -> bool: """Returns whether this extension is being built for the limited api. >>> _is_py_limited_api("auto", None) False >>> _is_py_limited_api("auto", True) True >>> _is_py_limited_api(True, False) True >>> _is_py_limited_api(False, True) False """ # If the extension explicitly states to use py_limited_api or not, use that. if ext_setting != "auto": return ext_setting # "auto" setting - use whether the bdist_wheel option is truthy. return bool(wheel_setting) setuptools-rust-1.2.0/setuptools_rust/clean.py000066400000000000000000000013021421635746700216730ustar00rootroot00000000000000import subprocess import sys from .command import RustCommand from .extension import RustExtension class clean_rust(RustCommand): """Clean Rust extensions.""" description = "clean Rust extensions (compile/link to build directory)" def initialize_options(self) -> None: super().initialize_options() self.inplace = False def run_for_extension(self, ext: RustExtension) -> None: # build cargo command args = ["cargo", "clean", "--manifest-path", ext.path] if not ext.quiet: print(" ".join(args), file=sys.stderr) # Execute cargo command try: subprocess.check_output(args) except: pass setuptools-rust-1.2.0/setuptools_rust/command.py000066400000000000000000000107261421635746700222410ustar00rootroot00000000000000from abc import ABC, abstractmethod from distutils import log from distutils.cmd import Command from distutils.errors import DistutilsPlatformError from typing import List, Optional from setuptools.dist import Distribution from .extension import RustExtension from .utils import get_rust_version class RustCommand(Command, ABC): """Abstract base class for commands which interact with Rust Extensions.""" # Types for distutils variables which exist on all commands but seem to be # missing from https://github.com/python/typeshed/blob/master/stdlib/distutils/cmd.pyi distribution: Distribution verbose: int def initialize_options(self) -> None: self.extensions: List[RustExtension] = [] def finalize_options(self) -> None: extensions: Optional[List[RustExtension]] = getattr( self.distribution, "rust_extensions", None ) if extensions is None: # extensions is None if the setup.py file did not contain # rust_extensions keyword; just no-op if this is the case. return if not isinstance(extensions, list): ty = type(extensions) raise ValueError( "expected list of RustExtension objects for rust_extensions " f"argument to setup(), got `{ty}`" ) for (i, extension) in enumerate(extensions): if not isinstance(extension, RustExtension): ty = type(extension) raise ValueError( "expected RustExtension object for rust_extensions " f"argument to setup(), got `{ty}` at position {i}" ) # Extensions have been verified to be at the correct type self.extensions = extensions def run(self) -> None: if not self.extensions: log.info("%s: no rust_extensions defined", self.get_command_name()) return all_optional = all(ext.optional for ext in self.extensions) try: version = get_rust_version() if version is None: min_version = max( # type: ignore[type-var] filter( lambda version: version is not None, (ext.get_rust_version() for ext in self.extensions), ), default=None, ) raise DistutilsPlatformError( "can't find Rust compiler\n\n" "If you are using an outdated pip version, it is possible a " "prebuilt wheel is available for this package but pip is not able " "to install from it. Installing from the wheel would avoid the " "need for a Rust compiler.\n\n" "To update pip, run:\n\n" " pip install --upgrade pip\n\n" "and then retry package installation.\n\n" "If you did intend to build this package from source, try " "installing a Rust compiler from your system package manager and " "ensure it is on the PATH during installation. Alternatively, " "rustup (available at https://rustup.rs) is the recommended way " "to download and update the Rust compiler toolchain." + ( f"\n\nThis package requires Rust {min_version}." if min_version is not None else "" ) ) except DistutilsPlatformError as e: if not all_optional: raise else: print(str(e)) return for ext in self.extensions: try: rust_version = ext.get_rust_version() if rust_version is not None and version not in rust_version: raise DistutilsPlatformError( f"Rust {version} does not match extension requirement {rust_version}" ) self.run_for_extension(ext) except Exception as e: if not ext.optional: raise else: command_name = self.get_command_name() print(f"{command_name}: optional Rust extension {ext.name} failed") print(str(e)) @abstractmethod def run_for_extension(self, extension: RustExtension) -> None: ... setuptools-rust-1.2.0/setuptools_rust/extension.py000066400000000000000000000223671421635746700226430ustar00rootroot00000000000000import json import os import re import subprocess from distutils.errors import DistutilsSetupError from enum import IntEnum, auto from typing import Any, Dict, List, NewType, Optional, Union from semantic_version import SimpleSpec from typing_extensions import Literal class Binding(IntEnum): """ Enumeration of possible Rust binding types supported by ``setuptools-rust``. Attributes: PyO3: This is an extension built using `PyO3 `_. RustCPython: This is an extension built using `rust-cpython `_. NoBinding: Bring your own bindings for the extension. Exec: Build an executable instead of an extension. """ PyO3 = auto() RustCPython = auto() NoBinding = auto() Exec = auto() def __repr__(self) -> str: return f"{self.__class__.__name__}.{self.name}" class Strip(IntEnum): """ Enumeration of modes for stripping symbols from the built extension. Attributes: No: Do not strip symbols. Debug: Strip debug symbols. All: Strip all symbols. """ No = auto() Debug = auto() All = auto() def __repr__(self) -> str: return f"{self.__class__.__name__}.{self.name}" class RustExtension: """Used to define a rust extension module and its build configuration. Args: target: The full Python dotted name of the extension, including any packages, i.e *not* a filename or pathname. It is possible to specify multiple binaries, if extension uses ``Binding.Exec`` binding mode. In that case first argument has to be dictionary. Keys of the dictionary correspond to the rust binary names and values are the full dotted name to place the executable inside the python package. To install executables with kebab-case names, the final part of the dotted name can be in kebab-case. For example, `hello_world.hello-world` will install an executable named `hello-world`. path: Path to the ``Cargo.toml`` manifest file. args: A list of extra arguments to be passed to Cargo. For example, ``args=["--no-default-features"]`` will disable the default features listed in ``Cargo.toml``. features: A list of Cargo features to also build. rust_version: Minimum Rust compiler version required for this extension. quiet: Suppress Cargo's output. debug: Controls whether ``--debug`` or ``--release`` is passed to Cargo. If set to `None` (the default) then build type is automatic: ``inplace`` build will be a debug build, ``install`` and ``wheel`` builds will be release. binding: Informs ``setuptools_rust`` which Python binding is in use. strip: Strip symbols from final file. Does nothing for debug build. script: Generate console script for executable if ``Binding.Exec`` is used. native: Build extension or executable with ``--target-cpu=native``. optional: If it is true, a build failure in the extension will not abort the build process, and instead simply not install the failing extension. py_limited_api: Similar to ``py_limited_api`` on ``setuptools.Extension``, this controls whether the built extension should be considered compatible with the PEP 384 "limited API". - ``'auto'``: the ``--py-limited-api`` option of ``setup.py bdist_wheel`` will control whether the extension is built as a limited api extension. The corresponding ``pyo3/abi3-pyXY`` feature will be set accordingly. This is the recommended setting, as it allows ``python setup.py install`` to build a version-specific extension for best performance. - ``True``: the extension is assumed to be compatible with the limited abi. You must ensure this is the case (e.g. by setting the ``pyo3/abi3`` feature). - ``False``: the extension is version-specific. """ def __init__( self, target: Union[str, Dict[str, str]], path: str = "Cargo.toml", args: Optional[List[str]] = None, features: Optional[List[str]] = None, rustc_flags: Optional[List[str]] = None, rust_version: Optional[str] = None, quiet: bool = False, debug: Optional[bool] = None, binding: Binding = Binding.PyO3, strip: Strip = Strip.No, script: bool = False, native: bool = False, optional: bool = False, py_limited_api: Literal["auto", True, False] = "auto", ): if isinstance(target, dict): name = "; ".join("%s=%s" % (key, val) for key, val in target.items()) else: name = target target = {"": target} self.name = name self.target = target self.args = args self.rustc_flags = rustc_flags self.binding = binding self.rust_version = rust_version self.quiet = quiet self.debug = debug self.strip = strip self.script = script self.native = native self.optional = optional self.py_limited_api = py_limited_api if features is None: features = [] self.features = [s.strip() for s in features] # get relative path to Cargo manifest file path = os.path.relpath(path) self.path = path self._cargo_metadata: Optional[_CargoMetadata] = None def get_lib_name(self) -> str: """Parse Cargo.toml to get the name of the shared library.""" metadata = self._metadata() root_key = metadata["resolve"]["root"] [pkg] = [p for p in metadata["packages"] if p["id"] == root_key] name = pkg["targets"][0]["name"] assert isinstance(name, str) return re.sub(r"[./\\-]", "_", name) def get_rust_version(self) -> Optional[SimpleSpec]: # type: ignore[no-any-unimported] if self.rust_version is None: return None try: return SimpleSpec(self.rust_version) except ValueError: raise DistutilsSetupError( "Can not parse rust compiler version: %s", self.rust_version ) def get_cargo_profile(self) -> Optional[str]: args = self.args or [] try: index = args.index("--profile") return args[index + 1] except ValueError: pass except IndexError: raise DistutilsSetupError("Can not parse cargo profile from %s", args) # Handle `--profile=` profile_args = [p for p in args if p.startswith("--profile=")] if profile_args: profile = profile_args[0].split("=", 1)[1] if not profile: raise DistutilsSetupError("Can not parse cargo profile from %s", args) return profile else: return None def entry_points(self) -> List[str]: entry_points = [] if self.script and self.binding == Binding.Exec: for executable, mod in self.target.items(): base_mod, name = mod.rsplit(".") script = "%s=%s.%s:run" % (name, base_mod, _script_name(executable)) entry_points.append(script) return entry_points def install_script(self, module_name: str, exe_path: str) -> None: if self.script and self.binding == Binding.Exec: dirname, executable = os.path.split(exe_path) script_name = _script_name(module_name) file = os.path.join(dirname, f"{script_name}.py") with open(file, "w") as f: f.write(_SCRIPT_TEMPLATE.format(executable=repr(executable))) def _metadata(self) -> "_CargoMetadata": """Returns cargo metedata for this extension package. Cached - will only execute cargo on first invocation. """ if self._cargo_metadata is None: metadata_command = [ "cargo", "metadata", "--manifest-path", self.path, "--format-version", "1", ] self._cargo_metadata = json.loads(subprocess.check_output(metadata_command)) return self._cargo_metadata def _uses_exec_binding(self) -> bool: return self.binding == Binding.Exec _CargoMetadata = NewType("_CargoMetadata", Dict[str, Any]) def _script_name(executable: str) -> str: """Generates the name of the installed Python script for an executable. Because Python modules must be snake_case, this generated script name will replace `-` with `_`. >>> _script_name("hello-world") '_gen_hello_world' >>> _script_name("foo_bar") '_gen_foo_bar' >>> _script_name("_gen_foo_bar") '_gen__gen_foo_bar' """ script = executable.replace("-", "_") return f"_gen_{script}" _SCRIPT_TEMPLATE = """ import os import sys def run(): path = os.path.split(__file__)[0] file = os.path.join(path, {executable}) if os.path.isfile(file): os.execv(file, sys.argv) else: raise RuntimeError("can't find " + file) """ setuptools-rust-1.2.0/setuptools_rust/py.typed000066400000000000000000000000001421635746700217300ustar00rootroot00000000000000setuptools-rust-1.2.0/setuptools_rust/setuptools_ext.py000066400000000000000000000277701421635746700237330ustar00rootroot00000000000000import os import subprocess import sys from distutils import log from distutils.command.clean import clean from typing import List, Tuple, Type, cast from setuptools.command.build_ext import build_ext from setuptools.command.install import install from setuptools.command.sdist import sdist from setuptools.dist import Distribution from typing_extensions import Literal from .extension import RustExtension try: from wheel.bdist_wheel import bdist_wheel except ImportError: bdist_wheel = None def add_rust_extension(dist: Distribution) -> None: sdist_base_class = cast(Type[sdist], dist.cmdclass.get("sdist", sdist)) sdist_options = sdist_base_class.user_options.copy() sdist_boolean_options = sdist_base_class.boolean_options.copy() sdist_negative_opt = sdist_base_class.negative_opt.copy() sdist_options.extend( [ ("vendor-crates", None, "vendor Rust crates"), ( "no-vendor-crates", None, "don't vendor Rust crates." "[default; enable with --vendor-crates]", ), ] ) sdist_boolean_options.append("vendor-crates") sdist_negative_opt["no-vendor-crates"] = "vendor-crates" class sdist_rust_extension(sdist_base_class): # type: ignore[misc,valid-type] user_options = sdist_options boolean_options = sdist_boolean_options negative_opt = sdist_negative_opt def initialize_options(self) -> None: super().initialize_options() self.vendor_crates = 0 def make_distribution(self) -> None: if self.vendor_crates: manifest_paths = [] for ext in self.distribution.rust_extensions: manifest_paths.append(ext.path) if manifest_paths: base_dir = self.distribution.get_fullname() dot_cargo_path = os.path.join(base_dir, ".cargo") self.mkpath(dot_cargo_path) cargo_config_path = os.path.join(dot_cargo_path, "config.toml") vendor_path = os.path.join(dot_cargo_path, "vendor") command = ["cargo", "vendor"] # additional Cargo.toml for extension 1..n for extra_path in manifest_paths[1:]: command.append("--sync") command.append(extra_path) # `cargo vendor --sync` accepts multiple values, for example # `cargo vendor --sync a --sync b --sync c vendor_path` # but it would also consider vendor_path as --sync value # set --manifest-path before vendor_path and after --sync to workaround that # See https://docs.rs/clap/latest/clap/struct.Arg.html#method.multiple for detail command.extend(["--manifest-path", manifest_paths[0], vendor_path]) cargo_config = subprocess.check_output(command) base_dir_bytes = ( base_dir.encode(sys.getfilesystemencoding()) + os.sep.encode() ) if os.sep == "\\": # TOML escapes backslash \ base_dir_bytes += os.sep.encode() cargo_config = cargo_config.replace(base_dir_bytes, b"") if os.altsep: cargo_config = cargo_config.replace( base_dir_bytes + os.altsep.encode(), b"" ) # Check whether `.cargo/config`/`.cargo/config.toml` already exists existing_cargo_config = None for filename in ( f".cargo{os.sep}config", f".cargo{os.sep}config.toml", ): if filename in self.filelist.files: existing_cargo_config = filename break if existing_cargo_config: cargo_config_path = os.path.join( base_dir, existing_cargo_config ) # Append vendor config to original cargo config with open(existing_cargo_config, "rb") as f: cargo_config = f.read() + b"\n" + cargo_config with open(cargo_config_path, "wb") as f: f.write(cargo_config) self.filelist.append(vendor_path) self.filelist.append(cargo_config_path) super().make_distribution() dist.cmdclass["sdist"] = sdist_rust_extension build_ext_base_class = cast( Type[build_ext], dist.cmdclass.get("build_ext", build_ext) ) build_ext_options = build_ext_base_class.user_options.copy() build_ext_options.append(("target", None, "Build for the target triple")) class build_ext_rust_extension(build_ext_base_class): # type: ignore[misc,valid-type] user_options = build_ext_options def initialize_options(self) -> None: super().initialize_options() self.target = os.getenv("CARGO_BUILD_TARGET") def run(self) -> None: if self.distribution.rust_extensions: log.info("running build_rust") build_rust = self.get_finalized_command("build_rust") build_rust.inplace = self.inplace build_rust.target = self.target build_rust.verbose = self.verbose options = self.distribution.get_cmdline_options().get("bdist_wheel", {}) plat_name = options.get("plat-name") or self.plat_name build_rust.plat_name = plat_name build_rust.run() build_ext_base_class.run(self) dist.cmdclass["build_ext"] = build_ext_rust_extension clean_base_class = cast(Type[clean], dist.cmdclass.get("clean", clean)) class clean_rust_extension(clean_base_class): # type: ignore[misc,valid-type] def run(self) -> None: clean_base_class.run(self) if not self.dry_run: self.run_command("clean_rust") dist.cmdclass["clean"] = clean_rust_extension install_base_class = cast(Type[install], dist.cmdclass.get("install", install)) # this is required because, install directly access distribution's # ext_modules attr to check if dist has ext modules class install_rust_extension(install_base_class): # type: ignore[misc,valid-type] def finalize_options(self) -> None: ext_modules = self.distribution.ext_modules # all ext modules mods = [] if self.distribution.ext_modules: mods.extend(self.distribution.ext_modules) if self.distribution.rust_extensions: mods.extend(self.distribution.rust_extensions) scripts = [] for ext in self.distribution.rust_extensions: scripts.extend(ext.entry_points()) if scripts: if not self.distribution.entry_points: self.distribution.entry_points = {"console_scripts": scripts} else: ep_scripts = self.distribution.entry_points.get( "console_scripts" ) if ep_scripts: for script in scripts: if script not in ep_scripts: ep_scripts.append(scripts) else: ep_scripts = scripts self.distribution.entry_points["console_scripts"] = ep_scripts self.distribution.ext_modules = mods install_base_class.finalize_options(self) # restore ext_modules self.distribution.ext_modules = ext_modules dist.cmdclass["install"] = install_rust_extension if bdist_wheel is not None: bdist_wheel_base_class = cast( # type: ignore[no-any-unimported] Type[bdist_wheel], dist.cmdclass.get("bdist_wheel", bdist_wheel) ) bdist_wheel_options = bdist_wheel_base_class.user_options.copy() bdist_wheel_options.append(("target", None, "Build for the target triple")) # this is for console entries class bdist_wheel_rust_extension(bdist_wheel_base_class): # type: ignore[misc,valid-type] user_options = bdist_wheel_options def initialize_options(self) -> None: super().initialize_options() self.target = os.getenv("CARGO_BUILD_TARGET") def finalize_options(self) -> None: scripts = [] for ext in self.distribution.rust_extensions: scripts.extend(ext.entry_points()) if scripts: if not self.distribution.entry_points: self.distribution.entry_points = {"console_scripts": scripts} else: ep_scripts = self.distribution.entry_points.get( "console_scripts" ) if ep_scripts: for script in scripts: if script not in ep_scripts: ep_scripts.append(scripts) else: ep_scripts = scripts self.distribution.entry_points["console_scripts"] = ep_scripts bdist_wheel_base_class.finalize_options(self) def get_tag(self) -> Tuple[str, str, str]: python, abi, plat = super().get_tag() arch_flags = os.getenv("ARCHFLAGS") universal2 = False if self.plat_name.startswith("macosx-") and arch_flags: universal2 = "x86_64" in arch_flags and "arm64" in arch_flags if universal2 and plat.startswith("macosx_"): from wheel.macosx_libfile import calculate_macosx_platform_tag macos_target = os.getenv("MACOSX_DEPLOYMENT_TARGET") if macos_target is None: # Example: macosx_11_0_arm64 macos_target = ".".join(plat.split("_")[1:3]) plat = calculate_macosx_platform_tag( self.bdist_dir, "macosx-{}-universal2".format(macos_target) ) return python, abi, plat dist.cmdclass["bdist_wheel"] = bdist_wheel_rust_extension def patch_distutils_build() -> None: """Patch distutils to use `has_ext_modules()` See https://github.com/pypa/distutils/pull/43 """ from distutils.command import build as _build class build(_build.build): # Missing type def from distutils.cmd.Command; add it here for now distribution: Distribution def finalize_options(self) -> None: build_lib_user_specified = self.build_lib is not None super().finalize_options() if not build_lib_user_specified: if self.distribution.has_ext_modules(): # type: ignore[attr-defined] self.build_lib = self.build_platlib else: self.build_lib = self.build_purelib _build.build = build # type: ignore[misc] def rust_extensions( dist: Distribution, attr: Literal["rust_extensions"], value: List[RustExtension] ) -> None: assert attr == "rust_extensions" has_rust_extensions = len(value) > 0 # Monkey patch has_ext_modules to include Rust extensions; pairs with # patch_distutils_build above. # # has_ext_modules is missing from Distribution typing. orig_has_ext_modules = dist.has_ext_modules # type: ignore[attr-defined] dist.has_ext_modules = lambda: (orig_has_ext_modules() or has_rust_extensions) # type: ignore[attr-defined] if has_rust_extensions: patch_distutils_build() add_rust_extension(dist) setuptools-rust-1.2.0/setuptools_rust/utils.py000066400000000000000000000050141421635746700217550ustar00rootroot00000000000000import os import subprocess from distutils.errors import DistutilsPlatformError from typing import List, Optional, Set, Tuple from semantic_version import Version from typing_extensions import Literal from .extension import Binding, RustExtension PyLimitedApi = Literal["cp36", "cp37", "cp38", "cp39", "cp310", True, False] def binding_features( ext: RustExtension, py_limited_api: PyLimitedApi, ) -> Set[str]: if ext.binding in (Binding.NoBinding, Binding.Exec): return set() elif ext.binding is Binding.PyO3: features = {"pyo3/extension-module"} if ext.py_limited_api == "auto": if isinstance(py_limited_api, str): python_version = py_limited_api[2:] features.add(f"pyo3/abi3-py{python_version}") elif py_limited_api: features.add(f"pyo3/abi3") return features elif ext.binding is Binding.RustCPython: return {"cpython/python3-sys", "cpython/extension-module"} else: raise DistutilsPlatformError(f"unknown Rust binding: '{ext.binding}'") def get_rust_version() -> Optional[Version]: # type: ignore[no-any-unimported] try: output = subprocess.check_output(["rustc", "-V"]).decode("latin-1") return Version(output.split(" ")[1]) except (subprocess.CalledProcessError, OSError): return None def get_rust_target_info(target_triple: Optional[str] = None) -> List[str]: cmd = ["rustc", "--print", "cfg"] if target_triple: cmd.extend(["--target", target_triple]) output = subprocess.check_output(cmd, universal_newlines=True) return output.splitlines() _rust_target_list = None def get_rust_target_list() -> List[str]: global _rust_target_list if _rust_target_list is None: output = subprocess.check_output( ["rustc", "--print", "target-list"], universal_newlines=True ) _rust_target_list = output.splitlines() return _rust_target_list def split_platform_and_extension(ext_path: str) -> Tuple[str, str, str]: """Splits an extension path into a tuple (ext_path, plat_tag, extension). >>> split_platform_and_extension("foo/bar.platform.so") ('foo/bar', '.platform', '.so') """ # rust.cpython-38-x86_64-linux-gnu.so to (rust.cpython-38-x86_64-linux-gnu, .so) ext_path, extension = os.path.splitext(ext_path) # rust.cpython-38-x86_64-linux-gnu to (rust, .cpython-38-x86_64-linux-gnu) ext_path, platform_tag = os.path.splitext(ext_path) return (ext_path, platform_tag, extension) setuptools-rust-1.2.0/tox.ini000066400000000000000000000006061421635746700162620ustar00rootroot00000000000000[tox] envlist = mypy,pytest [testenv:mypy] deps = # Need next mypy after 0.910 to get correct types for distutils, # but it's not released yet. mypy @ git+https://github.com/python/mypy fat_macho types-setuptools setenv = MYPYPATH={toxinidir} commands = mypy setuptools_rust {posargs} [testenv:pytest] deps = pytest commands = pytest setuptools_rust {posargs}