book

Fluent Python

Name: Fluent Python
Author: Luciano Ramalho
ISBN: 9781491946008

by Luciano Ramalho

August 2015

Intermediate

790 pages

18h 48m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
Who This Book Is ForWho This Book Is Not ForHow This Book Is OrganizedHands-On ApproachHardware Used for TimingsSoapbox: My Personal PerspectivePython JargonPython Version CoveredConventions Used in This BookUsing Code ExamplesSafari® Books OnlineHow to Contact UsAcknowledgments
I. Prologue
1. The Python Data Model
A Pythonic Card DeckHow Special Methods Are UsedEmulating Numeric TypesString RepresentationArithmetic OperatorsBoolean Value of a Custom TypeOverview of Special MethodsWhy len Is Not a MethodChapter SummaryFurther Reading
II. Data Structures
2. An Array of Sequences
Overview of Built-In SequencesList Comprehensions and Generator ExpressionsList Comprehensions and ReadabilityListcomps Versus map and filterCartesian ProductsGenerator ExpressionsTuples Are Not Just Immutable ListsTuples as RecordsTuple UnpackingNested Tuple UnpackingNamed TuplesTuples as Immutable ListsSlicingWhy Slices and Range Exclude the Last ItemSlice ObjectsMultidimensional Slicing and EllipsisAssigning to SlicesUsing + and * with SequencesBuilding Lists of ListsAugmented Assignment with SequencesA += Assignment Puzzlerlist.sort and the sorted Built-In FunctionManaging Ordered Sequences with bisectSearching with bisectInserting with bisect.insortWhen a List Is Not the AnswerArraysMemory ViewsNumPy and SciPyDeques and Other QueuesChapter SummaryFurther Reading
3. Dictionaries and Sets
Generic Mapping Typesdict ComprehensionsOverview of Common Mapping MethodsHandling Missing Keys with setdefaultMappings with Flexible Key Lookupdefaultdict: Another Take on Missing KeysThe __missing__ MethodVariations of dictSubclassing UserDictImmutable MappingsSet Theoryset LiteralsSet ComprehensionsSet Operationsdict and set Under the HoodA Performance ExperimentHash Tables in DictionariesPractical Consequences of How dict WorksHow Sets Work—Practical ConsequencesChapter SummaryFurther Reading
4. Text versus Bytes
Character IssuesByte EssentialsStructs and Memory ViewsBasic Encoders/DecodersUnderstanding Encode/Decode ProblemsCoping with UnicodeEncodeErrorCoping with UnicodeDecodeErrorSyntaxError When Loading Modules with Unexpected EncodingHow to Discover the Encoding of a Byte SequenceBOM: A Useful GremlinHandling Text FilesEncoding Defaults: A MadhouseNormalizing Unicode for Saner ComparisonsCase FoldingUtility Functions for Normalized Text MatchingExtreme “Normalization”: Taking Out DiacriticsSorting Unicode TextSorting with the Unicode Collation AlgorithmThe Unicode DatabaseDual-Mode str and bytes APIsstr Versus bytes in Regular Expressionsstr Versus bytes on os FunctionsChapter SummaryFurther Reading
III. Functions as Objects
5. First-Class Functions
Treating a Function Like an ObjectHigher-Order FunctionsModern Replacements for map, filter, and reduceAnonymous FunctionsThe Seven Flavors of Callable ObjectsUser-Defined Callable TypesFunction IntrospectionFrom Positional to Keyword-Only ParametersRetrieving Information About ParametersFunction AnnotationsPackages for Functional ProgrammingThe operator ModuleFreezing Arguments with functools.partialChapter SummaryFurther Reading
6. Design Patterns with First-Class Functions
Case Study: Refactoring StrategyClassic StrategyFunction-Oriented StrategyChoosing the Best Strategy: Simple ApproachFinding Strategies in a ModuleCommandChapter SummaryFurther Reading

