What is Python repr() Function?

Python repr() is a built-in function that you can use to acquire a string representation of an object in a form that could be readily used to recreate the object. With the ability to provide comprehensive and unambiguous details about the object.

When applied to various types, including numbers, strings, and lists, it returns a string that could be directly interpreted by the Python interpreter to construct an identical object. Notably, custom classes can define their own __repr__() method to offer personalized string representations, affording deeper insights into the object’s inner state when investigating issues.

But before diving into practical use cases of the Python repr() function, it’s essential to understand its syntax and parameter. Familiarizing yourself with these elements is crucial, as they empower you to utilize the function efficiently across various contexts. Let’s take a closer look at these aspects to establish a solid foundation.

Python repr() Syntax and Parameter

Grasping the syntax of the repr() function is uncomplicated. All you need to do is invoke the function and provide an argument. Let’s explore this:


When utilizing the repr() function, keep in mind that it operates with just one argument – the object you wish to depict. Nevertheless, particular built-in objects such as strings and numbers possess their individual default repr() implementations, which can be altered if necessary.

Now that you have a good grasp of the syntax and parameter of Python repr(), let’s delve into its return values to gain insight into how this function operates in real-world examples.

Python repr() Return Value

In Python, when you use Python repr(), it returns you a string that showcases the provided object in a way that’s really helpful for debugging and when you’re developing your code. The string that comes out is crafted to be easily read by machines, aiming to remove any uncertainty and potentially enabling you to recreate the object or understand its inner state more thoroughly.

The result of repr() becomes particularly handy when you need to delve into complex qualities of an object, such as its type and what it contains. For example:

Example Code
class MyClass: def __init__(self, value): self.value = value def __repr__(self): return f"MyClass({self.value})" obj = MyClass(42) representation = repr(obj) print("Original object:", obj) print("repr() representation:", representation)

Here, we’ve created a class named MyClass. Inside the class, there’s an initializer method (init) that takes a value as an argument and assigns it to the instance variable ‘value‘. Additionally, we’ve defined a special method named repr, which is responsible for creating a custom representation of the object.

When we create an instance of the MyClass class using obj = MyClass(42), it initializes the object with the value 42. Then, we use the repr() function to generate a textual representation of the object by calling its repr method. This custom representation is formed using the class name and the value associated with the object.

Finally, we print both the original object using print() and the representation obtained from repr() using print() function.

Original object: MyClass(42)
repr() representation: MyClass(42)

This showcases how the custom repr method influences the way the object is represented when using the repr() function.

As mentioned above that the repr() function serves the purpose of depicting an object’s representation. Now, we will explore instances and situations involving this function to provide you with a comprehensive understanding of its practical application and functioning in real-life contexts.

I. Creation of repr() Object

Starting with the creation of a repr() object: While you may be familiar with the idea of objects in the context of classes and instances, the notion of a repr() object could seem unfamiliar. However, don’t worry, because this entity is a concept that exists temporarily within the realm of Python’s internal workings.

When you invoke the repr() function, it constructs this object. Yet, unlike a physical item, it doesn’t persist in memory. Rather, it dynamically generates the string representation and provides it for your use, existing only for the time it’s needed. For instance:

Example Code
class Book: def __init__(self, title, author): self.title = title self.author = author def __repr__(self): return f"Book({self.title}, by {self.author})" book = Book("The Great Gatsby", "F. Scott Fitzgerald") representation = repr(book) print("Original book object:", book) print("repr() representation:", representation)

In this example, we’ve defined a class called Book with an initializer (init) that takes ‘title‘ and ‘author‘ as arguments and assigns them to instance variables. Additionally, we’ve overridden the repr method to provide a customized textual representation of the object.

When we create an instance of the Book class using book = Book("The Great Gatsby", "F. Scott Fitzgerald"), it generates an object that represents a book with the provided title and author. We then use the repr() function to generate a custom representation of the object by calling its repr method. Finally, we print both the original book object and the representation obtained from repr().

Original book object: Book(The Great Gatsby, by F. Scott Fitzgerald)
repr() representation: Book(The Great Gatsby, by F. Scott Fitzgerald)

The custom repr method gives you control over how the object is represented when using the repr() function, making it more informative and user-friendly.

II. Python repr() for Object String Representation

The string produced by repr() is often more detailed and specific than the default string representation provided by the str() function. It can include information that is critical for understanding the object's content and structure, which is valuable when troubleshooting issues in your code or gaining insights into complex data structures. Consider the below example:

Example Code
class Mountain: def __init__(self, name, height): self.name = name self.height = height def __repr__(self): return f"Mountain(name='{self.name}', height={self.height} meters)" everest = Mountain("Mount Everest", 8848) representation = repr(everest) print("Custom repr() representation:", representation)

For this example, we have defined a class called Mountain, which has an initializer (init) that takes ‘name‘ and ‘height‘ as arguments and assigns them to instance variables. We’ve also overridden the repr method to provide a customized textual representation of the object.

When we create an instance of the Mountain class using everest = Mountain("Mount Everest", 8848), it creates an object representing a mountain with the specified name and height. We then use the repr() function to generate a custom representation of the object by calling its repr method. Finally, we print the custom repr() representation of the object.

Custom repr() representation: Mountain(name=’Mount Everest’, height=8848 meters)

As you can observe in the above example, that the custom repr method ensures that the output provides meaningful information about the mountain’s name and height in a readable format.

III. Python repr() with Float

The repr() function in Python, when used with a floating-point number, returns a string representation of that floating-point value. This representation aims to be as precise as possible while still providing a human-readable and unambiguous format. Here’s how the repr() function behaves with a floating-point number:

Example Code
number = 3.141592653589793 representation = repr(number) print("Float representation:", representation)

Here, we are exploring how the repr() function behaves with a floating-point number. We start by initializing a floating-point variable number with the value 3.141592653589793, which represents the mathematical constant pi (π).

Next, we use Python repr() to create a string representation of the number. This representation is designed to maintain the precision of the original floating-point value while ensuring that it’s readable and understandable for humans. It’s important to note that repr() attempts to provide an accurate representation, so the output will have enough digits to uniquely identify the number. Finally, we print out the result using the print() function with a descriptive message.

Float representation: 3.141592653589793

This above example illustrates how the repr() function captures the value of the floating-point number while preserving its precision and readability.

IV. Python repr() with Complex Number

When you employ Python repr() with a complex number, it generates a string depiction of the complex number using a particular format. The objective of this depiction is to offer a clear understanding of the complex number’s real and imaginary components. To exemplify, let’s consider a complex number:

Example Code
class ComplexNumber: def __init__(self, real, imag): self.real = real self.imag = imag def __repr__(self): return f"ComplexNumber({self.real}, {self.imag}j)" def __add__(self, other): return ComplexNumber(self.real + other.real, self.imag + other.imag) complex_numbers = [ ComplexNumber(3, 4), ComplexNumber(1, 2), ComplexNumber(-2, 7) ] sum_result = sum(complex_numbers, ComplexNumber(0, 0)) for num in complex_numbers: print(repr(num)) print("Sum:", repr(sum_result))

In this example, First, we created a class called ComplexNumber. Inside this class, we’ve set up an __init__() method that lets us initialize the real and imaginary parts of a complex number. Additionally, we’ve added a special method called __repr__() which generates a formatted string representation of the complex number.

To make complex number addition work, we’ve also added another special method, __add__(). This method defines how two instances of the ComplexNumber class should be added together. It calculates the sum of the real parts and the sum of the imaginary parts to give us the result. Then, we’ve defined a list called complex_numbers that contains instances of the ComplexNumber class, each representing different complex numbers with distinct real and imaginary parts.

