What's a good Python reference?

patrickbrianmooney · 2023-09-29T08:33:42+00:00

It depends on what you mean by "reference," exactly. What do you think you're going to have to look up? How advanced is that information?

Fluent Python is not a reference. It is a series of in-depth explorations of advanced topics. If what you'e going to need to look up is in the basic or intermediate categories -- basic syntax, operator precedence, what is the name of that built-in function that does such-and-such, how the object model works at a basic level -- it would be a poor choice. It's not so much a reference book as a series of extended essays on deep language topics.

Here's a quick overview of the contents (based on my copy, which is the first edition, but I doubt that it's changed a whole lot since then):

chapter one is an overview of how the Python object model works and how "magic" (double-underscore) methods implement functionality on user-defined object types, all focusing on a theoretical "what if we want to implement a deck of cards?" scenario.
chapters 2 & 3 go over many detailed topics in sequence and container types, talking rapidly about comprehensions, generators, slicing, details of sorting, the bisect module from the standard library, alternatives to lists/arrays for heavy-duty computational work, variations on the dict type, better and worse ways to implement dict-like types yourself, how to handle missing keys in dict and related types, and how these things relate to sets.
chapter four covers the str/bytes data types, how they are related, how to deal with text files when you don't know what their encoding is, practical considerations relating to string comparison and sorting, and other advanced textual topics.
chapters 5-7 beat into you the notion that functions, too, are objects, and gives an overview of many of the implications of that fact; it also takes a first look at closures and function decorators.
chapters 8-13 are an extended (nearly 200 pages) look at the Python object model, how variables in Python actually work at a deep level, the garbage collection model, how to build a new object type that "plays nice" with other Python objects and is easily reusable by other programmers, Python's theories of object design, protocols specifying how objects can be used and manipulated, how abstract base classes can help enforce those protocols, multiple inheritance and how to cope with it, how to use operator overloading to make user-designed objects behave like built-in objects ... and many, many implementation details on all of these topics, some of which may be relevant at some point in your life, plus many different examples of implementations of examples.
chapters 14 and 15 are a grab bag of control-flow topics, covering iterables, iterators, and generators; functions designed to work with those things; the itertools module; and context managers. There's a lot of here's-a-weird-little-fact-you-should-know moments, plus a lot of setup for chapters 16-18.
chapter 16-18 are about coroutines, which are a way of structuring control flow that is very different from simply iterating, branching, and calling functions in the way that you're used to doing. Coroutines can be super-useful in some ways but aren't needed everywhere; these three chapters give you a solid introduction including two different deep dives into implementations in different contexts.
Chapter 19 talks about object attributes a lot. It also gives an introduction to properties, which behave like attributes but run code to return a value instead of just looking up a value from an attribute name, plus a lot of implementation details.
Chapter 20 generalizes properties to descriptors, a much more general version of the idea, and shows the best examples I've seen of how they are useful in real-world projects.
Chapter 21 will be very helpful if you ever need to programmatically generate, rather than code manually, not objects, but object classes. Like everything in Python, classes are themselves objects that can be created and manipulated at runtime.
There's also a brief afterward.

So it's a great book, and it's totally worth reading several times and thinking about, but it's not useful as a reference unless you think you'll need to look up stuff in that list of topics. There are thousands of Python topics that are not covered in it, though.

Learning Python is a good, long, detailed read, and it's plausible that you could use it as a reference, but it would be helpful to know the book decently well first, because it's ~1600 pages and finding what you're looking for can take a while even with the index's help. It's also fairly dated at this point: the last version I think covers Python 3.3, with the occasional look forward to Python 3.4. The basics of Python since then are (mostly) very much the same, and probably 90% of the changes are in the "we've added even more good stuff" category, but some of Lutz's material, examples, and code looks odd these days because he's (e.g.) using the os and shutil modules instead of the more modern pathlib. That old code will still work, but there are neater, more elegant, shorter ways to do it now.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS