Users Guide

Contents:

• Language Basics
  • Declaring Data Types
  • C variable and type definitions
  • Python functions vs. C functions
  • Automatic type conversions
  • Statements and expressions
  • Cython file types
  • Conditional Compilation
• Extension Types
  • Introduction
  • Static Attributes
  • Dynamic Attributes
  • Type declarations
  • Extension types and None
  • Special methods
  • Properties
  • C methods
  • Subclassing
  • Forward-declaring extension types
  • Fast instantiation
  • Instantiation from existing C/C++ pointers
  • Making extension types weak-referenceable
  • Controlling deallocation and garbage collection in CPython
  • Controlling pickling
  • Public and external extension types
  • Public extension types
  • Dataclass extension types
• Special Methods of Extension Types
  • Declaration
  • Docstrings
  • Initialisation methods: __cinit__() and __init__()
  • Finalization methods: __dealloc__() and __del__()
  • Arithmetic methods
  • Rich comparisons
  • The __next__() method
  • Special Method Table
• Sharing Declarations Between Cython Modules
  • Definition and Implementation files
  • What a Definition File contains
  • What an Implementation File contains
  • The cimport statement
  • Sharing C Functions
  • Sharing Extension Types
  • Versioning
• Interfacing with External C Code
  • External declarations
  • Using Cython Declarations from C
• Source Files and Compilation
  • Compiling from the command line
  • Basic setup.py
  • Multiple Cython Files in a Package
  • Integrating multiple modules
  • Compiling with pyximport
  • Compiling with cython.inline
  • Compiling with cython.compile
  • Compiling with Sage
  • Compiling with a Jupyter Notebook
  • Compiler directives
• Early Binding for Speed
• Using C++ in Cython
  • Overview
  • A simple Tutorial
  • Compilation and Importing
  • Advanced C++ features
  • RTTI and typeid()
  • Specify C++ language in setup.py
  • cpp_locals directive
  • Caveats and Limitations
• Fused Types (Templates)
  • Quickstart
  • Declaring Fused Types
  • Using Fused Types
  • Selecting Specializations
  • Built-in Fused Types
  • Casting Fused Functions
  • Type Checking Specializations
  • Conditional GIL Acquiring / Releasing
  • __signatures__
• Porting Cython code to PyPy
  • Reference counts
  • Object lifetime
  • Borrowed references and data pointers
  • Builtin types, slots and fields
  • GIL handling
  • Efficiency
  • Known problems
  • Bugs and crashes
• Migrating from Cython 0.29 to 3.0
  • Python 3 syntax/semantics
  • Python semantics
  • Binding functions
  • Namespace packages
  • NumPy C-API
  • Class-private name mangling
  • Arithmetic special methods
  • Exception values and noexcept
  • Annotation typing
  • C++ postincrement/postdecrement operator
  • Public Declarations in C++
  • ** power operator
• Limitations
  • Nested tuple argument unpacking
  • Inspect support
  • Stack frames
  • Identity vs. equality for inferred literals
• Differences between Cython and Pyrex
  • Python 3 Support
  • Conditional expressions “x if b else y”
  • cdef inline
  • Assignment on declaration (e.g. “cdef int spam = 5”)
  • ‘by’ expression in for loop (e.g. “for i from 0 <= i < 10 by 2”)
  • Boolean int type (e.g. it acts like a c int, but coerces to/from python as a boolean)
  • Executable class bodies
  • cpdef functions
  • Automatic range conversion
  • More friendly type casting
  • Optional arguments in cdef/cpdef functions
  • Function pointers in structs
  • C++ Exception handling
  • Synonyms
  • Source code encoding
  • Automatic typecheck
  • From __future__ directives
  • Pure Python mode
• Typed Memoryviews
  • Quickstart
  • Using memoryviews
  • Comparison to the old buffer support
  • Python buffer support
  • Memory layout
  • Memoryviews and the GIL
  • Memoryview Objects and Cython Arrays
  • Cython arrays
  • CPython array module
  • Coercion to NumPy
  • None Slices
  • Pass data from a C function via pointer
  • Performance: Disabling initialization checks
• Implementing the buffer protocol
  • A matrix class
  • Memory safety and reference counting
  • Flags
  • References
• Using Parallelism
  • Compiling
  • Breaking out of loops
  • Using OpenMP Functions
• Debugging your Cython program
  • Running the Debugger
  • Using the Debugger
  • Convenience functions
  • Configuring the Debugger
• Cython for NumPy users
  • Cython at a glance
  • Your Cython environment
  • Installation
  • Manual compilation
  • The first Cython program
  • Adding types
  • Efficient indexing with memoryviews
  • Tuning indexing further
  • Declaring the NumPy arrays as contiguous
  • Making the function cleaner
  • More generic code
  • Using multiple threads
  • Where to go from here?
• Creating Numpy ufuncs
• Pythran as a Numpy backend
  • Usage example with setuptools
• Cython and the GIL
  • Marking functions as able to run without the GIL
  • Releasing (and reacquiring) the GIL
  • Exceptions and the GIL
  • Don’t use the GIL as a lock
• Troubleshooting
  • Where the language is “messy”
  • AttributeErrors
  • Extension type class attributes vs instance attributes
  • Pitfalls of automatic type conversions
• FAQ
  • Basics
  • How do I …?
  • Explanations
  • About the project

Indices and tables

• Index

• Module Index

• Search Page