Forem: Amoh Gyebi Ampofo

F-Strings: The Ultimate Cheatsheet for Python String Formatting

Amoh Gyebi Ampofo — Sun, 13 Jul 2025 18:53:34 +0000

String formatting is an essential tool in any Python developer's toolbox. F-strings (formatted string literals), introduced in Python 3.6, are a modern and powerful update to traditional string formatting methods. They are faster at runtime, more readable, and more concise. Once you start using them, you likely won't go back.

First, let's briefly look at the older methods f-strings improve upon.

The str.format() method:

brother = "John"
sister = "Jane"

print("Hello, {0} and {1}".format(brother, sister))

String concatenation with +:

folder = "/home/user/john/movies"
filename = "Big Buck Bunny.mp4"

print("The folder name is '" + folder + "' and the filename is '" + filename + "'.")

The modulo operator % (C-style formatting):

print("The number %s is %d." % ("nineteen", 19))

All these methods work, but they can be verbose and hard to read, especially with multiple variables.

The Power and Simplicity of F-Strings

Now, let's see how f-strings can simplify the previous examples. You create an f-string by prefixing the string with the letter f or F.

Replacing str.format():

brother = "John"
sister = "Jane"

print(f"Hello, {brother} and {sister}")

Replacing concatenation:

folder = "/home/user/john/movies"
filename = "Big Buck Bunny.mp4"

print(f"The folder name is '{folder}' and the filename is '{filename}'.")

The output for both examples is identical to the originals, but the code is much cleaner.

Evaluating Expressions Inside F-Strings

You can even evaluate Python expressions directly inside the curly braces {}.

Function calls:

import os

fullpath = "/home/user/john/movies/Big Buck Bunny.mp4"

print(f"The directory is: {os.path.dirname(fullpath)}")

Math expressions:

x = 10
y = 5

print(f"Ten plus five is {x + y}, not {x - y}.")

Displaying Literal Curly Braces

If you need to include literal curly braces in your output, you can escape them by doubling them up ({{ or }}).

value = 42
print(f"The value is {{{value}}}")

Output:

The value is {42}

Debugging with F-Strings: Showing Variable Names and Values

F-strings have a powerful feature for debugging. By adding an equals sign = after a variable, you can print both the variable's name and its value.

Instead of writing this:

this_is_a_long_variable_name = "some text"

print('this_is_a_long_variable_name =', this_is_a_long_variable_name)

You can simply write this:

this_is_a_long_variable_name = "some text"

print(f"{this_is_a_long_variable_name=}")

Output:

this_is_a_long_variable_name='some text'

Using Format Specifiers

All format specifiers from the str.format() method are also compatible with f-strings. They follow the colon : inside the curly braces. These specifiers are part of Python's Format Specification Mini-Language.

Formatting Numbers

You can easily format large numbers with separators for readability.

total = 1000000

print(f"Your new balance is: ${total:,}")

Output:

Your new balance is: $1,000,000

Controlling Decimal Precision

You can control the number of decimal places shown for floating-point numbers.

pi = 3.1415926535

print(f"Pi rounded to two decimal places is: {pi:.2f}")

Output:

Pi rounded to two decimal places is: 3.14

Padding and Alignment

You can align text within a certain space and choose a character for padding.

^ centers the text.
< left-aligns the text.
> right-aligns the text.

print(f"{'start':*^50}")
print(f"{'Next':=<50}")
print(f"{'Previous':_>50}")
print(f"{'End':^50}")

Output:

**********************start***********************
Next==============================================
__________________________________________Previous
                       End

String Representations: `!s` and `!r`

F-strings allow you to specify which representation of an object to use: !s for str() (the default) and !r for repr().

from datetime import datetime
now = datetime.now()

print(f"Using !s: {now!s}")
print(f"Using !r: {now!r}")

Output:

Using !s: 2025-07-13 18:29:00.123456
Using !r: datetime.datetime(2025, 7, 13, 18, 29, 0, 123456)

Comments in F-Strings (Python 3.12+)

Starting with Python 3.12, you can add comments inside an f-string expression. The comment must start with a # and appear at the end of the expression.

value = 123.456
print(f"The value is {value:.2f # Round to 2 decimal places}")

Output:

The value is 123.46

Thank you for reading.

Buy my book on How not to become a broke software engineer on Gumroad or Amazon.

A Practical Guide to Python's @property Decorator (with Examples)

Amoh Gyebi Ampofo — Sun, 13 Jul 2025 17:58:47 +0000

This tutorial is for intermediate Python learners who are already familiar with simple Python syntax, such as if...else statements.

What is `@property`?

The Python @property decorator is used to turn a method into a property. This means you can interact with the method as if it were an attribute. For instance, you can assign a value to it with person.salary = 4500 or access its value without using parentheses, like print(person.salary). This is all possible if the method has been decorated with @property.

Why Would You Want to Use `@property`?

The @property decorator is particularly useful when you have an attribute that requires validation or sanitization to prevent corruption. For example, imagine you have a percentage value that needs to be displayed on a user interface. To fit your UI design, you might want to ensure it always has a maximum of two decimal places. You could add extra code to trim the value accordingly:

percent = 3/2346 * 100  # 0.1278772378516624
percent = float(f'{percent:.2f}') # Corrected to use f-string for formatting

You could encapsulate this logic in a function or method:

def calc_percent(old) -> float:
    return float(f'{old:.2f}') # Corrected to use f-string for formatting

But what if you could set a new value to it and access it just like a variable?

calc_percent = 15
print(calc_percent)

This can be achieved by using the @property decorator on a class method. You will need two methods: one that Python uses to set the value (the setter) and another to get the value (the getter). We will discuss this in the "How" section.

When Should You Use `@property`?

There are various instances where using a @property is beneficial. Some common use cases include when you want to:

Make a property read-only.
Prevent the deletion of a property.
Ensure all elements in a collection are homogeneous.
Prevent your code from breaking because a property doesn't exist or a list is empty.

How to Use `@property`

To use the @property decorator, you must work with methods inside a class.

Turning a Method into a Property

With the @property decorator, you can make a method behave like an attribute.

class ProgressReport:
    def __init__(self) -> None:
        self._progress = 19

    @property
    def progress(self):
        return self._progress

reporter = ProgressReport()
print(reporter.progress)

Output:

In the code above, progress becomes a property. When you access reporter.progress, it calls the progress method and returns the value of self._progress. The _progress attribute is treated as a private property by convention. The leading underscore signals to other developers that it should not be set directly.

Printing the type of the property shows no trace that it is a method:

print(type(reporter.progress))

Output:

<class 'int'>

The property decorator also allows you to define a "setter" method, which is called whenever you assign a value to the property. This enables you to control how values are set.

class ProgressReport:
    def __init__(self) -> None:
        self._progress = 19

    @property
    def progress(self):
        return self._progress

    @progress.setter
    def progress(self, value):
        if 0 <= value <= 100: # More Pythonic range check
            self._progress = value
        else:
            raise ValueError("Progress must be a value between 0 and 100") # More specific exception

reporter = ProgressReport()
reporter.progress = 500
print(reporter.progress)

Output:

Traceback (most recent call last):
  File "C:\Users\Ampofo\property.py", line 19, in <module>
    reporter.progress = 500
  File "C:\Users\Ampofo\property.py", line 16, in progress
    raise ValueError("Progress must be a value between 0 and 100")
ValueError: Progress must be a value between 0 and 100

In this example, we ensure that the property can only be set if the new value is between 0 and 100.

Making a Property Read-Only

You can make a property read-only by defining a setter that always raises an exception, preventing its value from being changed directly. However, you can still modify the underlying private attribute within the class.

Here, we create a method, update_progress, that we use to update the value of the property internally.

class ProgressReport:
    def __init__(self) -> None:
        self._progress = 19

    @property
    def progress(self):
        return self._progress

    @progress.setter
    def progress(self, value):
        raise AttributeError("progress is read-only") # More appropriate exception

    def update_progress(self, value):
        # You might add validation here as well
        if 0 <= value <= 100:
            self._progress = value
        else:
            raise ValueError("Progress must be a value between 0 and 100")

