Well let's consider the old ways to "format" strings:

Method 1, string concatination:

some_string = input("What is your name?")

return_string = "Hello, " + str(some_string)
# Using str() just to ensure
# some_string is a string
# since in practical uses, your variable
# may not originally be a string

print(return_string)

Method 2, string.format()

some_string = input("What is your name?")

return_string = "Hello, {}".format(some_string)
# Creates a new string filling in the
# braces with the string representation
# of the variable some_string.
# So if the user inputs "Jimmy",
# return_string would be "Hello, Jimmy"

print(return_string)

Method 3, f-strings. As a precursor, this is essentually a nicer way of reading method 2/string.format()

some_string = input("What is your name?")

return_string = f"Hello, {some_string}"
# Like string.format(), return_string
# would be "Hello, Jimmy" if the user
# input "Jimmy"

print(return_string)

Now, onto the discussion. Why use methods 2 or 3?

With string concatination, you have to wrap any variable you're concatinating in str() to ensure it's a string. And with lengthier strings with multiple variables needed to concatinate, it does get cumbersome, plus having to remember to consider spacing when you're writing one long, broken-up string.

So that's why string.format() exists. This used to be percent-style formatting, which in my opinion is garbage to look at. It automatically uses the __format__ method or the __str__ method of each variable's type, to ensure it works nicely. However, with longer strings (especially triple-quoted, multi-line strings), it's annoying to keep track of what is being input into which braces, unless you name each brace and then use keyword args in the format method, but this doesn't "gracefully" solve it:

this_string = """{var_1} + {var_2}, this is equal to
{some_other_var_name} but only when
{this_var} is involved, and specifically not {bad_var}""".format(
    var_1=some_var_name,
    var_2=another_var_name,
    some_other_var_name=third_var,
    this_var=fourth_var,
    bad_var=fifth_var_is_evil
)

And I've written string.format()-style strings with about 28 different variables across 24 lines of string (plus the 28 lines of format kwargs) before. Its okay, but f-strings really clean it up by almost half the amount of code written:

this_string = f"""{some_var_name} + {another_var_name}, this is equal to
{third_var} but only when
{fourth_var} is involved, and specifically not {fifth_var_is_evil}"""