You can nest expressions to evaluate inside expressions in an f-string. This means you can move the ternary right inside your f-string:

string = f'I am {num:{".2f" if ppl else ""}}'

Note the additional pair of braces needed for nesting.

But I don't think this is cleaner. Personally I find it harder to parse what's going on here, as opposed to your clear original version. After all simple is better than complex; flat is better than nested.

Can this be cleaner? Certainly. def combat(player, enemies, ultimate=False): actions = [ f'Attack - Attack for 1d{player.attack}', f'Cast {player.spell_name}: Cost - 10 mana', f'Heal - Restore 1d10 + {player.spell_power//2}: Cost - 5 mana', f'Drink Mana Potion - Restore mana equal to 1d6 + {player.spell_power}' ] if ultimate: actions.append( f'Use {player.ultimate}: {player.mp // 2 if player.name == "Paladin" else "No"} Mana' ) while True: ... How's that?

Both ternaries ("if expressions") and comprehensions ("for expressions") are allowed inside f-strings. However, they must be part of expressions that evaluate to strings. For example, key: value is a dict pair, and f"{key}: {value}" is required to produce a string.

>>> dct = {'a': 1, 'b': 2}
>>> newline = "\n"  # \escapes are not allowed inside f-strings
>>> print(f'{newline.join(f"{key}: {value}" for key, value in dct.items())}')
a: 1
b: 2

Note that if the entire f-string is a single format expression, it is simpler to just evaluate the expression directly.

>>> print("\n".join(f"{key}: {value}" for key, value in dct.items())))
a: 1
b: 2

Expressions inside format strings still follow their regular semantics. For example, a ternary may test whether an existing name is true. It will fail if the name is not defined.

>>> c, name = "Hello", ""
>>> f'{c} {name if name else "unknown"}'
'Hello unknown'
>>> del name
>>> f'{c} {name if name else "unknown"}'
NameError: name 'name' is not defined

str(None) is not None, but "None". So without that useless and harmful stringification:

foo = "soner test " \
f"{str(obj['my_str_index']) if obj['my_str_index'] is not None else 'null'}"

EDIT: A more legible way (note that interpolation in an f-string automatically stringifies, so we don't need str at all):

index = obj['my_str_index']
if index is None:
    index = "none"
foo = f"soner test {index}"

EDIT: Another way, with the walrus (limited to 3.8+):

foo = f"soner test {'null' if (index := obj['my_str_index']) is None else index}"

Your code actually is valid Python if you remove two characters, the comma and the colon.

>>> gender= "male"
>>> print "At least, that's what %s told me." %("he" if gender == "male" else "she")
At least, that's what he told me.

More modern style uses .format, though:

>>> s = "At least, that's what {pronoun} told me.".format(pronoun="he" if gender == "male" else "she")
>>> s
"At least, that's what he told me."

where the argument to format can be a dict you build in whatever complexity you like.

You can keep the condition inside the f-string if you use two of them, the 2nd one for the a:.2f

print(f'{f"{a:.2f}" if b else ""}')

The first line is testing if the words "base 10" are part of the string that the "err" object will print out. That's a good test since it's one of the most awkward parts of the standard message. The "err" was received in the "except" by using the "as" operator. The other part is an "f-string". It is essentially a more compact syntax for what you might do using the "format" function. For more details, see the section on Formatted string literals (https://docs.python.org/3/whatsnew/3.6.html#pep-498-formatted-string-literals) in the online documentation or the page on Literal String Interpolation (https://www.python.org/dev/peps/pep-0498/) in the PEP guide.

F strings are just a nice way to insert variables into a template string. Yes, there are other ways - but f strings are usually the best. What way would you use instead?