cpython

The Python programming language

63,003

30,165

63,003

8,753

View on GitHub

Top Related Projects

ironpython3

2,466

Implementation of Python 3.x for .NET Framework that is built on top of the Dynamic Language Runtime.

micropython

19,245

MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems

RustPython

18,676

A Python Interpreter written in Rust

Quick Overview

CPython is the reference implementation of the Python programming language. It is written in C and Python, and serves as the standard for other Python implementations. CPython is the most widely-used Python implementation and is the one you get when you download Python from python.org.

Pros

Widely supported and maintained by a large community
Excellent compatibility with C libraries through its C API
Comprehensive standard library with batteries included
Stable and reliable, with regular updates and security patches

Cons

Performance can be slower compared to some other implementations (e.g., PyPy)
Global Interpreter Lock (GIL) limits true multi-threading for CPU-bound tasks
Memory usage can be high, especially for large-scale applications
Limited support for just-in-time (JIT) compilation

Code Examples

Hello World example:

print("Hello, World!")

List comprehension example:

squares = [x**2 for x in range(10)]
print(squares)

Context manager example:

with open("example.txt", "w") as file:
    file.write("This is a test file.")

Asynchronous programming example:

import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(main())

Getting Started

To get started with CPython:

Download and install Python from python.org
Open a terminal or command prompt
Run Python interactively:

python

Or run a Python script:

python your_script.py

To install additional packages, use pip:

pip install package_name

Competitor Comparisons

ironpython3

2,466

Implementation of Python 3.x for .NET Framework that is built on top of the Dynamic Language Runtime.

Pros of IronPython3

Seamless integration with .NET Framework and CLR
Access to .NET libraries and APIs
Better performance for certain .NET-specific operations

Cons of IronPython3

Slower development cycle compared to CPython
Limited support for some Python libraries and packages
Smaller community and ecosystem

Code Comparison

CPython:

import sys

def example():
    print(f"Running on Python {sys.version}")

if __name__ == "__main__":
    example()

IronPython3:

import clr
import System

def example():
    print(f"Running on IronPython {System.Environment.Version}")

if __name__ == "__main__":
    example()

The main difference in the code examples is the use of .NET-specific imports and APIs in IronPython3, showcasing its integration with the .NET ecosystem. CPython uses standard Python libraries, while IronPython3 leverages .NET Framework capabilities.

CPython is the reference implementation of Python, offering broader compatibility and a larger ecosystem. IronPython3, on the other hand, provides unique advantages for .NET developers and applications requiring tight integration with the .NET Framework. The choice between the two depends on specific project requirements and the target environment.

micropython

19,245

MicroPython - a lean and efficient Python implementation for microcontrollers and constrained systems

Pros of MicroPython

Designed for microcontrollers and embedded systems with limited resources
Smaller memory footprint and faster startup time
Includes hardware-specific modules for easy interfacing with sensors and peripherals

Cons of MicroPython

Limited standard library compared to CPython
Fewer third-party packages available
May have slight performance differences in certain scenarios

Code Comparison

MicroPython:

import machine
led = machine.Pin(2, machine.Pin.OUT)
led.on()

CPython:

# No direct hardware access
# Requires additional libraries for similar functionality
import time
print("LED on")
time.sleep(1)

Summary

MicroPython is optimized for embedded systems, offering a smaller footprint and hardware-specific features. CPython provides a more comprehensive standard library and wider ecosystem support. The code comparison illustrates MicroPython's direct hardware access capabilities, which are not natively available in CPython without additional libraries.

jython

1,202

Python for the Java Platform

Pros of Jython

Seamless Java integration, allowing Python code to interact with Java libraries and classes
Better performance for certain tasks due to JVM optimization
Ability to compile Python code to Java bytecode for distribution

Cons of Jython

Slower development cycle compared to CPython
Limited support for some Python libraries and C extensions
Not always up-to-date with the latest Python language features

Code Comparison

CPython:

import sys

def example():
    print("Hello from CPython!")

if __name__ == "__main__":
    example()
    print(f"Python version: {sys.version}")

Jython:

import sys
from java.lang import System

def example():
    print("Hello from Jython!")

