| pipe operator, 36

+ operator, 43

--version flag, 1

% operator, 44, 50

* operator, 151–152

** operator, 153–154

@ symbol, 167

_asdict method, 226

_astuple method, 225, 227, 228–229

__call__ method, 204–205

__debug__ variable, 443–444

__delattr__ method, 252

__dict__, 306–310

__eq__ method, 226

__getattr__ method, 279–281

__getattribute__ method, 281–283

__getitem__ method, 261–263

__hash__ method, 258

__init__ method, 217–219, 235–236

__init_subclass__ method, 288–299, 306–310

__missing__ method, 124–127

@property decorator

• versus refactoring attributes, 270–274

• reuse, 274–279

• setters and getters, 266–269

_replace method, 255

__repr__ method, 223–224

__set_name__ method, 278, 302–303

__setattr__ method, 252, 283–285

accumulate function, 106–107

adjust module, 479–482

advanced string formatting, 52–55

algorithm, 493

• binary search, 502–503

• leaky-bucket, 270–273

alias, 136

all function, 98–100

animate function, 187

animation generator, 186–188

any function, 100–101

API

• exceptions, 595

• hooks, 201–203

• Python, 468, 471–472

• Python C extension, 460, 465

• stability, 590–592

append method, 182, 506

argparse module, 479–481

arguments

• function, 111–112, 135–137

• iterating over, 87–92

• keyword, 153–157, 161–162, 219–221

• keyword-only, 162–164

• None as default value, 157–160

• passing by reference, 251

• positional, 150–152

• positional-only, 164–166

asdict function, 226

assert statement, 404–408, 442–443

assertAlmostEqual method, 564–565

assertNotAlmostEqual method, 565

assignment expressions, 22–23, 24–30, 86

• exceptions, 180

• in list comprehensions, 178–181

• slices, 68–69

AST (abstract syntax tree), 205–206, 208–210

asynchronous coroutines, 319

asynchronous I/O, 368, 376

asyncio module, 329, 366–367, 368–384. See also coroutines

• event loops, 389–392

• thread/coroutine interoperability, 381–384

attributes, 306

• annotation, 299–303

• descriptor protocol, 274. See also descriptors

• establishing relationships between, 303–310

• lazy, 279–285

• modifying, 299–303

• protected, 247–250

• public, 245–250, 266–269

• updating values, 254–256

auto-formatting, black, 5–6

BaseException class, 419–424

batched function, 105–106

binary operators, 44

binary search algorithm, bisect module, 502–503

binary to Unicode conversion, 42

bisect module, 501–503

black, 5–6

blocking I/O, 324–329, 348, 348–349. See also coroutines

blocks, 399

• else, 82–84

• try, 412–414

• try/except/else, 400–402

• try/except/else/finally, 402–404

• try/finally, 399–400

Boolean logic, De Morgan’s laws, 101

break statement, 82–83, 85–86

breaking circular dependencies, 600–602

• dynamic imports, 604–605

• import, configure, run, 603–604

• reordering imports, 602

breakpoint function, 566–568

Bucket class, 270–273

buffer protocol, CPython, 487

built-in function.

• enumerate, 78–79

• filter, 174–175

• format, 52–53

• hash, 110

• help, 168

• isinstance, 206

• iter, 89–91

• map, 174, 175

• range, 77–78

• super, 238–240

• zip, 80–81

built-in modules, 217

bytearray, 489–491

bytecode, 324–325, 475–478

bytes, 41–46

C3 linearization, 238

capture patterns, 32–33

cardinality, 505–506

careful_divide function, 142

case clause, 33–34, 36–37

catch-all unpacking, 72–76, 138–139

CFFI module, 461

chain function, 102

chained exceptions, 428–436

child processes

• chaining, 322–323

• decoupling from parent, 321

• managing, 320–324

• polling, 320–321

circular dependencies, breaking, 600–602

• dynamic imports, 604–605

• import, configure, run, 603–604

• reordering imports, 602

class method polymorphism, 230–235

class/es

• BaseException, 419–424

• Bucket, 270–273

• composability, 310–317

• CountMissing, 204–205

• Decimal, 523–525

• decorators, 315–317

• defaultdict, 123–124, 202–204

• definition, 211–212

• deque, 504–509

• descriptor, 269, 275–279, 299–303, 306, 307

• docstrings, 584–585

• Exception, 416–424

• helper, 204

• hierarchy, 130

• inheritance, 286–287

• JsonMixin, 243–244

• lightweight, 140–141

• Lock, 332–333

• mix-in, 240–245

• OrderedDict, 112

• parent, 235–236, 237–240

• Point, 256–258

• public attributes, 245–250

• Queue, 337–344, 353–360

• refactoring, 131–133

• registration, 293–299

• serializing to and from JSON, 244

• storing values in attributes, 131–133

• ThreadPoolExecutor, 361–363, 394–397

• user-defined, 137

• versioning, 530–531

clause.

• case, 33–34, 36–37

• finally, 436–442

• if, 20, 36, 174

closures, 145–149, 203, 383

code. See also statements

• concurrent, 319

• expressions, 4–5

• formatting, 4

• microbenchmarks, 453–458

• modules, 5

• module-scoped, 593–595

• organization, 212

• polymorphism, 207–210

• port to coroutines and asynchronous I/O, 368–381

• Pythonic, 1

• refactoring, 131–133, 387

• testing, 533

• whitespace, 3–4

code points, 42

coin-flipping loop, 98–101

cold start, 475

collections.abc module, 91, 114

• defaultdict class, 123–124

• inheriting classes for custom container types, 260–264

combinations function, 108

combinations_with_replacement function, 108

command-line tool, timeit, 457–458

commands, interactive debugger, 567

comma/s. See also syntax

• implicit string concatenation, 64

• single-element tuple, 17–18

communicate method, 321

community-built modules, 575–576

comparing objects, 227–230

compile time, error detection, 6–8

composability, 310–317

comprehensions, 173

• assignment expressions, 178–181

• dictionary, 174, 179

• generator expressions, 184–186

• list, 79–80, 86, 98, 173–174

• with more than two subexpressions, 176–177

concatenation, string, 62–66

concurrency, 319

• coordinating work between threads, 333–344

• coroutines, 364–368

• fan-in, 348

• fan-out, 348, 349–353

• when to use, 344–349

concurrent.futures module, 361, 393–397

conditional expressions, 10, 19–23

containers, 261–263

• iterating over, 95–98

• iterator protocol, 89–92

• staging modifications, 96–97

contains function, 37

context managers, 409–412

contextlib module, 409–412

converting

• objects to tuples, 224–225

• Unicode to binary, 42

Conway’s Game of Life, 344–348, 364

coordinating work between threads, 333–344

copy method, 136

copyreg module, 528, 532

coroutines, 364–368

• interoperability with threads, 381–384

• moving code to, 368–381

• versus threads, 364

count variable, 24–26

CountMissing class, 204–205

CPU. See also concurrency; parallelism; performance; threads

• parallelism, 319

• pipeline, 333–337

• threads, 319

CPython, 324–325

• buffer protocol, 487

• compiling Python without GIL, 327

• extension modules, 467–474

• GIL (global interpreter lock), 324–327, 329, 330

• performance, 475

creating, objects, 217–218, 219–223, 250–251, 254–256

C-style formatting, 47–52

csv module, 303–306

ctypes module, 460, 462–467

Currying, 171–172

cycle function, 103

Cython, 461

data, semi-structured vs. encapsulated, 37–39

data races, preventing, 330–333

dataclasses module, 131, 217. See also object/s

• decorator, 218, 223

• keyword arguments, 219–221

• type checker, 218–219

datetime module, 521–523

De Morgan’s laws, 101

debugging. See also exceptions/exception handling

• interactive, 565–570

• memory usage, 570–573

• postmortem, 568–570

• print function, 58–62

• traceback, 424–436

Decimal class, 523–525

decorator/s, 166–169, 309, 309–310

• @property, 266–269, 270–279

• class, 315–317

• contextmanager, 409–410

• dataclasses module, 218

