Start free trial
Trending New Genres Authors
EnglishEnglish
EspañolSpanish
简体中文Chinese
繁體中文Chinese (Traditional)
FrançaisFrench
DeutschGerman
日本語Japanese
PortuguêsPortuguese
ItalianoItalian
한국어Korean
РусскийRussian
NederlandsDutch
العربيةArabic
PolskiPolish
हिन्दीHindi
Tiếng ViệtVietnamese
SvenskaSwedish
ΕλληνικάGreek
TürkçeTurkish
ไทยThai
ČeštinaCzech
RomânăRomanian
MagyarHungarian
УкраїнськаUkrainian
IndonesiaIndonesian
DanskDanish
SuomiFinnish
БългарскиBulgarian
עבריתHebrew
NorskNorwegian
HrvatskiCroatian
CatalàCatalan
SlovenčinaSlovak
LietuviųLithuanian
SlovenščinaSlovenian
СрпскиSerbian
EestiEstonian
LatviešuLatvian
فارسیPersian
മലയാളംMalayalam
தமிழ்Tamil
اردوUrdu
Searching...
SoBrief
Fluent Python

Fluent Python

Clear, Concise, and Effective Programming
Make Python's built-in features do more of the work, with less code and fewer brittle abstractions.
by Luciano Ramalho 2015 850 pages
4.62
1k+ ratings
Listen
Immersive
V2.3
Amazon Kindle Audible
Try Full Access for 3 Days
Unlock listening & more!
Continue

Key Takeaways

Make your objects speak Python’s protocols, and the language does the rest

Follow the language’s contracts. Python’s data model is the set of special methods that lets user-defined objects cooperate with built-in syntax. A FrenchDeck that implements only ` len ` and ` getitem ` already supports `len`, indexing, slicing, iteration, membership tests, and tools such as `random.choice` and `sorted`. The interpreter calls these methods on your behalf, often through a familiar operation rather than a direct method call.

Build on existing behavior. The same idea applies to operators, formatting, `with` blocks, and asynchronous operations. For example, ` enter ` and ` exit ` let an object manage setup and cleanup around a `with` block. Small, standard interfaces allow custom types to use Python’s libraries instead of rebuilding their features from scratch.

Analysis

What's powerful here is that Python's flexibility is not just a license to customize syntax. It is a way to make independently written components cooperate through shared behavioral expectations. That resembles a well-designed API contract: callers depend on what an object can do, not on its ancestry. The risk is that familiar syntax can hide surprising semantics. A custom + or len() implementation should therefore preserve the expectations users already bring to those operations.

Choose the collection whose memory model matches the work

Match structure to purpose. Lists and tuples hold references to separate Python objects, so they can contain mixed or nested data. Arrays store compact machine values directly and suit large numeric sequences. The book compares ten million double-precision floats: the binary array file uses 80 million bytes, while a text file of the same values uses about 181.5 million bytes. NumPy adds multidimensional arrays and fast operations across whole datasets.

Use the right behavior, too. Tuples work as fixed-position records or immutable sequences, but a tuple containing a list is not deeply immutable. A `deque` is better than a list for frequent additions and removals at both ends. Sets are useful when membership tests and uniqueness matter more than order.

Analysis

Data structure choice is a form of systems design, not mere style. Memory layout affects cache use, copying, and which operations are cheap, while the public interface communicates what the data means. The book's distinction between flexible containers and compact flat sequences gives readers a useful first diagnostic. One caution: compactness alone does not make an array preferable. The simplest structure that expresses the domain and workload is usually the safer choice.

Treat every assignment as sharing a reference, not copying data

Names point to objects. In Python, `b = a` binds a second name to the same list; it does not make a copy. If either name changes that list, both names observe the change. Equality compares values, while `is` tests whether two names refer to the identical object. Tuples do not remove this concern: their references cannot be replaced, but a mutable object inside one can still change.

Protect your boundaries. A shallow copy duplicates only the outer container. The book’s bus example shows how sharing a passenger list lets dropping someone from the bus silently alter the caller’s team roster. A mutable default argument causes a related bug: supposedly separate buses share the same default list. Use `None` and create a fresh list, or copy an input when the function should own its data.

Analysis

This is Python's practical ownership model in miniature. It gives programmers efficiency and flexibility, but leaves responsibility for aliasing with the API designer. Languages with explicit ownership rules make some sharing decisions visible at compile time; Python instead relies on conventions, documentation, and defensive copying. Copying everything is not a cure, because it costs memory and can break intentional sharing. The crucial question is whether callers expect mutation to travel across the boundary.