if __name__ == "__main__":
    example()
    print(f"Python version: {sys.version}")
    print(f"Java version: {System.getProperty('java.version')}")

The main difference in the code examples is that Jython can directly import and use Java classes, as shown with java.lang.System. This demonstrates Jython's ability to seamlessly integrate with Java, while CPython focuses solely on Python functionality.

RustPython

18,676

A Python Interpreter written in Rust

Pros of RustPython

Potentially faster execution due to Rust's performance benefits
Easier integration with Rust ecosystem and projects
Memory safety guarantees from Rust's ownership system

Cons of RustPython

Less mature and feature-complete compared to CPython
Smaller community and ecosystem support
Potential compatibility issues with some Python libraries

Code Comparison

CPython (C implementation):

static PyObject *
string_split(PyObject *self, PyObject *args)
{
    Py_ssize_t len = PyUnicode_GET_LENGTH(self);
    if (len == 0)
        return PyList_New(0);
    // ... (additional implementation)
}

RustPython (Rust implementation):

fn string_split(
    zelf: PyObjectRef,
    args: FuncArgs,
    vm: &VirtualMachine,
) -> PyResult {
    let s = zelf.payload::<PyString>().unwrap();
    if s.as_str().is_empty() {
        Ok(vm.ctx.new_list(vec![]))
    } else {
        // ... (additional implementation)
    }
}

Both implementations handle string splitting, but RustPython uses Rust's type system and error handling, while CPython uses C-style programming with Python's C API.

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

This is Python version 3.14.0 alpha 0

.. image:: https://github.com/python/cpython/actions/workflows/build.yml/badge.svg?branch=main&event=push :alt: CPython build status on GitHub Actions :target: https://github.com/python/cpython/actions

.. image:: https://dev.azure.com/python/cpython/_apis/build/status/Azure%20Pipelines%20CI?branchName=main :alt: CPython build status on Azure DevOps :target: https://dev.azure.com/python/cpython/_build/latest?definitionId=4&branchName=main

.. image:: https://img.shields.io/badge/discourse-join_chat-brightgreen.svg :alt: Python Discourse chat :target: https://discuss.python.org/

See the end of this file for further copyright and license information.

.. contents::

General Information

Website: https://www.python.org
Source code: https://github.com/python/cpython
Issue tracker: https://github.com/python/cpython/issues
Documentation: https://docs.python.org
Developer's Guide: https://devguide.python.org/

Contributing to CPython

For more complete instructions on contributing to CPython development, see the Developer Guide_.

.. _Developer Guide: https://devguide.python.org/

Using Python

Installable Python kits, and information about using Python, are available at python.org_.

.. _python.org: https://www.python.org/

Build Instructions

On Unix, Linux, BSD, macOS, and Cygwin::

./configure
make
make test
sudo make install

This will install Python as python3.

You can pass many options to the configure script; run ./configure --help to find out more. On macOS case-insensitive file systems and on Cygwin, the executable is called python.exe; elsewhere it's just python.

Building a complete Python installation requires the use of various additional third-party libraries, depending on your build platform and configure options. Not all standard library modules are buildable or useable on all platforms. Refer to the Install dependencies <https://devguide.python.org/getting-started/setup-building.html#build-dependencies>_ section of the Developer Guide_ for current detailed information on dependencies for various Linux distributions and macOS.

On macOS, there are additional configure and build options related to macOS framework and universal builds. Refer to Mac/README.rst <https://github.com/python/cpython/blob/main/Mac/README.rst>_.

On Windows, see PCbuild/readme.txt <https://github.com/python/cpython/blob/main/PCbuild/readme.txt>_.

To build Windows installer, see Tools/msi/README.txt <https://github.com/python/cpython/blob/main/Tools/msi/README.txt>_.

If you wish, you can create a subdirectory and invoke configure from there. For example::

mkdir debug
cd debug
../configure --with-pydebug
make
make test

(This will fail if you also built at the top-level directory. You should do a make clean at the top-level first.)

To get an optimized build of Python, configure --enable-optimizations before you run make. This sets the default make targets up to enable Profile Guided Optimization (PGO) and may be used to auto-enable Link Time Optimization (LTO) on some platforms. For more details, see the sections below.

