Not All Arguments Converted During String Formatting: Python TypeError Solved

Are you learning Python and thinking your code looks great while you keep getting the “typeerror: not all arguments converted during string formatting” error? Then you have an issue with your string formatting, but don’t worry. This error is specifically triggered by format specifier formatting errors. Continue reading this guide to find an array of resources to help you learn Python and the basics of string formatting. 

typeerror: not all arguments converted during string formatting error message in Python

String formatting basics

There are three basic formatting techniques that you can use to format Python strings: 

  1. String modulo operator
  2. Formatted string literal (f-string)
  3. String .format() method

The use case for each will mostly depend on the age of your codebase. For example, older codebases (especially in Python 2) are more likely to use the string modulo operator for formatting, whereas newer Python codebases may use f-strings or the .format() method. 

This guide is going to strictly focus on the string modulo operator to find the cause and solutions to the ‘typeerror: not all arguments converted during string formatting’ error. Check out the links at the end of this article if you want to learn more about f-strings or the string .format() method. 

1. String modulo operator 

The string modulo operator is a built-in formatting option that provides an easy way to format strings with positional arguments. Depending on your background, you may already be familiar with this type of string formatting, as it’s very similar to the printf() function in the language C. 

General string(%s) formatting syntax with string modulo operator:

<format_string> % <values>

Example: Basic string injection using the % operator is below:

x = ‘brown

