I don't think you can really blame Python for it. It's not like the language can (or should) prevent you from writing if something == False, it's perfectly valid code and it does work exactly the same as writing it idiomatically, so there's not really anything truly wrong with it.

That's just the nature of language idioms, you have to learn the "culture" of that language to see how other people using it will expect you to do certain things. I think a good way to learn is to work on a project with more-experienced devs that can review your code and point out when you do things non-idiomatically, and you can also look through the code they're writing to see how they do things.

I have trouble with short-term memory (ADHD), and one of my main issues with OOP in Python is simply forgetting what things are and do, even on small programs. Looking-up essential stuff every 5 to 10 seconds break my "flow", requiring constant "cognitive reboots". I figured a bit more verbosity might help, but, since I'm a beginner, I tend to mimic whatever book, documentation or tutorial I'm following just because I don't know any better.

Your suggestions seem really good, could you maybe point to some layman-friendly articles or documentation that goes over these features?

It’s not possible to write totally side-effect free code in Python, but generally, I try to not use any mutable data types, and if I do, I try to write functions to encapsulate any mutation. I like to pass around functions as first-class objects when it makes sense, such as making use of the key argument for sort, min, and max:

In [12]: words = ['foo', 'bar', 'baz', 'tildes']                                                                                             

In [13]: max(words, key=len)                                                                                                                 
Out[13]: 'tildes'

In [14]: items = [{'foo': 1, 'bar': 2}, {'foo': 1, 'bar': -2}]                                                                              

In [15]: from operator import itemgetter                                                                                                     

In [16]: sorted(items, key=itemgetter('foo', 'bar'))                                                                                         
Out[16]: [{'foo': 1, 'bar': -2}, {'foo': 1, 'bar': 2}]

Here’s an example of a program I wrote to compute Krippendorff’s alpha coefficient, a measure of inter-annotator reliability. I only made one class in that program, and that class is just a convenient namespace for consuming code to inject new delta functions. I actually don’t like my implementation there, and I suppose I could break it out into a separate module, but point was really just that I didn’t want to pollute the global namespace with lots of function names. I could also use a decorator (I did the decorator thing in this program with the Format class). I’m not totally happy with either solution, but they work.

E.g.,

In [1]: from krippendorff import Difference                                                                                                  

In [2]: class MyDifference(Difference): 
   ...:     def foo(self, v1, v2, *args): # v1 and v2 always differ by 1.0
   ...:         return 1.0 
   ...:     def bar(self, v1, v2, *args): # v1 and v2 never differ
   ...:         return 0.0 
   ...:                                                                                                                                      

In [4]: diff = MyDifference(float)                                                                                                           

In [5]: diff.nominal(None, None)                                                                                                             
Out[5]: 0.0

In [6]: diff.foo(None, None)                                                                                                                 
Out[6]: 1.0

In [7]: diff.bar(None, None)                                                                                                                 
Out[7]: 0.0

In [11]: Difference(float, method='ordinal')._delta(1.0, 3.0)                                                                                
Out[11]: 16.0

operator.methodcaller is really neat to allow stuff like Difference._delta which is very convenient for allowing a command line driver to specify which delta method to use by interpreting a string argument as a class method name. If you are interested in writing functional Python, I highly recommend checking out the operator, functools, and itertools modules from the standard library.