We’re using the sum() function to find the total sum of these complex numbers. We’re providing an initial ComplexNumber instance with real and imaginary parts set to 0 as the starting point for the summation. We’ve included a loop to go through each complex number in the complex_numbers list and print out their string representations using the repr() function. This gives us a clear view of how each complex number is structured. Finally, we’re printing out the sum of the complex numbers, and its representation is displayed as well.

ComplexNumber(3, 4j)
ComplexNumber(1, 2j)
ComplexNumber(-2, 7j)
Sum: ComplexNumber(2, 13j)

By employing this approach, you can easily use these custom complex numbers that can be created, added together, and displayed, all using Python’s object-oriented features.

Python repr() Advanced Examples

In the following section, we will examine several advanced examples of Python repr() function, highlighting its flexibility and wide range of applications.

I. Python repr() with User-Defined Classes

You can use Python repr() with user-defined classes to create a string representation of instances derived from those classes. This generated string representation aims to offer insights into the object’s attributes, features, and internal status, all formatted in a manner that’s especially advantageous for many purposes.

By establishing a custom repr() method within your self-made class, you’re efficiently outlining the strategy for representing instances of that class as strings. This enables you to dictate the presentation of your objects when utilizing the repr() function. For example.

Example Code
class PrimeNumber: def __init__(self, value): self.value = value def is_prime(self): if self.value <= 1: return False for i in range(2, int(self.value ** 0.5) + 1): if self.value % i == 0: return False return True def __repr__(self): return f"PrimeNumber({self.value})" prime1 = PrimeNumber(7) prime2 = PrimeNumber(13) repr_prime1 = repr(prime1) repr_prime2 = repr(prime2) print("Representation of prime1:", repr_prime1) print("Representation of prime2:", repr_prime2)

For this example, we’re exploring the use of the repr() function with a user-defined class called PrimeNumber. This class is designed to represent prime numbers. We define the PrimeNumber class with an __init__() method that initializes the value attribute with a given number. The is_prime() method checks whether the value is prime by iterating through possible divisors up to the square root of the value.

We also implement the __repr__() method, which returns a custom string representation of the PrimeNumber object. We format this representation as PrimeNumber({value}). After defining the class, we create two instances, prime1 with the value 7 and prime2 with the value 13.

We then use the repr() function to obtain the string representations of prime1 and prime2. Finally, we print out these representations to illustrates how the repr() method can be used to generate descriptive and informative string outputs for user-defined classes.

Representation of prime1: PrimeNumber(7)
Representation of prime2: PrimeNumber(13)

This showcases how the repr() function enhances the readability and usability of custom class instances.

II. Python repr() with Tuple

In Python, if you utilize the repr() function with a tuple, it presents a portrayal of the tuple's content. This portrayal aims to provide a thorough insight into the tuple's contents, including the elements and their associated values. This aspect is particularly advantageous for understanding the tuple's organization and the data it holds.

When repr() is used on a tuple, the resultant string representation encompasses the individual elements, each converted into a string format based on its particular data type. The complete representation is enclosed within parentheses, serving as a distinct indicator that the data pertains to a tuple. Let’s explore this through the following example:

Example Code
def factorial(n): if n == 0: return 1 else: return n * factorial(n - 1) factorial_values = [factorial(i) for i in range(6)] tuple_factorials = tuple(factorial_values) print("Factorial values as a tuple:", repr(tuple_factorials))

Here, we’re creating a function to calculate factorials and then using list comprehension and tuple conversion to showcase the use of the repr() function. We define a function called factorial(n) that calculates the factorial of a given positive integer n. If n is 0, the function returns 1, otherwise, it recursively calculates n times the factorial of n - 1.

We then use a list comprehension to calculate the factorials of numbers from 0 to 5 and store them in the factorial_values list. Next, we convert the factorial_values list into a tuple using the tuple() function.

