Great work!
I also memorized most functions by sound-alike.
I structured the order of my functions by “functionality”—and then quasi-alphabetically, but it took me a whole day to figure that out (i.e., categorize the functions) since I hadn’t previously programmed (before learning Python). I literally spent half of a day going back and forth between ChatGPT and the Python documentation.
Python Builtin Functions by Category.csv (5.0 KB)
Here’s what I did for rules (it was a lot of work, and I would happily do it again):
- I pulled up Python’s Standard Library Reference

- then I made a gigantic memory palace and assigned areas for the sections:
- Built-in Constants
- Built-in Types
- The Built-in Types area was huge because…
- I then assigned sub-areas for each of the sections in the Built-In Types:
- Truth Value Testing
- Boolean Operations —
and,or,not - Comparisons
- Numeric Types —
int,float,complex - Boolean Type -
bool - Iterator Types
- Sequence Types —
list,tuple,range - Text Sequence Type —
str - Binary Sequence Types —
bytes,bytearray,memoryview - Set Types —
set,frozenset - Mapping Types —
dict - Context Manager Types
- Type Annotation Types — Generic Alias, Union
- Other Built-in Types
- Special Attributes
- Integer string conversion length limitation
- and yes, for a number of these I had sub-sub areas, but at first I kinda just eyeballed how much locational space I might need and left the area mostly empty.
4 . For Exceptions I just memorized the Exception hierarchy
- I placed the hierarchy on multiple sides of our town’s Courthouse (the outside of it, I mean). The top of the hierarchy starts at the top of the multi-storied courthouse and the subclasses of the different Exception groups run down the sides of the building. I found this pretty easy. I did it in an afternoon or two.
- note: I’m not a particularly speedy mnemonist, just a persistent one.
-
Once I got the structure down (not perfectly, just down), I started going through the docs and picking sections to start memorizing from based on either what i was curious about, or whatever seemed like a good next step.
-
Rather than memorize a whole section at one time, I usually added details to multiple sections in the same day, and as the days went by and my recollection of the material strengthened, and bit by bit I continued to add details to various sections, pretty quickly the palace began filling out both in terms of breadth and depth.
Note:
I personally did a few things differently than listed above (just do whatever you think will be most useful to you):
- I memorized the Exceptions hierarchy somewhat later into this whole process, not near the beginning, but it’s been very handy to have memorized and didn’t take very much time. Doing it early has benefits.
- I memorized the entire top-level structure of the Standard Library Reference right at the start (this was all sort of an experiment in a way, you know?) see below
- I memorized all module (i.e., “library”) names up until the Concurrent Execution modules.
- I hand-picked some modules to start adding to and filling out as well somewhat early on.
For reference, that top-level hierarchy looks like this:
- Built-in Functions
- Built-in Constants
- Built-in Types
- Built-in Exceptions
- Text Processing Services
- Binary Data Services
- Data Types
- Numeric and Mathematical Modules
- Functional Programming Modules
- File and Directory Access
- Data Persistence
- Data Compression and Archiving
- File Formats
- Cryptographic Services
- Generic Operating System Services
- Concurrent Execution
- Networking and Interprocess Communication
- Internet Data Handling
- Structured Markup Processing Tools
- Internet Protocols and Support
- Multimedia Services
- Internationalization
- Program Frameworks
- Graphical User Interfaces with Tk
- Development Tools
- Debugging and Profiling
- Python Runtime Services
- Custom Python Interpreters
- Python Language Services
- MS Windows Specific Services
- Unix Specific Services
- Superseded Modules
- Security Considerations
Final note:
My process has been trial and error since I don’t know anyone who’s memorized programming documentation (I like looked, boy did I look) plus I’m new to programming.
I haven’t even been programming a year. ![]()
Part of the reason I’m working through Robert Sebesta’s Textbook Concepts of Programming Languages is to help me refine and clarify my process so I don’t have to unnecessarily memorize the same things for other programming languages.
- Redundancy is good in network engineering but not so good in both programming and mnemonics because it creates clutter and a lively breeding ground for our two great nemeses: Confusion and Errors.
edit: i keep fixing typos