reporter = ProgressReport()
reporter.update_progress(96)
print(reporter.progress)
reporter.progress = 99

Output:

96
Traceback (most recent call last):
  File "C:\Users\ampofo\property.py", line 20, in <module>
    reporter.progress = 99
  File "C:\Users\ampofo\property.py", line 12, in progress
    raise AttributeError("progress is read-only")
AttributeError: progress is read-only

If you do not intend to allow any modifications, you can omit the setter and any internal update methods entirely.

Controlling Deletion

You can also control the deletion of a property using @progress.deleter.

class ProgressReport:
    def __init__(self) -> None:
        self._progress = 19

    @property
    def progress(self):
        return self._progress

    @progress.setter
    def progress(self, value):
        raise AttributeError("progress is read-only")

    @progress.deleter
    def progress(self):
        print('Performing housekeeping before deletion...')
        del self._progress

reporter = ProgressReport()
del reporter.progress
print(reporter.progress)

Output:

Performing housekeeping before deletion...
Traceback (most recent call last):
  File "C:\Users\ampofo\property.py", line 25, in <module>
    print(reporter.progress)
  File "C:\Users\ampofo\property.py", line 8, in progress
    return self._progress
AttributeError: 'ProgressReport' object has no attribute '_progress'

As you can see, we performed some housekeeping tasks before deleting the property. If we wanted to prevent its deletion entirely, we could have simply not included the del self._progress line in the deleter method.

When Not to Use `@property`

In instances where you want to control the behavior of a container like a list or a dict, the @property decorator is not the right tool. But that shouldn't stop us! As developers, we find solutions to every problem. Python allows you to customize any type by subclassing it. We can subclass list and dict and add our modifications.

Customizing Lists

Normally, trying to access a non-existent index in a list results in an error:

list1 = [1, 2, 3]
print(list1[5])

Output:

Traceback (most recent call last):
  File "C:\Users\ampofo\property.py", line 2, in <module>
    print(list1[5])
IndexError: list index out of range

By subclassing list, you can create your own list class that changes this behavior. This way, you can prevent your code from breaking when an invalid index is accessed and instead return None.

class MyList(list):
    def __getitem__(self, index):
        try:
            return super().__getitem__(index)
        except IndexError:
            return None

list2 = MyList([1, 2, 3])
print(list2[5])

Output:

None

In the code above, we subclass list by creating a MyList class. We override the __getitem__ method, which is called whenever an item of the list is accessed (e.g., names[0]). Our new implementation returns None rather than raising an IndexError.

You can further customize other methods, like append, to enforce specific rules.

class MyHomogeneousList(list):
    def append(self, value):
        if not isinstance(value, int): # isinstance is the preferred way to check types
            print('This list only accepts integers.')
        else:
            super().append(value)

list2 = MyHomogeneousList([1, 2, 3])
list2.append('4')
list2.append(4)
print(list2)

Output:

This list only accepts integers.
[1, 2, 3, 4]

Customizing Dicts

If you want to modify the behavior of a dict, your best option is also to subclass it and introduce your alterations.

class MyDict(dict):
    def __setitem__(self, key, value) -> None:
        print(f"Inserting {key}")
        return super().__setitem__(key, value)

    def __getitem__(self, key):
        if key not in self:
            print(f"Key: '{key}' does not exist.")
            return None
        return super().__getitem__(key)

    def __delitem__(self, key) -> None:
        if key == 'admin':
            print("You can't delete the 'admin' entry.")
            return
        return super().__delitem__(key)

dict1 = MyDict({'admin': 'active'})
print(dict1['johndoe'])
dict1['janeaustin'] = 'inactive'
print(dict1)
del dict1['admin']
print(dict1) # Added to show the entry was not deleted

Output:

Key: johndoe doesn't exits
None
Inserting janeaustin
{'admin': 'active', 'janeaustin': 'inactive'}
You can't delete admin entry

