| by Arround The Web | No comments

Python Reference Error

Python programs consist of many errors and exceptions, and some of them are built in. These errors and exceptions occur whenever the Python interpreter encounters errors. A programmer is not immune to errors when writing a Python program and is likely to encounter unhandled errors. When we attempt to open a file that doesn’t exist or divide a number by zero, an exception is cast. Whenever these types of errors occur, Python creates the exception objects. If they are not handled correctly, Python prints a traceback of that error. This article is about one of the exceptions in Python that is called a reference error.

Reference Error

In Python, many errors and exceptions are categorized into two main groups: syntax errors and logical errors. Logical errors are also known as exceptions. Exceptions occur when incorrect or illegal operations are triggered. A reference error falls under the category of logical errors. Logical errors are those that occur at code execution time. When a weak reference proxy is employed to access a referent that is gathered from memory, a reference error is triggered. A reference error is part of Python’s built-in exceptions. These exceptions are thrown following the error that occurs.

In Python, a program has 4 functions – L, M, N, and O. If we use a program in which function L calls function M, function M calls function N, which in turn calls function O. Now, suppose that there is an exception that occurs in function N but which is not resolved or handled. The exception is passed to function M and then to function L. If the error is not resolved, an error occur and the program may fail.

Now, let’s discuss an example of a reference error.

Example 1:

In this example, we use a built-in function in Python to refer to an object. Look at the code in detail. First, we import the modules and creat a class named “check_Object” in which the object is passed. Here, we use the def_init_ (self, name) function and then define “self.name” as the name. Now, run the following code on your system:

import gc as g
import weakref as wk
class check_Object(object):
    def __init__(self, name):
self.name = name
def __del__(self):

    print('Delete it %s') % self
print('Reference object =', a.name)

The result that we get by running the previous code is given in the following illustration. You can see that we get a reference error that states that the weakly referenced object no longer exists.

Here, we can see that by asking to print a reference object without a proper object definition, we get a reference error.

The weak reference module permits a Python programmer to form the weak references to objects. A weak reference to an object is not enough to keep the object afloat and is the only remaining reference to the referent. These referents are weak references or collections of garbage that can be destroyed by the referent and memory that frees up can be used for something else.

Example 2:

Let’s take another example to understand this error better. As we discussed previously, when any object is weakly referenced in code, a reference error occurs. Using the following code, we now try to print the objects before and after using the delete command.

Here, we use a built-in function in Python to refer to an object and call it “obj1”. A class named “check_Object” is created. Here, we define two functions – “_init” and “_del_” – to perform the separate functions.

Following that, we use the created object of the class in the proxy command which is wk.proxy(obj_check). To print after the statement, the created “obj_check” is set to none.

import gc as g
import weakref as wk
class check_Object(object):
    def __init__(self, name):
        self.name = name
    def __del__(self):
        print ('Delete it %s') % self
obj_check = check_Object('object')
abc = wk.proxy(obj_check)
print('Before deleting =', abc.name)
obj_check  = None
print('After deleting = ', abc.name)

When we run the previous code, we get the following output:

As you can see, when we run the code, we get a reference error because before deleting the object, Python ignores the exception in the function and causes an error because the operands were of a different type and didn’t support it.

To sum up why the reference error occurs, we can say that when you remove an object from a program, a reference error occurs which causes all references to the object to be removed. The most common way that this error occurs is if your program has class 1 and class 2, and let’s say class 2 is deleted, we’re left with just class 1 with no binding to class 2. The relationship between classes 1 and 2 remains but there is no reference to class 2 because it has been removed or called back. The error may be caused by misconfiguration of the source roots and the program you are using may not know where to find the link.

How to Resolve Reference Errors in Python?

Reference errors can be resolved using an if-else statement or a try-without statement. We can see the code to resolve the reference error in the following example.

Example 3:

In this example, we demonstrate the code that can be used to resolve a reference error in a program. This code does not show any output. It simply contains some points that you can follow in your programs to avoid the reference errors.

def test_proxy_ref(self):
        a = C()
        a.bar = 1
        ref = weakref.proxy(a, self.callback)
        del a
        def check(proxy):
        self.assertRaises(weakref.ReferenceError, check, ref)
        if test_support.is_jython:
            self.assertRaises(weakref.ReferenceError, bool, ref)
            self.assertRaises(weakref.ReferenceError, bool, weakref.proxy(C()))
        self.assert_(self.cbcalled == 2)

The first function that we use is def test_proxy_ref(self) which is used to define a test proxy reference to self. We then define that the variable a = c() and a.bar = 1.

Now, we use the reference syntax “weak reference.proxy(a, self.callback)” to call back the reference that was mentioned. This callback function ensures that all references are invalidated before the callbacks are called. It is important that the first reference is called back or in simple terms. The most recent reference is cleaned up first before the second reference is called. This is a test that invalidates all references before any callbacks are made, so there is only a mention of the “_weakref” function. To check the proxy, we use the function check(proxy): proxy.bar. The extra collect function is used to kick the Python program into the device and helps with the callbacks that the thread needs to call.

The if-else function in Python is now used. This function is created to check the test phrase and execute the “if” statement in a case when the condition is true. Otherwise, the “else” statement is executed.


In this post, we learned that a reference error occurs because of the weak proxy reference. Many times, an error can occur in a program, either a syntax error or a logical error. A reference error falls under the category of logical error. We explained in which cases does a reference error occurs through an example. Try these examples on your system to get a better understanding of the topic of reference errors.

Share Button

Source: linuxhint.com

Leave a Reply