As I understand it, "weakref" is an overly elaborate term for simply a reference, that is, a pointer. But it has to be distinguished from conventional python references, which incorporate the reference counting mechanism that supports automatic garbage collection.

@@Graham_Wideman I haven't delved much into the details of python, but in Lua, a weak reference is a reference that is not counted for garbage collection. So, if something only has weak references, it is garbage collected.

@@alan5506 So you're saying Lua's use of the term "weak reference" is the same as what I wrote for Python?

​@@Graham_Wideman Yes.

@@Graham_Wideman A weak reference is more than a pointer, because it needs to know, if the object still exists. Technically, you have the object itself and the reference counter (which is also an object managing the number of strong and weak references). The object is deleted when all strong references are gone. The reference counter is deleted when all (strong and weak) references are gone. Hence, a weak reference also "incorporates the reference counting mechanism" and is in fact a "smart" pointer, just like strong references.

weakref video when

When weakref video

WeakWhen Ref Video

WhenRef Video Weak

Videoweak when ref ?

Gold

Does it return "This is Pam"?

In the exact same boat! As I've always said, deterministic destruction is a drug, once you have it you'll look for it everywhere.

I learned programming with C++, but my career took me to higher level lenguages. Destructors are, easily, the feature of C++ I miss the most.

Closures are distinct objects and they hold counted references to their upvalues, _if and only if_ they continue to exist after __del__ is executed it makes sense that they resurrect the object. If they don't, that's probably an interpreter bug or a completely braindead spec because it implies that either the count is checked before the locals of __del__ are collected or resurrection depends on whether the count was modified, not whether it's greater than zero.

They were executing _during_ del.

@@lawrencedoliveiro9104 This could very well be an interpreter bug then. Is it open source? Can you share a sample? I'd like to study this.

@@lawrencedoliveiro9104 To be clear, if the only reference to the closure was within the locals of the calling function that weren't upvalues, it should not count as a reference cycle, because the locals of a function that aren't upvalues die when the function stops executing. The names of upvalues are known statically, so they aren't supposed to count as references to the entire set of locals but the specific one.

@@tacticalassaultanteater9678 This was in my DBussy library.

Probably the NullPointerException will hit you just as often as in Java

I think that in CPython it does both reference counting and the generational gc, but I could be wrong

@@codeofdestiny6820 yes, gc is for avoid reference cycle in cpython

@ I don't understand your answer, can you elaborate?