Read more here
Buy my book on How not to become a broke software engineer here

Cover Photo by Tai Bui on Unsplash
Thank you for reading.

I Was an 'Expert' in Vanilla JS and Couldn't Get Hired. Here's Why

Amoh Gyebi Ampofo — Sat, 12 Jul 2025 17:55:46 +0000

For the first ten years of my software career, I was convinced that my deep passion for coding and my expert-level skills in Vanilla JS were all I needed to succeed. I loved what I did, and I was good at it. I was also completely wrong, and it left me with a decade of regrets.

After a series of failed interviews, I had to face a hard truth: the skills I loved weren't the skills employers were willing to pay for. If you're currently teaching yourself to code or feeling stuck in your junior role, I wrote this for you.

My first turning point came from a single sentence an employer said during an interview: "We aren't hiring people to build frameworks." It finally clicked. Companies don't pay you to reinvent the wheel; they pay you to solve business problems, quickly and efficiently. My niche expertise was a point of pride for me, but it was a liability in the job market.

My second turning point was even more painful. I finally received a job offer, contingent on passing a technical test. "No problem," I thought. "I'm a JavaScript expert." I failed spectacularly. The test wasn't about the niche things I was proud of; it was about core concepts and common libraries I had dismissed as "boring."

Those two failures forced me to admit my entire learning strategy was backward. I was following my curiosity instead of the market. So I threw out my old methods and decided to let job postings become my new textbook. Here are the three practical steps I took that changed everything:

1. I Became a Job Description Analyst. I stopped browsing random tutorials and started analyzing job descriptions. I'd open 20 postings for "React Developer" and put every single required skill into a spreadsheet. The ones that showed up more than half the time? That became my new curriculum.

2. I Focused on Stacks, Not Just Languages. I noticed that no one was just asking for "JavaScript." They were asking for React, TypeScript, Jest, and Webpack together. I stopped learning things in isolation and started learning the entire technology stack that companies actually use.

3. I Learned to Separate Hype from Reality. The tech world is full of hype. "Build once, run everywhere" sounds amazing, but I learned to ask: "Who is actually hiring for this?" I started paying attention to who was asking for the technology. If only brand-new startups were using a new framework, I'd watch it from a distance. But if established, major companies started listing it as a requirement, I knew it was time to take it seriously.

This shift in mindset from 'following my passion' to 'following the market' was just the first step on a long road. It took me years to undo my mistakes and learn the other hard lessons about structured learning, soft skills, and finding mentors.

I documented every lesson and every regret in my new book, 'The Broke Software Engineer: How I Wasted 10 Years So You Don't Have To.' I wrote it to be the guide I desperately wish I'd had when I started.

If my story resonates with you, you can grab the book on Gumroad or Amazon today.

And here's a special request: If you read it and find it valuable, leaving a short, honest review on Amazon would mean the world to me. Reviews are the single most helpful thing for a new author, as they help the book reach more developers who might be on the same frustrating path I was on.

Thank you for reading, and I hope my mistakes can become your shortcut.

Forem: Amoh Gyebi Ampofo

F-Strings: The Ultimate Cheatsheet for Python String Formatting

The Power and Simplicity of F-Strings

Evaluating Expressions Inside F-Strings

Displaying Literal Curly Braces

Debugging with F-Strings: Showing Variable Names and Values

Using Format Specifiers

Formatting Numbers

Controlling Decimal Precision

Padding and Alignment

String Representations: !s and !r

Comments in F-Strings (Python 3.12+)

A Practical Guide to Python's @property Decorator (with Examples)

What is @property?

Why Would You Want to Use @property?

When Should You Use @property?

How to Use @property

Turning a Method into a Property

Making a Property Read-Only

Controlling Deletion

When Not to Use @property

Customizing Lists

Customizing Dicts

I Was an 'Expert' in Vanilla JS and Couldn't Get Hired. Here's Why

String Representations: `!s` and `!r`

What is `@property`?

Why Would You Want to Use `@property`?

When Should You Use `@property`?

How to Use `@property`

When Not to Use `@property`