print(“John is %s and has % hair.” % (‘tall’, x)

This will output:

John is tall and has brown hair. 

You can use the modulo operator to inject more than just strings. It’s important to make sure you are using the correct identifiers when injecting. The modulo operator works for simpler expressions, but once you start injecting multiple identifiers, the expression becomes much more difficult to understand. All format specifiers are displayed below:

  • %s – String (or any object with a string representation, like numbers)
  • %d – Integers
  • %f – Floating point numbers
  • – Floating point numbers with a fixed amount of digits to the right of the dot.
  • %x/%X – Integers in hex representation (lowercase/uppercase)

Example: We’ve already covered strings, so let’s add complexity with integers(%d)

Format = “My name is %s and I am %d years old.”

Combine this format string with a tuple or multiple types:

My_info = (“John”, 20)
Alternative_info = (“Jane”, 25)

Now, you can combine this with a print statement to see how the %s and %d are replaced:

>>> print(format % My_info) 
My name is John and I am 20 years old. 

>>> print(format % Alternative_info)
My name is Jane and I am 25 years old. 

Example: Let’s combine a few more modulo specifiers, like floating point numbers, with(%f) and without( a specific number of digits

>>>print(‘Look how I can remove decimal places from this floating point number by using  
the modulo operator: %5.2f’ (5.987654))

The output:

Look how I can remove decimal places from this floating point number by using  
the modulo operator: 5.98

This is because the 2 indicated that only 2 decimal places should be displayed. 

2. Formatted string literal (F-String)

F-strings were introduced with Python version 3.6 (Alpha version August 2016). F-strings were designed to make formatting strings simpler. Instead of requiring a unique specifier depending on the type of string being formatted, a much simpler syntax is involved. F-strings can also be used to call functions, methods, and objects.

General string formatting syntax for F-Strings


Example: Basic F-String formatting

name = ‘John’
age = 20

print(f”My name is {name} and I am {age} years old”)

This will output:

My name is John and I am 20 years old

Example: Formatting with multiline F-Strings

name = ‘John’
age = 20
profession = ‘teacher’
location = ‘Philadelphia’

summary = (
	f”{name} is {age} years old.”
	f”{name} is a {profession} in {location}.”


The output:

John is 20 years old. 
John is a teacher in Philadelphia.

3. String .format() method

The .format() method is another method available for string formatting. As far as speed and ease of use, this method is in the middle. F-Strings are the simplest and most useful method, while the modulo operator is the most clunky. 

General string formatting syntax using the .format() method

string.format(value1, value2, value3, …)

Example: Simple .format() method usage. We will use {} to insert with the .format() method tagged on the end of each expression.

introduction = “My name is {name}, and I am {age} years old.”.format(name=”John”, age=  

profession = “I am a {profession} and I work in {location}.”.format(profession=”teacher”, 

Now when you print these two expressions:


You will get the following outputs:

My name is John, and I am 20 years old. 
I am a teacher and I work in Philadelphia.

Example: Using .format() method within a variable and assigned value.

First, create a variable for the string, you want to format:

variable_string = “My name is { }.”

Now, create a print statement where you call the .format() method with the value you want to be injected:


This will output:

My name is John.

What causes the “typeerror: not all arguments converted during string formatting” error?

If you run into the “typeerror: not all arguments converted during string formatting” error, you most likely have an issue with format specifiers. Format specifiers are the unique way to specify how you want strings formatted. 

You can find the three main reasons below:

1. Missing format specifier

When formatting strings, you need to consider the interpolation that is required when running your expressions. If you have a string and are trying to use a math operation on that string, you need to format that string into an integer first. 

2. Format specific and number of values don’t match

If your expression only has a set of number spaces for specifiers, but you are trying to inject more values than that, you will get the “typeerror: not all arguments converted during string formatting.” 

3. Mixing format specifiers

You should use each method for formatting strings separately. It means that within a single expression, you need to decide to use the modulo operator, f-strings, or .format() method. When you start mixing and matching different components within a single expression, typeerrors may pop up.

How to fix the “typeerror: not all arguments converted during string formatting”

1. Check for any missing format specifiers

Below is an example of a missing format specifier that will cause the “typeerror: not all arguments converted during string formatting” error.

x = 6
y = ‘2’
print (x % y)

Notice that x is an integer and y is a string. This will result in the typeerror because you are trying to divide an integer by a string. Instead, you need to add a format specifier so that y is formatted correctly and is treated as an integer. 

The way to correct this:

print(x % int(y))

This will result in the correct output:


2. Check that format specifiers and number of values match

Below is an example showcasing improper usage of specifiers and values. Then you will see how you should do it correctly so that you can check your own code. Let’s revisit an example from above:

name = ‘John’
age = 20
profession = ‘teacher’
location = ‘Philadelphia’

print(“My name is %s, and I am %d years old.” % (name, age, profession, location))

Notice that there are more values listed, name, age, profession, and location, than have matching specifiers in the expression. This is the issue. 

Instead, your expression should look like this:

print(“My name is %s, and I am %s years old.” % (name, age))

With the first expression, you would have gotten the “typeerror: not all arguments converted during string formatting,” but now your output will be:

My name is John, and I am 20 years old.

3. Check if format specifiers have been mixed across methods

Each string formatting method has a slightly different syntax that you must follow to avoid errors. These formatting methods are completely independent of one another. Continue reading to see an example where the specifiers have been mixed, flagging that pesky error message:

name = ‘John’
age = 20

print(“My name is %s, and I am %d years old.”.format(name, age)) 

Notice in the example above, we are using the modulus operator for string formatting in the expression and then using the .format() method to inject. This will not work.

Instead, your expression should read one of these two ways, depending on which method you decide to use:

  • Modulus Operator:
    print(“My name is %s, and I am %d years old.” % (name, age))
  • .format() Method:
    print(“My name is {1}, and I am {0} years old.”.format(name, age)) 

“TypeError: not all arguments converted during string formatting” error solved

If you’ve followed along with this tutorial, you’ve gained a lot of information about learning Python, string formatting methods, and resolving the “typeerror: not all arguments converted during string formatting” error. 

The three main string formatting methods are easy to use when you have a great baseline understanding. But if you’re still having issues with typeerrors, make sure your format specifiers are not missing, mixed, or unequal.

There are so many resources available if you are looking to learn more Python, and you can find the five best recommendations below.

Additional resources for learning Python

With the rising interest in learning a programming language, there is also a growing industry around websites and resources for learning programming languages. Python is a highly popular programming language among beginners because its syntax is easy to learn. Python is great for developing the backend of websites, automating everyday tasks, data analysis, and data visualization. 

Fifteen years ago, the resources for learning Python were limited to a handful of sites and books. Otherwise, you needed to go to college to get a computer science degree or teach yourself. But now, resources for learning Python are highly accessible. Some options are paid, but there are just as many high-quality freed options. 

Top resources for learning Python:

There are thousands of other options available online. Just remember that once you have the Python basics, the best way to learn is to build projects yourself. Don’t get stuck in a cycle of endless tutorials. The only way to truly learn programming is by doing. By developing an idea, even a very simple one like a calculator, and working through it, you will learn more than any tutorial can teach you. 

Leave a Comment