7. Function Decorators and Closures
Decorators 101When Python Executes DecoratorsDecorator-Enhanced Strategy PatternVariable Scope RulesClosuresThe nonlocal DeclarationImplementing a Simple DecoratorHow It WorksDecorators in the Standard LibraryMemoization with functools.lru_cacheGeneric Functions with Single DispatchStacked DecoratorsParameterized DecoratorsA Parameterized Registration DecoratorThe Parameterized Clock DecoratorChapter SummaryFurther Reading
IV. Object-Oriented Idioms
8. Object References, Mutability, and Recycling
Variables Are Not BoxesIdentity, Equality, and AliasesChoosing Between == and isThe Relative Immutability of TuplesCopies Are Shallow by DefaultDeep and Shallow Copies of Arbitrary ObjectsFunction Parameters as ReferencesMutable Types as Parameter Defaults: Bad IdeaDefensive Programming with Mutable Parametersdel and Garbage CollectionWeak ReferencesThe WeakValueDictionary SkitLimitations of Weak ReferencesTricks Python Plays with ImmutablesChapter SummaryFurther Reading
9. A Pythonic Object
Object RepresentationsVector Class ReduxAn Alternative Constructorclassmethod Versus staticmethodFormatted DisplaysA Hashable Vector2dPrivate and “Protected” Attributes in PythonSaving Space with the __slots__ Class AttributeThe Problems with __slots__Overriding Class AttributesChapter SummaryFurther Reading
10. Sequence Hacking, Hashing, and Slicing
Vector: A User-Defined Sequence TypeVector Take #1: Vector2d CompatibleProtocols and Duck TypingVector Take #2: A Sliceable SequenceHow Slicing WorksA Slice-Aware __getitem__Vector Take #3: Dynamic Attribute AccessVector Take #4: Hashing and a Faster ==Vector Take #5: FormattingChapter SummaryFurther Reading
11. Interfaces: From Protocols to ABCs
Interfaces and Protocols in Python CulturePython Digs SequencesMonkey-Patching to Implement a Protocol at RuntimeAlex Martelli’s WaterfowlSubclassing an ABCABCs in the Standard LibraryABCs in collections.abcThe Numbers Tower of ABCsDefining and Using an ABCABC Syntax DetailsSubclassing the Tombola ABCA Virtual Subclass of TombolaHow the Tombola Subclasses Were TestedUsage of register in PracticeGeese Can Behave as DucksChapter SummaryFurther Reading
12. Inheritance: For Good or For Worse
Subclassing Built-In Types Is TrickyMultiple Inheritance and Method Resolution OrderMultiple Inheritance in the Real WorldCoping with Multiple Inheritance1. Distinguish Interface Inheritance from Implementation Inheritance2. Make Interfaces Explicit with ABCs3. Use Mixins for Code Reuse4. Make Mixins Explicit by Naming5. An ABC May Also Be a Mixin; The Reverse Is Not True6. Don’t Subclass from More Than One Concrete Class7. Provide Aggregate Classes to Users8. “Favor Object Composition Over Class Inheritance.”Tkinter: The Good, the Bad, and the UglyA Modern Example: Mixins in Django Generic ViewsChapter SummaryFurther Reading
13. Operator Overloading: Doing It Right
Operator Overloading 101Unary OperatorsOverloading + for Vector AdditionOverloading * for Scalar MultiplicationRich Comparison OperatorsAugmented Assignment OperatorsChapter SummaryFurther Reading
V. Control Flow
14. Iterables, Iterators, and Generators
Sentence Take #1: A Sequence of WordsWhy Sequences Are Iterable: The iter FunctionIterables Versus IteratorsSentence Take #2: A Classic IteratorMaking Sentence an Iterator: Bad IdeaSentence Take #3: A Generator FunctionHow a Generator Function WorksSentence Take #4: A Lazy ImplementationSentence Take #5: A Generator ExpressionGenerator Expressions: When to Use ThemAnother Example: Arithmetic Progression GeneratorArithmetic Progression with itertoolsGenerator Functions in the Standard LibraryNew Syntax in Python 3.3: yield fromIterable Reducing FunctionsA Closer Look at the iter FunctionCase Study: Generators in a Database Conversion UtilityGenerators as CoroutinesChapter SummaryFurther Reading
15. Context Managers and else Blocks
Do This, Then That: else Blocks Beyond ifContext Managers and with BlocksThe contextlib UtilitiesUsing @contextmanagerChapter SummaryFurther Reading
16. Coroutines
How Coroutines Evolved from GeneratorsBasic Behavior of a Generator Used as a CoroutineExample: Coroutine to Compute a Running AverageDecorators for Coroutine PrimingCoroutine Termination and Exception HandlingReturning a Value from a CoroutineUsing yield fromThe Meaning of yield fromUse Case: Coroutines for Discrete Event SimulationAbout Discrete Event SimulationsThe Taxi Fleet SimulationChapter SummaryFurther Reading
17. Concurrency with Futures
Example: Web Downloads in Three StylesA Sequential Download ScriptDownloading with concurrent.futuresWhere Are the Futures?Blocking I/O and the GILLaunching Processes with concurrent.futuresExperimenting with Executor.mapDownloads with Progress Display and Error HandlingError Handling in the flags2 ExamplesUsing futures.as_completedThreading and Multiprocessing AlternativesChapter SummaryFurther Reading
18. Concurrency with asyncio
Thread Versus Coroutine: A Comparisonasyncio.Future: Nonblocking by DesignYielding from Futures, Tasks, and CoroutinesDownloading with asyncio and aiohttpRunning Circles Around Blocking CallsEnhancing the asyncio downloader ScriptUsing asyncio.as_completedUsing an Executor to Avoid Blocking the Event LoopFrom Callbacks to Futures and CoroutinesDoing Multiple Requests for Each DownloadWriting asyncio ServersAn asyncio TCP ServerAn aiohttp Web ServerSmarter Clients for Better ConcurrencyChapter SummaryFurther Reading
VI. Metaprogramming
19. Dynamic Attributes and Properties
Data Wrangling with Dynamic AttributesExploring JSON-Like Data with Dynamic AttributesThe Invalid Attribute Name ProblemFlexible Object Creation with __new__Restructuring the OSCON Feed with shelveLinked Record Retrieval with PropertiesUsing a Property for Attribute ValidationLineItem Take #1: Class for an Item in an OrderLineItem Take #2: A Validating PropertyA Proper Look at PropertiesProperties Override Instance AttributesProperty DocumentationCoding a Property FactoryHandling Attribute DeletionEssential Attributes and Functions for Attribute HandlingSpecial Attributes that Affect Attribute HandlingBuilt-In Functions for Attribute HandlingSpecial Methods for Attribute HandlingChapter SummaryFurther Reading
20. Attribute Descriptors
Descriptor Example: Attribute ValidationLineItem Take #3: A Simple DescriptorLineItem Take #4: Automatic Storage Attribute NamesLineItem Take #5: A New Descriptor TypeOverriding Versus Nonoverriding DescriptorsOverriding DescriptorOverriding Descriptor Without __get__Nonoverriding DescriptorOverwriting a Descriptor in the ClassMethods Are DescriptorsDescriptor Usage TipsDescriptor docstring and Overriding DeletionChapter SummaryFurther Reading
21. Class Metaprogramming
A Class FactoryA Class Decorator for Customizing DescriptorsWhat Happens When: Import Time Versus RuntimeThe Evaluation Time ExercisesMetaclasses 101The Metaclass Evaluation Time ExerciseA Metaclass for Customizing DescriptorsThe Metaclass __prepare__ Special MethodClasses as ObjectsChapter SummaryFurther Reading
Afterword
Further Reading
A. Support Scripts
Chapter 3: in Operator Performance TestChapter 3: Compare the Bit Patterns of HashesChapter 9: RAM Usage With and Without __slots__Chapter 14: isis2json.py Database Conversion ScriptChapter 16: Taxi Fleet Discrete Event SimulationChapter 17: Cryptographic ExamplesChapter 17: flags2 HTTP Client ExamplesChapter 19: OSCON Schedule Scripts and Tests
Python Jargon
Index

Content preview from Fluent Python

Colophon

The animal on the cover of Fluent Python is a Namaqua sand lizard (Pedioplanis namaquensis)—a slender creature with a long, pinkish-brown tail. It is black with four white stripes, brown legs with white spots, and a white belly.

Active during the day, it is one of the fastest lizards. It inhabits sparsely vegetated sand gravel flats, remaining dormant in burrows during the winter, which it digs at the base of bushes. The Namaqua sand lizard can be found throughout Namibia, in arid savannah and semi-desert regions. It feeds on small insects. In November, females lay between three to five eggs.

Many of the animals on O’Reilly covers are endangered; all of them are important to the world. To learn more about how you can help, go to animals.oreilly.com.

The cover image is from Wood’s Natural History #3. The cover fonts are URW Typewriter and Guardian Sans. The text font is Adobe Minion Pro; the heading font is Adobe Myriad Condensed; and the code font is Dalton Maag’s Ubuntu Mono.

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781491946237Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Fluent Python

by Luciano Ramalho

Colophon

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.