https://RustRocket.rs -- Cloud Monk Losang Jinpa, Ph.D., MCSE / MCT, https://Rustaceans.rs, Full Stack Cloud Native Rust DevOps Engineer - Rocket Framework Rust Microservices on Kubernetes-AWS-Azure-GCP

Fluent Python, 2nd Edition by Luciano Ramalho Index

Return to Fluent Python, 2nd Edition, Python, Python DevOps - Python Data Science - Python MLOps, Python Bibliography

“ (FlntPy 2022)

Symbol

Symbols

!= (not equal to) operator, Rich Comparison Operators

!r conversion field, String Representation

% (modulo) operator, What’s New in This Chapter, String Representation

%r placeholder, String Representation

* (star) operator, Emulating Numeric Types, Using * to Grab Excess Items-Unpacking with * in Function Calls and Sequence Literals, Using + and * with Sequences-A += Assignment Puzzler, From Positional to Keyword-Only Parameters, Overloading * for Scalar Multiplication-Overloading * for Scalar Multiplication

** (double star) operator, Unpacking Mappings, From Positional to Keyword-Only Parameters

*= (star equals) operator, Augmented Assignment with Sequences-A += Assignment Puzzler, Augmented Assignment Operators-Augmented Assignment Operators

*_ symbol, Pattern Matching with Sequences

*_new*_, Flexible Object Creation with __new__-Flexible Object Creation with __new__

+ operator, Emulating Numeric Types, Using + and * with Sequences-A += Assignment Puzzler, Overloading + for Vector Addition-Overloading + for Vector Addition

+= (addition assignment) operator, Augmented Assignment with Sequences-A += Assignment Puzzler, Augmented Assignment Operators-Augmented Assignment Operators

+ELLIPSIS directive, A Pythonic Card Deck

:= (Walrus operator), List Comprehensions and Readability

< (less than) operator, Rich Comparison Operators

⇐ (less than or equal to) operator, Rich Comparison Operators

== (equality) operator, Identity, Equality, and Aliases, Further Reading, Rich Comparison Operators

> (greater than) operator, Rich Comparison Operators

>= (greater than or equal to) operator, Rich Comparison Operators

@ sign, Using @ as an Infix Operator-Using @ as an Infix Operator

@asyncio.coroutine decorator, A Few Definitions

@cached_property, Step 5: Caching Properties with functools

@contextmanager decorator, Using @contextmanager-Using @contextmanager

@dataclassdefault settings, More About @dataclass

example using, @dataclass Example: Dublin Core Resource Record-@dataclass Example: Dublin Core Resource Record

field options, Field Options-Field Options

init-only variables, Initialization Variables That Are Not Fields

keyword parameters accepted by, More About @dataclass

post-init processing, Post-init Processing-Post-init Processing

typed class attributes, Typed Class Attributes

__hash__ method (dunder hash method), More About @dataclass

@typing.overload decorator, Overloaded Signatures-Takeaways from Overloading max

[] (square brackets), A Pythonic Card Deck, List Comprehensions and Readability, Unpacking Sequences and Iterables, Multidimensional Slicing and Ellipsis

\ (backslash), List Comprehensions and Readability

\ line continuation escape, List Comprehensions and Readability

\N{} (Unicode literals escape notation), Beware of Encoding Defaults

_ symbol, Pattern Matching with Sequences

__ (double underscore), The Python Data Model

__abs__ (dunder abs), Emulating Numeric Types

__add__ (dunder add), Emulating Numeric Types

__bool__ (dunder bool), Boolean Value of a Custom Type

__bytes__ (dunder bytes), Object Representations

__call__ (dunder call), Further Reading

__class__ (dunder class), Special Attributes that Affect Attribute Handling, Classes as Objects

__contains__ (dunder contains), A Pythonic Card Deck, The __missing__ Method (dunder missing)

__delattr__ (dunder delattr), Special Methods for Attribute Handling

__delete__ (dunder delete), Attribute Descriptors

__del__ (dunder del), del and Garbage Collection

__dict__ (dunder dict), Special Attributes that Affect Attribute Handling

__dir__ (dunder dir), Special Methods for Attribute Handling

__enter__ (dunder enter), Context Managers and with Blocks

__eq__, (dunder eq) Vector Take #4: Hashing and a Faster ==-Vector Take #4: Hashing and a Faster ==

__exit__, (dunder exit) Context Managers and with Blocks

__format__ (dunder format), Object Representations, Formatted Displays, Vector Take #5: Formatting-Vector Take #5: Formatting, Further Reading

__getattribute__ (dunder getattribute), Special Methods for Attribute Handling

__getattr__, (dunder getattr) Vector Take #3: Dynamic Attribute Access-Vector Take #3: Dynamic Attribute Access, Special Methods for Attribute Handling

__getitem__ (dunder getitem), A Pythonic Card Deck-A Pythonic Card Deck, Multidimensional Slicing and Ellipsis, Vector Take #2: A Sliceable Sequence-A Slice-Aware __getitem__

__get__ (dunder get), Attribute Descriptors

__hash__ (dunder has), More About @dataclass, Vector Take #4: Hashing and a Faster ==-Vector Take #4: Hashing and a Faster ==

__iadd__ (dunder iadd), Augmented Assignment with Sequences

__init_subclass__ (dunder init_subclass), Introducing __init_subclass__-Why __init_subclass__ Cannot Configure __slots__

__init__ (dunder init), How Special Methods Are Used, Post-init Processing, Vector Take #1: Vector2d Compatible

__invert__ (dunder invert), Unary Operators

__iter__ (dunder iter), Sentence Classes with __iter__-How a Generator Works

__len__ (dunder len), A Pythonic Card Deck-A Pythonic Card Deck, Why len Is Not a Method, Vector Take #2: A Sliceable Sequence-A Slice-Aware __getitem__

__missing__ (dunder missing), The __missing__ Method-Inconsistent Usage of __missing__ in the Standard Library

