String.format()

Table of Contents

Although string.format() is generally slower than f-strings, it has a few unique capabilities that cannot be replicated, primarily due to its dynamic nature.

We use f-string and string.format() for string formatting. And both have differ in syntax, readability, performance and capabilities.

	`f-string`	`string.format()`
Syntax	Use a concise syntax with an `f` prefix	Use placeholders `{}` in the string with arguments to the `format()`
Readability	More readable and intuitive	Less concise esp with multiple arguments
Performance	Generally faster (evaluated at compile time)	Slower (involes method calls and runtime processing
Flexibility	Directly embed expressions	Supports positional, keyword, and indexed placeholders (more control)
Debugging	Handle error at runtime	More forgiving with missing arguments or handled dynamically

Why String.format()?
#

Here are the a few capabilities that only work in string.format().

Dynamic Placeholder Reuse:

template = "{0} loves {1} and {0} also loves {2}"
result = template.format("Alice", "Bob", "Charlie")
# Output: Alice loves Bob and Alice also loves Charlie

Dynamic Template Construction:
- Support storing the template as a string and apply format() later with varying arguments.
```
template = "Hello, {name}!"  # Could come from a file or user input
result = template.format(name="Alice")
```

Advanced Mapping with Dictionaries:

Support unpacking dictionaries directly into placeholders using **kwargs.

data = {"name": "Alice", "age": 30}
result = "Name: {name}, Age: {age}".format(**data)
# Output: Name: Alice, Age: 30

Legacy Compatibility:
- string.format() is available in Python 2.x and earlier versions of Python 3.

Custom Formatting with Custom Specification:

string.format() can be used with custom formatters by overridding the __format__ method.

class Person:
def __init__(self, name):
    self.name = name
def __format__(self, format_spec):
    return f"Person: {self.name.upper()}" \
           if format_spec == "upper" else self.name

person = Person("Alice")
result = "Hello, {0:upper}!".format(person)
# Output: Hello, Person: ALICE!

Conclusion
#

Generally, f-string is preferred for its simplicity and speed. And string.format() can offers unique features like placeholder reuse, dynamic template hanlding, and dictionary unpacking that f-string can’t directly replicate.

For most modern Python applications, f-string is the go-to choice, but string.format() remains relevant for specific use cases that involving legacy code.

Use f-string when: