Index
A
- abstract base classes (ABCs)
- about / Using function annotations and abstract base classes
- reference link / Using collections.abc
- Abstract Syntax Tree (AST)
- about / Metaprogramming, Abstract Syntax Tree
- import hooks / Import hooks
- import hooks, URL / Import hooks
- acceptance tests
- about / Acceptance tests
- adapter pattern
- about / Adapter
- application-level isolation
- Python environments / Application-level isolation of Python environments
- need for / Why isolation?
- popular solutions / Popular solutions
- virtualenv / virtualenv
- venv / venv
- buildout / buildout
- Application Binary Interface (ABI) / How do extensions in C or C++ work
- approximate member query (AMQ) / Using probabilistic data structures
- approximation algorithms / Using heuristics and approximation algorithms
- architectural trade offs
- using / Using architectural trade-offs
- heuristics and approximation algorithms, using / Using heuristics and approximation algorithms
- argument checking
- about / Argument checking
- argument inbound outbound / How Python deals with memory
- asynchronous programming
- about / Asynchronous programming
- cooperative multitasking / Cooperative multitasking and asynchronous I/O
- asynchronous I/O / Cooperative multitasking and asynchronous I/O
- Python async / Python async and await keywords
- await keywords / Python async and await keywords
- asyncio module / asyncio in older versions of Python
- example / A practical example of asynchronous programming
- nonasynchronous code integration with async using futures / Integrating nonasynchronous code with async using futures
- atomisator package
- URL / Writing a story
- attribute access patterns
- about / Advanced attribute access patterns
- descriptors / Descriptors
- lazily evaluated attributes / Real-life example – lazily evaluated attributes
- properties / Properties
- slots / Properties, Slots
- automation
- deploying, Fabric used / Deployment automation using Fabric
- Awesome-python
- URL / Useful resources
B
- bandersnatch
- URL / PyPI mirroring
- behavioral patterns
- about / Behavioral patterns
- observer pattern / Observer
- visitor / Visitor
- template / Template
- Benevolent Dictator For Life (BDFL)
- reference link / The private controversy
- best practices / Best practices
- best practices, arguments
- rules / Best practices for arguments
- iterative design, used for building / Building arguments by iterative design
- trusting / Trust the arguments and your tests
- *args argument / Using *args and **kwargs magic arguments carefully
- **kwargs argument / Using *args and **kwargs magic arguments carefully
- bidding service
- big O notation
- about / Reducing the complexity, The big O notation
- URL / The big O notation
- binding convention flags / Calling and binding conventions
- Blinker
- reference link / Observer
- Bloom filter
- Borg / Singleton
- bottlenecks
- finding / Finding bottlenecks
- CPU usage, profiling / Profiling CPU usage
- memory usage, profiling / Profiling memory usage
- network usage, profiling / Profiling network usage
- bpython
- build artifacts / Continuous integration
- Buildbot
- buildout / buildout
- build slaves / Buildbot
- built-in multiprocessing module
- about / The built-in multiprocessing module
- process pools, using / Using process pools
- multiprocessing.dummy, using as multithreading interface / Using multiprocessing.dummy as a multithreading interface
- bytes
- about / Strings and bytes
- versus byte string / Strings and bytes
C
- C
- about / Different language means – C or C++
- extensions, working / How do extensions in C or C++ work
- C++
- about / Different language means – C or C++
- extensions, working / How do extensions in C or C++ work
- C3 / Understanding Python's Method Resolution Order
- cache services
- about / Cache services
- memcached / Memcached
- caching
- about / Caching, Caching
- deterministic caching / Deterministic caching
- nondeterministic caching / Nondeterministic caching
- CDN (Content Delivery Network) / PyPI mirroring
- Celery
- challenges
- about / Challenges
- additional complexity / Additional complexity
- debugging / Debugging
- Circus
- clang / bdist and wheels
- class decorators
- about / Class decorators
- __new__() method, overriding for instance creation process / Using the __new__() method to override instance creation process
- class names
- selecting / Class names
- client / Proxy
- code
- instrumenting / Code instrumentation and monitoring
- monitoring / Code instrumentation and monitoring
- errors, logging / Logging errors – sentry/raven
- system and application metrics, monitoring / Monitoring system and application metrics
- application logs, dealing with / Dealing with application logs
- low-level log practices / Basic low-level log practices
- log processing, tools / Tools for log processing
- code coverage
- about / Testing coverage
- code generation
- tips / Projects using code generation patterns
- Falcons compiled router / Falcon's compiled router
- Hy / Hy
- code vendoring
- collections
- about / Collections
- lists / Collections
- tuples / Lists and tuples
- dictionaries / Dictionaries
- sets / Sets
- module / Beyond basic collections – the collections module
- collections.abc, abstract base classes
- Container / Using collections.abc
- Iterable / Using collections.abc
- Callable / Using collections.abc
- Hashable / Using collections.abc
- Sized / Using collections.abc
- collections module
- about / Using collections
- deque / deque
- defaultdict / defaultdict
- namedtuple / namedtuple
- common pattern
- about / Common patterns
- automated inclusion of version string / Automated inclusion of version string from package
- README file / README file
- dependencies, managing / Managing dependencies
- compile / exec, eval, and compile
- complexity
- reducing / Reducing the complexity
- about / Reducing the complexity
- cyclomatic complexity / Cyclomatic complexity
- worst-case complexity / The big O notation
- concurrency
- benefits / Why concurrency?
- about / Why concurrency?
- issues, approaching / Why concurrency?
- Concurrent Version System (CVS) / Centralized systems
- consumer layout
- index pages, working on / Working on the index pages
- module helpers, registering / Registering module helpers
- index markers, adding / Adding index markers
- cross-references / Cross-references
- containerization
- versus virtualization / Containerization versus virtualization
- contextlib module / As a function – the contextlib module
- context managers
- about / Context managers – the with statement
- syntax / General syntax and possible implementations
- implementations / General syntax and possible implementations
- as class / As a class
- as function / As a function – the contextlib module
- context provider
- about / Context provider
- continuous development processes
- about / Continuous development processes
- continuous integration (CI) / Continuous integration
- continuous delivery / Continuous delivery
- continuous delivery, prerequisites / Continuous delivery
- continuous deployment / Continuous deployment
- continuous integration, popular tools / Popular tools for continuous integration
- right tool, selecting / Choosing the right tool and common pitfalls
- common pitfalls / Choosing the right tool and common pitfalls
- continuous integration (CI)
- reference link / Continuous integration
- every commit, testing / Testing every commit
- testing, merging through / Merge testing through CI
- matrix testing / Matrix testing
- tools / Popular tools for continuous integration
- convention flags
- METH_VARARGS / Calling and binding conventions
- METH_KEYWORDS / Calling and binding conventions
- METH_NOARGS / Calling and binding conventions
- METH_O / Calling and binding conventions
- CPU usage, bottlenecks
- profiling / Profiling CPU usage
- macro-profiling / Macro-profiling
- micro-profiling / Micro-profiling
- Pystones, measuring / Measuring Pystones
- CPython
- about / Not only CPython
- CPython core
- reference link / Buildbot
- creational patterns
- about / Creational patterns
- singleton / Singleton
- cross-version compatibility
- maintaining, tools / The popular tools and techniques used for maintaining cross-version compatibility
- ctypes
- about / ctypes
- libraries, loading / Loading libraries
- used, for calling C functions / Calling C functions using ctypes
- Python functions, passing as C callbacks / Passing Python functions as C callbacks
- CFFI / CFFI
- ctypes.CDLL class / Loading libraries
- ctypes.PyDLL class / Loading libraries
- cx_Freeze
- reference link / cx_Freeze
- cyclomatic complexity
- Cython
- about / Cython
- as source to source compiler / Cython as a source to source compiler
- as language / Cython as a language
D
- data descriptor / Descriptors
- data uniqueness / Proxy
- deadlock / What is multithreading?
- decorator pattern / Structural patterns
- decorators
- about / Decorators
- syntax / General syntax and possible implementations
- implementations / General syntax and possible implementations
- as functions / As a function
- as class / As a class
- parametrizing / Parametrizing decorators
- introspection preserving / Introspection preserving decorators
- defaultdict / defaultdict
- delayed processing
- demand-side platforms (DSP) / Improving performance in critical code sections
- dependency compatibility / Testing environment and dependency compatibility
- dependency matrix testing
- about / Dependency matrix testing
- deque / deque
- descriptor protocol / Descriptors
- Design by Contract (Dbc)
- reference link / Trust the arguments and your tests
- design patterns
- creational patterns / Creational patterns
- structural patterns / Structural patterns
- behavioral patterns / Behavioral patterns
- deterministic caching
- about / Deterministic caching
- deterministic profiler / Profiling CPU usage
- development mode / setup.py develop or pip -e
- devpi
- URL / PyPI mirroring
- dictionaries
- about / Dictionaries
- implementation details / Implementation details
- weaknesses and alternatives / Weaknesses and alternatives
- distributed systems
- about / Distributed systems
- distributed strategies / Distributed strategies
- Distributed VCS (DVCS) / Centralized systems
- django-userena project
- Django REST Framework
- doctest
- URL / Python standard test tools
- about / doctest
- doctest module
- reference link / Constants
- Document-driven development (DDD)
- about / Document-driven development
- story, writing / Writing a story
- documentation
- building / Building the documentation
- portfolio, building / Building the portfolio
- documentation portfolio / Building the documentation
- document landscape / Building the documentation
- Domain Specific Language (DSL) / Metaprogramming
- Dublin Core information
- reference link / Adapter
- Dylan programming language
- dynamic libraries, without extensions
- interfacing / Interfacing with dynamic libraries without extensions
- ctypes / ctypes
E
- Elasticsearch / Tools for log processing
- Epydoc
- reference link / Module helper
- eval / exec, eval, and compile
- eval() / exec, eval, and compile
- event-driven programming
- reference link / Observer
- exec / exec, eval, and compile
- URL / exec, eval, and compile
- executors
- and futures / Executors and futures
- using, in event loop / Using executors in an event loop
- extensions
- using / Why you might want to use extensions
- performance, improving in critical code sections / Improving performance in critical code sections
- existing code written in different languages, integrating / Integrating existing code written in different languages
- third-party dynamic libraries, integrating / Integrating third-party dynamic libraries
- custom datatypes, creating / Creating custom datatypes
- writing / Writing extensions
- pure C extensions / Pure C extensions
- Cython / Cython
- extra commands / setup.py
- eXtreme Programming (XP) / Continuous integration
F
- Fabric
- used, for deploying automation / Deployment automation using Fabric
- URL / Deployment automation using Fabric
- and Python 3 / Deployment automation using Fabric
- fake
- about / Fakes and mocks
- building / Building a fake
- Falcons compiled router
- about / Falcon's compiled router
- URL / Falcon's compiled router
- FIFO (First In First Out) queue / deque
- filesystem hierarchy
- about / The filesystem hierarchy
- flake8
- about / Useful tools, pep8 and flake8
- foreign function library
- reference link / Loading libraries
- forking / Multiprocessing
- for
else
statement
- about / The for … else … statement
- functional programming
- URL / Caching
- functional testing
- URL / Acceptance tests
- functional tests
- about / Functional tests
- function annotations
- about / Function annotations
- general syntax / The general syntax
- possible uses / The possible uses
- function library
- reference link / Loading libraries
- future module
- futures
- used, for integrating nonasynchronous code with async / Integrating nonasynchronous code with async using futures
- and executors / Executors and futures
- fuzz testing
- reference link / Trust the arguments and your tests
G
- gcc / bdist and wheels
- getter / Descriptors
- Gevent
- reference link / A practical example of asynchronous programming
- GIL (global interpreter lock) / Jython
- Git
- reference link / Distributed strategies
- Git flow
- about / Git flow and GitHub flow
- reference link / Git flow and GitHub flow
- GitHub flow
- about / Git flow and GitHub flow
- reference link / Git flow and GitHub flow
- GitLab CI
- about / GitLab CI
- Global Interpreter Lock (GIL) / Why you might want to use extensions, How Python deals with threads
- GLSL (OpenGL Shading Language) / Real-life example – lazily evaluated attributes
- Gprof2Dot
- URL / Macro-profiling
- Grafana
- Graphite
- Graphviz
- URL / Macro-profiling, objgraph
- Gunicorn
- reference link / Multiuser applications
H
- hashable / Lists and tuples, Implementation details
- heuristics algorithms / Using heuristics and approximation algorithms
- Hy
- about / Some tips on code generation, Hy
- URL / Hy
- HyperLogLog
I
- immutable / Lists and tuples
- import path hooks / Import hooks
- include file / bdist and wheels
- index
- index mirror
- integration tests
- about / Integration tests
- interactive debuggers
- about / Interactive debuggers
- interfaces, structural patterns
- about / Interfaces
- zope.interface, using / Using zope.interface
- function annotations, using / Using function annotations and abstract base classes
- abstract base classes, using / Using function annotations and abstract base classes
- using collections.abc, using / Using collections.abc
- interpreter directive / Standalone executables
- IOPS (Input Output Operations Per Second) / Tools for log processing
- IPython
- ironclad
- URL / IronPython
- IronPython
- about / IronPython
- URL / IronPython
- isolation
- about / Isolation
- iterators
- about / Iterators
J
K
- Kibana / Tools for log processing
- kilo pystones / Measuring Pystones
L
- landscape, building
- about / Building the landscape
- producer's layout / Producer's layout
- consumer's layout / Consumer's layout
- lazily loaded modules / Changes in the standard library
- linearization / Understanding Python's Method Resolution Order
- Liskov substitution principle / Template
- list
- searching in / Searching in a list
- set, using instead / Using a set instead of a list
- external calls, cutting / Cut the external calls, reduce the workload
- workload, reducing / Cut the external calls, reduce the workload
- lists
- about / Lists and tuples
- implementation details / Implementation details
- comprehensions / List comprehensions
- other idioms / Other idioms
- load tests
- about / Load and performance testing
- logrotate / Basic low-level log practices
- Logstash / Tools for log processing
M
- macro-profiling
- about / Macro-profiling
- MacroPy project
- URL / Abstract Syntax Tree
- MD5
- about / Memcached
- memcached
- about / Memcached
- memoizing
- URL / Caching
- memory usage, bottlenecks
- profiling / Profiling memory usage
- memory, usage / How Python deals with memory
- memory, profiling / Profiling memory
- objgraph / objgraph
- C code memory / C code memory leaks
- memory_profiler
- URL / Profiling memory
- Memprof
- URL / Profiling memory
- metaclasses
- syntax / The general syntax
- new Python 3 syntax / New Python 3 syntax for metaclasses
- usage / Metaclass usage
- pitfalls / Metaclass pitfalls
- metaheuristics / Using heuristics and approximation algorithms
- meta hooks / Import hooks
- metaprogramming
- about / Metaprogramming
- methods / Decorators – a method of metaprogramming
- class decorators / Class decorators
- metclasses
- about / Metaclasses
- Method Resolution Order (MRO) / Accessing methods from superclasses
- MFC framework
- reference link / Observer
- micro-profiling
- about / Micro-profiling
- Millions Of Whetstone Instructions Per Second (MWIPS)
- URL / Measuring Pystones
- mixedCase / Functions and methods
- mocks
- using / Using mocks
- module names
- rules / Module and package names
- module pattern / Structural patterns
- monkeypatches / Fakes and mocks
- Monostate / Singleton
- multiprocessing
- about / Multiprocessing
- built-in module / The built-in multiprocessing module
- multithreading
- about / Multithreading, What is multithreading?
- in Python / How Python deals with threads
- using / When should threading be used?
- used, for building responsive interfaces / Building responsive interfaces
- used, for delegating work / Delegating work
- used, for multiuser applications / Multiuser applications
- threaded application, example / An example of a threaded application
- Munin
- munin-node-c
- munin-node-python
- munin-python package
- MVC paradigm
- reference link / Visitor
N
- namedtuple / namedtuple
- namespace packages
- about / Namespace packages
- uses / Why is it useful?
- PEP 420 (Implicit Namespace Packages / PEP 420 – implicit namespace packages
- in previous Python versions / Namespace packages in previous Python versions
- naming guide
- about / The naming guide
- has prefix, using for Boolean elements / Using the has or is prefix for Boolean elements
- is prefix, using for Boolean elements / Using the has or is prefix for Boolean elements
- plural, using for variables / Using plurals for variables that are collections
- explicit names, using for dictionaries / Using explicit names for dictionaries
- generic names, avoiding / Avoiding generic names
- reference link / Avoiding generic names
- existing names, avoiding / Avoiding existing names
- naming styles
- about / Naming styles
- applying, to variables / Variables
- net-snmp
- URL / Profiling network usage
- network usage, bottlenecks
- profiling / Profiling network usage
- non-data descriptor / Descriptors
- non-preemptive multitasking / Cooperative multitasking and asynchronous I/O
- nondeterministic caching
- about / Nondeterministic caching
- nose
- URL / unittest alternatives, Integration with setuptools and a plug-in system
- about / nose
- test runner / Test runner
- tests, writing / Writing tests
- test fixtures, writing / Writing test fixtures
- setuptools and plug-in system, integration with / Integration with setuptools and a plug-in system
- wrap-up / Wrap-up, py.test
- ntop
- URL / Profiling network usage
O
- object built-in type
- about / Subclassing built-in types
- objgraph
- about / objgraph
- observer pattern
- about / Observer
- open addressing
- URL / Implementation details
- optimization
- rules / The three rules of optimization
- work, prioritizing / Make it work first
- users point of view, working from / Work from the user's point of view
- code, making readable / Keep the code readable and maintainable
- code, making maintainable / Keep the code readable and maintainable
- optimization, strategy
- about / Optimization strategy
- faults, detecting / Find another culprit
- hardware resources, examining / Scale the hardware
- speed test, examining / Writing a speed test
P
- package
- creating / Creating a package
- Python packaging tools, confusing state / The confusing state of Python packaging tools
- project configuration / Project configuration
- custom setup command / The custom setup command
- working with in development stage / Working with packages during development
- setup.py install command / setup.py install
- uninstalling / Uninstalling packages
- setup.py develop / setup.py develop or pip -e
- pip -e / setup.py develop or pip -e
- uploading / Uploading a package
- Python Package Index (PyPI) / PyPI – Python Package Index
- source packages, versus built packages / Source packages versus built packages, sdist
- used, for deployment / Deployment using a package
- package names
- rules / Module and package names
- parallel processing / Why concurrency?
- Pathrate
- URL / Profiling network usage
- pdb
- URL / Interactive debuggers
- Peephole optimizer / String concatenation
- PEP 8
- about / PEP 8 and naming best practices
- reference links / PEP 8 and naming best practices
- naming best practices / PEP 8 and naming best practices
- advantages / Why and when to follow PEP 8?
- team-specific style guidelines / Beyond PEP 8 – team-specific style guidelines
- pep8
- about / Useful tools
- pep8 tool
- about / pep8 and flake8
- PEP 420 (Implicit Namespace Packages) / PEP 420 – implicit namespace packages
- PEP 440 (Version Identification and Dependency Specification / Automated inclusion of version string from package
- PEP 3107 / The possible uses
- performance tests
- about / Load and performance testing
- pickle
- URL / Caching
- pitfalls, continuous integration (CI)
- complex build strategies / Problem 1 – too complex build strategies
- long building time / Problem 2 – too long building time
- external job definitions / Problem 3 – external job definitions
- lack of isolation / Problem 4 – lack of isolation
- Plone
- reference link / Module helper
- portfolio
- creating / Making your own portfolio
- landscape, building / Building the landscape
- documentation, building / Documentation building and continuous integration
- continuous integration / Documentation building and continuous integration
- portfolio, building
- about / Building the portfolio
- usage / Building the portfolio, Usage
- operations / Building the portfolio, Operations
- design / Design
- Ppackage repository
- reference link / .pypirc
- precedence / Understanding Python's Method Resolution Order
- probabilistic data structures
- process supervision tools
- using / Using process supervision tools
- productivity tools
- about / Popular productivity tools
- Python shells, custom / Custom Python shells – IPython, bpython, ptpython, and so on
- PYTHONSTARTUP environment variable, setting up / Setting up the PYTHONSTARTUP environment variable
- project configuration
- about / Project configuration
- setup.py / setup.py
- setup.cfg / setup.cfg
- MANIFEST.in / MANIFEST.in
- important metadata / Most important metadata
- trove classifiers / Trove classifiers
- common patterns / Common patterns
- provisional package
- URL / Using mocks
- proxy / Proxy
- proxy decorators
- about / Proxy
- ptpython
- pure C extensions
- about / Pure C extensions
- Python/C API / A closer look at Python/C API
- conventions, calling / Calling and binding conventions
- conventions, binding / Calling and binding conventions
- exception handling / Exception handling
- GIL, releasing / Releasing GIL
- reference counting algorithm / Reference counting
- reference counting / Reference counting
- PVTS (Python Tools for Visual Studio) / IronPython
- py.test
- URL / unittest alternatives
- about / py.test
- test fixtures, writing / Writing test fixtures
- test functions and classes, disabling / Disabling test functions and classes
- distributed tests, automated / Automated distributed tests
- wrap-up / Wrap-up
- py2app
- reference link / py2exe and py2app
- py2exe
- reference link / py2exe and py2app
- PyInstaller
- reference link / PyInstaller
- Pylint
- about / Useful tools, Pylint
- Pympler
- URL / Profiling memory
- PyPA
- reference link / The current landscape of Python packaging thanks to PyPA
- PyPA (Python Packaging Authority) / Application-level isolation of Python environments
- PyPI
- reference link / Uploading a package
- PyPI (Python Package Index)
- PyPI mirroring
- about / PyPI mirroring
- PyPy
- about / PyPy
- pyrilla project
- Pystones
- measuring / Measuring Pystones
- about / Measuring Pystones
- pytest-dbfixtures
- reference link / Problem 4 – lack of isolation
- Python
- history / Where are we now and where we are going?
- changes / Why and how does Python change?
- wiki page, URL / Why should I care?
- useful resources / Useful resources
- built-in types / Python's built-in types
- strings and bytes / Strings and bytes
- implementation details / Implementation details
- features / Advanced syntax
- reference link / A reStructuredText primer
- URL / How Python deals with memory
- Python-Dev mailing list
- reference link / The private controversy
- Python/C API
- reference link / Calling and binding conventions
- Python 2
- URL / Why should I care?, New Python 3 syntax for metaclasses
- super / Old-style classes and super in Python 2
- old style classes / Old-style classes and super in Python 2
- Python 3
- adoption / Python 3 adoption at the time of writing this book
- URL / The main syntax differences and common pitfalls
- groups / The main syntax differences and common pitfalls
- syntax changes / Syntax changes
- standard library, changes / Changes in the standard library
- datatypes and collections, changes / Changes in datatypes and collections
- new features, URL / The possible uses
- Python built-ins
- URL / exec, eval, and compile
- Python development
- modern approaches / Modern approaches to Python development
- Python documentation
- URL / Weaknesses and alternatives
- reference link / A closer look at Python/C API
- Python Enhancement Proposal (PEP)
- Python environments
- application-level isolation / Application-level isolation of Python environments
- Python Method Resolution Order
- Python Package Index (PyPI)
- about / PyPI – Python Package Index
- uploading to / Uploading to PyPI – or other package index
- .pypirc / .pypirc
- Python Packaging Authority (PyPA) / The confusing state of Python packaging tools
- Python packaging tools
- about / The confusing state of Python packaging tools
- current landscape / The current landscape of Python packaging thanks to PyPA
- recommendations / Tool recommendations
- Python Packaging User Guide
- reference link / The confusing state of Python packaging tools
- recommendations / Tool recommendations
- Python shells
- Python standard test tools
- about / Python standard test tools
- unittest / unittest
- doctest / doctest
- PYTHONSTARTUP environment variable
- setting up / Setting up the PYTHONSTARTUP environment variable
- Python Timsort / Passing Python functions as C callbacks
- Python Weekly
- URL / Useful resources
- Python Wheels page
- reference link / bdist and wheels
Q
- Quicksort algorithm / Passing Python functions as C callbacks
R
- race hazard / What is multithreading?
- Read the Docs
- reference link / Documentation building and continuous integration
- Real Time Bidding (RTB) / Improving performance in critical code sections
- Redis Queue (RQ)
- Reentrant locks / What is multithreading?
- reference counting algorithm / Reference counting
- reference ownership
- passing of ownership / Reference counting
- borrowed references / Reference counting
- stolen references / Reference counting
- repositories
- unstable repository / Distributed strategies
- stable repository / Distributed strategies
- release repositories / Distributed strategies
- requests package
- reference link / Facade
- reStructuredText
- reference link / README file, A reStructuredText primer
- about / A reStructuredText primer
- section structure / Section structure
- lists / Lists
- inline markup / Inline markup
- literal block / Literal block
- links / Links
- reverse HTTP proxies
- about / Using reverse HTTP proxies
- rules, technical writing
- about / The seven rules of technical writing
- two step writing / Write in two steps
- readership, targeting / Target the readership
- simple style, reference link / Use a simple style
- simple style, using / Use a simple style
- information scope, limiting / Limit the scope of information
- realistic code examples, using / Use realistic code examples
- sufficient approach, using / Use a light but sufficient approach
- sufficient approach, reference link / Use a light but sufficient approach
- templates, using / Use templates
S
- S5
- reference link / A reStructuredText primer
- Semantic Versioning
- Sentry
- Service Level Agreements / Load and performance testing
- sets
- about / Sets
- implementation details / Implementation details
- setter / Descriptors
- SHA
- about / Memcached
- shebang / Standalone executables
- signals / Multiprocessing
- Six
- slots / Properties, Slots
- source packages, versus built packages
- about / Source packages versus built packages
- sdist / sdist
- bdist / bdist and wheels
- wheels / bdist and wheels
- Soya 3D
- URL / Make it work first
- special methods
- reference link / Special methods
- SpeedStep / Micro-profiling
- Sphinx
- reference link / Consumer's layout
- about / Cross-references
- Stackless Python
- URL / Stackless Python
- stackless Python
- about / Stackless Python
- standalone executables
- about / Standalone executables
- uses / When are standalone executables useful?
- popular tools / Popular tools
- Python code, security / Security of Python code in executable packages
- Python code security, decompilation process / Making decompilation harder
- standard commands / setup.py
- statistical profiler / Profiling CPU usage
- StatsD
- step / Buildbot
- string
- concatenation / String concatenation
- strings
- about / Strings and bytes
- structural patterns
- about / Structural patterns
- adapter pattern / Adapter
- interfaces / Interfaces
- proxy / Proxy
- facade / Facade
- subclassing built-in types
- about / Subclassing built-in types
- Subversion (SVN) / Centralized systems
- super
- about / Old-style classes and super in Python 2
- pitfalls / super pitfalls
- and explicit class calls, mixing / Mixing super and explicit class calls
- heterogeneous arguments / Heterogeneous arguments
- superclasses
- methods, accessing from / Accessing methods from superclasses
- Supervisor / Basic low-level log practices
- system-level environment isolation
- about / System-level environment isolation
- Vagrant used / Virtual development environments using Vagrant
- containerization, versus virtualization / Containerization versus virtualization
T
- task queues
- TDD
- about / Test-driven development principles
- benefits / Test-driven development principles
- software regression, preventing / Preventing software regression
- code quality, improving / Improving code quality
- developer documentation, providing / Providing the best developer documentation
- robust code, producing / Producing robust code faster
- TDD, tests
- about / What kind of tests?
- acceptance tests / Acceptance tests
- unit tests / Unit tests
- functional tests / Functional tests
- integration tests / Integration tests
- load and performance testing / Load and performance testing
- code quality testing / Code quality testing
- technical writing
- template pattern
- about / Template
- test discovery / unittest
- test fixtures
- writing / Writing test fixtures
- package level / Writing test fixtures
- module level / Writing test fixtures
- test level / Writing test fixtures
- testing
- The Hitchhikers Guide to Packaging / The confusing state of Python packaging tools
- threaded application example
- about / An example of a threaded application
- one thread per item, using / Using one thread per item
- thread pool, using / Using a thread pool
- two-way queues, using / Using two-way queues
- errors, dealing with / Dealing with errors and rate limiting
- rate limiting / Dealing with errors and rate limiting
- timeslicing mechanism / What is multithreading?
- tools
- Pylint / Useful tools, Pylint
- pep8 / Useful tools, pep8 and flake8
- flake8 / Useful tools, pep8 and flake8
- tools, continuous integration (CI)
- about / Popular tools for continuous integration
- Jenkins / Jenkins
- Buildbot / Buildbot
- Travis CI / Travis CI
- GitLab CI / GitLab CI
- tools, standalone executables
- PyInstaller / PyInstaller
- cx_Freeze / cx_Freeze
- py2exe / py2exe and py2app
- py2app / py2exe and py2app
- Tox tool
- reference link / Matrix testing
- Traveling Salesman Problem (TSP) / Using heuristics and approximation algorithms
- Travis CI
- reference link / Travis CI
- about / Travis CI, Choosing the right tool and common pitfalls
- URL / Dependency matrix testing
- trove classifiers / Trove classifiers
- tuples
- about / Lists and tuples
- Twelve-Factor App
- about / The Twelve-Factor App
- rules / The Twelve-Factor App
- URL / The Twelve-Factor App, Deployment using a package
- conventions and practices / Common conventions and practices
- Filesystem Hierarchy Standard / The filesystem hierarchy
- isolation / Isolation
- process supervision tools, using / Using process supervision tools
- application code, running in user space / Application code should be run in user space
- reverse HTTP proxies, using / Using reverse HTTP proxies
- processes, reloading / Reloading processes gracefully
- type annotations
- reference link / Using function annotations and abstract base classes
U
- unittest
- about / Python standard test tools, unittest
- URL / Python standard test tools, Writing tests
- pitfalls / unittest pitfalls
- alternatives / unittest alternatives
- unit tests
- about / Unit tests
- usage, portfolio
- useracceptance tests
- about / Acceptance tests
- uWSGI
- reference link / Multiuser applications
V
- Vagrant
- using, for virtual development environments / Virtual development environments using Vagrant
- Valgrind / C code memory leaks
- variables
- constants / Constants
- naming / Naming and usage
- usage / Naming and usage
- public variable / Public and private variables
- private variable / Public and private variables
- functions / Functions and methods
- methods / Functions and methods
- private controversy / The private controversy
- special methods / Special methods
- arguments / Arguments
- properties / Properties
- classes / Classes
- modules / Modules and packages
- packages / Modules and packages
- Vehicle Routing Problem (VRP) / Using heuristics and approximation algorithms
- venv / venv
- URL / venv
- version control systems (VCS)
- about / Version control systems
- centralized systems / Centralized systems
- distributed systems / Distributed systems
- centralized version control systems / Centralized or distributed?
- Git, using / Use Git if you can
- Git flow / Git flow and GitHub flow
- GitHub flow / Git flow and GitHub flow
- virtualenv / virtualenv
- virtualization
- versus containerization / Containerization versus virtualization
- visitor pattern
- about / Visitor
W
- wireshark
- URL / Profiling network usage
- worst-case complexity / The big O notation
X
- XML-RPC protocol
- URL / Argument checking
Y
- yield statement
- about / The yield statement
Z
- Zope Component Architecture (ZCA)
- about / Structural patterns
- reference link / Structural patterns