Use functions as interchangeable strategies before building single-method classes

Functions are full participants. Python functions can be stored, passed as arguments, and returned from other functions. In the book’s discount example, orders receive one of three functions: a 5% loyalty discount, a 10% discount on qualifying bulk items, or a 7% discount for orders with at least ten distinct items. Replacing one-method strategy classes with functions removes boilerplate while keeping each rule separate.

Add machinery only when useful. A registration decorator can collect new strategies so a central list does not need manual updates. Closures let a function retain state, as in a running average, while decorators can wrap calls for timing or caching. When callable behavior needs substantial internal state, a class with ` call ` may still be the clearer choice.

Analysis

The useful distinction is not functional versus object-oriented programming, but the amount of structure a problem actually needs. First-class functions make small policies easy to compose and test, while callable objects remain available when state and multiple operations belong together. This is a practical application of minimizing accidental complexity. Still, replacing every class with a function can obscure domain identity or lifecycle, so the gain comes from choosing the lighter abstraction when it genuinely fits.

Add type hints where they catch real errors, not to satisfy a quota

Hints guide tools, not Python itself. Python’s gradual type system lets a project add annotations incrementally. A checker such as Mypy can flag a function declared to accept a `Duck` when it is called with a plain `Bird`, even though the runtime still relies on supported operations. Type hints do not validate values at runtime, guarantee business rules, or improve execution speed.

Describe behavior, not just names. A static protocol can say that an argument must support a particular operation, preserving duck-typed flexibility while enabling static checks. `TypedDict` can describe a JSON-like record, but it cannot prove that data parsed from JSON really has the promised keys or values. Runtime validation and tests remain necessary, and some dynamic Python APIs are not worth making cumbersome just to eliminate unannotated code.

Analysis

Typing is most valuable when it makes a team's assumptions visible and catches mismatches before execution. It is least valuable when annotations merely restate obvious code or create a false impression that external data has been checked. The book's distinction between static analysis and runtime behavior is essential in a world where type systems increasingly shape API design. A sensible policy treats hints as an additional feedback channel, not as a substitute for tests, validation, or judgment.

Prefer composition; make inheritance earn its coupling cost

Reuse can bind too tightly. Subclassing built-in `dict` or `list` can fail in surprising ways because some methods implemented in C do not call overrides added by a subclass. The book’s customized dictionary works more reliably when built on `collections.UserDict`, which delegates to an internal dictionary. Composition often avoids these traps by letting an object use another object’s services without claiming to be that object.

Use inheritance deliberately. Multiple inheritance relies on the method resolution order and cooperative `super()` calls. Mixins can add a focused behavior, but every method in the chain must cooperate. The author recommends explicit abstract interfaces for type relationships, narrow mixins for code reuse, and aggregate classes where a useful combination is intended for users.

Analysis

Inheritance can communicate a genuine subtype relationship, but it also couples implementation choices across a class hierarchy. Composition makes that dependence explicit at the point of use and is often easier to change. The examples of Django and Tkinter show that multiple inheritance can work, but also that a user may inherit a sprawling surface area they never needed. The goal is not to ban inheritance; it is to distinguish substitutability from convenience reuse.

Use lazy generators to process streams without building the whole result

Produce data on demand. An iterator supplies one item at a time. A generator function uses `yield` to preserve its state between items, avoiding the hand-written index bookkeeping of a classic iterator class. The book’s `Sentence` example first stores every word eagerly, then switches to `re.finditer` so each word is found only when requested.

Compose the stream. Generator expressions can feed constructors or loops without building an intermediate list. The standard library’s `itertools` functions filter, combine, and transform iterables; `yield from` lets one generator delegate to another, as in a tree traversal. Laziness can save substantial memory, but it does not make an endless input safe to materialize: calling `list()` on an infinite generator will never finish.

Analysis

Laziness is valuable because it separates the description of a computation from the moment its data is consumed. That supports large inputs and composable pipelines, much as streaming systems avoid retaining an entire dataset. But lazy code can move errors to the point of iteration, which may be far from where the generator was created. Developers should make consumption boundaries clear and remember that a generator is a one-pass process, not a reusable collection.

Match data by shape to make interpreters and record handling legible

