Hacker News Reader

Comment by TZubiri | Hacker News Reader

Been using python for almost 10 years. I never use any of the funky strings.

Instead of reading like 10 PEPs for f strings, I just use the + operator on strings and backslash escaping, big whoop.

Instead of 10 PEPs, you could read one helpful cheatsheet: https://www.pythonmorsels.com/string-formatting/#cheat-sheet....

Doesn't cover:

- the trailing slash detail detailed in the OP

- raw strings at all

- more complex stuff like raw format strings

Also, my mind is a temple, I don't learn python from cheatsheets from random secondary sources.

age = 32

print(f"Age: {age}")

Thus concludes the lecture on f-strings.

I find it funny and satisfying that Python has converged to it's own "printf", by which I mean print(f"").

It’s unclear what the big advantage is over `print("Age: "+age)`. It’s even more characters, in that specific example.

If age is a number, that won’t work.

Admittedly I’m not so familiar with Python; it does work in Java. In that case, introducing a less hazardous string concatenation operator would seem more universally useful.

In Python, that less hazardous string concatenation operator is an f-string.

I’m assuming you can only use it with string literals, hence it is less universally useful.

Nope, you can put expressions in them:

f'{a} = {functionThatReturnsAButHasSideEffects()}'

Toy examples aren’t the use case, rather multiple variables or expressions, perhaps with formatting (padding) as well.

f-string is shorter, less err prone, and faster for medium complexity or above.

  >>> age = 32
  >>> print("Age: " + age)
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  TypeError: can only concatenate str (not "int") to str

  >>> print("Age: " + str(age))
  Age: 32

As a side note, I always found it amusing that Python is dynamic but doesn't let you do this, while C# has static typing but lets you do string + number. (I looked into it a while back, I think it's because both are Object, so it does operator overloading on Object+Object and then checks the types...)

Right, because x + " " + y is more clear than of simply f"{x} {y}".

Been using python for longer than 10 years and immediately started using f-strings when I could. It takes almost no time to understand the basics.

Personally I do find the first version clearer, because it is based on general language rules.

Especially if you come from other languages. a + " " + b will be clearer to devs that aren't senior python developers. the f string thing is just a marginal improvement at the cost of alienating other devs. But it's great for gatekeeping and job security.

> come from other languages

According to Wikipedia[1] the history of string formatting goes back to 1950s. Also, basically every major programming language these days implements it in some form.

[1] https://en.wikipedia.org/wiki/Printf

> senior python developers > great for gatekeeping and job security

Ah, okay, it's just a troll.

But the link you shared describes a syntax that is very different.

"%T", T t

  not "{ (expr).__str__()} "

> Ah, okay, it's just a troll.

If that helps you sleep at night

Reply on news.ycombinator.com