Finally, we use the repr() function to obtain the string representation of the tuple_factorials tuple. The repr() function generates a readable and informative string that represents the tuple. When we print out the result using print(), we can see the string representation of the tuple containing the calculated factorial values.

Factorial values as a tuple: (1, 1, 2, 6, 24, 120)

This example illustrates how the repr() function can provide a clear and structured representation of data structures like tuples, making them more understandable and useful for debugging and analysis.

III. Python repr() with Set

Python Sets – those special collections of unique items that plays a role when it comes to the repr() function. When you provide a set, repr() generates a clear representation that displays the set’s contents. Take a look at the following example to better understand how the repr() function works with the set data type in Python.

Example Code
def fibonacci(n): fibonacci_set = set() a, b = 0, 1 for _ in range(n): fibonacci_set.add(a) a, b = b, a + b return fibonacci_set fibonacci_set = fibonacci(10) set_representation = repr(fibonacci_set) print("Fibonacci numbers as a set:", set_representation)

In this example, we’ve defined a function fibonacci(n) that generates the first n terms of the Fibonacci series using a loop. The fibonacci_set set is used to store the generated Fibonacci numbers. We start with two initial values a and b, and in each iteration, we add the value of a to the set, and then update a and b to generate the next Fibonacci number.

After generating the Fibonacci numbers and storing them in the set, we use the repr() function to obtain the string representation of the fibonacci_set. This representation will display the set’s elements enclosed within curly braces and separated by commas. Finally, we print out the result using the print() function, which will show the string representation of the set containing the Fibonacci numbers.

Fibonacci numbers as a set: {0, 1, 2, 3, 34, 5, 8, 13, 21}

This example illustrates how the repr() function can provide a clear and structured representation of sets, making it easier to visualize and understand their contents.

IV. Handling Exceptions and Errors with repr()

Handling exceptions and errors with repr() involves using the repr() function as a tool to manage and understand exceptions that might occur during program execution. Exceptions are errors that disrupt the normal flow of code execution, and they can happen for various reasons, such as division by zero, accessing non-existent dictionary keys, or encountering unsupported operations.

By using repr() in exception handling, you can provide more informative and helpful error messages when exceptions occur. Instead of the default error messages, which might be cryptic or not very informative, you can use the repr() function to generate custom string representations of objects involved in the exception. This can aid in quickly diagnosing the issue, especially when complex data structures are involved. For example, consider a scenario where you’re trying to access a key that doesn’t exist in a dictionary.

Example Code
my_dict = {'key1': 42, 'key2': 'value'} try: value = my_dict['nonexistent_key'] except KeyError as e: error_msg = f"KeyError: The key '{e}' doesn't exist in the dictionary." print(error_msg)

For this example, we start with a dictionary named my_dict containing a couple of key-value pairs. Now, let’s say we attempt to access a key that doesn’t exist in this dictionary. To handle this situation, we’ve enclosed the dictionary access in a try-except block. Inside the try block, we’re trying to access the key ‘nonexistent_key‘ from the dictionary. However, since this key doesn’t exist, a KeyError exception is raised. We’ve caught this exception using the except block that follows.

In the except block, we create a custom error message by combining the string KeyError: The key with the string representation of the variable e, which holds the key causing the error. We use repr(e) to convert the key into a more informative string representation. Finally, we print out the custom error message, which provides better context about the error by indicating which key is missing in the dictionary.

KeyError: The key ”nonexistent_key” doesn’t exist in the dictionary.

By crafting error messages in this manner, using the repr() function to enhance the representation of objects in exceptions, you can improve the readability and utility of error messages when issues arise during program execution. This approach simplifies the process of identifying and addressing problems in your code.

With your firm grasp on the Python repr() function and its applications across various scenarios, it’s time to delve into its comparison with the str() function. This exploration will provide you with deeper insights into the inner workings of repr() and how it differs from the str() function.

Difference between repr() and str()