Let structure guide control flow. Python’s `match` and `case` can inspect sequences, mappings, and class attributes while binding parts of a value to names. A mapping pattern can recognize a versioned book record without requiring every unrelated key to be listed. Sequence patterns can express nested structures and use guards for extra conditions.

See the interpreter example. Peter Norvig’s small Scheme interpreter represents expressions as nested Python lists. Pattern matching makes cases such as quotation, conditionals, function definitions, and calls resemble the data they process. A catch-all case is important: without one, malformed input can pass through a match statement without any action. Patterns improve clarity, but their order and guards still form executable logic that must be tested.

Analysis

Pattern matching is especially effective when code is translating among structured representations, because the control flow can mirror the data grammar. That makes it useful for interpreters, parsers, and versioned records, rather than simply a prettier switch statement. The danger is treating a successful shape match as proof of semantic validity. Guards, explicit error cases, and runtime checks still matter when the data is incomplete or comes from outside the program.

Keep text as Unicode inside, and specify encodings at every boundary

Separate characters from bytes. Python `str` represents Unicode text; `bytes` represents encoded data. The word “café” has four characters but occupies five bytes in UTF-8 because “é” takes two bytes. Encoding converts text to bytes, and decoding converts bytes back to text. The book’s “Unicode sandwich” means decoding as data enters a program, processing with `str`, and encoding only when data leaves.

Never trust a platform default. Writing a UTF-8 file and reopening it under a different default can turn “café” into garbled text. The book demonstrates this on Windows with a CP1252 default. Unicode normalization is also needed for reliable comparison: a character may have one composed code point or a base character plus a combining mark. Strong compatibility normalization can change meaning, so use it selectively.

Analysis

Text bugs are often boundary bugs disguised as language bugs. Making encoding explicit turns an implicit environmental assumption into a visible interface contract, which is especially important when files move between systems. Normalization adds a second layer: identical-looking text may not be byte-for-byte identical, but aggressive cleanup can erase distinctions users care about. Robust text handling therefore needs both technical consistency and awareness of the language and task.

Choose threads for waiting, processes for computation, and coroutines for cooperative I/O

Match concurrency to the bottleneck. The GIL allows only one Python thread at a time to execute Python code in CPython, so threads usually do not speed up CPU-heavy Python work. Processes can use multiple CPU cores, although starting them and moving data between them costs more. Coroutines are lightweight and can manage many waiting tasks in one thread, but only when they regularly yield control with `await`.

The examples make the trade-off concrete. Downloading twenty flags took about 7.18 seconds sequentially, versus about 1.40 seconds with threads and 1.35 seconds with asyncio. For a CPU-intensive prime check, processes outperform threads. A blocking `time.sleep` inside an asyncio coroutine freezes the event loop, so blocking work must be replaced with an asynchronous operation or delegated to an executor.

Analysis

The chapter resists the misleading idea that a concurrency tool is a general speed switch. It distinguishes waiting from computation and emphasizes the whole system, including communication and scheduling overhead. That systems perspective is more durable than memorizing one benchmark. Coroutines reduce the cost of many waiting tasks, but their cooperative nature makes one overlooked blocking call consequential. Performance choices should follow measurement of the real workload, not enthusiasm for a fashionable model.

Use properties and metaprogramming to remove repeated rules, not to show off

Make ordinary attributes safe to evolve. A property can replace a public field without changing how callers read or assign it. In the bulk-food example, a weight property rejects zero or negative values while keeping `item.weight` as the interface. A descriptor packages reusable attribute behavior, such as the `Quantity` rule used for both weight and price. Python’s ` set_name ` can give each descriptor its managed attribute name automatically.

Escalate carefully. Class decorators and ` init_subclass ` can configure classes with less machinery than a metaclass. Metaclasses can customize class creation itself, including ` slots `, but introduce more timing and inheritance complexity. The book’s practical advice is to reserve these tools for reusable libraries and frameworks, where eliminating repeated work justifies the extra abstraction.

Analysis

Metaprogramming is most convincing when it turns a repeated rule into a single, testable mechanism. The examples show that Python can move validation and class setup out of application code without forcing callers to adopt a new interface. Yet every hidden mechanism raises the cost of debugging because behavior is assembled indirectly. The right test is whether the abstraction reduces total cognitive load for both users and maintainers, not whether the language makes it possible.

Analysis

Fluent Python is a technical guide organized around a practical thesis: proficiency comes from understanding the behavioral contracts built into the language, then choosing the lightest tool that fits. The book moves from sequences, mappings, text, and object references to functions, classes, protocols, concurrency, and metaprogramming. Its recurring teaching method is concrete: a small object such as a card deck or vector is built, tested, and refined until an abstract language feature has a visible consequence.

