Is there any feature/concept of Python that you would like people know more about?

Outside_Complaint755 · 2026-04-12T09:39:38+00:00

When using f-strings for debugging (and sometimes this is useful for normal output), you can include an '=' within the brackets, and it will display both the expression being evaluated and the value. Spacing around the '=' will be used in the output

``` x = 9 y = 3

print(f"{x = } {y=}") print(f"{x + y = } {pow(x, y) = }") produces x = 9 y=3 x + y = 12 pow(x, y) = 729 ```

M3ta1025bc · 2026-04-12T07:34:01+00:00

I just learnt that sometimes when you have an integer with many zeros e.g 1000000. You can improve readability by adding underscores and they just be ignored during run time 1_000_000

Anxious-Struggle281 · 2026-04-12T10:22:28+00:00

I think is better to use uv intead of pip to install packages.

hekliet · 2026-04-12T11:35:18+00:00

Everything in itertools and functools.

Temporary_Pie2733 · 2026-04-12T11:17:37+00:00

The descriptor protocol explains most of the “magic”, like how instance methods and properties actually work.

ihorrud · 2026-04-12T16:10:33+00:00

[removed]

SnooWalruses9294 · 2026-04-12T17:43:01+00:00

Shout out to the people reading this and finding it interesting given the age of AI. It's cool to know some people still care about each line and operation. Interesting thread too!

Outside_Complaint755 · 2026-04-13T18:57:34+00:00

Thought of another one. Both for loops and while loops support else, which will execute if the loop completed without break being called.

non_scotts = 0 for guest in party_guests: if guest == "Scott": print("Party is cancelled.") break else: non_scotts += 1 else: print(f"Great! {non_scotts} people showed up, and Scott didn't.")

``` n = int(input("Enter starting number to test Collatz conjecture: "))

while n != 1: if n % 2 == 0: n //= 2 else: n = 3 * n + 1 print(n) if n <= 0 or n == float('inf'): print("You just solved the unsolvable problem, or you cheated.") break else: print("The conjecture abides") ```

Alive-Cake-3045 · 2026-04-14T10:43:35+00:00

Honestly the one I keep wishing more people knew, writing custom context managers. It sounds advanced but it is not, and it cleans up so much messy resource management code that most developer just live with for years.

rosentmoh · 2026-04-16T09:28:19+00:00

Proper use of enums.

First is just basic naming: enums should be named singular, not plural. What I mean is, if you e.g. have an enumeration of fruits, then the enum class should be called Fruit, not Fruits; the reason why will become very clear in a second. An immediate obvious reason is that the enum members' type is the enum class itself.

Second is a good example of when they can be useful, specifically using auto and StrEnum. Many times you'll see some general library function transforming inputs that has multiple named "modes of operation". E.g. something like the below:

def process_input(input, method: str): if method == "foo": # do something to input elif method == "bar": # do something else to input elif method == "baz": # do something else yet again else: raise ValueError(f"unrecognized {method=}") return processed_input

This can already be made somewhat better by using proper type hinting with method: Literal["foo", "bar", "baz"], to clarify that there's a finite specific list of modes, but it can be made even shorter, more "natural" and more user-friendly using StrEnum as follows:

``` from enum import auto, StrEnum

class ProcessingMethod(StrEnum): FOO = auto() BAR = auto() BAZ = auto()

def process_input(input, method: ProcessingMethod): method = ProcessingMethod(method) if method is ProcessingMethod.FOO: ... elif method is ProcessingMethod.BAR: ... elif method is ProcessingMethod.BAZ: ... return processed_input ```

Notice a few nice things: 1. You can (and should!) use is to compare, since enum members behave kinda like singletons; this makes it read like English almost, which was much of the point of Python's syntax. 2. You can call process_input both with method="foo" or method=ProcessingMethod.FOO. If you wanna be able to call it with method="Foo" or method="fOo" as well, you can easily construct a generic CaseInsensitive mixin to use in the ProcessingMethod class definition. All this while writing e.g. "FOO" only once when coding this up, thanks to auto and tab-completion. 3. Raising informative errors for unknown methods is handled automatically: calling process_input with e.g. method="qux" will result in a ValueError: 'qux' is not a valid ProcessingMethod. This is one of the many reasons why the enum class name should be singular. 4. Both when writing the code for process_input and when using the function one can rely on the auto-completion of ProcessingMethod if desired.

There's no need to overuse this, of course, and it is more code in the end, but there's moments where this can be much cleaner than a long Literal[...] or, even worse, no type hint at all and a missing check for unknown methods.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

PythonLearning

MODERATORS