• function, 166–169, 309, 310–312

• singledispatch, 212–216

• trace_func, 312–313

decoupling, child process from parent, 321

defaultdict class, 123–124, 202–204

dependency/ies, 212, 481. See also breaking circular dependencies

• circular, breaking, 600–605

• encapsulating, 559–562

• hell, 577

• injection, 604

• reproducing, 580–582

deployment environment, 593–595

deque class, 504–509

descriptors, 269, 275–279, 299–303, 306, 307

deserialize function, 296–297

destructuring, 34–37

deterministic behavior, 203

development environment, 593

diamond inheritance, 237–240

dictionary/ies, 109, 306

• __dict__, 306–310

• comprehensions, 174, 179

• converting objects to, 225–226

• format strings, 50–52

• handling missing keys, 117–121, 122–127

• immutable objects, 256–260

• iterating over, 92–93, 109–116

• KeyError exception, 117–118

• key/value pairs, 12

• nested, 127–130

• whitespace, 4

docstrings, 158–160, 582–583

• class, 584–585

• function, 585–586

• module, 584

dot_product function, 463–464

double-ended queue, 507

dropwhile function, 105

duck typing, 113, 500–501, 616

dumps function, 225–226

dynamic attributes, 265

dynamic imports, 604–605

dynamic inspection, 240–241

else blocks, 82–84, 400–402

empty sequence, looping over, 83

empty tuple, 16

encapsulated data, 37–39

encapsulating dependencies, 559–562

encoding, open, 46

enhance module, 479–482

enumerate function, 78–79. See also iteration

equivalence checking, object, 226–227

error/s. See also exceptions/exception handling

• checking, 6–8

• implicit concatenation, 63–64

escaping, 63

eval function, 445–446

evaluate function, 206–208

event loop, 364–365

event loops, 389–392

exceptions/exception handling, 268, 399

• assert statement, 404–408

• in assignment expressions, 180

• BaseException class, 419–424

• chained, 428–436

• Exception class, 416–424

• generator, 195–199

• GeneratorExit, 420, 438–442

• IndexError, 336

• KeyboardInterrupt, 419

• KeyError, 117–118, 433

• MissingError, 429–436

• NameError, 147

• OSError, 353

• raise statement, 405–408

• raising, 142–145

• Reset, 197

• root, 595–600

• ServerMissingKeyError, 433

• StopIteration, 88, 198, 438

• SyntaxError, 533

• traceback, 424–428

• try blocks, 412–414

• try/except/else blocks, 400–402

• try/except/else/finally blocks, 402–404

• try/finally blocks, 399–400

• ValueError, 401

• variables, 414–416

exec function, 445–446

explicit string concatenation, 66

expression/s, 4–5

• assignment, 22–23, 24–30, 68–69, 86, 178–181

• conditional, 10, 19–23

• C-style formatting, 47–52

• generator, 181, 184–186

• lambda, 172

• starred, 73–76, 140

• yield, 187–188, 409–410

extending tuples, 131

extension modules, 467–474, 625

fail function, 19–20

fan-in, 348

fan-out, 348, 349–353

FIFO (first in, first out) queue, 504–509. See also producer–consumer queue; queue

file system cache, 477

files

• read mode, 46

• write mode, 45

filter function, 174–175

filtering items from an iterator

• dropwhile function, 105

• filterfalse function, 105

• islice function, 104

• takewhile function, 104–105

finally blocks, 399–400

finally clause, 436–442

first-class function, 202

floating point tests, 563–565

for loops, 14–15, 173–174

• avoiding else blocks, 82–84

• iterator protocol, 89–92

• variables, 85–86

for statement, 79, 80

format

• code, 4

• specifiers, 47–48, 53

format built-in function, 52–53

formatting, 47

• advanced string, 52–55

• C-style, 47–52

• f-string, 56–58

functional-style programming, 250–251

• dynamic inspection, 240–241

• mix-in classes, 240–245

• single dispatch, 212–216

function/s, 175, 238–240, 315–317

• accumulate, 106–107

• all, 98–100

• animate, 187

• any, 100–101