The strongest unifying idea is that Python rewards interoperability. A class that implements a small protocol can immediately work with syntax and libraries it was never explicitly designed for. First-class functions reduce the need for ceremony, generators make data processing incremental, and context managers encode cleanup around a block. These are not isolated tricks; they are ways to let the language carry repetitive control flow.

The book is also unusually candid about trade-offs. Tuples can contain mutable objects, descriptors can hide behavior, type hints can create false confidence about unvalidated data, and inheritance can make simple reuse brittle. Its treatment of concurrency is similarly grounded: threads are useful for waiting, processes for CPU-heavy work, and coroutines only remain responsive when blocking calls are kept out of the event loop.

The breadth is the book’s main summarizing challenge. Its parts can look like separate reference manuals, and later chapters assume comfort with concepts introduced earlier. The best adaptation therefore follows the repeated design question beneath them: what behavior does the caller need, what protocol expresses it, and what complexity is justified? That question turns the book from a catalogue of Python features into a method for designing readable, interoperable software. The caveat is that “Pythonic” is not a fixed checklist. Idioms change with versions and workloads, so the durable lesson is to understand the underlying semantics before adopting a fashionable shorthand.

Summary in 30 Seconds
Python objects that support standard protocols work naturally with built-in syntax and libraries. Assignments share references, so mutable data needs deliberate copying or ownership boundaries. Generators process items on demand, while functions can replace many single-method strategy classes. Threads suit waiting, processes suit CPU-heavy work, and coroutines suit cooperative I/O. In one download test, concurrency cut the time for twenty images from 7.18 seconds to about 1.4.
Contains spoilers

Last updated:

Report Issue

Review Summary

4.62 out of 5
Average of 1k+ ratings from Goodreads and Amazon.

Fluent Python receives overwhelmingly positive reviews, praised for its in-depth coverage of advanced Python topics. Readers appreciate the clear explanations, practical examples, and insights into Python's design philosophy. Many consider it essential for intermediate to advanced programmers seeking to deepen their understanding of the language. The book is noted for its comprehensive approach, covering topics like data models, concurrency, and metaprogramming. While some found it challenging, most agree it's a valuable resource for mastering Python's intricacies and writing idiomatic code.

Your rating:
4.71
305 ratings
Want to read the full book?

Glossary

Python Data Model

Protocols behind Python syntax

The collection of special methods and behavioral interfaces that let objects participate in Python operations. Implementing methods such as __getitem__ or __len__ can make a user-defined object work with indexing, iteration, or len(). The interpreter usually invokes these methods in response to syntax or built-in functions.

duck typing

Type by supported behavior

A way of using objects based on the operations they provide rather than their declared class. If code needs to iterate over an object, it can try to obtain an iterator instead of requiring a particular concrete type. This supports flexible collaboration, though unsupported operations may fail at runtime.

call by sharing

Arguments share object references

Python’s parameter-passing behavior: a function receives references to the objects supplied by its caller. A function can mutate a shared mutable object, so the caller sees that change, but rebinding the local parameter does not rebind the caller’s variable. This explains both mutable-argument side effects and mutable-default bugs.

gradual type system

Optional static type checking

A type system that allows annotated and unannotated Python code to coexist. External checkers use hints to find some likely mistakes without changing runtime behavior. Missing annotations are generally treated permissively, and hints do not validate actual values or make the program run faster.

static protocol

Checkable structural interface

A protocol defined with typing.Protocol to describe methods or attributes a type checker expects. A class need not inherit from the protocol; it is compatible when its structure meets the declared interface. This brings static checking to Python’s behavior-based style of programming.

descriptor

Reusable attribute manager

An object whose class implements methods such as __get__, __set__, or __delete__, allowing it to control access to an attribute in another class. Properties are built on the descriptor mechanism. Descriptors support reusable validation, computed values, and other attribute behavior.

generator

On-demand iterator

An iterator created by a generator function containing yield, or by a generator expression. It preserves its execution state between yielded values and produces the next item only when requested. This enables lazy processing without constructing a complete intermediate collection.

Unicode sandwich

Decode in, encode out

A text-handling practice that decodes incoming bytes into Unicode strings at the system boundary, keeps internal processing in text, and encodes only when writing or transmitting data. It reduces accidental mixing of bytes and text and makes encoding choices explicit at input and output.

