Python str() Function

Spread the love

The str( ) function converts the specified value into a string.


The syntax of the str() function is straightforward:

str(object, encoding='utf-8', errors='strict')


The str( ) function takes three parameters.

  • object – Any object. Specifies the object to convert into a string.
  • encoding – The encoding of the object. Default is UTF-8
  • errors – Specifies what to do if the decoding fails

Return Value:

string: The str() function returns a string that is a printable representation of the input object.

String Conversion of Built-in Types

Python’s str() can handle almost any object, including numeric types, sequences, collections, and even custom objects. Here are some examples:

Numeric Types

For numeric types (int, float, complex), str() converts numbers into a string format that represents the number as it is written in code.

num_int = 42
num_float = 3.1415
num_complex = 1+2j

print(str(num_int))      # "42"
print(str(num_float))    # "3.1415"
print(str(num_complex))  # "(1+2j)"

In each case, the str() function gives you the textual version of the numbers, which you can then use to format output, store in a file, or further manipulate as a string.

Lists and Tuples

For lists and tuples, str() converts the entire collection into a string that contains the printable representation of each item, formatted as if you’ve typed out the list or tuple in Python code.

list_of_ints = [1, 2, 3, 4, 5]
tuple_of_ints = (1, 2, 3, 4, 5)

print(str(list_of_ints))  # "[1, 2, 3, 4, 5]"
print(str(tuple_of_ints)) # "(1, 2, 3, 4, 5)"

This is particularly useful for quickly displaying or logging the contents of collections.


Dictionaries are turned into a string representation that includes curly braces with key-value pairs, similar to how you’d write a dictionary in Python code.

dict_of_values = {'a': 1, 'b': 2, 'c': 3}

print(str(dict_of_values))  # "{'a': 1, 'b': 2, 'c': 3}"


Sets are converted to a string that begins and ends with curly braces {}, containing all the elements of the set separated by commas.

set_of_numbers = {1, 2, 3, 4, 5}

print(str(set_of_numbers))  # "{1, 2, 3, 4, 5}"

Note that sets are unordered, so the order of elements in the string representation may not match the order in which you defined or manipulated the set.


The Boolean values True and False are converted into their respective string representations, "True" and "False".

bool_true = True
bool_false = False

print(str(bool_true))   # "True"
print(str(bool_false))  # "False"


The None object is turned into the string "None".

none_val = None

print(str(none_val))   # "None"

The Magic Behind str(): The str Method

Every object in Python can define its own __str__ method. When str() is called on an object, it internally calls the __str__ method to determine what string representation should be returned.

Customizing str() with str

You can define custom behavior for str() by implementing the __str__ method in your classes:

class Product:
    def __init__(self, name, price): = name
        self.price = price

    def __str__(self):
        return f'Product: {}, Price: {self.price}'

p = Product('Book', 29.99)
print(str(p))  # Outputs: Product: Book, Price: 29.99

Difference Between str() and repr()

Another function similar to str() is repr(), which also returns a string representation of an object. The main difference is the purpose: repr() is used for debugging and development, showing the object’s representation in a way that it can be used to recreate the object, while str() is for a more user-friendly string representation.

class Product:
    def __init__(self, name, price): = name
        self.price = price

    def __str__(self):
        return f'Product: {}, Price: {self.price}'
    def __repr__(self):
        return f'Product("{}", {self.price})'
p = Product('Book', 29.99)
print(str(p))   # Outputs: Product: Book, Price: 29.99
print(repr(p))  # Outputs: Product("Book", 29.99)

Advanced Use Cases of str()

The str() function in Python is commonly seen in basic operations like conversions and print statements. However, it also has advanced use cases that are important in more complex scenarios. Here, we’ll discuss some of these advanced use cases and understand how str() function fits into larger Python applications.


In the context of logging, str() is frequently used to ensure that the objects being logged are in a human-readable format. Since logs are meant to be reviewed by developers or by a system that expects textual data, using str() on objects before logging is crucial.

import logging

class CustomData:
    def __init__(self, data): = data

    def __str__(self):
        return f'CustomData({})'

data_instance = CustomData(42)  # The __str__ method is called here.

Data Serialization

While Python offers serialization modules like pickle, sometimes you need a simple way to serialize custom objects into a string format for storage or transmission. Implementing a __str__ method allows for a straightforward string conversion that can be reversed (deserialized) if the __str__ is designed carefully.

class SerializableObject:
    def __init__(self, identifier):
        self.identifier = identifier

    def __str__(self):
        return f'SerializableObject({self.identifier})'

    def from_str(cls, string):
        identifier = string.split('(')[1].rstrip(')')
        return cls(identifier)

# Serialize
obj = SerializableObject('id123')
serialized_str = str(obj)

# Deserialize
new_obj = SerializableObject.from_str(serialized_str)

Working with Web Frameworks

In web development with frameworks like Django or Flask, converting objects to strings becomes necessary when generating HTML dynamically. Here, str() can be used to convert context data to a string format that can be inserted into templates.

from flask import Flask, render_template_string

app = Flask(__name__)

def index():
    my_data = {'key1': 'value1', 'key2': 'value2'}
    # The str() function converts the dictionary into a string
    # which can then be embedded or manipulated within the HTML
    return render_template_string("<div>{{ data_str }}</div>", data_str=str(my_data))

if __name__ == "__main__":

API Development

When creating APIs, especially RESTful services, it’s often necessary to convert complex objects to strings in order to format them as JSON or XML. This is particularly the case when dealing with models or data structures that are not directly serializable by libraries like json.

from flask import Flask, jsonify

app = Flask(__name__)

class APIObject:
    def __init__(self, name, value): = name
        self.value = value

    def __str__(self):
        return f'{{"name": "{}", "value": {self.value}}}'

def get_data():
    obj = APIObject('sample', 100)
    # The APIObject is not JSON serializable, but its string representation is.
    return jsonify({'data': str(obj)})

if __name__ == "__main__":

Test Assertions

When writing tests, especially unit tests, you may need to assert the equality of complex objects. By providing a __str__ method, you can simplify these assertions and produce readable test failure messages.

import unittest

class TestCustomData(unittest.TestCase):
    def test_str(self):
        data_instance = CustomData(42)
        self.assertEqual(str(data_instance), 'CustomData(42)')


In these advanced scenarios, the str() function is often implicit, and it’s the __str__ method on the objects that is doing the heavy lifting. A well-designed __str__ method can make objects more friendly for logging, serialization, web contexts, APIs, and testing, contributing to the robustness and maintainability of the codebase.


The str() function in Python is an essential tool for converting objects into strings. Whether for display purposes, logging, or as part of string manipulation operations, understanding how to use str() effectively is a vital skill for Python developers. With the ability to customize its behavior, str() becomes even more powerful, allowing developers to define clear and readable representations for their custom objects, leading to more maintainable and intuitive code.

Leave a Reply