• arguments, 111–112, 135–137, 153–160,161–166

• asdict, 226

• async, 364–365

• batched, 105–106

• bisect_left, 502–503

• breakpoint, 566–568

• careful_divide, 142

• chain, 102

• closure, 145–149, 203, 383

• combinations, 108

• combinations_with_replacement, 108

• contains, 37

• coroutines, 364–368

• cycle, 103

• decorator, 166–169, 309, 310–312

• deserialize, 296–297

• docstrings, 585–586

• dot_product, 463–464

• dropwhile, 105

• dumps, 225–226

• enumerate, 78–79

• eval, 445–446

• evaluate, 206–208

• exec, 445–446

• fail, 19–20

• filter, 174–175

• filterfalse, 105

• finally clause, 436–437

• first-class, 202

• format, 52–53

• generator, 87, 173, 182–184. See also generator/s

• get_cause, 435

• get_stats, 139–140

• hash, 110

• help, 168

• helper, 8–11, 21, 42–43, 84, 126, 145–146, 168–169, 232, 251

• hooks, 201–203

• index_words, 182, 183–184

• isinstance, 206

• islice, 104

• iter, 89–91

• kernel, 460

• key, 494–499

• lambda, 170–171

• log_missing, 202

• lookup, 431–436

• map, 174

• mapreduce, 233–235

• my_print, 213

• namedtuple, 259

• None return value, 142

• normalization, 87, 89

• normalize_defensive, 91–92

• pairwise, 106

• partial, 171–172

• patch, 555–558

• permutations, 107

• positional arguments, 150–152

• print, 58–62

• product, 107

• raising exceptions, 142–145

• range, 77–78

• repeat, 103

• returning more than one value, 138–141

• run_report, 416–418

• setUpModule, 548–549

• sorted, 499–501

• with statement, 408–412

• takewhile, 104–105

• tearDownModule, 548–549

• tee, 103

• utility, 451

• wrapper, 168

• zip, 80–81

• zip_longest, 81, 103–104

functools module, 170, 171–172

gc module, 571–572

GeneratorExit exception, 420, 438–442

generator/s, 87, 173, 182–184, 189–191

• animation, 186–188

• assignment expressions, 181

• compose with yield from expression, 186–188

• expressions, 184–186

• lazy, 80–81

• passing iterators as arguments, 188–195

• throw method, 195–199

• wave, 189–195

get method, 9–11, 118–120

get_cause function, 435

get_stats function, 139–140

getter methods, 266–269

GIL (global interpreter lock), 324–327, 329, 330

glider, 345–346

global scope, 147

guard expression, 36

hash function, 110

heap, 514

heapq module, 514–519

help function, 168

helper class, 204

helper function, 8–11, 21, 42–43, 84, 126, 145–146, 168–169, 232, 251

helper method, 123

• open_picture, 126–127

• TestCase class, 535–541

hooks, 201–203

• __getattr__, 279–281

• __getattribute__, 281–283

• __setattr__, 283–285

if clause, 36, 174

if statements, 19

immutable objects

• creating, 250–251

• using in dictionaries and sets, 256–260

implicit string concatenation, 62–66

imports, 5, 592, 601, 604–605

in operator, 117, 119

index_words function, 182, 183–184

IndexError exception, 336

indexing, 72–73. See also slicing

• negative, 68

• parallel, 79–80

• with slicing, 67–69

• strings, 10–11

inheritance

• class, 286–287

• diamond, 237–240

• multiple, 236, 239, 240

inheriting classes for custom container types, 260–264

initializing parent classes, 235–236

inline negation, 5

insert_value, profiling, 448–451

insertion ordering, dictionary, 109–116

insertion_sort, profiling, 448–451

integration tests, 541–542

interactive debugging, 565–568

interpolated format strings, 56–58

I/O

• asynchronous, 368, 376

• blocking, 324–329, 348

• threaded, porting to asyncio, 368–381

isinstance function, 206

islice function, 104

islice method, 72

iter built-in function, 89–91

iteration/iterators, 77, 182–183. See also loop/s

• exception, 88