Global Interpreter Lock

One Python thread executes at once

The GIL is a lock in CPython that allows only one thread at a time to execute Python code. Threads can still help with I/O because they spend time waiting, and some extensions release the lock. For CPU-intensive Python work across cores, separate processes are generally needed.

context manager

Controls a block’s setup and cleanup

An object used by a with statement to perform setup on entry and cleanup on exit. The synchronous protocol uses __enter__ and __exit__; asynchronous context managers use __aenter__ and __aexit__. A context manager can also handle or propagate exceptions raised inside the block.

yield from

Delegates generator work

An expression that lets a generator delegate iteration to a subgenerator or other iterable. Values from the delegated source flow directly to the caller while the outer generator is suspended. It can also capture a subgenerator’s return value, a feature used in classic coroutine patterns.

class metaprogramming

Customizing classes at creation

Techniques for creating or modifying classes while a program runs. Class factories, class decorators, __init_subclass__, and metaclasses offer increasing levels of control. These mechanisms are useful for reusable frameworks, but can make application code harder to understand when simpler tools would suffice.

FAQ

What's Fluent Python about?

  • Comprehensive Guide: Fluent Python by Luciano Ramalho is a deep dive into Python programming, focusing on writing clear, concise, and effective code.
  • Advanced Topics: It covers advanced features such as data models, decorators, generators, and concurrency, making it suitable for experienced developers.
  • Practical Approach: The book includes practical examples and exercises to help readers apply Python's features effectively in real-world scenarios.

Why should I read Fluent Python?

  • Enhance Your Skills: Reading Fluent Python will help you become a more proficient Python programmer by exposing you to advanced concepts and best practices.
  • Idiomatic Python: The book teaches you how to write Pythonic code, which is not only efficient but also easier to read and maintain.
  • Real-World Applications: The examples and exercises are designed to reflect real-world programming challenges, making the learning experience relevant and applicable.

What are the key takeaways of Fluent Python?

  • Understanding Python's Data Model: A major takeaway is the importance of understanding Python's data model, which underpins how objects and classes work.
  • Emphasis on Functions: The book highlights the significance of first-class functions and higher-order functions, which allow for more flexible and reusable code.
  • Asynchronous Programming: It covers asynchronous programming in detail, explaining how to write concurrent code using the asyncio library.

What are the best quotes from Fluent Python and what do they mean?

  • "Python is an easy to learn, powerful programming language.": This quote highlights Python's accessibility for beginners while emphasizing its robustness for experienced developers.
  • "Premature abstraction is as bad as premature optimization.": This warns against overcomplicating code before necessary, encouraging clear and functional code first.
  • "Knowing what is ready to use can save you from reinventing the wheel.": This underscores the importance of utilizing Python's extensive standard library and built-in features.

How does Fluent Python explain the Python Data Model?

  • Core Concept: The Python Data Model is a framework that formalizes the interfaces of Python's building blocks, such as sequences, functions, and classes.
  • Special Methods: It includes special methods (often called "dunder" methods) that allow objects to interact with Python's syntax and built-in functions.
  • Consistency in Behavior: By adhering to the data model, programmers can ensure that their custom objects behave consistently with Python's built-in types.

What is the significance of decorators in Fluent Python?

  • Decorator Basics: Decorators are functions that modify the behavior of other functions or methods, applied using the @decorator syntax.
  • Closure and Scope: Understanding closures is crucial for decorators, as they often need to access variables from their enclosing scope.
  • Practical Examples: The book provides practical examples of decorators, including how to create parameterized decorators that accept arguments.

How does Fluent Python address asynchronous programming?

  • Asyncio Library: The book provides a comprehensive overview of the asyncio library, essential for writing concurrent code in Python.
  • Async/Await Syntax: It introduces the async/await syntax, explaining how it simplifies writing asynchronous code and improves readability.
  • Practical Examples: Readers are provided with practical examples of using asyncio to handle I/O-bound tasks efficiently.

What are generators and how are they used in Fluent Python?

  • Definition of Generators: Generators are a type of iterable, defined using functions that yield values instead of returning them, allowing for lazy evaluation.
  • Memory Efficiency: They are memory efficient because they generate items on-the-fly and do not require the entire dataset to be stored in memory.
  • Use Cases: The book illustrates various use cases for generators, including data processing pipelines and asynchronous programming.

How does Fluent Python explain the use of type hints?

  • Gradual Typing: The book introduces the concept of gradual typing, allowing developers to add type hints without enforcing strict type checking.
  • Type Hinting Syntax: It covers the syntax for type hints, including how to annotate function parameters and return types.
  • Benefits of Type Hints: Type hints improve code readability and help catch type-related errors during static analysis.

What is the role of metaclasses in Fluent Python?

  • Class Factories: Metaclasses are described as class factories that control the creation and behavior of classes.
  • Dynamic Class Creation: They allow for customization of class attributes and methods at the time of class creation.
  • Advanced Usage: While powerful, metaclasses are best suited for library and framework development rather than everyday application code.

How does Fluent Python address the concept of context managers?

  • Context Manager Basics: Context managers are used to manage resources, ensuring they are properly acquired and released.
  • Using the with Statement: The book emphasizes the use of the with statement to simplify resource management.
  • Custom Context Managers: Readers learn how to create custom context managers by implementing the __enter__ and __exit__ methods.

What are the differences between classmethod and staticmethod in Fluent Python?

  • Purpose of classmethod: A classmethod receives the class as its first argument, allowing it to access class-level attributes and methods.
  • Purpose of staticmethod: A staticmethod does not receive any special first argument and behaves like a regular function within a class.
  • Use Cases: classmethod is useful for methods that need to interact with the class itself, while staticmethod is suitable for utility functions related to the class.

About the Author

Luciano Ramalho is a highly respected Python expert and author. Known for his deep understanding of the language, Ramalho has made significant contributions to the Python community. His writing style is praised for being clear, engaging, and pedagogically sound. Readers appreciate his ability to explain complex concepts through well-crafted examples and his insights into Python's design principles. Ramalho's expertise extends beyond just syntax, encompassing the language's philosophy and best practices. His work often includes historical context and comparisons to other programming languages, providing readers with a comprehensive understanding of Python's place in the programming world.

Download PDF

To save this Fluent Python summary for later, download the free PDF. You can print it out, or read offline at your convenience.
Download PDF
File size: 0.43 MB     Pages: 22

Download EPUB

To read this Fluent Python summary on your e-reader device or app, download the free EPUB. The .epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.
Download EPUB
File size: 1.36 MB     Pages: 26
Want to read the full book?
Follow
Listen
Home
Swipe
Library
Get App
Try Full Access for 3 Days
Listen, bookmark, and more
Compare Features Free Pro
📖 Read Summaries
Read unlimited summaries. Free users get 3 per month
🎧 Listen to Summaries
Listen to unlimited summaries in 40 languages
—
❤️ Unlimited Bookmarks
Free users are limited to 4
—
📜 Unlimited History
Free users are limited to 4
—
📥 Unlimited Downloads
Free users are limited to 1
—
Risk-Free Timeline
Today: Get Instant Access
Listen to full summaries of 26,000+ books. That's 12,000+ hours of audio!
Day 2: Trial Reminder
We'll send you a notification that your trial is ending soon.
Day 3: Your subscription begins
You'll be charged on Nov 24,
cancel anytime before.
Consume 2.8× More Books
2.8× more books Listening Reading
Our users love us
600,000+ readers
Trustpilot Rating
TrustPilot
4.6 Excellent
This site is a total game-changer. I've been flying through book summaries like never before. Highly, highly recommend.
— Dave G
Worth my money and time, and really well made. I've never seen this quality of summaries on other websites. Very helpful!
— Em
Highly recommended!! Fantastic service. Perfect for those that want a little more than a teaser but not all the intricate details of a full audio book.
— Greg M
Save 62%
Yearly
$119.88 $44.99/year/yr
$3.75/mo
Monthly
$9.99/mo
Start a 3-Day Free Trial
3 days free, then $44.99/year. Cancel anytime.
Unlock a world of fiction & nonfiction books
26,000+ books for the price of 2 books
Read any book in 10 minutes
Discover new books like Tinder
Request any book if it's not summarized
Read more books than anyone you know
#1 app for book lovers
Lifelike & immersive summaries
30-day money-back guarantee
Download summaries in EPUBs or PDFs
Cancel anytime in a few clicks

Why one summary?

Scanner
Find a barcode to scan

⭐
⭐
⭐
We have a special gift for you
Open
38% off
DISCOUNT FOR YOU
⭐
⭐
⭐
$79.99
$49.99/year
Only $4.16 per month
Continue
2 taps to start, super easy to cancel
Settings
General
Widget
Loading...