Now, as your journey culminates, let’s take a moment to differentiate between the repr() and str() functions—two siblings in the Python universe. While both functions offer string representations, they serve distinct purposes.

Python repr() function aims to provide a representation that’s unambiguous and suitable for developers and debugging. On the other hand, the str() function focuses on producing a user-friendly string representation that’s readable and presentable to end-users. So, let’s consider two situations to comprehend the contrast between repr() and str().

I. Python repr() Function

By examining the preceding instances involving the repr() function, you’ve gained an understanding. Now, let’s examine a scenario in contrast to repr(), focusing on the str() function, to enhance your comprehension further.

Example Code
class Person: def __init__(self, name, age): self.name = name self.age = age def __repr__(self): return f"Person(name='{self.name}', age={self.age})" person = Person("Alice", 30) person_representation = repr(person) print("Original object:", person) print("repr() representation:", person_representation)

Here, we define a Person class with an __init__() method to initialize the name and age attributes. We also define a custom __repr__() method to generate a string representation of the object. Subsequently, we instantiate the Person class, naming the instance person. By calling repr(person), we obtain a string representation of the person object. The output will display the original object and its repr() representation, highlighting how the repr() function represents the object.

Original object: Person(name=’Alice’, age=30)
repr() representation: Person(name=’Alice’, age=30)

This code illustrates how the repr() function works in generating machine-readable and informative representations of objects for debugging and development purposes.

II. Python str() Function

In Python, the str() function is used to convert different data types, including numbers, lists, tuples, and objects, into human-readable string representations. It returns a string representation of the specified object, which is often more suitable for displaying to users or including in text-based outputs.

The str() function is primarily used for creating visually informative and readable representations of data. For built-in data types, the str() function generally provides a friendly representation that’s easier for humans to understand. However, for custom objects or classes, the str() function relies on the __str__() method if it’s defined within the class. If the __str__() method is not defined, the default implementation provides basic information about the object’s type and memory address. Here’s an example showcasing the use of the str() function.

Example Code
num = 42 num_str = str(num) print("Original number:", num) print("str() representation:", num_str)

In this example, we have a simple illustration of how to use the str() function to work with data in Python. We start by assigning the value 42 to the variable num. Then, we use the str() function to convert this numeric value into a string representation, which we store in the variable num_str.

To display the results, we utilize the print() function. We show the original number by printing the content of the num variable, and alongside it, we print the outcome of the str() function using the num_str variable. This showcase how the str() function transforms the numeric value into a string representation. When we run this code, we’ll observe the original number and its corresponding string representation printed out for our examination.

Original number: 42
str() representation: 42

This showcases the conversion functionality of the str() function and its role in generating human-readable string versions of different data types.

Congratulations on gaining a strong understanding of the Python repr() function! You’ve delved into its world and explored its capabilities across various contexts. Now, armed with this knowledge, you’re ready to use the power of repr() in your programming journey.

You’ve learned that the repr() function acts as your tool for crafting object representations that are not just informative but also instrumental in debugging and development. By applying repr() to different types, you’ve seen how it generates clear and precise representations that can even be used to recreate objects. But the journey doesn’t stop here. You’ve explored the syntax and parameters of repr(), allowing you to wield it efficiently. Remember, it’s not just about strings; it’s about gaining insight into an object’s inner workings. From classes to floats, complex numbers to sets, you’ve witnessed the flexibility and convenience of repr().

In your coding adventures, you’ve created your own repr() methods within classes, taken control of error messages with custom representations, and even witnessed how it can aid in visualization and documentation. With these tools in hand, you can now craft comprehensive representations, visualize machine learning models, and create clear code documentation.

So, as you embark on your coding journey, remember that repr() is not just a function; it’s your companion in unraveling the complexities of your code. It’s your key to understanding objects and their inner states, making your debugging and development experiences smoother and more insightful. Keep exploring, keep learning, and keep harnessing the power of repr() to elevate your Python programming skills!

Scroll to Top