• generator, 87

• lists, 79–80, 87

• over arguments, 87–92

• over containers, 95–98

• over dictionaries, 92–93, 109–116

• over lists, 94–95

• over sets, 93, 96

• passing into generators as arguments, 188–195

• passing to all built-in function, 98–100

• passing to any built-in function, 100–101

• StopIteration exception, 88

• zip generator, 80–81

iterator protocol, 89–92

itertools, 72, 185–186

• accumulate function, 106–107

• batched function, 105–106

• chain function, 102

• combinations function, 108

• combinations_with_replacement function, 108

• cycle function, 103

• dropwhile function, 105

• filterfalse function, 105

• islice function, 104

• pairwise function, 106

• permutations function, 107

• product function, 107

• repeat function, 103

• takewhile function, 104–105

• tee function, 103

• zip_longest function, 81, 103–104

JSON, 37–38, 244, 293–297

JsonMixin class, 243–244

kernel functions, 460

key function, 494–499

KeyboardInterrupt exception, 419

KeyError exception, 117–118, 433

keyword

• arguments, 153–157, 161–162, 219–221

• -only arguments, 162–164

• strict, 81

lambda function, 170–171, 495

lazy attributes, 279–285

lazy generator, 80–81

lazy loading, 478–485

leaky-bucket algorithm, 270–273

lightweight class, 140–141

linking iterators together

• chain function, 102

• cycle function, 103

• repeat function, 103

• tee function, 103

• zip_longest function, 103–104

list/s, 260–261. See also indexing

• cardinality, 505–506

• comprehensions, 79–80, 86, 98, 173–177, 178–181, 184–186

• dequeuing items, 504–509

• dictionary value, 119–121

• iterating over, 94–95

• iteration, 78, 87

• nested, 127–130

• priority queue, 509–514

• sorting items in, 145, 493–499

literal values, 16

Lock class, 332–333

log_missing function, 202

lookup function, 431–436

loop/s, 77

• break statement, 82–83, 85–86

• coin-flipping, 98–101

• in comprehensions, 176–177

• else block, avoiding, 82–84

• event, 364–365, 389–392

• for, 14–15, 85–86, 173–174

• -and-a-half idiom, 29–30

• iterator protocol, 89–92

• range function, 77–78

• while, 29, 382–383

managing, child processes, 320–324

map function, 174, 175

mapreduce function, 233–235

match statement, 30–34, 370

• destructuring, 34–37

• semi-structured vs. encapsulated data, 37–39

memory

• bytecode caching, 475–478

• file system cache, 477

• lazy loading, 478–485

• leaks, 278–279

• usage, debugging, 570–573

memoryview type, 487–491

metaclasses, 265, 285–287

• class registration, 293–299

• modifying a class’s attributes, 299–303

• subclass validation, 287–291

• TraceMeta, 313–314

method/s

• @property. See @property decorator

• _asdict, 226

• _astuple, 225, 227, 228–229

• __call__, 204–205

• __delattr__, 252

• __eq__, 226

• __getattr__, 279–281

• __getitem__, 261–263

• __hash__, 258

• __init__, 217–219, 235–236

• __init_subclass__, 288–299, 306–310

• __iter__, 89–91

• __missing__, 124–127

• _replace, 255

• __repr__, 223–224

• __set_name__, 278, 302–303

• __setattr__, 252, 283–285

• append, 182, 506

• assertAlmostEqual, 564–565

• assertNotAlmostEqual, 565

• communicate, 321

• copy, 136

• get, 9–11, 118–120

• getter, 266–269, 276

• helper, 123

• islice, 72

• open_picture, 126–127

• pretty, 209

• print_callees, 452–453

• print_callers, 452

• public attributes, 246

• quantize, 525

• read, 230–231

• register, 213

• run, 198–199

• send, 189–191

• setdefault, 120–121, 122–123, 125

• setter, 266–269, 276

• sort, 145–149, 201–202, 493–499

• str.format, 54–55

• throw, 195–199

• title, 50

• update, 96

• whitespace, 4

metrics, 447

microbenchmarks, 453–458, 490–491, 512–517

