Python Memory Management and Tips Transcripts
Chapter: Allocating memory in Python
Lecture: Allocation in action

Login or purchase this course to watch this video and the rest of the course contents.
0:00 Let's do a little thought experiment. Imagine we have this one line of Python code,
0:03 which we know whole tons of stuff is happening down in the runtime.
0:07 But on the Python side, it's simple.
0:08 We have a person object. We want to create them, past some initial data over
0:12 to them, their name is Michael, and so on.
0:15 Now let's imagine that to accomplish this operation we need 78 bytes of RAM from the
0:23 operating system. What happens? How does that get into Python? Like,
0:28 what part of memory do we get?
0:30 How is it organized and so on?
0:32 So a very simplistic and naive way to think about this would be all right,
0:37 what we're gonna do is going to go down to the C-layer, and C-Layer
0:40 is going to use the underlying operating system mechanism for getting itself some memory.
0:46 It'll malloc it, right? So malloc is the C allocation side and then free, we would call
0:52 free on the pointer to make that memory go away,
0:54 Okay? So you might just think that the C runtime just goes to the
0:58 operating system and says "give me 78 bytes", and the operating system says "super,
1:03 we're gonna provide 78 bytes of virtual memory that we've allocated to that process",
1:09 which then, boom into that we put the thing that we need, some object
1:14 that has an id and the id wasn't explicitly set.
1:17 But, let's say it's generated.
1:18 The id is that in the name is Michael. Well,
1:23 that seems straightforward enough. I mean,
1:24 you have these layers, right?
1:26 Python is running and then Python is running actually implemented in C and C is running on top
1:31 of the operating system and the operating system is running on real RAM on top of hardware.
1:36 So this seems like a reasonable thought process.
1:39 But no, no, no. This is not what happens.
1:43 There's a whole lot more going on.
1:44 In fact, that's what this whole chapter is about,
1:46 is talking about what happens along these steps.
1:50 And it's not what we've described here.
1:53 Let's try again. So at
1:55 the base we, of course,
1:56 still have RAM. We have hardware.
1:58 That's where memory lives. We still have an operating system.
2:01 Operating systems provide virtual memory to the various processes that are running so that one process
2:07 can't reach in and grab the memory of another.
2:09 For example, we saw that there's ways in the operating system to allocate stuff.
2:15 So at C, there's an API called malloc that's gonna talk to the underlying operating
2:20 system. This is what we had sort of envisioned the world to be before.
2:24 But there's additional layers of really advanced stuff happening on top here.
2:29 Above this, we have what's called Pythons allocator or the PyMem
2:34 API and PyMalloc.
2:36 So the C runtime doesn't just call malloc,
2:39 it calls PyMalloc, which runs through a whole bunch of different strategies to do
2:44 things more efficiently. We saw that in python and Cpython in particular,
2:49 that every tiny little piece of data that you work with, everything, numbers,
2:53 characters, strings, all the way up to lists and dictionaries and whatnot,
2:58 these are all objects, and every one of them requires a special separate allocation,
3:02 often very small bits of data,
3:04 and that's why Python has this
3:06 Pymalloc. But wait, there's more.
3:10 If you're allocating something small, and by small,
3:14 I mean sys.getsizeof,
3:16 not my fancy reversal thing. So if you're allocating something that is in its own
3:21 essence small, then Python is going to use something called the "Small Object Allocator",
3:27 which goes through a whole bunch of patterns and techniques to optimize this further,
3:32 and we're going to dig into that a bunch.
3:34 So if you want to see all this happening,
3:35 you can go to "", the link at
3:40 the bottom, and actually the source code is ridiculously well documented.
3:45 There's like paragraphs of stuff talking about all these things in here,
3:49 but there's actually, in there, There's a picture, ASCII art-like picture that looks
3:53 very much like this diagram that I drew for you with some details that I left
3:57 out, but they're in the source code.