Python Memory Management and Tips Transcripts
Chapter: Efficient data structures
Lecture: Data with cycles

Learn more about this course
Login or purchase this course to watch this video and the rest of the course contents.
0:00 Alright, let's write some code and create some cycles.
0:03 Now we sort of saw that in the GC section before,
0:05 but I want to start from scratch
0:07 so we have some nice, clean examples to work with,
0:09 and I'm gonna create another person class here that's similar,
0:12 but not the same as what we had before.
0:15 I'm just gonna paste this because we kind of did do this before.
0:19 Over here, we've got our person class.
0:21 It's created, it has a name.
0:24 It also auto generates its
0:25 id, and it has a list of friends.
0:27 It has this class method that will just auto-increment the
0:31 id, like 1, 2, 3 and so on,
0:33 and then finally, this class will tell you if it was cleaned up. This will
0:37 tell you that, yes, the cycle has been broken and the thing got cleaned
0:41 up, or, you know what? It didn't.
0:43 So, this is off to a good start.
0:45 The other thing that I'm gonna create is something to play with it.
0:48 I'll just call it "app_cycles" following my pattern that we're going to run things that are
0:52 named "app" and just trigger so I can hit the hockey to make it run and do our
0:56 fmain live template and boom,
0:58 we've got something to start from.
1:00 So what I wanna do is creates two people, have a person, and the name will
1:04 be Michael and a second person whose name is Sarah.
1:12 Okay, we got are two people here.
1:14 Now I want to let you play with it in different ways.
1:17 Sometimes they'll have cycles, sometimes they won't.
1:20 So I'm gonna ask a question.
1:21 I'll say if we'll ask the user "do you want cycles?"
1:28 We'll do like a "[y/n]?"
1:30 We'll say "If that is equal to yes,
1:35 then we're going to create some friends"
1:36 You know, we'll do that friend thing.
1:38 So p1, that's Michael, append p2,
1:42 and then we'll do the reverse like so.
1:45 So if they say yes, that's going to create a cycle.
1:48 And then we're going to zero them out here, like that
1:55 and we'll print out "program closing,
1:59 kthxbye". PyCharm thinks it's misspelled,
2:04 but no, no, K,
2:05 thanks, bye. That's a good thing.
2:06 And let's just flush it so we can
2:09 see stuff right away. Well,
2:12 let's go ahead and run this and we'll see if we have the cycle, this we've
2:15 kind of already looked at, but we're about to do something new here.
2:18 So we're going to see that if we do create the cycle,
2:21 this will not clean it up.
2:23 So the goodbye people, they're deleted will happen after this.
2:26 But if we say no, then they'll be cleaned up right here,
2:29 Yeah? let's do that. Did we will create a cycle?
2:32 Let's say no, and person was cleaned up.
2:35 Michael and Sarah. K, thanks,
2:37 bye. But this time, if we say yes,
2:39 the garbage collector does not have enough container object allocations.
2:43 Remember it needs 700 and we've done 2.
2:46 So that's not enough, so it's not going to trigger any sort of GC.
2:49 So the program exits and then basically as it goes out the door,
2:53 it does its final cleanup here.
2:55 Okay, so this is pretty interesting,
2:58 but I'd like the program itself to know if the cycle is detected. Now,
3:02 previously, we use that memutil thing that could tell us how many references were
3:06 pointing at a thing. But I want to introduce you to another idea that we
3:10 can play with. We could use the other one,
3:13 but I think we'll learn something here as well.
3:15 So I'm gonna create this thing called a "weak reference" and we can go and just
3:18 say "we're gonna create a weakref" by importing the library and we'll say "refer to
3:24 p1". What's gonna happen here is this is gonna retain something that maybe can
3:30 point to the object. But it can only point the object if it hasn't been
3:33 cleaned up. So previously we could say,
3:37 Well, "there was this thing out in memory and it created a cycle and it
3:41 didn't get cleaned up, but we only know that it used to be there".
3:45 You can't say "let me access it as if it were still alive" or revive it
3:49 In a sense, this weak reference will let us do that. So we'll do
3:53 the same here, and down at the bottom,
3:56 we'll do, I guess we'll say the things already closing or whatever,
4:00 but then we'll say "if we want to check
4:03 is this thing still around?" The way you do that with a weak reference is
4:06 You invoke it and it'll return p1 if it can,
4:10 if it's still around, otherwise it will return none. we'll say "if either these come
4:14 back with an object, we'll print..." This, we'll say, if either of them are alive,
4:36 we're gonna say "that's a cycle because nothing else points at it",
4:39 and we'll let people know, otherwise,
4:40 "no cycles found". So let's run it just one more time with our cool weak reference.
4:43 So, no. So they were cleaned up when we set them to none.
4:48 K, thanks, bye. No cycles found.
4:51 Let's run this again. Yes.
4:53 Create the cycle. Ah, cycles
4:55 found, cycles found. And then those things got cleaned up.
5:00 Here we are in this situation where we have these person classes,
5:04 they have friends. Most importantly,
5:06 we have these two things and they need to know about each other,
5:09 right? Michael needs to know about Sarah.
5:12 Sarah needs to know about Michael.
5:14 You might think, Well, that's just the way it is.
5:18 Is there any other possible data structure or mechanism we could use that's not going to
5:23 create a cycle? Remember, these things are going to survive a while.
5:26 If there's going many of them,
5:27 they're going to get promoted into Gen 1
5:29 and then to Gen 2, and when those things get inspected,
5:32 it's going to be expensive. They're gonna hang on around in memory longer than they
5:35 otherwise should. remember, Gen 1 is 10 times less likely
5:40 and Gen 2 is 100 times less likely to be even inspected. So avoiding creating the cycle
5:46 in the first place may be a really good idea.
5:48 Alright, So how do we do that?
5:50 How do we create this?
5:51 Well, the stage is set. In the next demo
5:53 we're going to go and use a slightly different data structure that will have the same
5:58 accomplishment. Like you could say,
6:00 a friend of Michael is Sarah, and vice versa without creating cycles.