MissingError exception, 429–436

mix-in classes, 240–245

mocks, 550–558. See also test/s

module/s, 5, 109

• adjust, 479–482

• argparse, 479–481

• asyncio, 329, 366–367, 368–384

• bisect, 501–503

• built-in, 217

• bytecode caching, 475–478

• CFFI, 461

• collections.abc, 91, 114, 260–264

• community-built, 575–576

• concurrent.futures, 361, 393–397

• contextlib, 409–412

• copyreg, 528, 532

• CProfile, 449–450

• csv, 303–306

• ctypes, 460, 462–467

• dataclasses, 131, 217, 218–219

• datetime, 521–523

• decimal, 523–525

• docstrings, 584

• enhance, 479–482

• extension, 467–474, 625

• functools, 170, 171–172

• gc, 571–572

• heapq, 514–519

• lazy-loading, 478–485

• multiprocessing, 393–397

• Numba, 461

• Numby, 461

• pdb, 566–568

• pickle, 526–532

• pkgutil, 624–626

• root exception, 595–600

• -scoped code, 593–595

• subprocess, managing child processes, 320–324

• threading, 332

• time, 519–521

• timeit, 453–458

• traceback, 424–428

• tracemalloc, 572–573

• typing, 613–621

• unittest, 533–535, 548

• version, 577–578

• warnings, 605–613

• zipimport, 622–624

• zoneinfo, 522–523

MRO (method resolution order), 238

multiple inheritance, 236, 239, 240

multiple return values, unpacking, 138–141

multiple-assignment unpacking, 11–15

multiprocessing module, 393–397

multithreading, preemptive, 325, 331–333

mutex, 325, 330, 332–333, 408

my_print function, 213

mypy tool, 115–116

Mypyc, 461

namedtuple function, 259

NameError exception, 147

negative indexing, 68

None, using as default argument value, 157–160

nonlocal statement, 148–149

normalization function, 87, 89

normalize_defensive function, 91–92

Numba module, 461

Numby module, 461

object/s, 60

• AST (abstract syntax tree), 208–210

• converting to dictionaries, 225–226

• converting to tuples, 224–225

• creating, 217–218, 219–223

• creating copies with replaced attributes, 254–256

• diamond inheritance, 237–240

• dynamic internal state, 127

• enabling for comparison, 227–230

• equivalence checking, 226–227

• immutable, 250–251, 256–260

• -oriented polymorphism, 207–210

• preventing from being modified, 251–254

• representing as strings, 223–224

• serialization, 168, 528–530

• sorting, 494–495

OOP (object-oriented programming)

• class definition, 211–212

• dependencies, 212. See also dependency/ies

• polymorphism, 207–210

open encoding mode, 46

open source projects, 621–626

open_picture method, 126–127

operating system

• blocking I/O, 327, 348–349

• system calls, 327–329

operator

• %, 44, 50

• *, 151–152

• **, 153–154

• | pipe, 36

• +, 43

• binary, 44

• in, 117, 119

• ternary, 19–20

• walrus, 24–30, 179–181. See also assignment expressions

OrderedDict class, 112

OSError exception, 353

packages, 588

• namespaces, 588–590

• stable APIs, 590–592

pairwise function, 106

parallel indexing, 79–80

parallelism, 319

• concurrent.futures, 393–397

• data races, preventing, 330–333

• fan-out, 350–353

• managing child processes, 320–324

parent class

• diamond inheritance, 237–240

• initializing, 235–236

parent process, decoupling child process from, 321

parentheses

• assignment expressions, 22–23

• single-element tuple, 16–19

partial function, 171–172

patch functions, 555–558

