When is del called

A few types used internally by the interpreter are exposed to the user. Their definitions may change with future versions of the interpreter, but they are mentioned here for completeness. Code objects represent byte-compiled executable Python code, or bytecode.

Unlike function objects, code objects are immutable and contain no references directly or indirectly to mutable objects. Frame objects represent execution frames. They may occur in traceback objects see below , and are also passed to registered trace functions.

Note that this may lead to undefined interpreter behaviour if exceptions raised by the trace function escape to the function being traced. This method clears all references to local variables held by the frame. Also, if the frame belonged to a generator, the generator is finalized.

This helps break reference cycles involving frame objects for example when catching an exception and storing its traceback for later use. RuntimeError is raised if the frame is currently executing. Traceback objects represent a stack trace of an exception. A traceback object is implicitly created when an exception occurs, and may also be explicitly created by calling types. For implicitly created tracebacks, when the search for an exception handler unwinds the execution stack, at each unwound level a traceback object is inserted in front of the current traceback.

When an exception handler is entered, the stack trace is made available to the program. See section The try statement. It is accessible as the third item of the tuple returned by sys. When the program contains no suitable handler, the stack trace is written nicely formatted to the standard error stream; if the interpreter is interactive, it is also made available to the user as sys. The line number and last instruction in the traceback may differ from the line number of its frame object if the exception occurred in a try statement with no matching except clause or with a finally clause.

They are also created by the built-in slice function. Special read-only attributes: start is the lower bound; stop is the upper bound; step is the step value; each is None if omitted. These attributes can have any type. This method takes a single integer argument length and computes information about the slice that the slice object would describe if applied to a sequence of length items. It returns a tuple of three integers; respectively these are the start and stop indices and the step or stride length of the slice.

Missing or out-of-bounds indices are handled in a manner consistent with regular slices. Static method objects provide a way of defeating the transformation of function objects to method objects described above.

A static method object is a wrapper around any other object, usually a user-defined method object. When a static method object is retrieved from a class or a class instance, the object actually returned is the wrapped object, which is not subject to any further transformation.

Static method objects are also callable. Static method objects are created by the built-in staticmethod constructor. A class method object, like a static method object, is a wrapper around another object that alters the way in which that object is retrieved from classes and class instances.

Class method objects are created by the built-in classmethod constructor. A class can implement certain operations that are invoked by special syntax such as arithmetic operations or subscripting and slicing by defining methods with special names. Except where mentioned, attempts to execute an operation raise an exception when no appropriate method is defined typically AttributeError or TypeError.

Setting a special method to None indicates that the corresponding operation is not available. When implementing a class that emulates any built-in type, it is important that the emulation only be implemented to the degree that it makes sense for the object being modelled.

For example, some sequences may work well with retrieval of individual elements, but extracting a slice may not make sense.

Called to create a new instance of class cls. The remaining arguments are those passed to the object constructor expression the call to the class. It is also commonly overridden in custom metaclasses in order to customize class creation. The arguments are those passed to the class constructor expression. Called when the instance is about to be destroyed. This is also called a finalizer or improperly a destructor. It is possible though not recommended!

This is called object resurrection. CPython implementation detail: It is possible for a reference cycle to prevent the reference count of an object from going to zero.

In this case, the cycle will be later detected and deleted by the cyclic garbage collector. A common cause of reference cycles is when an exception has been caught in a local variable. Documentation for the gc module. In particular:. As a consequence, the global variables it needs to access including other modules may already have been deleted or set to None. If at all possible, this should look like a valid Python expression that could be used to recreate an object with the same value given an appropriate environment.

The return value must be a string object. This is typically used for debugging, so it is important that the representation is information-rich and unambiguous. This method differs from object.

The default implementation defined by the built-in type object calls object. Called by bytes to compute a byte-string representation of an object. This should return a bytes object. Called by the format built-in function, and by extension, evaluation of formatted string literals and the str. See Format Specification Mini-Language for a description of the standard formatting syntax. A rich comparison method may return the singleton NotImplemented if it does not implement the operation for a given pair of arguments.

By convention, False and True are returned for a successful comparison. However, these methods can return any value, so if the comparison operator is used in a Boolean context e.

To automatically generate ordering operations from a single root operation, see functools. Virtual subclassing is not considered. Called by built-in function hash and for operations on members of hashed collections including set , frozenset , and dict.

The only required property is that objects which compare equal have the same hash value; it is advised to mix together the hash values of the components of the object that also play a part in comparison of objects by packing them into a tuple and hashing the tuple. This is typically 8 bytes on bit builds and 4 bytes on bit builds.

An easy way to do this is with python -c "import sys; print sys. Hashable call. Although they remain constant within an individual Python process, they are not predictable between repeated invocations of Python. This is intended to provide protection against a denial-of-service caused by carefully-chosen inputs that exploit the worst case performance of a dict insertion, O n 2 complexity. Changing hash values affects the iteration order of sets. Python has never made guarantees about this ordering and it typically varies between bit and bit builds.

Called to implement truth value testing and the built-in operation bool ; should return False or True. The following methods can be defined to customize the meaning of attribute access use of, assignment to, or deletion of x. This method should either return the computed attribute value or raise an AttributeError exception. Note that at least for instance variables, you can fake total control by not inserting any values in the instance attribute dictionary but instead inserting them in another object.

Called unconditionally to implement attribute accesses for instances of the class. This method should return the computed attribute value or raise an AttributeError exception. In order to avoid infinite recursion in this method, its implementation should always call the base class method with the same name to access any attributes it needs, for example, object.

This method may still be bypassed when looking up special methods as the result of implicit invocation via language syntax or built-in functions. See Special method lookup. For certain sensitive attribute accesses, raises an auditing event object. Called when an attribute assignment is attempted. This is called instead of the normal mechanism i. For certain sensitive attribute assignments, raises an auditing event object.

This should only be implemented if del obj. For certain sensitive attribute deletions, raises an auditing event object. Called when dir is called on the object.

A sequence must be returned. If an attribute is not found on a module object through the normal lookup, i. If found, it is called with the attribute name and the result is returned. If present, this function overrides the standard dir search on a module. For a more fine grained customization of the module behavior setting attributes, properties, etc. For example:. New in version 3. Called to get the attribute of the owner class class attribute access or of an instance of that class instance attribute access.

The optional owner argument is the owner class, while instance is the instance that the attribute was accessed through, or None when the attribute is accessed through the owner. Called to set the attribute on an instance instance of the owner class to a new value, value. See Invoking Descriptors for more details. For callables, it may indicate that an instance of the given type or a subclass is expected or required as the first positional argument for example, CPython sets this attribute for unbound methods that are implemented in C.

If any of those methods are defined for an object, it is said to be a descriptor. For instance, a. However, if the looked-up value is an object defining one of the descriptor methods, then Python may override the default behavior and invoke the descriptor method instead. Where this occurs in the precedence chain depends on which descriptor methods were defined and how they were called. The starting point for descriptor invocation is a binding, a.

How the arguments are assembled depends on a :. The simplest and least common call is when user code directly invokes a descriptor method: x. If binding to an object instance, a. If binding to a class, A. If a is an instance of super , then the binding super B, obj. For instance bindings, the precedence of descriptor invocation depends on which descriptor methods are defined.

In contrast, non-data descriptors can be overridden by instances. Python methods including staticmethod and classmethod are implemented as non-data descriptors. Accordingly, instances can redefine and override methods. This allows individual instances to acquire behaviors that differ from other instances of the same class. The property function is implemented as a data descriptor. Accordingly, instances cannot override the behavior of a property. Attribute lookup speed can be significantly improved as well.

This class variable can be assigned a string, iterable, or sequence of strings with variable names used by instances. Attempts to assign to an unlisted variable name raises AttributeError. If a class defines a slot also defined in a base class, the instance variable defined by the base class slot is inaccessible except by retrieving its descriptor directly from the base class.

This renders the meaning of the program undefined. In the future, a check may be added to prevent this. Mappings may also be used; however, in the future, special meaning may be assigned to the values corresponding to each key. Multiple inheritance with multiple slotted parent classes can be used, but only one parent is allowed to have attributes created by slots the other bases must have empty slot layouts - violations raise TypeError. This way, it is possible to write classes which change the behavior of subclasses.

This method is called whenever the containing class is subclassed. If defined as a normal instance method, this method is implicitly converted to a class method. The default implementation object. The actual metaclass rather than the explicit hint can be accessed as type cls. When a class is created, type.

Automatically called at the time the owning class owner is created. The object has been assigned to name in that class:. See Creating the class object for more details. By default, classes are constructed using type. The class body is executed in a new namespace and the class name is bound locally to the result of type name, bases, namespace.

The class creation process can be customized by passing the metaclass keyword argument in the class definition line, or by inheriting from an existing class that included such an argument. Any other keyword arguments that are specified in the class definition are passed through to all metaclass operations described below.

If found, it is called with the original bases tuple. This method must return a tuple of classes that will be used instead of this base. The tuple may be empty, in such case the original base is ignored. PEP - Core support for typing module and generic types. The most derived metaclass is selected from the explicitly specified metaclass if any and the metaclasses i. The most derived metaclass is one which is a subtype of all of these candidate metaclasses. If none of the candidate metaclasses meets that criterion, then the class definition will fail with TypeError.

Once the appropriate metaclass has been identified, then the class namespace is prepared. The class body is executed approximately as exec body, globals , namespace. The key difference from a normal call to exec is that lexical scoping allows the class body including any methods to reference names from the current and outer scopes when the class definition occurs inside a function. However, even when the class definition occurs inside the function, methods defined inside the class still cannot see names defined at the class scope.

This class object is the one that will be referenced by the zero-argument form of super. This allows the zero argument form of super to correctly identify the class being defined based on lexical scoping, while the class or instance that was used to make the current call is identified based on the first argument passed to the method.

CPython implementation detail: In CPython 3. If present, this must be propagated up to the type. Failing to do so will result in a RuntimeError in Python 3. When using the default metaclass type , or any metaclass that ultimately calls type.

The type. After the class object is created, it is passed to the class decorators included in the class definition if any and the resulting object is bound in the local namespace as the defined class.

A database connection seems to be used often as an example that doesn't work well using with , since you usually need to leave the section of code that creates the connection and have the connection closed in a more event-driven rather than sequential timeframe.

While I tried to provide simplified code, my real problem is more event-driven, so with is not an appropriate solution with is fine for the simplified code.

I also wanted to avoid atexit , as my program can be long-running, and I want to be able to perform the cleanup as soon as possible. Python as a language makes no guarantees as to when it will destroy an object. CPython as the most common implementation of Python, uses reference counting. As a result del will often work as you expect. However it will not work in the case that you have a reference cycle. Python doesn't detect this and so won't clean it up right away. And its not just reference cycles.

If an exception is throw you probably want to still call your destructor. However, Python will typically hold onto to the local variables as part of its traceback. This is guaranteed to work, and you can even check the parameters to see whether you are handling an exception and do something different in that case. I sense that what you are really after is a flexible way to bind different functionality to an object representing program state, also known as polymorphism.

I suggest you look again at your class organization. Perhaps you need to separate a core, persistent data object from transient state objects. Use the has-a paradigm rather than is-a: each time state changes, you either wrap the core data in a state object, or you assign the new state object to an attribute of the core. If you're sure you can't use that kind of pythonic OOP, you could still work around your problem another way by defining all your functions in the class to begin with and subsequently binding them to additional instance attributes unless you're compiling these functions on the fly from user input :.

This is how functions defined on the class behave. Unfortunately for some use cases python doesn't perform the same logic for functions attached to the instance itself, but you can modify it to do this. I've had similar problems with descriptors bound to instances. Performance here probably isn't as good as using weakref , but it is an option that will work transparently for any dynamically assigned function with the use of only python builtins.

If you find yourself doing this often, you might want a custom metaclass that does dynamic binding of instance-level functions. Another alternative is to add the function directly to the class, which will then properly perform the binding when it's called. For a lot of use cases, this would have some headaches involved: namely, properly namespacing the functions so they don't collide. The instance id could be used for this, though, since the id in cPython isn't guaranteed unique over the life of the program, you'd need to ponder this a bit to make sure it works for your use case Another alternative rather than messing with python magic methods is to explicitly add a method for calling your dynamically bound functions.

This has the downside that your users can't call your function using normal python syntax:. Stack Overflow for Teams — Collaborate and share knowledge with a private group. Create a free Team What is Teams? Collectives on Stack Overflow. Learn more. Asked 10 years, 5 months ago. Active 2 months ago. Viewed 52k times. MethodType func, d2 d2. MethodType func, d3 d3. Brett Stottlemyer Brett Stottlemyer 2, 4 4 gold badges 23 23 silver badges 36 36 bronze badges.

Yeah, types. MethodType func, d2 has a reference to d2 and you put that on d2 , so you have a circular reference. Nothing surprising about it, but why do you do that if that's not what you want?

Jochen Ritzel - I DO want a dynamically bound method. I've created a class that adds methods getattr as needed. I was hoping there was a simple way to remove the circular dependency. The code above is simplified to show the issue. Visit the Fishing section for more information. For information on mandatory boat inspection for invasive mussels, see our Invasive Mussel Program page.

The public may rent motorboats, patio boats, pedal boats, and canoes at the East Beach marina area. Kayaks can be rented at the Kayak Center at the east beach. Any size boat may be launched at the public boat ramp. For more information and a schedule of fees, see our Boating and Sailing page. The boat speed limit is 10 miles per hour on the entire lake.

Interpretive staff accompany visitors on scheduled natural and cultural history boat tours of the lake. Call the Del Valle Visitor Center at for information. All bathroom buildings and many water fountains are wheelchair accessible.

The family campground has two wheelchair accessible campsites. Paved and gently sloped paths include portions of the Westshore and Eastshore trails. About 1. The park entrance is about four miles ahead. Drive south on North Livermore Avenue. Continue on Arroyo Road past the entrance to the U. The staging area is on the left at the end of Arroyo Road No parking fee.