How to use tostring() Equivalent in Python

In this article, we explore various methods to achieve the equivalent of the toString() function in Python. toString() is a commonly used function in languages like C++ and Java to convert objects into string representations. In Python, we have several alternatives to achieve the same result. This tutorial is about how to use the tostring() Equivalent in Python.

Strings in Python

In programming, “String” is a data type used to represent text rather than integers. Letters, numbers, symbols, and even spaces can all be found in a string, which is a collection of characters. To be recognized as a string, it must be enclosed in quotation marks.

Here’s an example:

For instance, the phrase “What is computer? ” and the word “computer” Both of these strings are in a template language. The sequence of characters “098”%/!)(/”&%%” is also considered a string.

txt = "What is computer?"
print(txt," ", type(txt))


What is computer?
What is computer?   <class 'str'>

tostring() In Python

toString() is a built-in C++ and Java function and is the standard way to return a string data type. The toString() method is used to express any object as a string. The object’s String representation is returned by the toString() function. When you print an object, the Java compiler calls the object’s toString() method internally.

Python does have a tostring() method, But we use different equivalent methods to do the same tasks. In Python, we use the str() function instead of the tostring(). The function str() turns a variety of arguments including integers and floats into strings.

If you want to learn more about Python Programming, Visit Python Programming Tutorials.

  *Working on Jupyter Notebook Anaconda Environment

Methods to Cast a String in Python

1. Using a built-in str() approach

str(), a built-in function in Python, is the equivalent of tostring(). str() is the simplest and most convenient approach to convert any data type to the string data type. To check the data type of the variable, the type() function determines the data type of any variable or data structure in Python. 

Here in the following example, it executes the tostring() equivalent operation in Python using str() function. 

integer = 10
print(("integer: "), integer)

#printing the data type of the integer using type() function

#store modified value in string
string = str(integer)

print(("string: "), integer)


integer:  10
<class 'int'>
string:  10
<class 'str'>

2. Using built-in format() approach

The built-in format() approach in Python is used to format and display data as strings. It allows you to create custom string representations of variables by specifying placeholders within a string and replacing them with corresponding values using the format() method. This is commonly used for creating formatted output, such as displaying variables with specific precision, alignment, or textual descriptions.

When format() is called, the placeholder, indicated by the curly bracket {}, is filled in with a specific value. In this placeholder, we set the value we want to display at the output. 

Here’s an example:

# declaring  variables
year = 2022
new_year = 2023

# To cast an number/integer into string using format method
string = "It's a year {}, The New year will be {}.".format( year, new_year)


<class 'int'>
It's a year 2022, The New year will be 2023.
<class 'str'>

3. Using built-in repr() Method for tostring() Equivalent in Python

In Python, the built-in repr() method is used to obtain a string representation of an object, which is often used as an equivalent to the toString() method in other programming languages. It returns a string that, when passed to eval(), would create an object with the same value.

Here’s an example:

class Person:
    def __init__(self, name, age): = name
        self.age = age

    def __repr__(self):
        return f"Person('{}', {self.age})"

alice = Person("Alice", 30)
alice_str = repr(alice)

# Now, you can recreate the 'alice' object from the 'alice_str'
new_alice = eval(alice_str)




In this example, the __repr__ method is defined in the Person class to provide a string representation, and repr(alice) generates a string that can recreate the original alice object when passed to eval(). This makes repr() a useful equivalent to toString() for creating string representations of objects in Python.

4. Using str.isdigit() approach

In Python, the str.isdigit() method is used to check if a given string consists of only numeric characters (0-9). It can be used as a way to determine if a string is effectively a numeric value and serves as a simple way to check if the string can be converted to an integer.

Here’s an example:

numeric_str = "12345"
non_numeric_str = "Hello123"

# Using str.isdigit() to check if a string is composed of only digits
if numeric_str.isdigit():
    print("Numeric string:", numeric_str)
    print("Non-numeric string:", numeric_str)

if non_numeric_str.isdigit():
    print("Numeric string:", non_numeric_str)
    print("Non-numeric string:", non_numeric_str)


Numeric string: 12345
Non-numeric string: Hello123

In this example, numeric_str is a string containing only numeric characters, and non_numeric_str contains both alphabetic and numeric characters. When we use str.isdigit(), it will correctly identify numeric_str as a numeric string and non_numeric_str as a non-numeric string. This method is often used to validate and process user inputs when expecting numeric values, such as age or an ID number.

5. Using a built-in f-string approach

Using f-strings in Python is a modern and concise way to achieve the equivalent of tostring() for various data types. F-strings allow you to embed expressions directly within string literals.

Here’s a basic example:

name = "Alice"
age = 30

# Using f-string to format a string with variables
formatted_string = f"My name is {name}, and I am {age} years old."


My name is Alice, and I am 30 years old.

In this example, the f before the string indicates an f-string. You can directly include variables and expressions within curly braces {} within the string, and they will be evaluated and replaced when the string is created. This makes it a convenient and readable way to create formatted strings and is often used as an equivalent to tostring() for creating string representations of data.

Certainly! F-strings can be used to convert objects to strings, providing a user-friendly representation of the object’s data. Here’s a creative example using an object:

class Book:
    def __init__(self, title, author, pages):
        self.title = title = author
        self.pages = pages

    def __str__(self):
        return f"{self.title} by {}, {self.pages} pages"

# Create a Book object
book = Book("The Great Gatsby", "F. Scott Fitzgerald", 180)

# Use an f-string to convert the object to a string
book_info = f"Book Information: {book}"


Book Information: The Great Gatsby by F. Scott Fitzgerald, 180 pages

In this example, we have a Book class with a __str__ method that returns a string representation of the book object. We then use an f-string to create a string that represents the book object with its title, author, and page count.

F-strings make it easy to create custom string representations for objects, improving code readability and usability.

6. Using %d Placeholder method

Python allows us to print numerical or integer values into a string by using the %d placeholder. You write the string that you want to print within the print command and then place a placeholder (%d) into it and close it with commas(‘ ‘), to do justice with Python syntax, then use the % operator for string formatting, and within square brackets () call a variable you want to cast to a string.

Here’s an example using %d:

apples = 10
bananas = 7
total_fruit = apples + bananas

fruit_basket_message = "In the fruit basket, there are %d apples and %d bananas. That's a total of %d pieces of fruit!" % (apples, bananas, total_fruit)

In this example, we have variables apples and bananas, and we want to create a descriptive string that includes the counts and total. The %d placeholders are used to insert the integer values into the string.


In the fruit basket, there are 10 apples and 7 bananas. That's a total of 17 pieces of fruit!

While the %d placeholder is still functional, it’s good to know that more modern and preferred methods for string formatting, such as f-strings and the .format() method, are available in Python.


On this page, you will find various methods showcased with Python example code to achieve the equivalent of tostring() for different data types. These methods are particularly useful when you need to convert data from various types into strings. After reviewing and grasping the methods and examples provided, you will be well-equipped to tackle challenges related to finding the Python equivalent of tostring() to suit your specific needs.

Leave a Comment

Your email address will not be published. Required fields are marked *