New
Python Crash Course, 3rd Edition
A Hands-On, Project-Based Introduction to Programming in Python
by Eric Matthes
2023
View →
Pages
970
Published
2022
Python
✨ New
Fluent Python
Clear, Concise, and Effective Programming with Python's Most Powerful Features
Write Python that reads like expert code — by understanding what the language was designed to do, not just how to make it work.
Fluent Python takes you past syntax and into the mechanics that make Python distinctive. Luciano Ramalho walks through the data model, sequences, functions as objects, object-oriented idioms, and concurrency with precision and depth. At 970 pages, this is a thorough treatment of the language aimed at programmers who already write Python and want to write it the way experienced Pythonistas actually do.
Advertisement
About this book
Most Python programmers learn enough to get their code running. Fluent Python is for the ones who want to understand why it runs the way it does, and how to use the language the way its designers intended.
Luciano Ramalho spent years studying the CPython source, the Python data model, and the patterns that distinguish idiomatic Python from code that merely works. This book is the result: a structured, example-driven tour of the language features that separate competent Python from fluent Python.
The book opens with the Python data model — the protocol layer that powers operator overloading, iteration, context managers, and more. From there it moves through sequences and mappings in depth, first-class functions, decorators, closures, object-oriented design with descriptors and metaclasses, and finally concurrency with asyncio, threads, and concurrent.futures. Every chapter builds on the last, and every concept is grounded in runnable examples.
This second edition has been updated for Python 3.10, covering pattern matching introduced in Python 3.10, revised type hinting coverage aligned with modern usage, and updated concurrency chapters that reflect the current state of asyncio.
- The Python data model and how dunder methods give your objects native behavior
- Sequences, dicts, and sets at the implementation level
- Functions as first-class objects, closures, and parametrized decorators
- Type hints, protocols, and the limits of static typing in Python
- Object-oriented idioms: inheritance, mixins, operator overloading, and descriptors
- Concurrency with threads, processes, and asyncio coroutines
- Structural pattern matching with match/case
If you write Python regularly and still feel like you are working around the language rather than with it, Fluent Python is the book that closes that gap. It does not teach you to write more Python. It teaches you to write better Python.
🎯 What you'll learn
- Implement dunder methods to give your own classes native Python behavior like iteration, comparison, and arithmetic
- Choose the right sequence or mapping type for a given problem based on how each is implemented
- Write decorators that accept parameters and compose cleanly with other decorators
- Use type hints and protocols to express interfaces without sacrificing Python's flexibility
- Design class hierarchies that rely on composition and mixins rather than deep inheritance chains
- Apply descriptors to control attribute access in reusable, framework-quality ways
- Structure concurrent programs using asyncio coroutines, threads, and process pools appropriately for each workload
- Read and understand pattern matching with match/case and apply it to real dispatch problems
👤 Who is this book for?
- Intermediate Python developers who can already write scripts and applications but want to understand the language at a deeper level
- Backend engineers who use Python daily and notice gaps between their code and the patterns they see in well-regarded open-source libraries
- Data scientists and analysts who are fluent in Python's scientific stack but less confident in the core language mechanics beneath it
- Engineers moving to Python from another language who want to avoid carrying over idioms that do not translate
- Senior developers preparing to mentor others on Python best practices and needing a solid reference for idiomatic patterns
Table of contents
-
01
The Python Data Model
Introduces the special method protocol that underpins all native Python behavior. You implement a simple card deck class to see how dunder methods connect your objects to built-in functions and operators.
-
02
An Array of Sequences
Covers lists, tuples, arrays, and their variants at the implementation level. You learn when to use each, how slicing and unpacking work internally, and how to avoid common performance traps.
-
03
Dictionaries and Sets
Examines the hash table implementation behind dicts and sets, explaining why key order is preserved, what makes a valid key, and how to choose between mapping types for different use cases.
-
04
Unicode Text Versus Bytes
Explains the boundary between text and binary data in Python 3, covering encodings, the codec system, and the correct patterns for reading, writing, and converting text in real applications.
-
05
Data Class Builders
Surveys named tuples, dataclasses, and attrs as tools for building data-holding classes. You compare their trade-offs and learn which to reach for depending on mutability, validation, and serialization needs.
-
06
Functions as First-Class Objects
Treats functions as objects: callable attributes, higher-order functions, and the functional programming features Python supports. You learn where this style fits naturally and where it does not.
-
07
Decorators and Closures
Builds a complete mental model of how closures capture variables and how decorators transform callables. You implement parameterized decorators and understand the stacking order when multiple decorators apply.
-
08
Type Hints in Functions
Introduces gradual typing, type aliases, and the use of mypy for checking annotated code. You learn how to add hints that document intent without over-constraining the flexibility Python programmers expect.
-
09
Pythonic Objects
Covers the dunder methods that control object representation, comparison, hashing, and formatting. You build a Vector class that behaves like a native Python type throughout this chapter and the next.
-
10
Interfaces, Protocols, and ABCs
Distinguishes duck typing, nominal typing, and structural subtyping, and shows when abstract base classes add value versus when they introduce unnecessary ceremony. You implement a protocol for a real use case.
-
11
Inheritance and Mixins
Examines when inheritance is appropriate, how multiple inheritance and the MRO work, and how mixin classes let you compose behavior without committing to a rigid hierarchy.
-
12
Operator Overloading
Shows how to implement arithmetic, comparison, and augmented-assignment operators correctly, including the rules around reflected methods and when not to overload.
-
13
Iterators, Generators, and Classic Coroutines
Explains the iterator protocol, generator functions, and generator expressions in depth. You replace hand-written iterator classes with generators and see how this pattern scales to lazy pipelines.
-
14
Concurrency Models in Python
Maps out the options for concurrent and parallel Python code, covering threads, processes, the GIL, and asyncio. You develop a framework for choosing the right model for CPU-bound versus I/O-bound work.
-
15
Concurrent Executors and asyncio
Puts concurrent.futures and asyncio to work on practical I/O-bound tasks. You write async client code, manage task groups, and handle cancellation and error propagation correctly.
Frequently asked questions
Do I need to be an expert Python programmer to read this book?
You need to be comfortable writing Python already. The book assumes you know basic syntax, control flow, and standard library fundamentals. It is not an introduction to programming or to Python.
Which Python version does this edition cover?
The second edition covers Python 3.10, including structural pattern matching introduced in that release. Most content applies to Python 3.8 and later, and the few version-specific features are clearly marked.
Is this a reference book or one I read cover to cover?
It works both ways. Ramalho designed the chapters to build on each other, so reading front to back gives the clearest picture. But each chapter is also self-contained enough to use as a reference when a specific topic comes up.
Does the book include code examples I can run?
Yes. Every substantive concept is illustrated with runnable code. O'Reilly maintains a companion repository with the book's example files, linked from the book's page on the O'Reilly website.
Is this book useful if I mainly write Python for data science rather than software engineering?
Yes, though the examples lean toward general-purpose and systems programming. The data model, sequence, and functional programming chapters are directly applicable regardless of your domain.
How does this compare to other intermediate Python books?
Fluent Python goes deeper into the language internals and idiomatic patterns than most comparably positioned books. If you want coverage of specific frameworks or libraries, this is not that book — it focuses on the language itself.
Advertisement
You might also like
New