@@codeofdestiny6820 in the reference count there may be cases where A references B and B references A generating a reference cycle A B, depending on the implementation: 1 - the count of A never reaches zero, or 2 - it reaches zero but A and B leave the count however without deallocating memory and become inaccessible. some languages use strong and weak reference to solve this, A strong references B and B weak references A, A B (bad illustration in asc), when the count for A goes to zero, B will be automatically deallocated by have a weak reference to A (swift and also is posible in cpython but not is the default). cpython uses the garbage collector to solve this, because if A and B become inaccessible without deallocating memory, the garbage collector will solve why it knows the inaccessible objects (I don't know the details it but this is the idea)

Slapping (self) on the end of the dunder name helps. __del__(self)

A programmer should never do something silent as a fallback for if they forget something. If they forget something the program should tell at the programmer loudly and throw an error.

@@minerscale In pure best practices ideals, yes, I agree. Fail on it. However, there are plenty of people/organizations who won't follow/followed best practices. And won't (or won't be given time by their higher ups to) learn those best practices and refactor accordingly. If it is an existing code base you are adding this check to, then businesses will not like you "breaking" their application/stack, even if what is actually broken is their code. Or even if it is a new API, there is a good chance developers will find this strictness too annoying and/or time consuming. and instead chooses (or the higher-ups choose) some competing product. Instead of doing the right thing and fixing their own coding practices. It sucks, but here in the real business world, not accounting for or providing avenues to deal with less than ideal development circumstances (or outright laziness) will cause friction I think the best solution is configurable behavior, "fail", "warn", and maybe "ignore". Kind of like how "strict mode" works on Android (if set, raises exception if a resource cleanup is missed, else it just logs a warning)

We have some legacy C++ code with initialize/finalize methods. It’s disgusting, whoever wrote it was trying to write Java code in C++.

Glad you made it all the way!

How to do this? Please share

O_TMPFILE option to open(2).

@@illegalsmirf You can delete open files in Linux. You can read/write them, and pass open file descriptors to them to children.

Glad you like them!

Working on one already!

Watch the new typing stuff and the one on the history and direction of the match statement!

Because div is ambiguous, Python has two divs, a/b and a//b!

@@mCoding yeah but surely the / ought to be ___div___ and // like ___floordiv___ or something

Excellent idea, but unfortunately trying to import a module during interpreter shutdown is likely to cause a crash or other badness for ... "reasons". You also shouldn't attempt to start new threads or subprocesses.

My solution to this is to register an atexit function in the containing module that goes through all classes that have potentially troublesome ‗‗del‗‗ methods and delete them from the class. E.g. def _atexit() : for cłass in Connection, Server, PreallocatedSend, Message, PendingCall, Error, AddressEntries : delattr(cłass, "__del__") ♯end for ♯end _atexit atexit.register(_atexit) Instances that disappear during normal program operation get cleaned up as usual; ones that are left at program termination are not.

Agreed and I know exactly what you mean coming from C++. Btw weakref finalize uses atexit under the hood.

It turns out weakref uses atexit under the hood ^^ so not much probably

Yes. But also see my comment about atexit.

Dunder == "Double underscore" refers to names in Python that begin and end with two underscores, like in the video title.

He means Cython I’d guess

I think he meant other implementations of python per se. CPython is an individual reference implementation, but there are a lot of other implementations, like IronPython, PyPy, Jython and less known ones.

@@deimuader ok thanks bro! Yea i guess I had always heard terms like PyPy and Jython before, but never actually connected it to what they really were. The fact that most python implementations are Cython makes a lot of sense as to why python can have some nice bindings with C. Thanks for the responses yall!

At the end he does ask to comment if you want to know more about weakrefs, so I guess that was his cliffhanger and you would like to see that follow-up... 😉

A finalizer is for doing anything you need to do right before an object is garbage collected.

@@mCoding "A finalizer is for..." Yes, that much is obvious from the name. But in this video we don't seem to see where that "doing anything" is actually defined and how it gets invoked. I know, I could RTFM... just that it seemed like rather a hole in this otherwise nice story.

I made sure to avoid using a math word in a programming video but you're absolutely right. Idempotent is the technically best way to describe them (or how they _should_ be).

The whole idea is that it eliminates a whole class of errors. Think about it, if you have an API where you create a thing, and you need to destroy that thing (else get a resource leak, or maybe other bad things happen), and you expect the users of the API to clean it up... wouldn't it just be easier if the language had a built in feature to make sure you can never get that wrong? It lowers the complexity of APIs, because there is no additional function to clean things up, it's tied to the object and (more or less) never gets called manually) Now you just declare a thing, and when you're done with it the cleanup code gets run, either via garbage collection + a callback, or in C++ you have RAII, which in turn is the basis for OBRM in Rust - the latter two being completely deterministic. It is the single feature from C++ that I love so much that I could never use C, because it doesn't have that.

Indeed weakrefs can break this cycle, although CPython 3.4+ is able to detect and delete these cycles so it is not necessary. Though i will certainly talk about this if i do a weakref video!

Weak refs are useful. But why does Java need _three_ different kinds of weak refs, when Python can make do with one?

@@lawrencedoliveiro9104 I don't know exactly, but Java in comparison with Python has GC (Garbage Collector) that defines behaviour of working with each type of reference (Soft/Weak/Phantom). This behaviour can also rely on jvm realisation (e.g., _as I know or think_, Hotspot uses timestamps for SoftReference and IBM VM counts how many gc calls this ref survived). I didn't find any useful material to put here, so I wish you good luck with understanding refs in Java

It would only count if you disliked it!

If you know you know!

I mean... pretty sure someone who searches for "with statement" will end up at the right place, and it is arguably clearer what a "with statement" is referring to than a "context manager" to someone who doesn't already know what with statements and context managers are and how they are related.

This mechanism is still needed for things like wrappers for non-Python libraries. They tend to expect explicit calls to dispose of objects, and it’s nice if the Python user doesn’t have to worry about such things. It takes a certain amount of mechanism to ensure this happens reliably.

As an addendum: Go's _defer_ can actually be used for all the things above, since Go has a different type of garbage collector and, as a compiled language, it actually just rewrites your function to execute _defer_ at the end of it instead of at the point it was called, no different than try/finally statements. Of course, Go has a runtime.SetFinalizer which is more closely related to Python's dunder del, but that one is far more explicit and doesn't attach itself to every instance of a struct(though technically you could write a constructor to do just that). The exact same caveats as dunder del applies to it.

to perform an assertion on a condition, an AssertionError would be raised if the condition evaluates to False. It is really useful when you're writing tests

You can add a message to that Assertion Error by providing a second argument, e.g assert a!=b, "Oh dear - a shouldn't equal b"

Throws an error if a condition is false.

Be careful with asserts, as they can be optimized away if you start a script with python -O script.py.

Maybe one day... not today though!

It’s not so unreliable. It can be useful -- with care.