Profile Guided Optimization ^^^^^^^^^^^^^^^^^^^^^^^^^^^

PGO takes advantage of recent versions of the GCC or Clang compilers. If used, either via configure --enable-optimizations or by manually running make profile-opt regardless of configure flags, the optimized build process will perform the following steps:

The entire Python directory is cleaned of temporary files that may have resulted from a previous compilation.

An instrumented version of the interpreter is built, using suitable compiler flags for each flavor. Note that this is just an intermediary step. The binary resulting from this step is not good for real-life workloads as it has profiling instructions embedded inside.

After the instrumented interpreter is built, the Makefile will run a training workload. This is necessary in order to profile the interpreter's execution. Note also that any output, both stdout and stderr, that may appear at this step is suppressed.

The final step is to build the actual interpreter, using the information collected from the instrumented one. The end result will be a Python binary that is optimized; suitable for distribution or production installation.

Link Time Optimization ^^^^^^^^^^^^^^^^^^^^^^

Enabled via configure's --with-lto flag. LTO takes advantage of the ability of recent compiler toolchains to optimize across the otherwise arbitrary .o file boundary when building final executables or shared libraries for additional performance gains.

What's New

We have a comprehensive overview of the changes in the What's New in Python 3.14 <https://docs.python.org/3.14/whatsnew/3.14.html>_ document. For a more detailed change log, read Misc/NEWS <https://github.com/python/cpython/tree/main/Misc/NEWS.d>, but a full accounting of changes can only be gleaned from the commit history <https://github.com/python/cpython/commits/main>.

If you want to install multiple versions of Python, see the section below entitled "Installing multiple versions".

Documentation

Documentation for Python 3.14 <https://docs.python.org/3.14/>_ is online, updated daily.

It can also be downloaded in many formats for faster access. The documentation is downloadable in HTML, PDF, and reStructuredText formats; the latter version is primarily for documentation authors, translators, and people with special formatting requirements.

For information about building Python's documentation, refer to Doc/README.rst <https://github.com/python/cpython/blob/main/Doc/README.rst>_.

Testing

To test the interpreter, type make test in the top-level directory. The test set produces some output. You can generally ignore the messages about skipped tests due to optional features which can't be imported. If a message is printed about a failed test or a traceback or core dump is produced, something is wrong.

By default, tests are prevented from overusing resources like disk space and memory. To enable these tests, run make buildbottest.

If any tests fail, you can re-run the failing test(s) in verbose mode. For example, if test_os and test_gdb failed, you can run::

make test TESTOPTS="-v test_os test_gdb"

If the failure persists and appears to be a problem with Python rather than your environment, you can file a bug report <https://github.com/python/cpython/issues>_ and include relevant output from that command to show the issue.

See Running & Writing Tests <https://devguide.python.org/testing/run-write-tests.html>_ for more on running tests.

Installing multiple versions

On Unix and Mac systems if you intend to install multiple versions of Python using the same installation prefix (--prefix argument to the configure script) you must take care that your primary python executable is not overwritten by the installation of a different version. All files and directories installed using make altinstall contain the major and minor version and can thus live side-by-side. make install also creates ${prefix}/bin/python3 which refers to ${prefix}/bin/python3.X. If you intend to install multiple versions using the same prefix you must decide which version (if any) is your "primary" version. Install that version using make install. Install all other versions using make altinstall.

For example, if you want to install Python 2.7, 3.6, and 3.14 with 3.14 being the primary version, you would execute make install in your 3.14 build directory and make altinstall in the others.

Release Schedule

See PEP 745 <https://peps.python.org/pep-0745/>__ for Python 3.14 release details.

Copyright and License Information

See the LICENSE <https://github.com/python/cpython/blob/main/LICENSE>_ for information on the history of this software, terms & conditions for usage, and a DISCLAIMER OF ALL WARRANTIES.

This Python distribution contains no GNU General Public License (GPL) code, so it may be used in proprietary projects. There are interfaces to some GNU code but these are entirely optional.

All trademarks referenced herein are property of their respective holders.

Top Related Projects

Convert designs to code with AI

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot