Books & Videos

Table of Contents

  1. Chapter 1 Understanding Performant Python

    1. The Fundamental Computer System

    2. Putting the Fundamental Elements Together

    3. So Why Use Python?

  2. Chapter 2 Profiling to Find Bottlenecks

    1. Profiling Efficiently

    2. Introducing the Julia Set

    3. Calculating the Full Julia Set

    4. Simple Approaches to Timing—print and a Decorator

    5. Simple Timing Using the Unix time Command

    6. Using the cProfile Module

    7. Using runsnakerun to Visualize cProfile Output

    8. Using line_profiler for Line-by-Line Measurements

    9. Using memory_profiler to Diagnose Memory Usage

    10. Inspecting Objects on the Heap with heapy

    11. Using dowser for Live Graphing of Instantiated Variables

    12. Using the dis Module to Examine CPython Bytecode

    13. Unit Testing During Optimization to Maintain Correctness

    14. Strategies to Profile Your Code Successfully

    15. Wrap-Up

  3. Chapter 3 Lists and Tuples

    1. A More Efficient Search

    2. Lists Versus Tuples

    3. Wrap-Up

  4. Chapter 4 Dictionaries and Sets

    1. How Do Dictionaries and Sets Work?

    2. Dictionaries and Namespaces

    3. Wrap-Up

  5. Chapter 5 Iterators and Generators

    1. Iterators for Infinite Series

    2. Lazy Generator Evaluation

    3. Wrap-Up

  6. Chapter 6 Matrix and Vector Computation

    1. Introduction to the Problem

    2. Aren’t Python Lists Good Enough?

    3. Memory Fragmentation

    4. Applying numpy to the Diffusion Problem

    5. numexpr: Making In-Place Operations Faster and Easier

    6. A Cautionary Tale: Verify “Optimizations” (scipy)

    7. Wrap-Up

  7. Chapter 7 Compiling to C

    1. What Sort of Speed Gains Are Possible?

    2. JIT Versus AOT Compilers

    3. Why Does Type Information Help the Code Run Faster?

    4. Using a C Compiler

    5. Reviewing the Julia Set Example

    6. Cython

    7. Shed Skin

    8. Cython and numpy

    9. Numba

    10. Pythran

    11. PyPy

    12. When to Use Each Technology

    13. Foreign Function Interfaces

    14. Wrap-Up

  8. Chapter 8 Concurrency

    1. Introduction to Asynchronous Programming

    2. Serial Crawler

    3. gevent

    4. tornado

    5. AsyncIO

    6. Database Example

    7. Wrap-Up

  9. Chapter 9 The multiprocessing Module

    1. An Overview of the Multiprocessing Module

    2. Estimating Pi Using the Monte Carlo Method

    3. Estimating Pi Using Processes and Threads

    4. Finding Prime Numbers

    5. Verifying Primes Using Interprocess Communication

    6. Sharing numpy Data with multiprocessing

    7. Synchronizing File and Variable Access

    8. Wrap-Up

  10. Chapter 10 Clusters and Job Queues

    1. Benefits of Clustering

    2. Drawbacks of Clustering

    3. Common Cluster Designs

    4. How to Start a Clustered Solution

    5. Ways to Avoid Pain When Using Clusters

    6. Three Clustering Solutions

    7. NSQ for Robust Production Clustering

    8. Other Clustering Tools to Look At

    9. Wrap-Up

  11. Chapter 11 Using Less RAM

    1. Objects for Primitives Are Expensive

    2. Understanding the RAM Used in a Collection

    3. Bytes Versus Unicode

    4. Efficiently Storing Lots of Text in RAM

    5. Tips for Using Less RAM

    6. Probabilistic Data Structures

  12. Chapter 12 Lessons from the Field

    1. Adaptive Lab’s Social Media Analytics (SoMA)

    2. Making Deep Learning Fly with RadimRehurek.com

    3. Large-Scale Productionized Machine Learning at Lyst.com

    4. Large-Scale Social Media Analysis at Smesh

    5. PyPy for Successful Web and Data Processing Systems

    6. Task Queues at Lanyrd.com