[Solved] typeerror: unsupported format string passed to list.__format__

Formatting a list in an incorrect manner gives the ‘typeerror: unsupported format string passed to list.__format__’ error. You may encounter this while working with list-objects. But first, let’s know how the format function works.

What is a type error?

A type error occurs when you are using the wrong type of data. For example, if you try to perform an operation on a string that only works with numbers, you’ll get an error. This can be especially tricky when working with strings that have spaces in them—if you try to use a string like “1234” as a number, it will throw an error.

Therefore, in Python, it’s important to make sure that your code is always valid and won’t cause errors due to improper data types.

.format() function

The format function is used to print a string to a specific format. The syntax of the format function is:fmt(string, args). Its syntax can also be written as:

{ }.format(n)

And an example of an easy demonstration is:

str = "{} provides python blogs"
print(str.format("Pythonpool"))

Here, the single formatting method is used. When you’re formatting a string, you can use the format function to create a new string that contains the data you want to display. This can be useful for things like displaying dates or numbers in a readable format.

Also, the format string is a sequence of characters that is used to print values or strings in PPython. For example, if you want to print a string value with any length, then you can use the str() function in Python. This function takes an argument as its input, and it returns a string representation of that argument. In short, it is a sequence of characters that determines how data will be formatted.

What is an unsupported format string?

The Python format string syntax is straightforward: you can use it to print strings, convert them, and more. However, there are some things you should be aware of when working with the format string syntax.

The first thing to note is that strings in Python can be printed with a mixture of positional arguments (e.g., “Hello”) and named arguments (e.g., “str(hello)” ). However, if you use a named argument without also specifying a corresponding positional argument—for example, hello(“world”) —the named argument will be interpolated into your string instead of being assigned to a variable. This is called an unsupported format string because the format function does not know how to handle an unassigned variable in your code.

A second thing to note is that the format function expects its argument to be a single object (e.g., not a list or tuple). You can pass multiple objects into the same format statement by separating each object with commas or semicolons (e.g., “hello = ‘string1’ + ‘string2′” ). But if you try something like this: hello = [“string1”, “string2”] , then Python will raise an exception.

Why you got the ‘typeerror: unsupported format string passed to list.__format__’ error?

We can categorize the origin of this error into two types:

• format() on objects of type list
• Specify the list object as an argument

Example:

list1 = [1,2,3,4]
print(f"List contents are: {list1:04d}")
#will give an error as we have list object as the argument of this function.

Type error with formatted code

If you are getting a type error while using the format function in your code, then it means that there is no support for the format in your Python version. Therefore, check whether your version supports it or not. If yes then try to use it with another module like Numpy or Pandas etc.

Dealing with the typeerror: unsupported format string passed to list.__format__ error

list.format() with correct parameters

It is not that a list and format function aren’t compatible, but you need to write the list.format() function with the correct parameters.

list1 = [1.1888, 2.2777, 3.8883, 4.7774]
# formatting with lists, 2 decimal places
ans = ['{:.2f}'.format(i) for i in list1]
print(ans)

So you will get the following output:

['100.77', '17.23', '60.99', '300.84']

See Also: 2 Causes of TypeError: ‘Tuple’ Object is not Callable in Python(Opens in a new browser tab)

Multiple Lists

In case of multiple lists, say 2, try zipping the respective elements to get the combined list.

l1 = [1,2,3,4]
l2 = [5,6,7,8]
for l1,l2 in zip(l1,l2):
    print('{:5}{:10}'.format(l1,l2))

Here, the braces represent the spacing used while formatting.

1         5
    2         6
    3         7
    4         8

List as a string

Change the list to string type first. You can use the join() method for the same. You can follow the given example:

list1 = [1, 2, 3]
newstr = " ".join(str(i) for i in list1)
print("Contents of list are: {}".format(newstr))

Hence, with the help of this code, you will get the given output:

Contents of list are: 1 2 3
#the list contents are now formatted. The elements of list are separated by #whitespace.

List as tuple

Another approach is to change the list to a tuple first and then use format() to format the list-converted-to-tuple.

l1=[1,2,3]
my_tuple = tuple(l1)
print("Contents of tuple are: {}".format(my_tuple))

In this case, we are no more using a list object. An object of type tuple exists because we changed the list to a tuple. Now, we will obtain the given output:

Contents of tuple are: (1, 2, 3)

Using numpy

You can use the format function in Python with numpy arrays too. Specify the format specifier and to avoid error, use the map function and typecast into a list. The map function will work on all numpy values. In other words, it will take all values of array in consideration i.e. iterate over all values.

import numpy as np
x = np.array([1.9999, 2.7777, 3.66666], dtype=np.float32)
list(map('{:.2f}%'.format,x))

Custom class and then adding __str__ class method

You can use f formatting with __str__ class method. You need to call this function and use f formatting with it.

class Student:
    def __init__(self, s_name, s_age):
        self.name = s_name
        self.age = s_age

    def __str__(self):
        return f'The student's name is {self.name} and age is {self.age}'

A = Student('Sam', 21)
print(str(A))

TypeError: unsupported format string passed to Series.format

While working with the pandas series dataframe, you may encounter this error. This happens due to incorrect formatting of the f format function. To resolve this, you need to map the lambda function to all values, as is given in the example below:

lambda series: series.apply(lambda value: f"{value:,}")

Alternatively, you can also use:

pd.options.display.float_format"{:,}".format

See Also : [Solved] Typeerror: Non-Empty Format String Passed to Object.__format__(Opens in a new browser tab)

TypeError: unsupported format string passed to a tuple.format

In case you get this type of error while working with tuples, you must have formatted the tuples incorrectly. So you can format them individually to get rid of the error. Else, you have to change to str type. Consider the given example for your reference:

data = [[1, "Python"], [2, "Java"], [3, "C"]]
print("{0:16}{1:8}".format("Number", "Name"))
for i in data:
    print("{0:<16}{1:8}".format(str(i), i[1]))

Alternatively, you may use this approach with the print statement. Here we have accessed elements one by one.

print("{0:<8}{1:8}".format(i[0], i[1]))

FAQs

Conclusion

You must have learned about the ‘typeerror: unsupported format string passed to list.__format__.’ There can be several causes of this error, but they mostly revolve around using a list object in an improper manner with a format function.