PEP 8 (Python Enhancement Proposal #8), 3

• automation, 5–6

• expressions and statements, 4–5

• imports, 5

• naming, 4

• whitespace, 3–4

performance. See also profiling

• CPython, 475

• engineering, 447

• extension modules, 467–474

• lazy-loading modules, 478–485

• loading modules from zip archives, 622–623

• metrics, 447

• microbenchmarks, 490–491, 512–517

• producer–consumer queue, 504–509

• profiling, 448–453

• replacing Python with another programming language, 458–462

• search, 501–503

• timeit microbenchmarks, 453–458

permutations function, 107

pickle module, 526–528

• default attribute values, 528–530

• stable import paths, 531–532

• versioning classes, 530–531

pip tool, 575–577

pipeline, 333–337, 416–417

piping data into a subprocess, 321–322

pkgutil module, 624–626

Point objects, 256–258

polymorphism, 207–210, 230–235

porting code to use coroutines and asyncio, 368–384

• bottom-up approach, 387–388

• top-down approach, 384–387

positional arguments, variable, 150–152

positional-only arguments, 164–166

postmortem debugging, 568–570

preemptive multithreading, 325, 331–333

pretty method, 209

pretty print, 215

preventing objects from being modified, 251–254

print function, 58–62

print_callees method, 452–453

print_callers method, 452

priority queue, 509–519

private attributes, 246–247

producer–consumer queue, 504–509

producing combinations of items from iterators

• accumulate function, 106–107

• batched function, 105–106

• combinations function, 108

• combinations_with_replacement function, 108

• pairwise function, 106

• permutations function, 107

• product function, 107

product function, 107

profiling, 448

• insertion_sort and insert_value, 448–451

• print_callees method, 452–453

• print_callers method, 452

• utility functions, 451

programs. See also code; performance

• bytecode, 324–325

• concurrent, 319. See also concurrency

• deployment environment, 593–595

• development environment, 593

• pipeline, 333–337

• piping data into a subprocess, 321–322

• preemptive multithreading, 325

• speedup, 319

protected attributes, 247–250

public attributes, 245–250, 266–269

pylint, 6

PyPI (Python Package Index), 575

Python

• C extension API, 460, 465

• knowing the version you’re using, 1–3

• replacing with another programming language, 458–462

• support for threads, 327–329

Pythonic style, 1

quantize method, 525

query string parameter, 8–9

queue

• priority, 509–519

• producer-consumer, 504–509

Queue class, 337–344, 353–360

quota, leaky-bucket algorithm, 270–273

raise statement, 405–408

raising exceptions, 142–145. See also exceptions/exception handling

• assert statement, 404–408

• generator, 195–199

• raise statement, 405–408

• try blocks, 412–414

range function, 77–78

read binary mode, 46

read method, 230–231

refactoring, 131–133, 387

register method, 213

registration, class, 293–299

repeat function, 103

replacing Python with another programming language, 458–462

repr, difference between str and, 58–62

reproducing dependencies, 580–582

Reset exception, 197

root exceptions, 595–600

rule of least surprise, 265

run method, 198–199

run_report function, 416–418

runtime, error checking, 6–8

scope, global, 147

scoping bug, 147–148

scripts, 399

security

• eval and exec built-in functions, 446

• pickle module, 526

semi-structured data, 37–39

send method, 189–191

sequences, 261–264. See also list/s

• empty, looping over, 83

• slicing, 67–70

ServerMissingKeyError exception, 433

setdefault method, 120–121, 122–123, 125

sets

• immutable objects, 256–260

• iterating over, 93, 96

setter methods, 266–269

setUpModule function, 548–549

simulate function, 365–367

single dispatch, 212–216. See also OOP (object-oriented programming)

single-element tuple

• parentheses, 16–17

• trailing comma, 17

slicing, 67–68, 70

• indexing, 67–69

• memoryview, 487–488

• stride syntax, 70–72

• syntax, 67

sort method, 145–149, 201–202, 493–501

sorted function, 499–501

speedup, 319

staging modifications, 96–97

star args, 150–152

starred expression, 73–76, 140

statement/s, 4–5

• assert, 404–408, 442–443

• break, 82–83, 85–86

• for, 79, 80

• if, 19

• import, 5, 592

• match, 30–39, 370

• nonlocal, 148–149

• raise, 405–408

• with, 408–412

static analysis, 613–621

static error, 7

StopIteration exception, 88, 198, 438

str, 41–46, 58–62, 524

str.format method, 54–55

strict keyword, zip function, 81

striding, 70–72

string/s

• advanced formatting, 52–55

• concatenation, 62–66

• C-style formatting, 47–52

• indexing, 10–11

• interpolated format, 56–58

• literals, 63

• repr, 58–62

• representing objects as, 223–224

subclass/es

• protected attributes, 247–250

• validation, 287–291

subprocess module, managing child processes, 320–324

super function, 238–240

superclass, 207, 297

SWIG, 461

syntax

• slicing, 67–68

• stride, 70–72

• unpacking, 12–15, 138–139

SyntaxError exception, 533

system calls, 327–329

takewhile function, 104–105

as targets, enabling, 410–412

tearDownModule function, 548–549

tee function, 103

ternary operator, 19–20

TestCase subclasses, 535–541, 547–548

test/s, 533. See also debugging

• encapsulating dependencies, 559–562

• floating point, 563–565

• harness, 547–549

• integration, 541–542

• mocks, 550–558

• TestCase subclasses, 535–541

• unit, 542–547

• unittest module, 533–535

threaded I/O, porting to asyncio, 368–381

threading module, 332

ThreadPoolExecutor class, 361–363, 394–397

thread/s, 319. See also concurrency; parallelism

• avoiding for on-demand fan-out, 349–353

• blocking I/O, 327–329

• combining with coroutines, 381–384

• coordinating work between, 333–344

• versus coroutines, 364

• interoperability with coroutines, 381–384

• locks, 332–333

• preemption, 331–333

• preventing data races, 330–333

• Python support for, 327–329

• worker, 330–331, 335–337, 339–340, 342, 354, 358, 389–392

throw method, 195–199

time module, 519–521

timeit microbenchmarks, 453–458

title method, 50

tools. See also itertools; modules

• black, 5–6

• Cython, 461

• error checking, 8

• mypy, 115–116

• Mypyc, 461

• pip, 575–577

• static analysis, 614–621

• SWIG, 461

• timeit, 457–458

• venv, 578–580

trace_func decorator, 312–313

traceback, 424–436

tracemalloc module, 572–573

TraceMeta metaclass, 313–314

trailing comma, single-element tuple, 17–18

tree walking, 206

try blocks, 412–414

try/except/else blocks, 400–402

try/except/else/finally blocks, 402–404

try/finally blocks, 399–400

tuple/s, 11–12, 131

• comparator methods, 496

• converting objects to, 224–225

• empty, 16

• extending, 131

• literal values, 16

• nested, 127–130

• single-element, 16

  • parentheses, 16–17

  • trailing comma, 17–18

• two-, 143

type annotation, 115–116, 144–145, 254, 586–587

type checker, static, 613–621

type registration, 293–299

typing module, 613–621

underscore (_), 213

Unicode

• to binary conversion, 42

• code points, 42

• sandwich, 42–43

unit tests, 542–547

unittest module, 533–535, 548

unpacking, 12–15

• catch-all, 72–76, 138–139

• multiple return values, 138–141

• multiple-assignment, 11–15

update method, 96

user-defined classes, 137

UTC (Coordinated Universal Time), 519

utility functions, 451

validation, subclass, 287–291

ValueError exception, 401

varargs, 150–152

variable/s

• __debug__, 443–444

• alias, 136

• count, 24–26

• exception, 414–416

• for loop, 85–86

• scope, 147–148

venv, 578–580

version

• class, 530–531

• module, 577–578

• Python 2, 2

• Python 3, 2–3

walrus operator, 24–30, 179. See also assignment expressions

warnings module, 605–613

wave generator, 189–195

while loop, 29, 82–84, 382–383

whitespace, 3–4

with statement, 408–412

wordcode, 324–325

worker threads, 330–331, 335–337, 339–340, 342, 354, 358, 389–392

wrapper function, 168

wraps function, 168–169

write binary mode, 45

write text mode, 45

yield expressions, 187–188, 409–410

Zen of Python, The, 4

zero-copy operations, 487–491

zip function, 80–81

zip_longest function, 81, 103–104

zipimport module, 622–624

zoneinfo module, 522–523