__mro__ (dunder [[mro), Classes as Objects

__mul__ (dunder mul), Emulating Numeric Types

__name__ (dunder name), Classes as Objects

__neg__ (dunder neg), Unary Operators

__post_init__ (dunder post_init), Post-init Processing

__pos__ (dunder pos), Unary Operators

__prepare__ (dunder prepare), A Metaclass Hack with __prepare__-A Metaclass Hack with __prepare__

__repr__ (dunder repr), Emulating Numeric Types-String Representation, Object Representations, Vector Take #1: Vector2d Compatible

__setattr__ (dunder setattr), Special Methods for Attribute Handling

__setitem__ (dunder setitem), Multidimensional Slicing and Ellipsis

__set__ (dunder set), Attribute Descriptors

__slots__ (dunder slots), Saving Memory with __slots__-Summarizing the Issues with __slots__, Vector Take #3: Dynamic Attribute Access, Special Attributes that Affect Attribute Handling, Why __init_subclass__ Cannot Configure __slots__

__str__ (dunder str), String Representation, Object Representations

{} (curly brackets), List Comprehensions and Readability

ǀ (pipe) operator, Merging Mappings with |, Using OR-patterns

ǀ= (pipe equals) operator, Merging Mappings with |

… (ellipsis), A Pythonic Card Deck, Multidimensional Slicing and Ellipsis

A

abc.ABC class, ABCs in the Standard Library

abc.Iterable, abc.Iterable versus abc.Sequence

abc.Sequence, abc.Iterable versus abc.Sequence

ABCs (abstract base classes)ABC syntax details, ABC Syntax Details

defining and using ABCs, Defining and Using an ABC-Defining and Using an ABC

further reading on, Further Reading

goose typing and, Goose Typing-Goose Typing

overview of, Chapter Summary

in Python standard library, ABCs in the Standard Library-ABCs in the Standard Library

Soapbox discussion, Further Reading-Further Reading

structural typing with, Structural Typing with ABCs-Structural Typing with ABCs

subclassing ABCs, Subclassing an ABC-Subclassing an ABC, Subclassing an ABC-Subclassing an ABC

type hints (type annotations), Abstract Base Classes-The fall of the numeric tower

UML class diagrams, Collection API-Collection API

usage of register, Usage of register in Practice

virtual subclasses of ABCs, A Virtual Subclass of an ABC-A Virtual Subclass of an ABC

abs built-in function, Emulating Numeric Types

actual type parameters, Basic Jargon for Generic Types

addition assignment (+ operator, Augmented Assignment with Sequences-A += Assignment Puzzler, Augmented Assignment Operators-Augmented Assignment Operators

aliasing, Identity, Equality, and Aliases-The Relative Immutability of Tuples

anonymous functions, Anonymous Functions, Further Reading, Closures

Any type, The Any Type-Subtype-of versus consistent-with

AnyStr, The AnyStr predefined type variable

.append method, Deques and Other Queues

apply function, Higher-Order Functions-Modern Replacements for map, filter, and reduce

argumentsfreezing with functools.partial, Freezing Arguments with functools.partial

key argument, Further Reading

keyword-only arguments, From Positional to Keyword-Only Parameters

arrays, Overview of Built-In Sequences, Arrays-Arrays

as keyword, Pattern Matching with Sequences

assignment expression (:, List Comprehensions and Readability

asynchronous generators, The Nine Flavors of Callable Objects, A Few Definitions

asynchronous programming asynchronous context managers, Asynchronous Context Managers-Asynchronous Context Managers

asyncio script example, An asyncio Example: Probing Domains-Guido’s Trick to Read Asynchronous Code

avoiding CPU-bound traps, Avoiding CPU-Bound Traps

awaitables, New Concept: Awaitable

benefits of, Running Circles Around Blocking Calls

Curio project, async Beyond asyncio: Curio-async Beyond asyncio: Curio

delegating tasks to executors, Delegating Tasks to Executors-Delegating Tasks to Executors

enhancing asyncio downloader, Enhancing the asyncio Downloader-Making Multiple Requests for Each Download

further reading on, Further Reading

iteration and iterables, Asynchronous Iteration and Asynchronous Iterables-Asynchronous comprehensions

myth of I/O-bound systems, The Myth of I/O-Bound Systems

overview of, Chapter Summary

relevant terminology, A Few Definitions

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

topics covered, Asynchronous Programming

type hinting asynchronous objects, Type Hinting Asynchronous Objects

writing asyncio servers, Writing asyncio Servers-An asyncio TCP Server

Asynchronous Server Gateway Interface (ASGI), WSGI Application Servers

asyncio package achieving peak performance with, The All-or-Nothing Problem

documentation, Asynchronous Programming

downloading with, Downloading with asyncio and HTTPX-The All-or-Nothing Problem

enhancing asyncio downloader, Enhancing the asyncio Downloader-Making Multiple Requests for Each Download

example script, An asyncio Example: Probing Domains-Guido’s Trick to Read Asynchronous Code

queue implementation by, Deques and Other Queues

writing asyncio servers, Writing asyncio Servers-An asyncio TCP Server

asyncpg, Asynchronous Context Managers

attribute descriptors (see also attributes; dynamic attributes and properties)attribute validation, Descriptor Example: Attribute Validation-LineItem Take #5: A New Descriptor Type

descriptor docstring and overriding deletion, Descriptor Doc string and Overriding Deletion

descriptor usage tips, Descriptor Usage Tips-Descriptor Usage Tips

further reading on, Further Reading

methods as descriptors, Methods Are Descriptors-Methods Are Descriptors

overriding versus nonoverriding, Step 5: Caching Properties with functools, Overriding Versus Nonoverriding Descriptors-Overwriting a Descriptor in the Class

overview of, Chapter Summary

purpose of, Attribute Descriptors

relevant terminology, Terms to understand descriptors

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

topics covered, Attribute Descriptors

attributes (see also attribute descriptors; dynamic attributes and properties)dynamic attribute access, Vector Take #3: Dynamic Attribute Access-Vector Take #3: Dynamic Attribute Access

handling attribute deletion, Handling Attribute Deletion

overriding class attributes, Overriding Class Attributes-Overriding Class Attributes

private and protected, Private and “Protected” Attributes in Python-Private and “Protected” Attributes in Python

properties and up-front costs, Further Reading

safety versus security in private, Further Reading

using attribute descriptors for validation, Descriptor Example: Attribute Validation-LineItem Take #5: A New Descriptor Type

using properties for attribute validation, Using a Property for Attribute Validation-LineItem Take #2: A Validating Property

virtual attributes, Dynamic Attributes and Properties

augmented assignment operators, Augmented Assignment with Sequences-A += Assignment Puzzler, Augmented Assignment Operators-Augmented Assignment Operators

averages, computing, Example: Coroutine to Compute a Running Average-Example: Coroutine to Compute a Running Average

await keyword, New Concept: Awaitable

B

backslash (\), List Comprehensions and Readability

behavioral subtyping, Subtype-of versus consistent-with

binary records, parsing with struct, What’s New in This Chapter

binary sequences, Byte Essentials (see also Unicode text versus bytes)

bisect module, list.sort Versus the sorted Built-In

blue tool, A Default Parameter Value

BOMs (byte-order marks), BOM: A Useful Gremlin

bool type, Boolean Value of a Custom Type

Boolean values, custom types and, Boolean Value of a Custom Type

built-in functions, The Nine Flavors of Callable Objects

byte sequences, How to Discover the Encoding of a Byte Sequence (see also Unicode text versus bytes)

bytecode, disassembling, Variable Scope Rules

C

call by sharing, Function Parameters as References

callable objects nine types of, The Nine Flavors of Callable Objects-The Nine Flavors of Callable Objects

user-defined, User-Defined Callable Types

using iter() with, Using iter with a Callable-Using iter with a Callable

Callable type, Callable

card deck example, A Pythonic Card Deck-A Pythonic Card Deck

Cartesian products, Cartesian Products-Cartesian Products

case folding, Case Folding

chain generator, Reinventing chain

ChainMap, collections.ChainMap

charactersfinding Unicode by name, Finding Characters by Name-Finding Characters by Name

numeric meaning of, Numeric Meaning of Characters-Numeric Meaning of Characters

Chardet library, How to Discover the Encoding of a Byte Sequence

cladistics, Goose Typing

class metaprogramming benefits and drawbacks of, Class Metaprogramming

built-in class factory, type: The Built-In Class Factory

class factory function, A Class Factory Function-A Class Factory Function

classes as objects, Classes as Objects

enhancing classes with class decorators, Enhancing Classes with a Class Decorator-Enhancing Classes with a Class Decorator

further reading on, Further Reading

import time versus runtime, What Happens When: Import Time Versus Runtime-Evaluation Time Experiments

__init_subclass__ (dunder init_subclass), Introducing __init_subclass__-Why __init_subclass__ Cannot Configure __slots__

metaclass basics, Metaclasses 101-Metaclass Evaluation Time Experiment

metaclass issues, Metaclasses in the Real World-Metaclasses Should Be Implementation Details

metaclass solution for checkedlib.py, A Metaclass Solution for Checked-A Metaclass Solution for Checked

overview of, Chapter Summary

__prepare__ method (dunder prepare), A Metaclass Hack with __prepare__-A Metaclass Hack with __prepare__

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

useful applications of metaclasses, Wrapping Up

classes (see also protocols)as callable objects, The Nine Flavors of Callable Objects

implementing generic classes, Implementing a Generic Class-Basic Jargon for Generic Types

topics covered, How the Book Is Organized

undocumented classes, Further Reading

classic refactoring strategy, Classic Strategy-Classic Strategy

classmethod decorator, classmethod Versus static method

client codes, Subgenerators with yield from

clock decoratorsclass-based, A Class-Based Clock Decorator

parameterized, The Parameterized Clock Decorator-The Parameterized Clock Decorator

closures (see decorators and closures)

cls.[[mro(), Classes as Objects

cls.__bases__ (dunder bases), Classes as Objects

cls.__qualname__ (dunder qualname), Classes as Objects

cls.__subclasses__() (dunder subclasses), Classes as Objects

code examples, obtaining and using, Using Code Examples

code points, Character Issues, Further Reading

code smells, Data Class Builders, Data Class as a Code Smell-Data Class as Intermediate Representation, Goose Typing

codecs, Basic Encoders/Decoders

Collection API, Collection API-Collection API

collections.abc module abstract base classes defined in, ABCs in the Standard Library

ChainMap, collections.ChainMap

Counter, collections.Counter

defaultdict and OrderedDict, Overview of Common Mapping Methods, collections.OrderedDict

Mapping and MutableMapping ABCs, Standard API of Mapping Types

multiple inheritance in, ABCs Are Mixins Too

UserDict, Subclassing UserDict Instead of dict

collections.deque class, Deques and Other Queues-Deques and Other Queues

collections.namedtuple, A Pythonic Card Deck, Classic Named Tuples-Classic Named Tuples

Command pattern, The Command Pattern-The Command Pattern

comments and questions, How to Contact Us

comparison operators, Identity, Equality, and Aliases, Rich Comparison Operators-Rich Comparison Operators

computed properties caching properties with functools, Step 5: Caching Properties with functools-Step 5: Caching Properties with functools

data-driven attribute creation, Step 1: Data-Driven Attribute Creation-Step 1: Data-Driven Attribute Creation

properties that compute values, Computed Properties

property caching, Step 4: Bespoke Property Cache-Step 4: Bespoke Property Cache

property overriding existing attributes, Step 3: Property Overriding an Existing Attribute

property to retrieve linked records, Step 2: Property to Retrieve a Linked Record-Step 2: Property to Retrieve a Linked Record

concatenation, Using + and * with Sequences-A += Assignment Puzzler

concurrency modelsbasics of concurrency, The Big Picture

benefits of concurrency, Concurrency Models in Python

further reading on, Further Reading-Concurrency and Scalability Beyond Python

Global Interpreter Lock impact, The Real Impact of the GIL-3. Answer for asyncio

Hello World example, A Concurrent Hello World-Supervisors Side-by-Side

indefinite loops and sentinels, Code for the Multicore Prime Checker

multicore processors and, Python in the Multicore World-Distributed Task Queues

overview of, Chapter Summary

process pools, A Homegrown Process Pool-Thread-Based Nonsolution

Python programming concepts, Processes, Threads, and Python’s Infamous GIL-Processes, Threads, and Python’s Infamous GIL

relevant terminology, A Bit of Jargon-A Bit of Jargon

significant changes to, What’s New in This Chapter

Soapbox discussion, Concurrency and Scalability Beyond Python-Concurrency and Scalability Beyond Python

structured concurrency, async Beyond asyncio: Curio

topics covered, Concurrency Models in Python

concurrent executorsconcurrent web downloads, Concurrent Web Downloads-Where Are the Futures?

downloads with progress display and error handling, Downloads with Progress Display and Error Handling-Using futures.as_completed

Executor.map, Experimenting with Executor.map-Experimenting with Executor.map

further reading on, Further Reading

launching processes with concurrent.futures, Launching Processes with concurrent.futures-Multicore Prime Checker Redux

overview of, Chapter Summary

purpose of, Concurrent Executors

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

concurrent.futures downloading with, Downloading with concurrent.futures-Downloading with concurrent.futures

launching processes with, Launching Processes with concurrent.futures-Multicore Prime Checker Redux

consistent-with relationships, Subtype-of versus consistent-with

Container interface, Collection API

container sequences, Overview of Built-In Sequences, Further Reading

contention, A Bit of Jargon

context managers@contextmanager decorator, Using @contextmanager-Using @contextmanager

asynchronous, Asynchronous Context Managers-Asynchronous Context Managers

asynchronous generators as, Asynchronous generators as context managers

context lib utilities, The context lib Utilities

creative uses for, Context Managers and with Blocks

demonstrations of, Context Managers and with Blocks-Context Managers and with Blocks

methods included in interface, Context Managers and with Blocks

parenthesized in Python 3.10, Context Managers and with Blocks

purpose of, Context Managers and with Blocks

contravariance (see variance)

control flow, How the Book Is Organized (see also asynchronous programming; concurrent executors; concurrency models; iterators; generators; with, match, and else blocks)

cooperative multiple inheritance, Multiple Inheritance and Method Resolution Order

copies deep, Deep and Shallow Copies of Arbitrary Objects-Deep and Shallow Copies of Arbitrary Objects

shallow, Copies Are Shallow by Default-Copies Are Shallow by Default

coroutine objects, Classic Coroutines

coroutinescomputing running averages, Example: Coroutine to Compute a Running Average-Example: Coroutine to Compute a Running Average

definition of term, A Bit of Jargon

further reading on, Further Reading

generator-based, A Few Definitions

generic type hints for, Generic Type Hints for Classic Coroutines

Global Interpreter Lock impact, 3. Answer for asyncio

overview of, Chapter Summary

returning values from, Returning a Value from a Coroutine-Returning a Value from a Coroutine

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

spinners (loading indicators) using, Spinner with Coroutines-Experiment: Break the spinner for an insight

topics covered, Iterators, Generators, and Classic Coroutines

types of, A Few Definitions

understanding classic, Classic Coroutines

Counter, collections.Counter

covariance (see variance)

CPU-bound systems, Avoiding CPU-Bound Traps

Curio project, async Beyond asyncio: Curio-async Beyond asyncio: Curio

curly brackets ({}), List Comprehensions and Readability

D

Dask, Data Science

data attributes (see attributes)

data class builders@dataclass, More About @dataclass-@dataclass Example: Dublin Core Resource Record

classic named tuples, Classic Named Tuples-Classic Named Tuples

data class as code smell, Data Class as a Code Smell-Data Class as Intermediate Representation

further reading on, Further Reading

main features, Main Features-New class at runtime

overview of, Overview of Data Class Builders-Overview of Data Class Builders, Chapter Summary

pattern matching class instances, Pattern Matching Class Instances-Positional Class Patterns

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

topics covered, Data Class Builders

type hints, Type Hints 101-Inspecting a class decorated with dataclass

typed named tuples, Typed Named Tuples

data descriptors (see overriding descriptors)

data model (see Python Data Model)

data science, Data Science

data structures, How the Book Is Organized (see also data class builders; dictionaries and sets; object references; sequences; Unicode text versus bytes)

data wranglingwith dynamic attributes, Data Wrangling with Dynamic Attributes-Data Wrangling with Dynamic Attributes

flexible object creation, Flexible Object Creation with __new__ (dunder new) - Flexible Object Creation with __new__

invalid attribute name problem, The Invalid Attribute Name Problem

JSON-like data, Exploring JSON-Like Data with Dynamic Attributes-Exploring JSON-Like Data with Dynamic Attributes

decimal.Decimal class, Unary Operators

decoding (see also Unicode text versus bytes)basics of, Basic Encoders/Decoders-Basic Encoders/Decoders

definition of, Character Issues

understanding encode/decode problems, Understanding Encode/Decode Problems-BOM: A Useful Gremlin

decorator-enhanced strategy pattern, Decorator-Enhanced Strategy Pattern-Decorator-Enhanced Strategy Pattern

decorators and closuresclassmethod versus static method, classmethod Versus static method

closure basics, Closures-Closures

closures in lis.py, Procedure: A Class Implementing a Closure

decorator basics, Decorators 101-Decorators 101

decorator execution, When Python Executes Decorators

decorator implementation, Implementing a Simple Decorator-How It Works

decorators in Python standard library, Decorators in the Standard Library-Memoization with functools.cache

enhancing classes with class decorators, Enhancing Classes with a Class Decorator-Enhancing Classes with a Class Decorator

further reading on, Further Reading

nonlocal declarations, The nonlocal Declaration-Variable Lookup Logic

overview of, Chapter Summary

parameterized decorators, Parameterized Decorators-A Class-Based Clock Decorator

purpose of, Decorators and Closures

registration decorators, Registration Decorators

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

topics covered, Decorators and Closures

variable scope rules, Variable Scope Rules-Variable Scope Rules

deep copies, Deep and Shallow Copies of Arbitrary Objects-Deep and Shallow Copies of Arbitrary Objects

defaultdict, Overview of Common Mapping Methods, defaultdict: Another Take on Missing Keys

defensive programming, Inserting or Updating Mutable Values, Defensive Programming and “Fail Fast”-Defensive Programming and “Fail Fast”

del statement, del and Garbage Collection-del and Garbage Collection, Handling Attribute Deletion

delegating generators, Subgenerators with yield from

deprecated collection types, Generic Collections

deque (double-ended queue), When a List Is Not the Answer, Deques and Other Queues-Deques and Other Queues

descriptor classes, Terms to understand descriptors

descriptor instances, Terms to understand descriptors

descriptors, Inspecting a typing.NamedTuple, Attribute Descriptors (see also attribute descriptors)

design patterns (see functions, design patterns with first-class)

destructuring, Pattern Matching with Sequences

diacritics, normalization and, Extreme “Normalization”: Taking Out Diacritics-Extreme “Normalization”: Taking Out Diacritics

dictcomps (dict comprehensions), dict Comprehensions

dictionaries and sets automatic handling of missing keys, Automatic Handling of Missing Keys-Inconsistent Usage of __missing__ in the Standard Library

consequences of how dict works, Practical Consequences of How dict Works

consequences of how set works, Practical Consequences of How Sets Work

dictionary views, Dictionary Views-Dictionary Views

further reading on, Further Reading

immutable mappings, Immutable Mappings

internals of, What’s New in This Chapter

modern dict syntax, Modern dict Syntax-Merging Mappings with |

overview of, Chapter Summary

pattern matching with mappings, Pattern Matching with Mappings-Pattern Matching with Mappings

set operations, Set Operations-Set Operations

set operations on dict views, Set Operations on dict Views

set theory, Set Theory-Set Comprehensions

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

standard API of mapping types, Standard API of Mapping Types-Inserting or Updating Mutable Values

topics covered, Dictionaries and Sets

variations of dict, Variations of dict-Subclassing UserDict Instead of dict

dir(object) function, Built-In Functions for Attribute Handling

dis module, Variable Scope Rules

displays, formatting, Formatted Displays-Formatted Displays

distributed task queues, Distributed Task Queues

Django generic views mixins, Django Generic Views Mixins-Django Generic Views Mixins

doctest package documentation, Hands-On Approach

ellipsis in, A Pythonic Card Deck

double star (**) operator, Unpacking Mappings, From Positional to Keyword-Only Parameters

double underscore (__), The Python Data Model

double() function, The Typed double Function-The Typed double Function

Dublin Core Schema, @dataclass Example: Dublin Core Resource Record

duck typing, Overview of Common Mapping Methods, Types Are Defined by Supported Operations, Further Reading, Protocols and Duck Typing, Further Reading, Interfaces, Protocols, and ABCs, Runtime Checkable Static Protocols

dunder methods, The Python Data Model

dynamic attributes and properties coding property factories, Coding a Property Factory-Coding a Property Factory

computed properties, Computed Properties-Step 5: Caching Properties with functools

data wrangling with dynamic attributes, Data Wrangling with Dynamic Attributes-Flexible Object Creation with __new__

dynamic versus virtual attributes, Dynamic Attributes and Properties

essential attributes and functions for attribute handling, Essential Attributes and Functions for Attribute Handling-Special Methods for Attribute Handling

further reading on, Further Reading

handling attribute deletion, Handling Attribute Deletion

overview of, Chapter Summary

property class, A Proper Look at Properties-Property Documentation

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

using properties for attribute validation, Using a Property for Attribute Validation-LineItem Take #2: A Validating Property

dynamic protocols, Protocols and Duck Typing, Two Kinds of Protocols

dynamic type, The Any Type-Subtype-of versus consistent-with

E

ellipsis (…), A Pythonic Card Deck, Multidimensional Slicing and Ellipsis

else blocks, Do This, Then That: else Blocks Beyond if-Do This, Then That: else Blocks Beyond if

emojisbuilding, What’s New in This Chapter

console font and, Beware of Encoding Defaults

finding characters by name, Finding Characters by Name-Finding Characters by Name

in the Museum of Modern Art, Further Reading

increasing issues with, Further Reading

UCS-2 versus UTF-16 encoding, Basic Encoders/Decoders

varied support for, Finding Characters by Name

encoding (see also Unicode text versus bytes)basics of, Basic Encoders/Decoders-Basic Encoders/Decoders

definition of, Character Issues

encoding defaults, Beware of Encoding Defaults-Beware of Encoding Defaults

understanding encode/decode problems, Understanding Encode/Decode Problems-BOM: A Useful Gremlin

equality (= operator, Identity, Equality, and Aliases, Further Reading, Rich Comparison Operators

error handling, in network I/O, Downloads with Progress Display and Error Handling-Using futures.as_completed

execution units, A Bit of Jargon

Executor.map, Experimenting with Executor.map-Experimenting with Executor.map

executors, delegating tasks to, Delegating Tasks to Executors-Delegating Tasks to Executors (see also concurrent executors)

explicit self argument, Further Reading

F

f-string syntax benefits of, What’s New in This Chapter

delegation of formatting by, Formatted Displays

string representation using special methods, String Representation

fail-fast philosophy, Inserting or Updating Mutable Values, Vector Take #4: Hashing and a Faster ==, Defensive Programming and “Fail Fast”-Defensive Programming and “Fail Fast”

FastAPI framework, A FastAPI Web Service-A FastAPI Web Service

FIFO (first in, first out)]], When a List Is Not the Answer, Deques and Other Queues

filter function, Listcomps Versus map and filter, Higher-Order Functions-Modern Replacements for map, filter, and reduce

filtering generator functions, Generator Functions in the Standard Library

first-class functions (see functions, as first-class objects)

first-class objects, Functions as First-Class Objects

flake8 tool, A Default Parameter Value

flat sequences, Overview of Built-In Sequences, Further Reading

flawed typing, Imperfect Typing and Strong Testing

fluentpython.com, Companion Website: fluentpython.com

ForkingMixIn, ThreadingMixIn and ForkingMixIn

formal type parameters, Basic Jargon for Generic Types

format() function, Formatted Displays

forward reference problem, Problems with Annotations at Runtime

free variables, Closures, Procedure: A Class Implementing a Closure

frozenset, Set Theory (see also dictionaries and sets)

function decorators (see decorators and closures)

function parameters, introspection of, What’s New in This Chapter

function-class duality, Further Reading

function-oriented refactoring strategy, Function-Oriented Strategy-Function-Oriented Strategy

functional programming packages for, Packages for Functional Programming-Freezing Arguments with functools.partial

with Python, Further Reading

functionsabs built-in function, Emulating Numeric Types

dir(object) function, Built-In Functions for Attribute Handling

disassembling bytecode of, Variable Scope Rules

double() function, The Typed double Function

filter, map, and reduce functions, Listcomps Versus map and filter, Higher-Order Functions

format() function, Formatted Displays

getattr function, Special Methods for Attribute Handling

getattr(object, name, default) function, Built-In Functions for Attribute Handling

globals() function, Finding Strategies in a Module

hasattr function, Special Methods for Attribute Handling

higher-order functions, Higher-Order Functions-Modern Replacements for map, filter, and reduce

id() function, Identity, Equality, and Aliases

iter() function, Why Sequences Are Iterable: The iter Function

len() function, A Pythonic Card Deck

map function, Listcomps Versus map and filter

max() function, Max Overload

repr() function, Object Representations

setattr function, Special Methods for Attribute Handling

setattr(object, name, value) function, Built-In Functions for Attribute Handling, Built-In Functions for Attribute Handling

single dispatch generic functions, Single Dispatch Generic Functions-Function single[[dispatch

str() function, String Representation, Object Representations

super() function, Vector Take #3: Dynamic Attribute Access, The super() Function

zip() function, Vector Take #4: Hashing and a Faster ==

functions, as first-class objects (see also decorators and closures)anonymous functions, Anonymous Functions

callable objects, The Nine Flavors of Callable Objects-The Nine Flavors of Callable Objects

definition of term, Functions as First-Class Objects

flexible parameter handling and, From Positional to Keyword-Only Parameters-Positional-Only Parameters

further reading on, Further Reading

higher-order functions, Higher-Order Functions-Modern Replacements for map, filter, and reduce

overview of, Chapter Summary

packages for functional programming, Packages for Functional Programming-Freezing Arguments with functools.partial

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

topics covered, How the Book Is Organized

treating functions like objects, Treating a Function Like an Object-Treating a Function Like an Object

user-defined callable types, User-Defined Callable Types

functions, design patterns with first-class Command pattern, The Command Pattern-The Command Pattern

decorator-enhanced strategy pattern, Decorator-Enhanced Strategy Pattern-Decorator-Enhanced Strategy Pattern

dynamic languages and, Design Patterns with First-Class Functions

further reading on, Further Reading

overview of, Chapter Summary

refactoring strategies, Case Study: Refactoring Strategy-Finding Strategies in a Module

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

functions, type hints inannotating positional only and variadic parameters, Annotating Positional Only and Variadic Parameters

benefits and drawbacks of, Type Hints in Functions

flawed typing and strong testing, Imperfect Typing and Strong Testing

further reading on, Further Reading

gradual typing, About Gradual Typing-Using None as a Default

overview of, Chapter Summary

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

supported operations and, Types Are Defined by Supported Operations-Types Are Defined by Supported Operations

topics covered, Type Hints in Functions

types usable in annotations, Types Usable in Annotations-NoReturn

functools module caching properties with, Step 5: Caching Properties with functools-Step 5: Caching Properties with functools

freezing arguments with, Freezing Arguments with functools.partial-Freezing Arguments with functools.partial

functools.cache decorator, Memoization with functools.cache-Memoization with functools.cache

functools.lru_cache function, Using lru_cache

functools.single[[dispatch decorator, Function single[[dispatch-Function single[[dispatch

futuresbasics of, Where Are the Futures?-Where Are the Futures?

definition of term, Concurrent Executors

futures.as_completed, Using futures.as_completed-Using futures.as_completed

G

garbage collection, del and Garbage Collection-del and Garbage Collection, Further Reading

generator expressions (genexps), List Comprehensions and Readability, Generator Expressions, Modern Replacements for map, filter, and reduce, When to Use Generator Expressions, Async Comprehensions and Async Generator Expressions-Asynchronous comprehensions

generatorsarithmetic progression generators, An Arithmetic Progression Generator-Arithmetic Progression with iter tools

asynchronous generator functions, Asynchronous Generator Functions-Asynchronous generators versus native coroutines

examples of, How a Generator Works-How a Generator Works

further reading on, Further Reading

generator functions in Python standard library, The Nine Flavors of Callable Objects, Generator Functions in the Standard Library-Generator Functions in the Standard Library

generator-based coroutines, A Few Definitions

generic iterable types, Generic Iterable Types

humble generators, The Secret of Native Coroutines: Humble Generators

iterable reducing functions, Iterable Reducing Functions-Iterable Reducing Functions

versus iterators, When to Use Generator Expressions

lazy generators, Lazy Sentences-Sentence Take #5: Lazy Generator Expression

overview of, Chapter Summary

Sentence classes with, Sentence Take #3: A Generator Function

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

subgenerators with yield from expression, Subgenerators with yield from-Traversing a Tree

topics covered, Iterators, Generators, and Classic Coroutines

when to use generator expressions, When to Use Generator Expressions

yield keyword, How a Generator Works

generic classes, implementing, Implementing a Generic Class-Basic Jargon for Generic Types

generic collectionsparameterized generics and Type Var, Parameterized Generics and Type Var-The AnyStr predefined type variable

Soapbox discussion, Further Reading

type annotations and, Generic Collections-Generic Collections

generic functions, single dispatch, Single Dispatch Generic Functions-Function single[[dispatch

generic mapping types, Generic Mappings

generic static protocols, Implementing a Generic Static Protocol-Implementing a Generic Static Protocol

getattr function, Special Methods for Attribute Handling

getattr(object, name[, default) function, Built-In Functions for Attribute Handling

gevent library, Experiment: Break the spinner for an insight

Global Interpreter Lock (GIL), NumPy, Processes, Threads, and Python’s Infamous GIL, The Real Impact of the GIL-3. Answer for asyncio, Python in the Multicore World, The GIL

globals() function, Finding Strategies in a Module

goose typing ABC syntax details, ABC Syntax Details

ABCs in Python standard library, ABCs in the Standard Library-ABCs in the Standard Library

abstract base classes (ABCs), Goose Typing-Goose Typing

defining and using ABCs, Defining and Using an ABC-Defining and Using an ABC

definition of term, Interfaces, Protocols, and ABCs

overview of, Goose Typing

structural typing with ABCs, Structural Typing with ABCs-Structural Typing with ABCs

subclassing ABCs, Subclassing an ABC-Subclassing an ABC, Subclassing an ABC-Subclassing an ABC

usage of register, Usage of register in Practice

virtual subclasses of ABCs, A Virtual Subclass of an ABC-A Virtual Subclass of an ABC

gradual type system (see also type hints (type annotations))abstract base classes, Abstract Base Classes-The fall of the numeric tower

Any type, The Any Type-The Any Type

basics of, About Gradual Typing

Callable type, Callable

further reading on, Further Reading

generic collections, Generic Collections-Generic Collections

generic mappings, Generic Mappings

implementing generic classes, Implementing a Generic Class-Basic Jargon for Generic Types

implementing generic static protocols, Implementing a Generic Static Protocol-Implementing a Generic Static Protocol

in practice, Gradual Typing in Practice-Using None as a Default

Iterable, Iterable-abc.Iterable versus abc.Sequence

legacy support and deprecated collection types, Generic Collections

NoReturn type, NoReturn

Optional and Union types, Optional and Union Types

overloaded signatures, Overloaded Signatures-Takeaways from Overloading max

overview of, Chapter Summary

parameterized generics and Type Var, Parameterized Generics and Type Var-The AnyStr predefined type variable

reading hints at runtime, Reading Type Hints at Runtime-Dealing with the Problem

significant changes to, What’s New in This Chapter

simple types and classes, Simple Types and Classes

Soapbox discussion, Further Reading

static protocols, Static Protocols-Static Protocols

subtype-of versus consistent-with relationships, Subtype-of versus consistent-with-Subtype-of versus consistent-with

topics covered, More About Type Hints

tuple types, Tuple Types-Tuples as immutable sequences

type casting, Type Casting-Type Casting

Typed Dict, Typed Dict

variance and, Variance-Variance rules of thumb

greater than (>) operator, Rich Comparison Operators

greater than or equal to (> operator, Rich Comparison Operators

greenlet package, Experiment: Break the spinner for an insight

H

hasattr function, Special Methods for Attribute Handling

hash code, versus hash value, What Is Hashable

hash tables, Dictionaries and Sets

hashable, definition of, What Is Hashable

heapq package, Deques and Other Queues

higher-order functions, Higher-Order Functions-Modern Replacements for map, filter, and reduce

HTTPServer class, ThreadingMixIn and ForkingMixIn

HTTPX library, Downloading with asyncio and HTTPX-The All-or-Nothing Problem

humble generators, The Secret of Native Coroutines: Humble Generators

I

I/O (input/output) (see network I/O)

id() function, Identity, Equality, and Aliases

immutable mappings, Immutable Mappings

immutable sequences, Overview of Built-In Sequences

implicit conversion, Unicode Text Versus Bytes

import time versus runtime, When Python Executes Decorators, What Happens When: Import Time Versus Runtime

indefinite loops, Code for the Multicore Prime Checker

infix operators, Operator Overloading, Using @ as an Infix Operator-Wrapping-Up Arithmetic Operators

inheritance and subclassing best practices, Coping with Inheritance-Tkinter: The Good, the Bad, and the Ugly

further reading on, Further Reading

mixin classes, Mixin Classes-Case-Insensitive Mappings

multiple inheritance and method resolution order, Multiple Inheritance and Method Resolution Order-Multiple Inheritance and Method Resolution Order

overview of, Chapter Summary

real-world examples of, Multiple Inheritance in the Real World-Multiple Inheritance in Tkinter

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

subclassing ABCs, Subclassing an ABC-Subclassing an ABC, Subclassing an ABC-Subclassing an ABC

subclassing built-in types, Subclassing Built-In Types Is Tricky-Subclassing Built-In Types Is Tricky

super() function, The super() Function-The super() Function

topics covered, Inheritance: For Better or for Worse

virtual subclasses of ABCs, A Virtual Subclass of an ABC-A Virtual Subclass of an ABC

input expanding generator functions, Generator Functions in the Standard Library

interfaces (see also goose typing; protocols)Container interface, Collection API

further reading on, Further Reading

Iterable interface, Collection API, Iterable, Programming Ducks

overview of, Chapter Summary

protocols as informal, Further Reading

role in object-oriented programming, Interfaces, Protocols, and ABCs

significant changes to, What’s New in This Chapter

Sized interface, Collection API

Soapbox discussion, Further Reading-Further Reading

topics covered, The Typing Map

typing map, The Typing Map

ways of defining and using, Interfaces, Protocols, and ABCs

interning, Tricks Python Plays with Immutables

invalid attribute name problem, The Invalid Attribute Name Problem

inverted indexes, Writing asyncio Servers

is operator, Choosing Between == and is, Tricks Python Plays with Immutables

.items method, Set Operations on dict Views

iter() function, Why Sequences Are Iterable: The iter Function-Using iter with a Callable

Iterable interface, Collection API, Iterable-abc.Iterable versus abc.Sequence, Programming Ducks-Python Digs Sequences

iterablesasynchronous, Asynchronous Iteration and Asynchronous Iterables-Asynchronous comprehensions

iterable reducing functions, Iterable Reducing Functions-Iterable Reducing Functions

versus iterators, Iterables Versus Iterators-Iterables Versus Iterators

unpacking, Unpacking Sequences and Iterables-Nested Unpacking

iteratorsasynchronous, Asynchronous Iteration and Asynchronous Iterables-Asynchronous comprehensions

further reading on, Further Reading

versus generators, When to Use Generator Expressions

generic iterable types, Generic Iterable Types

iter() function, Why Sequences Are Iterable: The iter Function-Using iter with a Callable

versus iterables, Iterables Versus Iterators-Iterables Versus Iterators

lazy sentences, Lazy Sentences-Sentence Take #5: Lazy Generator Expression

overview of, Chapter Summary

role of, Iterators, Generators, and Classic Coroutines

Sentence classes with __iter__ (dunder iter), Sentence Classes with __iter__-How a Generator Works

sequence protocol, A Sequence of Words-A Sequence of Words

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

topics covered, Iterators, Generators, and Classic Coroutines

iter tools module, Arithmetic Progression with iter tools

J

JSON-like data, Exploring JSON-Like Data with Dynamic Attributes-Exploring JSON-Like Data with Dynamic Attributes

K

key argument, Further Reading

keysautomatic handling of missing, Automatic Handling of Missing Keys-Inconsistent Usage of __missing__ (dunder missing) in the Standard Library

converting nonstring keys to str, Subclassing UserDict Instead of dict

hashability, Standard API of Mapping Types

persistent storage for mapping, shelve.Shelf

practical consequences of using dict, Practical Consequences of How dict Works

preserving key insertion order, Collection API, Modern Features Simplify or Replace Metaclasses

sorting multiple, The operator Module

.keys method, Set Operations on dict Views

keyword class patterns, Keyword Class Patterns

keyword-only arguments, From Positional to Keyword-Only Parameters

keyword sas keyword, Pattern Matching with Sequences

await keyword, New Concept: Awaitable

lambda keyword, Anonymous Functions

nonlocal keyword, The nonlocal Declaration-Variable Lookup Logic, (set! …)

reserved keywords, (quote …)

yield keyword, The Nine Flavors of Callable Objects, Don’t Make the Iterable an Iterator for Itself-How a Generator Works, When to Use Generator Expressions, Classic Coroutines, Example: Coroutine to Compute a Running Average, Using @contextmanager

KISS principle, Further Reading, Further Reading, Concurrency and Scalability Beyond Python

L

lambda keyword, Anonymous Functions

lazy sentences, Lazy Sentences-Sentence Take #5: Lazy Generator Expression

Least Recently Used (LRU), Using lru_cache

len() function, A Pythonic Card Deck

less than (<) operator, Rich Comparison Operators

less than or equal to (⇐) operator, Rich Comparison Operators

line breaks, List Comprehensions and Readability

lis.py interpreter Environment class, The Environment

evaluate function, The Evaluator-Catch syntax errors

imports and types, Imports and Types

OR-patterns, Using OR-patterns

parser, The Parser-The Parser

pattern matching in, Pattern Matching Sequences in an Interpreter-Shortcut syntax for function definition

Procedure class, Procedure: A Class Implementing a Closure-Procedure: A Class Implementing a Closure

REPL (read-eval-print-loop), The REPL

Scheme syntax, Scheme Syntax-Scheme Syntax

topics covered, Pattern Matching in lis.py: A Case Study

list comprehensions (listcomps)asynchronous, Async Comprehensions and Async Generator Expressions-Asynchronous comprehensions

building lists from cartesian products, Cartesian Products

building sequences with, List Comprehensions and Generator Expressions

versus generator expressions, Generator Expressions

local scope within, List Comprehensions and Readability

readability and, List Comprehensions and Readability

syntax tip, List Comprehensions and Readability

versus map and filter functions, Listcomps Versus map and filter, Modern Replacements for map, filter, and reduce

listsalternatives to, When a List Is Not the Answer-Deques and Other Queues

building lists of lists, Building Lists of Lists

list.sort versus sorted built-in, list.sort Versus the sorted Built-In-list.sort Versus the sorted Built-In

mixed-bag, Further Reading

multiline, List Comprehensions and Readability

shallow copies of, Copies Are Shallow by Default-Copies Are Shallow by Default

versus tuples, Comparing Tuple and List Methods

using tuples as immutable, Tuples as Immutable Lists-Tuples as Immutable Lists

locks, definition of term, A Bit of Jargon

LRU (see Least Recently Used)

M

magic methods, The Python Data Model, Further Reading

managed attributes, Terms to understand descriptors

managed classes, Terms to understand descriptors

managed instances, Terms to understand descriptors

map function, Listcomps Versus map and filter, Higher-Order Functions-Modern Replacements for map, filter, and reduce

mappingsautomatic handling of missing keys, Automatic Handling of Missing Keys-Inconsistent Usage of __missing__ (dunder missing) in the Standard Library

case-insensitive, Case-Insensitive Mappings-Case-Insensitive Mappings

immutable mappings, Immutable Mappings

mapping generator functions, Generator Functions in the Standard Library

merging, Merging Mappings with |

pattern matching with, Pattern Matching with Mappings-Pattern Matching with Mappings

standard API of mapping types, Standard API of Mapping Types-Inserting or Updating Mutable Values

unpacking, Unpacking Mappings

match blocks (see with, match, and else blocks)

match/case statement, Pattern Matching with Sequences, Pattern Matching with Mappings

mathematical vector operations, Overloading + for Vector Addition

max() function, Max Overload-Takeaways from Overloading max

memoization, Memoization with functools.cache-Memoization with functools.cache

memory, saving with __slots__ (dunder slots), Saving Memory with __slots__-Summarizing the Issues with __slots__

memoryview class, Memory Views-Memory Views

metaclassesbasics of, Metaclasses 101-Metaclasses 101

considerations for use, Metaclasses in the Real World-Metaclasses Should Be Implementation Details

customizing classes, How a Metaclass Customizes a Class

definition of term, type: The Built-In Class Factory

example metaclass, A Nice Metaclass Example-A Nice Metaclass Example

metaclass evaluation time experiment, Metaclass Evaluation Time Experiment-Metaclass Evaluation Time Experiment

metaclass solution for checkedlib.py, A Metaclass Solution for Checked-A Metaclass Solution for Checked

useful applications of, Wrapping Up

metaobjects, Further Reading

metaprogramming, How the Book Is Organized (see also attribute descriptors; class metaprogramming; dynamic attributes and properties)

method resolution order (MRO), Multiple Inheritance and Method Resolution Order-Multiple Inheritance and Method Resolution Order

methods, as callable objects, The Nine Flavors of Callable Objects (see also sequences, special methods for; special methods)

Meyer's Uniform Access Principle, Further Reading-Further Reading

Mills & Gizmos Notation (MGN), Terms to understand descriptors

mixin classes, Mixin Classes-Case-Insensitive Mappings

mixin methods, ABCs Are Mixins Too

modulo (%) operator, What’s New in This Chapter, String Representation

monkey-patching, Monkey Patching]]: Implementing a Protocol at Runtime-Monkey Patching]]: Implementing a Protocol at Runtime, Further Reading, Overwriting a Descriptor in the Class

MRO (see method resolution order)

multicore processing data science, Data Science

distributed task queues, Distributed Task Queues

increased availability of, Python in the Multicore World

server-side web/mobile development, Server-Side Web/Mobile Development

system administration, System Administration

WSGI application servers, WSGI Application Servers

multiline lists, List Comprehensions and Readability

multiple inheritance (see also inheritance and subclassing)method resolution order and, Multiple Inheritance and Method Resolution Order-Multiple Inheritance and Method Resolution Order

real-world examples of, Multiple Inheritance in the Real World-Multiple Inheritance in Tkinter

multiplication, scalar, Emulating Numeric Types, Overloading * for Scalar Multiplication-Overloading * for Scalar Multiplication

multiprocessing package, Deques and Other Queues, Spinner with Processes

mutable objects, Further Reading (see also object references)

mutable parameters, Mutable Types as Parameter Defaults: Bad Idea-Defensive Programming with Mutable Parameters

mutable sequences, Overview of Built-In Sequences

mutable values, inserting or updating, Inserting or Updating Mutable Values-Inserting or Updating Mutable Values

MutableMapping ABC, Standard API of Mapping Types

Mypy type checker, Gradual Typing in Practice-Using None as a Default

my_fmt.format() method, What’s New in This Chapter

N

name mangling, Private and “Protected” Attributes in Python

namedtuple, Classic Named Tuples-Classic Named Tuples

native coroutinesversus asynchronous generators, Asynchronous generators versus native coroutines

definition of term, A Few Definitions

functions defined with async def, The Nine Flavors of Callable Objects

humble generators and, The Secret of Native Coroutines: Humble Generators

network I/O downloading with asyncio, Downloading with asyncio and HTTPX-The All-or-Nothing Problem

downloading with concurrent.futures, Downloading with concurrent.futures-Downloading with concurrent.futures

downloads with progress display and error handling, Downloads with Progress Display and Error Handling-Using futures.as_completed

enhancing asyncio downloader, Enhancing the asyncio Downloader-Making Multiple Requests for Each Download

essential role of concurrency in, Concurrent Web Downloads-Concurrent Web Downloads

myth of I/O-bound systems, The Myth of I/O-Bound Systems

role of futures, Where Are the Futures?-Where Are the Futures?

sequential download script, A Sequential Download Script-A Sequential Download Script

NFC (see Normalization Form C)

nominal typing, Types Are Defined by Supported Operations

nonlocal keyword, The nonlocal Declaration-Variable Lookup Logic, (set! …)

nonoverriding descriptors, Step 5: Caching Properties with functools, Overriding Versus Nonoverriding Descriptors-Overwriting a Descriptor in the Class

NoReturn type, NoReturn

Normalization Form C (NFC), Normalizing Unicode for Reliable Comparisons

normalized text matching, Utility Functions for Normalized Text Matching-Extreme “Normalization”: Taking Out Diacritics

not equal to (! operator, Rich Comparison Operators

numbers ABCs, The numbers ABCs and Numeric Protocols-The numbers ABCs and Numeric Protocols

numbers package, The fall of the numeric tower

numeric protocols, The numbers ABCs and Numeric Protocols-The numbers ABCs and Numeric Protocols

numeric tower, The fall of the numeric tower

numeric typeschecking for convertibility, Runtime Checkable Static Protocols, The numbers ABCs and Numeric Protocols

emulating using special methods, Emulating Numeric Types-Emulating Numeric Types

hashability of, What Is Hashable

support for, The numbers ABCs and Numeric Protocols

NumPy, NumPy-NumPy

O

object referencesaliasing, Identity, Equality, and Aliases-The Relative Immutability of Tuples

deep copies, Deep and Shallow Copies of Arbitrary Objects-Deep and Shallow Copies of Arbitrary Objects

del and garbage collection, del and Garbage Collection-del and Garbage Collection

distinction between objects and their names, Object References, Mutability, and Recycling

function parameters as references, Function Parameters as References-Defensive Programming with Mutable Parameters

further reading on, Further Reading

immutability and, Tricks Python Plays with Immutables

overview of, Chapter Summary

shallow copies, Copies Are Shallow by Default-Copies Are Shallow by Default

Soapbox discussion, Further Reading

variables as labels versus boxes, Variables Are Not Boxes-Variables Are Not Boxes

objectscallable objects, The Nine Flavors of Callable Objects-The Nine Flavors of Callable Objects, Using iter with a Callable-Using iter with a Callable

first-class, Functions as First-Class Objects

flexible object creation, Flexible Object Creation with __new__-Flexible Object Creation with __new__

mutable, Further Reading

treating functions like, Treating a Function Like an Object-Treating a Function Like an Object

user-defined callable objects, User-Defined Callable Types

operator module, The operator Module-The operator Module

operator overloading augmented assignment operators, Augmented Assignment Operators-Augmented Assignment Operators

basics of, Operator Overloading 101

further reading on, Further Reading

infix operator method names, Wrapping-Up Arithmetic Operators

infix operators, Operator Overloading

overloading * for scalar multiplication, Overloading * for Scalar Multiplication-Overloading * for Scalar Multiplication

overloading + for vector addition, Overloading + for Vector Addition-Overloading + for Vector Addition

overview of, Chapter Summary

rich comparison operators, Rich Comparison Operators-Rich Comparison Operators

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

topics covered, Operator Overloading

unary operators, Unary Operators-Unary Operators

using @ as infix operator, Using @ as an Infix Operator-Using @ as an Infix Operator

Optional type, Optional and Union Types

OR-patterns, Using OR-patterns

OrderedDict, Overview of Common Mapping Methods, collections.OrderedDict

os functions, str versus bytes in, str Versus bytes in os Functions

overloaded signatures, Overloaded Signatures-Takeaways from Overloading max

overriding descriptors, Step 5: Caching Properties with functools, Properties Override Instance Attributes, Overriding Versus Nonoverriding Descriptors-Overwriting a Descriptor in the Class

P

parallelism, Concurrency Models in Python, A Bit of Jargon

parameterized decorators, Parameterized Decorators-A Class-Based Clock Decorator

parameterized types, Basic Jargon for Generic Types

parametersannotating positional only and variadic parameters, Annotating Positional Only and Variadic Parameters

introspection of function parameters, What’s New in This Chapter

keyword-only, From Positional to Keyword-Only Parameters

mutable, Mutable Types as Parameter Defaults: Bad Idea-Defensive Programming with Mutable Parameters

parameter passing, Function Parameters as References

positional, From Positional to Keyword-Only Parameters-Positional-Only Parameters

pattern matching*_ symbol, Pattern Matching with Sequences

destructuring, Pattern Matching with Sequences

in lis.py interpreter, Pattern Matching Sequences in an Interpreter-Shortcut syntax for function definition, Pattern Matching in lis.py: A Case Study-Using OR-patterns

with mappings, Pattern Matching with Mappings-Pattern Matching with Mappings

match/case statement, Pattern Matching with Sequences

pattern matching class instances, Pattern Matching Class Instances-Positional Class Patterns

tuples and lists, Pattern Matching with Sequences

type information, Pattern Matching with Sequences

_ symbol, Pattern Matching with Sequences

patterns (see functions, design patterns with first-class; pattern matching)

pickle module, shelve.Shelf

Pingo library, Immutable Mappings

pipe (ǀ) operator, Merging Mappings with |, Using OR-patterns

pipe equals (ǀ operator, Merging Mappings with |

plain-text, How to Discover the Encoding of a Byte Sequence, Further Reading

.pop method, Deques and Other Queues

positional class patterns, Positional Class Patterns

positional parameters, From Positional to Keyword-Only Parameters-Positional-Only Parameters

positional patterns, Supporting Positional Pattern Matching

process pools code for multicore prime checker, Code for the Multicore Prime Checker-Code for the Multicore Prime Checker

example problem, A Homegrown Process Pool

process-based solution, Process-Based Solution

thread-based nonsolution, Thread-Based Nonsolution

understanding elapsed times, Understanding the Elapsed Times

varying process numbers, Experimenting with More or Fewer Processes

processes definition of term, A Bit of Jargon

launching with concurrent.futures, Launching Processes with concurrent.futures-Multicore Prime Checker Redux

progress displays, Downloads with Progress Display and Error Handling-Using futures.as_completed

Project Jupyter, Data Science

proper tail calls (PTC), Further Reading-Further Reading

properties (see computed properties; dynamic attributes and properties)

property class, A Proper Look at Properties-Property Documentation

protocol classes, Protocols and Duck Typing

Protocol type, Static Protocols-Static Protocols

protocols (see also interfaces)defensive programming, Defensive Programming and “Fail Fast” - Defensive Programming and “Fail Fast”

duck typing and, Protocols and Duck Typing

further reading on, Further Reading

implementing at runtime, Monkey Patching]]: Implementing a Protocol at Runtime-Monkey Patching]]: Implementing a Protocol at Runtime

implementing generic static protocols, Implementing a Generic Static Protocol-Implementing a Generic Static Protocol

as informal interfaces, Further Reading

meanings of protocol, Two Kinds of Protocols

numeric, The numbers ABCs and Numeric Protocols-The numbers ABCs and Numeric Protocols

overview of, Chapter Summary

sequence and iterable protocols, Programming Ducks-Python Digs Sequences

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

static protocols, Protocols and Duck Typing, Static Protocols-The numbers ABCs and Numeric Protocols

topics covered, The Typing Map

PSF (see Python Software Foundation)

PUG (see Python Users Group)

PyICU, Sorting with the Unicode Collation Algorithm

PyLadies, Afterword

py test package, Hands-On Approach

Pythonappreciating language-specific features, Preface

approach to learning, Five Books in One-Hands-On Approach

community support for, Afterword

fluentpython.com, Companion Website: fluentpython.com

functional programming with, Further Reading

functioning with multicore processors, Python in the Multicore World-Distributed Task Queues

further reading on, Further Reading

prerequisites to learning, Who This Book Is For

target audience, Who This Book Is Not For

versions featured, Who This Book Is For

Python Data Model further reading on, Further Reading

__getitem__ and __len__, A Pythonic Card Deck-A Pythonic Card Deck

making len work with custom objects, Why len Is Not a Method

overview of, The Python Data Model, Chapter Summary

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

special methods overview, Overview of Special Methods-Overview of Special Methods

using special methods, How Special Methods Are Used-Collection API

Python Software Foundation (PSF), Afterword

Python type checkers, Gradual Typing in Practice

Python Users Group (PUG), Afterword

python-tulip list, Afterword

Pythonic Card Deck example, A Pythonic Card Deck-A Pythonic Card Deck

Pythonic objects (see also objects)alternative constructor for, An Alternative Constructor

building user-defined classes, A Pythonic Object

classmethod versus static method, classmethod Versus static method

formatted displays, Formatted Displays-Formatted Displays

further reading on, Further Reading

hashable Vector2d, A Hashable Vector2d-A Hashable Vector2d

object representations, Object Representations

overriding class attributes, Overriding Class Attributes-Overriding Class Attributes

overview of, Chapter Summary

private and protected attributes, Private and “Protected” Attributes in Python-Private and “Protected” Attributes in Python

saving memory with __slots__, Saving Memory with __slots__-Summarizing the Issues with __slots__

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

supporting positional patterns, Supporting Positional Pattern Matching

topics covered, A Pythonic Object

Vector2d class example, Vector Class Redux-Vector Class Redux

Vector2d full listing, Complete Listing of Vector2d, Version 3-Complete Listing of Vector2d, Version 3

Pythonic sums, Further Reading-Further Reading

pyuca library, Sorting Unicode Text, Chapter Summary

Q

quantity properties, Coding a Property Factory-Coding a Property Factory

questions and comments, How to Contact Us

queuesdefinition of term, A Bit of Jargon

deque (double-ended queue), When a List Is Not the Answer, Deques and Other Queues

distributed task queues, Distributed Task Queues

implementing, Deques and Other Queues

==R==

race conditions, Code for the Multicore Prime Checker

random.choice function, A Pythonic Card Deck

recycling (see garbage collection)

reduce function, Higher-Order Functions-Modern Replacements for map, filter, and reduce

reducing functions, Vector Take #4: Hashing and a Faster ==, Iterable Reducing Functions-Iterable Reducing Functions

refactoring strategieschoosing the best, Choosing the Best Strategy: Simple Approach

classic, Classic Strategy-Classic Strategy

Command pattern, The Command Pattern-The Command Pattern

decorator-enhanced pattern, Decorator-Enhanced Strategy Pattern-Decorator-Enhanced Strategy Pattern

finding strategies in modules, Finding Strategies in a Module-Finding Strategies in a Module

function-oriented, Function-Oriented Strategy-Function-Oriented Strategy

reference counting, del and Garbage Collection

registration decorators, Registration Decorators, A Parameterized Registration Decorator-A Parameterized Registration Decorator

regular expressions, str versus bytes in, str Versus bytes in Regular Expressions

repr() function, Object Representations

reserved keywords, (quote …)

rich comparison operators, Rich Comparison Operators-Rich Comparison Operators

running averages, computing, Example: Coroutine to Compute a Running Average-Example: Coroutine to Compute a Running Average

S

S-expression, Scheme Syntax

salts, What Is Hashable

Scheme language, Pattern Matching Sequences in an Interpreter-Shortcut syntax for function definition, Scheme Syntax-Scheme Syntax

SciPy, NumPy-NumPy

scope dynamic scope versus lexical scope, Further Reading-Further Reading

function local scope, Variable Scope Rules

module global scope, Variable Scope Rules

variable scope rules, Variable Scope Rules-Variable Scope Rules

within comprehensions and generator expressions, List Comprehensions and Readability

semaphores, Throttling Requests with a Semaphore-Throttling Requests with a Semaphore

Sentence classes, Sentence Classes with __iter__-How a Generator Works

sentinels, Code for the Multicore Prime Checker

sequence protocol, Programming Ducks-Python Digs Sequences, A Sequence of Words-A Sequence of Words

sequencesalternatives to lists, When a List Is Not the Answer-Deques and Other Queues

further reading on, Further Reading

list comprehensions and generator expressions, List Comprehensions and Generator Expressions-Tuples Are Not Just Immutable Lists

list.sort versus sorted built-in, list.sort Versus the sorted Built-In-list.sort Versus the sorted Built-In

overview of, Chapter Summary

overview of built-in, Overview of Built-In Sequences-Overview of Built-In Sequences

pattern matching with, Pattern Matching with Sequences-Shortcut syntax for function definition

significant changes to, What’s New in This Chapter

slicing, Slicing-Assigning to Slices

Soapbox discussion, Further Reading-Further Reading

topics covered, An Array of Sequences

tuples, Tuples Are Not Just Immutable Lists-Comparing Tuple and List Methods

uniform handling of, An Array of Sequences

unpacking sequences and iterables, Unpacking Sequences and Iterables-Nested Unpacking

using + and * with, Using + and * with Sequences-A += Assignment Puzzler

sequences, special methods forapplications beyond three dimensions, Vector: A User-Defined Sequence Type

dynamic attribute access, Vector Take #3: Dynamic Attribute Access-Vector Take #3: Dynamic Attribute Access

__format__, Vector Take #5: Formatting-Vector Take #5: Formatting

further reading on, Further Reading

__hash__ and __eq__, Vector Take #4: Hashing and a Faster ==-Vector Take #4: Hashing and a Faster ==

overview of, Chapter Summary

protocols and duck typing, Protocols and Duck Typing

significant changes to, What’s New in This Chapter

sliceable sequences, Vector Take #2: A Sliceable Sequence-A Slice-Aware __getitem__

Soapbox discussion, Further Reading-Further Reading

topics covered, Special Methods for Sequences

Vector implementation strategy, Vector: A User-Defined Sequence Type

Vector2d compatibility, Vector Take #1: Vector2d Compatible-Vector Take #1: Vector2d Compatible

sequential.py program, A Homegrown Process Pool

server-side web/mobile development, Server-Side Web/Mobile Development

serversAsynchronous Server Gateway Interface (ASGI), WSGI Application Servers

HTTPServer class, ThreadingMixIn and ForkingMixIn

TCP servers, An asyncio TCP Server-An asyncio TCP Server

test servers, Downloads with Progress Display and Error Handling

ThreadingHTTPServer class, ThreadingMixIn and ForkingMixIn

Web Server Gateway Interface (WSGI), WSGI Application Servers

writing asyncio servers, Writing asyncio Servers-An asyncio TCP Server

setattr function, Special Methods for Attribute Handling

sets (see also dictionaries and sets)consequences of how set works, Practical Consequences of How Sets Work

set comprehensions, Set Comprehensions

set literals, Set Literals

set operations, Set Operations-Set Operations

set operations on dict views, Set Operations on dict Views

set theory, Set Theory-Set Theory

shallow copies, Copies Are Shallow by Default-Copies Are Shallow by Default

shelve module, shelve.Shelf

simple class patterns, Simple Class Patterns

single dispatch generic functions, Single Dispatch Generic Functions-Function single[[dispatch

Sized interface, Collection API

slicing assigning to slices, Assigning to Slices

excluding last item in, Why Slices and Ranges Exclude the Last Item

multidimensional slicing and ellipses, Multidimensional Slicing and Ellipsis

slice objects, Slice Objects

sliceable sequences, Vector Take #2: A Sliceable Sequence-A Slice-Aware __getitem__

Soapbox sidebars@dataclass, Further Reading

anonymous functions, Further Reading

__call__, Further Reading

code points, Further Reading

data model versus object model, Further Reading

design patterns, Further Reading

duck typing, Further Reading, Further Reading

dynamic scope versus lexical scope, Further Reading-Further Reading

equality (= operator, Further Reading

explicit self argument, Further Reading

flat versus container sequences, Further Reading

__format__, Further Reading

function-class duality, Further Reading

functional programming with Python, Further Reading

generic collections, Further Reading

inheritance across languages, Further Reading

interfaces, Further Reading

key argument, Further Reading

lis.py and evaluate function, Further Reading

magic methods, Further Reading

metaobjects, Further Reading

minimalistic iterator interface, Further Reading

mixed-bag lists, Further Reading

monkey-patching, Further Reading

multilevel class hierarchies, Further Reading

mutability, Further Reading

non-ASCII names in source code, Further Reading

object destruction and garbage collection, Further Reading

operator overloading, Further Reading

Oracle, Google, and the Timbot, Further Reading

plain-text, Further Reading

pluggable generators, Further Reading-Further Reading

programming language design, Further Reading

proper tail calls (PTC), Further Reading-Further Reading

properties and up-front costs, Further Reading

protocols as informal interfaces, Further Reading

Python decorators and decorator design pattern, Further Reading

Pythonic sums, Further Reading-Further Reading

safety versus security in private attributes, Further Reading

static typing, Further Reading

syntactic sugar, Further Reading

thread avoidance, Further Reading

threads-and-locks versus actor-style programming, Concurrency and Scalability Beyond Python-Concurrency and Scalability Beyond Python

trade-offs of built-ins, Further Reading

tuples, Further Reading

Twisted library, Further Reading

type hints (type annotations), Further Reading-Further Reading

typing map, Further Reading

undocumented classes, Further Reading

Uniform Access Principle, Further Reading-Further Reading

uvloop, Further Reading

variance notation in other classes, Further Reading

with statements, Further Reading

sorted function, list.sort Versus the sorted Built-In-list.sort Versus the sorted Built-In

special methods (see also sequences, special methods for)advantages of using, A Pythonic Card Deck

Boolean values of custom types, Boolean Value of a Custom Type

calling, How Special Methods Are Used

Collection API, Collection API-Collection API

emulating numeric types, Emulating Numeric Types-Emulating Numeric Types

__getitem__ and __len__, A Pythonic Card Deck-A Pythonic Card Deck

naming conventions, The Python Data Model

purpose of, The Python Data Model

special method names (operators excluded), Overview of Special Methods

special method names and symbols for operators, Overview of Special Methods

string representation, String Representation

spinners (loading indicators) (see also network I/O)comparing supervisor functions, Supervisors Side-by-Side

created using coroutines, Spinner with Coroutines-Experiment: Break the spinner for an insight

created with multiprocessing package, Spinner with Processes

created with threading, Spinner with Threads-Spinner with Threads

Global Interpreter Lock impact, The Real Impact of the GIL-3. Answer for asyncio

keeping alive, 3. Answer for asyncio

square brackets ([]), A Pythonic Card Deck, List Comprehensions and Readability, Unpacking Sequences and Iterables, Multidimensional Slicing and Ellipsis

stacked decorators, Memoization with functools.cache

star (*) operator, Emulating Numeric Types, Using * to Grab Excess Items-Unpacking with * in Function Calls and Sequence Literals, Using + and * with Sequences-A += Assignment Puzzler, From Positional to Keyword-Only Parameters, Overloading * for Scalar Multiplication-Overloading * for Scalar Multiplication

star equals (* operator, Augmented Assignment Operators-Augmented Assignment Operators

static duck typing, Static Protocols, Interfaces, Protocols, and ABCs, Chapter Summary

static protocolsbest practices for protocol design, Best Practices for Protocol Design

definition of, Two Kinds of Protocols

designing, Designing a Static Protocol-Designing a Static Protocol

versus dynamic protocols, Protocols and Duck Typing

extending, Extending a Protocol

implementing generic static protocols, Implementing a Generic Static Protocol-Implementing a Generic Static Protocol

limitations of runtime protocol checks, Limitations of Runtime Protocol Checks

numbers ABCS and numeric protocols, The numbers ABCs and Numeric Protocols-The numbers ABCs and Numeric Protocols

runtime checkable, Runtime Checkable Static Protocols-Runtime Checkable Static Protocols

Soapbox discussion, Further Reading

supporting, Supporting a Static Protocol-Supporting a Static Protocol

type hints (type annotations), Static Protocols-Static Protocols

typed double function, The Typed double Function-The Typed double Function

static typing, Interfaces, Protocols, and ABCs

static method decorator, classmethod Versus static method

storage attributes, Terms to understand descriptors

str() function, String Representation, Object Representations

str.format() method, What’s New in This Chapter, Formatted Displays

Strategy pattern, Classic Strategy-Classic Strategy

stringsdefault sorting of, list.sort Versus the sorted Built-In

dual-mode str and bytes APIs, Dual-Mode str and bytes APIs-str Versus bytes in os Functions

normalizing Unicode for reliable comparisons, Normalizing Unicode for Reliable Comparisons-Extreme “Normalization”: Taking Out Diacritics

representation using special methods, String Representation

strong testing, Imperfect Typing and Strong Testing

struct module, What’s New in This Chapter

structural typing, Structural Typing with ABCs-Structural Typing with ABCs

structured concurrency, async Beyond asyncio: Curio

subclassing (see inheritance and subclassing)

subgenerators, Subgenerators with yield from

subtype-of relationships, Subtype-of versus consistent-with

super() function, Vector Take #3: Dynamic Attribute Access, The super() Function-The super() Function

syntactic sugar, Further Reading

Syntax Error, Syntax Error When Loading Modules with Unexpected Encoding

system administration, System Administration

T

tail call optimization (TCO), Further Reading-Further Reading

TCP servers, An asyncio TCP Server-An asyncio TCP Server

Tensor Flow, Data Science

test servers, Downloads with Progress Display and Error Handling

text files, handling, Handling Text Files-Beware of Encoding Defaults (see also Unicode text versus bytes)

ThreadingHTTPServer class, ThreadingMixIn and ForkingMixIn

ThreadingMixIn class, ThreadingMixIn and ForkingMixIn

threadsdefinition of term, A Bit of Jargon

enhancing asyncio downloader, Using asyncio.as_completed and a Thread-Making Multiple Requests for Each Download

further reading on, Concurrency with Threads and Processes

Global Interpreter Lock impact, 2. Answer for threading

spinners (loading indicators) using, Spinner with Threads-Spinner with Threads

thread avoidance, Further Reading

thread-based process pools, Thread-Based Nonsolution

throttling, Throttling Requests with a Semaphore-Throttling Requests with a Semaphore

Timsort algorithm, Further Reading

Tkinter GUI toolkit benefits and drawbacks of, Tkinter: The Good, the Bad, and the Ugly

multiple inheritance in, Multiple Inheritance in Tkinter-Multiple Inheritance in Tkinter

tree structures, traversing, Traversing a Tree-Traversing a Tree

tuplesclassic named tuples, Classic Named Tuples-Classic Named Tuples

immutability and, Tricks Python Plays with Immutables

as immutable lists, Tuples as Immutable Lists-Tuples as Immutable Lists

versus lists, Comparing Tuple and List Methods

nature of, Further Reading

as records, Tuples as Records-Tuples as Records

relative immutability of, The Relative Immutability of Tuples

simplified memory diagram for, Overview of Built-In Sequences

tuple unpacking, Tuples as Records

type hints (type annotations), Tuple Types-Tuples as immutable sequences

typing.NamedTuple, Typed Named Tuples

Twisted library, Further Reading

type casting, Type Casting-Type Casting

type hints (type annotations)annotating positional only and variadic parameters, Annotating Positional Only and Variadic Parameters

for asynchronous objects, Type Hinting Asynchronous Objects

basics of, Type Hints 101-Inspecting a class decorated with dataclass

benefits and drawbacks of, Type Hints in Functions

flawed typing and strong testing, Imperfect Typing and Strong Testing

further reading on, Further Reading

generic type hints for coroutines, Generic Type Hints for Classic Coroutines

gradual typing, About Gradual Typing-Using None as a Default (see also gradual type system)

overview of, Chapter Summary

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

supported operations and, Types Are Defined by Supported Operations-Types Are Defined by Supported Operations

topics covered, Type Hints in Functions

types usable in, Types Usable in Annotations-NoReturn

typed double function, The Typed double Function-The Typed double Function

Typed Dict, Data Class Builders, Typed Dict-Typed Dict

Typeshed project, Iterable

Type Var, Parameterized Generics and Type Var-The AnyStr predefined type variable

typing map, The Typing Map, Further Reading (see also type hints (type annotations))

typing module, Types Usable in Annotations

typing.NamedTuple, Typed Named Tuples

U

UCA (see Unicode Collation Algorithm)

UCS-2 encoding, Basic Encoders/Decoders

UML class diagramsABCs in collections.abc, ABCs in the Standard Library

annotated with MGN, Terms to understand descriptors, A Metaclass Solution for Checked

Command design pattern, The Command Pattern

django.views.generic.base module, Django Generic Views Mixins

django.views.generic.list module, Django Generic Views Mixins

fundamental collection types, Collection API

managed and descriptor classes, LineItem Take #3: A Simple Descriptor

MutableSequence ABC and superclasses, Subclassing an ABC

Sequence ABC and abstract classes, Python Digs Sequences

simplified for collections.abc, Overview of Built-In Sequences

simplified for MutableMapping and superclasses, Standard API of Mapping Types

simplified for MutableSet and superclasses, Set Operations

Strategy design pattern, Classic Strategy

Tkinter Text widget class and superclasses, Multiple Inheritance and Method Resolution Order

TomboList, A Virtual Subclass of an ABC

unary operators, Unary Operators-Unary Operators

undocumented classes, Further Reading

Unicode Collation Algorithm (UCA), Sorting with the Unicode Collation Algorithm

Unicode literals escape notation (\N{}), Beware of Encoding Defaults

Unicode sandwich, Handling Text Files

Unicode text versus bytes basic encoders/decoders, Basic Encoders/Decoders-Basic Encoders/Decoders

byte essentials, Byte Essentials-Byte Essentials

characters and Unicode standard, Character Issues-Character Issues

dual-mode str and bytes APIs, Dual-Mode str and bytes APIs-str Versus bytes in os Functions

further reading on, Further Reading

handling text files, Handling Text Files-Beware of Encoding Defaults

normalizing Unicode for reliable comparisons, Normalizing Unicode for Reliable Comparisons-Extreme “Normalization”: Taking Out Diacritics

overview of, Chapter Summary

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading

sorting Unicode text, Sorting Unicode Text-Sorting with the Unicode Collation Algorithm

topics covered, Unicode Text Versus Bytes

understanding encode/decode problems, Understanding Encode/Decode Problems-BOM: A Useful Gremlin

Unicode database, The Unicode Database-Numeric Meaning of Characters

UnicodeDecodeError, Coping with UnicodeDecodeError

UnicodeEncodeError, Coping with UnicodeEncodeError

Uniform Access Principle, Further Reading-Further Reading

Union type, Optional and Union Types

unittest module, Hands-On Approach

unpacking iterables]] and mappings, From Positional to Keyword-Only Parameters

mapping unpackings, Unpacking Mappings

nested, Nested Unpacking

sequences and iterables, Unpacking Sequences and Iterables

using * to grab excess items, Using * to Grab Excess Items

with * in function calls and sequence literals, Unpacking with * in Function Calls and Sequence Literals

user-defined functions, The Nine Flavors of Callable Objects

UserDict, Subclassing UserDict Instead of dict-Subclassing UserDict Instead of dict

UTF-8 decoding, How to Discover the Encoding of a Byte Sequence

UTF-8-SIG encoding, BOM: A Useful Gremlin

uvloop, Further Reading

V

variable annotations meaning of, The Meaning of Variable Annotations-Inspecting a class decorated with dataclass

syntax of, Variable Annotation Syntax

variable scope rules, Variable Scope Rules-Variable Scope Rules

variablesfree, Closures

init-only variables, Initialization Variables That Are Not Fields

as labels versus boxes, Variables Are Not Boxes-Variables Are Not Boxes

lookup logic, Variable Lookup Logic

variadic parameters, Annotating Positional Only and Variadic Parameters

variance contravariant types, A Contravariant Trash Can

covariant types, A Covariant Dispenser

in callable types, Variance in Callable types

invariant types, An Invariant Dispenser

overview of, Variance Review

relevance of, Variance

rules of thumb, Variance rules of thumb

variance notation in other classes, Further Reading

vars(object) function, Built-In Functions for Attribute Handling

Vector class, multidimensional applications beyond three dimensions, Vector: A User-Defined Sequence Type

dynamic attribute access, Vector Take #3: Dynamic Attribute Access-Vector Take #3: Dynamic Attribute Access

__format__ (dunder format), Vector Take #5: Formatting-Vector Take #5: Formatting

further reading on, Further Reading

__hash__ (dunder hash) and __eq__ (dunder eq), Vector Take #4: Hashing and a Faster ==-Vector Take #4: Hashing and a Faster ==

implementation strategy, Vector: A User-Defined Sequence Type

overview of, Chapter Summary

protocols and duck typing, Protocols and Duck Typing

sliceable sequences, Vector Take #2: A Sliceable Sequence-A Slice-Aware __getitem__

topics covered, Special Methods for Sequences

Vector2d compatibility, Vector Take #1: Vector2d Compatible-Vector Take #1: Vector2d Compatible

Vector2d class example, Vector Class Redux-Vector Class Redux

full listing, Complete Listing of Vector2d, Version 3-Complete Listing of Vector2d, Version 3

hashable, A Hashable Vector2d

vectorsoverloading + for vector addition, Overloading + for Vector Addition-Overloading + for Vector Addition

representing two-dimensional, Emulating Numeric Types-Emulating Numeric Types

virtual attributes, Dynamic Attributes and Properties

virtual subclasses, A Virtual Subclass of an ABC-A Virtual Subclass of an ABC

==W==

Walrus operator (:, List Comprehensions and Readability

weak references, del and Garbage Collection

Web Server Gateway Interface (WSGI), WSGI Application Servers

web/mobile development, Server-Side Web/Mobile Development

with, match, and else blockscontext managers and with blocks, Context Managers and with Blocks-Using @contextmanager

else clause, Do This, Then That: else Blocks Beyond if-Do This, Then That: else Blocks Beyond if

further reading on, Further Reading

overview of, Chapter Summary

pattern matching in lis.py, Pattern Matching in lis.py: A Case Study-Using OR-patterns

purpose of with statements, Context Managers and with Blocks

significant changes to, What’s New in This Chapter

Soapbox discussion, Further Reading-Further Reading

topics covered, with, match, and else Blocks

Y

yield from expression, Subgenerators with yield from-Traversing a Tree

yield keyword, The Nine Flavors of Callable Objects, Don’t Make the Iterable an Iterator for Itself-How a Generator Works, When to Use Generator Expressions, Classic Coroutines, Example: Coroutine to Compute a Running Average, Using @contextmanager

Z

zero-based indexing, Slicing

zip() function, Vector Take #4: Hashing and a Faster ==

Python: Python Variables, Python Data Types, Python Control Structures, Python Loops, Python Functions, Python Modules, Python Packages, Python File Handling, Python Errors and Exceptions, Python Classes and Objects, Python Inheritance, Python Polymorphism, Python Encapsulation, Python Abstraction, Python Lists, Python Dictionaries, Python Tuples, Python Sets, Python String Manipulation, Python Regular Expressions, Python Comprehensions, Python Lambda Functions, Python Map, Filter, and Reduce, Python Decorators, Python Generators, Python Context Managers, Python Concurrency with Threads, Python Asynchronous Programming, Python Multiprocessing, Python Networking, Python Database Interaction, Python Debugging, Python Testing and Unit Testing, Python Virtual Environments, Python Package Management, Python Data Analysis, Python Data Visualization, Python Web Scraping, Python Web Development with Flask/Django, Python API Interaction, Python GUI Programming, Python Game Development, Python Security and Cryptography, Python Blockchain Programming, Python Machine Learning, Python Deep Learning, Python Natural Language Processing, Python Computer Vision, Python Robotics, Python Scientific Computing, Python Data Engineering, Python Cloud Computing, Python DevOps Tools, Python Performance Optimization, Python Design Patterns, Python Type Hints, Python Version Control with Git, Python Documentation, Python Internationalization and Localization, Python Accessibility, Python Configurations and Environments, Python Continuous Integration/Continuous Deployment, Python Algorithm Design, Python Problem Solving, Python Code Readability, Python Software Architecture, Python Refactoring, Python Integration with Other Languages, Python Microservices Architecture, Python Serverless Computing, Python Big Data Analysis, Python Internet of Things (IoT), Python Geospatial Analysis, Python Quantum Computing, Python Bioinformatics, Python Ethical Hacking, Python Artificial Intelligence, Python Augmented Reality and Virtual Reality, Python Blockchain Applications, Python Chatbots, Python Voice Assistants, Python Edge Computing, Python Graph Algorithms, Python Social Network Analysis, Python Time Series Analysis, Python Image Processing, Python Audio Processing, Python Video Processing, Python 3D Programming, Python Parallel Computing, Python Event-Driven Programming, Python Reactive Programming.

Variables, Data Types, Control Structures, Loops, Functions, Modules, Packages, File Handling, Errors and Exceptions, Classes and Objects, Inheritance, Polymorphism, Encapsulation, Abstraction, Lists, Dictionaries, Tuples, Sets, String Manipulation, Regular Expressions, Comprehensions, Lambda Functions, Map, Filter, and Reduce, Decorators, Generators, Context Managers, Concurrency with Threads, Asynchronous Programming, Multiprocessing, Networking, Database Interaction, Debugging, Testing and Unit Testing, Virtual Environments, Package Management, Data Analysis, Data Visualization, Web Scraping, Web Development with Flask/Django, API Interaction, GUI Programming, Game Development, Security and Cryptography, Blockchain Programming, Machine Learning, Deep Learning, Natural Language Processing, Computer Vision, Robotics, Scientific Computing, Data Engineering, Cloud Computing, DevOps Tools, Performance Optimization, Design Patterns, Type Hints, Version Control with Git, Documentation, Internationalization and Localization, Accessibility, Configurations and Environments, Continuous Integration/Continuous Deployment, Algorithm Design, Problem Solving, Code Readability, Software Architecture, Refactoring, Integration with Other Languages, Microservices Architecture, Serverless Computing, Big Data Analysis, Internet of Things (IoT), Geospatial Analysis, Quantum Computing, Bioinformatics, Ethical Hacking, Artificial Intelligence, Augmented Reality and Virtual Reality, Blockchain Applications, Chatbots, Voice Assistants, Edge Computing, Graph Algorithms, Social Network Analysis, Time Series Analysis, Image Processing, Audio Processing, Video Processing, 3D Programming, Parallel Computing, Event-Driven Programming, Reactive Programming.

Python Glossary, Python Fundamentals, Python Inventor: Python Language Designer: Guido van Rossum on 20 February 1991; PEPs, Python Scripting, Python Keywords, Python Built-In Data Types, Python Data Structures - Python Algorithms, Python Syntax, Python OOP - Python Design Patterns, Python Module Index, pymotw.com, Python Package Manager (pip-PyPI), Python Virtualization (Conda, Miniconda, Virtualenv, Pipenv, Poetry), Python Interpreter, CPython, Python REPL, Python IDEs (PyCharm, Jupyter Notebook), Python Development Tools, Python Linter, Pythonista-Python User, Python Uses, List of Python Software, Python Popularity, Python Compiler, Python Transpiler, Python DevOps - Python SRE, Python Data Science - Python DataOps, Python Machine Learning, Python Deep Learning, Functional Python, Python Concurrency - Python GIL - Python Async (Asyncio), Python Standard Library, Python Testing (Pytest), Python Libraries (Flask), Python Frameworks (Django), Python History, Python Bibliography, Manning Python Series, Python Official Glossary - Python Glossary, Python Topics, Python Courses, Python Research, Python GitHub, Written in Python, Python Awesome List, Python Versions. (navbar_python - see also navbar_python_libaries, navbar_python_standard_library, navbar_python_virtual_environments, navbar_numpy, navbar_datascience)

Fair Use Sources

Fair Use Sources:

Fair Use Source: B09WZJMMJP (FlntPy 2022)

SYI LU SENG E MU CHYWE YE. NAN. WEI LA YE. WEI LA YE. SA WA HE.

Table of Contents

Fluent Python, 2nd Edition by Luciano Ramalho Index

Symbol

A

B

C

D

E

F

G

H

I

J

K

L

M

N

O

P

Q

S

T

U

V

Y

Z

Fair Use Sources