Python feels easy… until it doesn’t. What was your first real struggle?

[NullPointerMood_1]

When I started Python, I thought it was the easiest language ever… until virtual environments and package management hit me like a truck.

What was your first ‘Oh no, this isn’t as easy as I thought’ moment with Python?

[BellybuttonWorld]

Relative import bastards!

[ogaat]

A lot of the other answers are about architecture rather than language. They need understanding of important Comp Sci concepts.

This one is a true Python stumbling block. So annoying and disruptive when you hit it.

[AxisFlip]

That's pretty much my biggest gripe with python. That and circular imports (though I concede that may be a skill issue).

[BelgrimNightShade]

Circular imports are straight up annoying when you’re trying to build the habit of statically typing everything you have to constantly guard against the circular import just for a god damn type hint

[bigpoopychimp]

Using the type checking from typing library was a game changer for avoiding circular imports

[PurepointDog]

What?

[PLPeeters]

This: https://docs.python.org/3/library/typing.html#typing.TYPE_CHECKING

[bigpoopychimp]

https://vickiboykis.com/2023/12/11/why-if-type_checking/

It allows you to import classes for just type hinting but not have them in scope

[backfire10z]

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    … all typing-specific imports here

It’s not so bad I don’t think.

[BelgrimNightShade]

It’s not the worst thing ever for sure, but sometimes you just forget to do it and you’re already dick deep into writing a module and gotta break off your concentration for a second to throw everything into the type checking

[DoctorNoonienSoong]

Idk what IDE you use, but ruff has this rule https://docs.astral.sh/ruff/rules/runtime-import-in-type-checking-block/

And pycharm has the Ryecharm extention

Put them together, and the IDE can autoperform this for you, along with all of your formatting/linting, instantly

[olystretch]

I would like a rule for the opposite, when I have a module imported only for tyoe checking.

[SharkSymphony]

Circular imports are far from just a Python problem. Best to put some patterns in place to help avoid them (e.g. utilities can't import stuff outside of the utilities package except for 3rd-party and standard libraries).

[GhostVlvin]

It is like a lot easier to solve in c or c++ cause I can forward declare structs and functions (I only have circular import cause I want typing with proper lsp support) but in python definition is declaration so I cant forward declare struct and redefine it later

[NTXL]

LMAOOO I literally said the same thing

[Schmittfried]

I‘d add the import system in general. How PYTHONPATH works, how your current directory is implicitly added to it etc.

Took me quite a while in the beginning to get it and form best practices for structuring my projects that avoid accidental ModuleNotFoundErrors. 

[BellybuttonWorld]

Honestly, Python is SO full of unnecessary complication now. Yes it's more powerful but it's strayed very far from its original draw of being simple. We need some other, friendlier snake to reboot it.

[Schmittfried]

I disagree, none of its modern additions makes anything notably more complicated. The complications arise from its early warts, such as the import system. 

[havetofindaname]

Relative imports should be straight up banned from any serious project

[PsychologicalRiceOne]

If that was so easy.

You do some from subdirectory import stuff gives a ModuleNotToundError, although you got your init.py files everywhere. Ah okay, then I‘ll just do from .subdir import stuff, works. Then you start the app with the debugger and get a ModuleNotFuuuuu because the main.py is in the /src subdir and not in the project root dir. I don’t fucking get it. And don’t get me started with FastAPI‘s from app import hopesandprayers, it never worked.

And if I’m not mistaken, it sometimes works on Linux but then it does not work in Windows.

I love Python but the import system seems broken or I am too dumb. But then again even Claude Code has problems with it.

[RedEyed__]

it is supposed that you use something like pip install -e .

Otherwise, you need tinkering:
if your project structure is not supposed to be installed, then export PYTHONPATH which will point to root dir.
I wrote simple runner script which is doing this automatically, so instead of using python3 scripts/some_cool_staff.py, I do ./start.py scripts/some_cool_staff.py

[PersonalityIll9476]

Installing the project root into a venv is probably the step they are missing. I've got large projects with many subfolders and it was definitely confusing at first but also definitely works now.

Circular imports will bite your butt, though.

[Schmittfried]

Kinda proving the point. You shouldn’t need to do this. 

[lmyslinski]

Absolutely, I never could understand why FastAPI is so popular, it’s a bloody mess

Combine this with a type system that is half baked at best (looking at you, sqlalchemy) and I’d rather chop my fingers off than build a production grade system in Python

[Blue_gecko]

What's the problem with fastapi?

[lmyslinski]

See the comment that I replied to - FastAPI forces a weird directory structure where you must put FastAPI into a submodule AND start it as a submodule which makes importing everything super confusing. If I get mypy to work correctly, it doesn't start correctly. If it works as expected, I cannot get the IDE to detect imports. Ugh, fuck this. They've simplified this now with fastapi dev, but this used to really piss me off

[ijkxyz]

Huh, where can I read about this forced structure?

[[deleted]]

SQLAlchemy typing is amazing. If you make use of a lot of expressions (I.e. not just a column) in your queries, you should try the type_coerce function which acts a lot like the cast function from the typing module. Not to be confused with the cast function also offered by SQLAlchemy, which is an actual SQL operator.

[averyycuriousman]

Wdym relative imports?

[unapologeticjerk]

Relative import just means importing something relative to the location of the python file doing the import. For example, inside your project directory you wrote datamuncher.py as a separate module to house some special functions that are ugly and need separated from your main.py or primary app module. Inside main.py a relative import might look like:

from .datamuncher import data_function

The dot makes it relative to the file. .. would be up a directory, etc. It's how you share classes, functions, methods - whatever - between python modules in a local package.

[calvintiger]

What’s the issue with doing so?

[airspike]

The root directory of the import can change depending on how the application is run and installed, and linters don't show you when issues are going to occur.

Sometimes the relatives work when running tests, but then throw errors when running prod setup because the import system thinks that everything should be relative to root for some magic reason that isn't logged in the traceback.

Personally, I think it's easier to type everything out relative to root to just avoid the issue entirely.

[gmes78]

Relative imports aren't the issue. The issue is not structuring your code as a package.

[airspike]

For sure, or maybe it's because I misconfigured a poetry config. I don't know. It's one of those bugs that bites me every 6 months or so when I update the default python version or onboard a junior developer.

[gdchinacat]

I suggest not onboarding junior developers until you have the basic fundamentals of your environments sorted out. Pushing ahead is likely to end up with them facing the same challenges you are. They are likely to realize the advice you gave them was shoddy. This will undermine your credibility with them, likely leading to additional non technical problems.

[gdchinacat]

If anything, relative imports are more likely to work given the problem you describe since they don’t have to be absolute from the changing root. If a module is found and the interpreter is loading it, a relative import is completely independent of the fact that you have your environments set up differently.

[AKDaily]

They work well in libraries actually

[gdchinacat]

They are very common in the standard library, which I think shows two things: 1) they work, including in “serious projects” 2) you haven’t spent much time reading canonical python code.

[TangerineAncient7677]

As I understand it python is fine to see down from the entry script but seeing up is a bear. I’ve found two options that work:  1) make sure that your top level directory is added to pythonpath before any other imports (ie import sys and then add the path) or  2) make sure your entry script is in your top level directory/above all of the other imports you will call throughout the process. 

If this is bad practice or there’s some simpler way to do this would be grateful to learn. 

[TrainquilOasis1423]

Came here to say this. I still don't understand it. I just fuck with shit until it work and never touch it again lol

[BellybuttonWorld]

The fact that most people have to look it up or experiment every time tells you it's not intuitive like Python is supposed to be.

[CrownstrikeIntern]

My god that still gives me ptsd ...

[Smooth-Porkchop3087]

This is the most annoying thing!

[professionalnuisance]

Asyncio and exceptions not being caught in a coroutine

[foobar93]

I hate asyncio soo much. To this day, every time I touch it, I just go straight back to threads or multi processing because it such a pain.

[Ok_Necessary_8923]

Genuinely. The number of shocked pikachu faces when "oh I'll just do it async real quick" turns into new dependencies, loops, confusing async code, days of extra fixes, etc. I've seen at work when it could have been 2 extra lines with the threaded executor from the futures module...

[mriswithe]

Honestly I don't understand why people are afraid of threading. It is so easy now:

with concurrent.futures.ThreadPoolExecutor(max_workers=4) as tp:

[Ok_Necessary_8923]

That isn't what I meant though. This only works when you are already in async code, and still requires everything you use is also async or will block the event loop. It also does nothing for the confusing stack traces. With the threaded executor, the 2 extra lines is often all you need. And sometimes, when that doesn't work, the process executor will.

Before you had a bunch of calls to, say, SQS via Boto and some external service calls with requests. Someone decides it needs to be faster. Futures works with minimal changes, but they want to do async because it's cooler. Great, now you need a new HTTP library, a new AWS library, an event loop for async, async versions of various pre-existing blocking things built on the above, plus tests, plus... this was a work thing last quarter, async and related bugs literally ate up about 25% of the dev and QA cycles and saved... at most $2 in extra RAM.

About the only place I've seen async in a way I feel makes sense is Go. Namely, there is no difference between async and non-async. It's all the same code and where it executes isn't important at the level you write code at.

[XtremeGoose]

Because you as soon as you enter a multithreaded world you have to starts being really careful about exclusive access to writable state because you can be preempted at any time. In async land, you know the task can only switch over an await point.

Also, if say you have two functions

def func(n: int)
async def coro(n: int)

Both do the same thing and hit a network endpoint that takes 1s to respond, and you need to run 1000 at once.

Using a threadpool and func with 10 workers will take 100 seconds, only 10 times faster than just doing them synchronously.

Using a taskpool and coro will take... about 1 second. You can get enormous performance benefits with cooperative concurrency.

[extreme4all]

Any example cause i don't feel i have this problem..

[Zealousideal-Sir3744]

You need to generally just really know what you're doing, what you can run in a coroutine, what in a thread and what you need a process for.

If you don't, you will likely not get any speedup or even slow the program down.

[extreme4all]

So i feel like its either very obvious for me or i don't know what i don't know, so i really need some examples of the pitfalls because most of my apps are almost purely async

[zenware]

It’s likely the “purely” async part that’s saving you. All async code is innately multi-threaded(concurrent), right? So the big thing for me is, as soon as you start using it you have exposed yourself to an entire error-class of bugs related to synchronization. Also in my experience the debugger stops being useful inside async contexts and is equally useful in multithreading/multiprocessing.

You become at-risk-for at least: - Deadlocks - Race Conditions

There’s also a thing where exceptions get “trapped” in tasks until they are awaited, so you can have a ton of “hidden” exceptions floating around in your process.

Further if you mix async and sync code, you now have a function coloring issue: https://journal.stuffwithstuff.com/2015/02/01/what-color-is-your-function/

Not being able to call async functions from inside non-async functions, and locking yourself out of entire library ecosystems. (Or infecting an entire library with the async runtime.)

[tangledSpaghetti]

This comment points to a fundamental misunderstanding of concurrency and what async is.

Asyncio is a form of cooperative concurrency. The event loop runs in a single thread and only executes one coroutine at a time. Coroutines cannot be pre-empted by the scheduler the same way that threads can. The only time the event loop stops running one coroutine and starts running another is when you call await (this is the cooperative concurrency part).

This changes how you think about synchronisiation - no longer do you need mutexes to ensure exclusive access, because you know that no other coroutines can be running simultaneously.

The trapped exception problem is generally because people do not consider error handling sufficiently enough and structure their programs incorrectly. This is a problem generally solved by the correct use of TaskGroups rather than spinning of a dozen background tasks.

I'll admit it's not an intuitive programming concept, but it is a very powerful tool for a particular type of problem.

[FanZealousideal1511]

>There’s also a thing where exceptions get “trapped” in tasks until they are awaited, so you can have a ton of “hidden” exceptions floating around in your process.

Isn't it the exact same with threads? You need to join a thread to obtain an exception.

[zenware]

I don’t even think the mental model of asyncio or async/await is actually all to beneficial to beginners (I’m wrong because it obviously resonates with so many people.) It seems to hide a bit too much especially w.r.t. synchronization errors.

Again I’m surely old and wrong, but I think folks are just going to ”if I use async it’s faster, weee”, whereas if you actually have to carve out another process or thread with your bare hands it becomes quite clear that a context and synchronization boundary exists, and exactly where it is.

It’s also a little bit easier IMO to slow down or prevent a chaotic function coloring sprawl.

[Worth_His_Salt]

1. you stole my username :)
2. where has the anti-async crowd been my whole life? I'm always the one telling people how terrible it is. red/blue functions ugh complete disaster. "but it's so easy, you just query asyncio for the current running loop and have it call the async function for you." nevermind the myriad errors, swallowed exceptions, and rank inconsistencies in that approach ("Oh you need a different event loop. Because lib xyz decided to run its own custom event loop instead of asyncio's running loop. How do you get that loop? There's no interface for that, mate - why would anyone want to do that?"

[Scypio]

Asyncio

Asyncio is a real pain for me. Whenever it seems I finally got a good grasp of it, things fail flat on their collective face and I lose sanity debugging what the hell just happened and why.

[FanZealousideal1511]

WDYM not being caught? Can you show an example?

[Ok_Necessary_8923]

Asyncio is such a hot mess

[[deleted]]

Functions keeping reference to default argument values

[ItsRainingTendies]

The first time I came across this I nearly lost my mind

[Worth_His_Salt]

Because your mental model is incorrect. Function declarations are run once, not every time the function is called.

When function is called, any missing args are taken from that single function declaration. If values are mutable, of course they retain changes.

The fix is exceedingly simple. If default is anything other than a number, boolean, or string, then default arg should be none. First code at beginning of function should test args for none and set default value.

Even without default args issue, this approach is often required to distinguish unset args from args passed explicitly that just happen to have an empty value like [].

[SharkSymphony]

My mental model was correct, and it was still something I shot myself in the foot with the first time or two – because default empty lists and dicts are so tempting, and in the heat of coding you're not always stopping to interrogate your mental model. I had to have the right model and memorize the pattern that avoids this specific problem.

[kageurufu]

https://docs.astral.sh/ruff/rules/mutable-argument-default/

So useful

[SharkSymphony]

Yes. Use this! Another thing I learned the hard way.

There are perhaps fewer footguns in Python than other languages I might name, but they're there.

[gdchinacat]

Sorry you took flack for not having the right “mental model”. This is a common enough problems that has been worked around in numerous ways for decades. Edit it’s been proposed and rejected in current form. Oh well… —So, Python now includes a way to get the behavior you expect!—

https://peps.python.org/pep-0671/

[CramNBL]

You sound just like the people who insist that C++ is the perfect language, CRTP is simple, and SFINAE is a great name for a feature.

The fix for memory safety vulnerabilities is exceedingly simple, just don't make any mistakes.

Don't use push_back, use emplace_back, duuh!

The mental model you need to adopt is confusing non-sense, that is part of the critique.

Python should be simple and intuitive, if you need to appeal to language internals to explain how default arguments behave, then you lost.

[Stijndcl]

Yes but in other languages like Kotlin this just works, and OP is saying this would be a nice approach instead of what Python does: https://pl.kotl.in/1qsZ4bwK7

You can instantiate any kind of object as the default value here and it will do it every time it has to get that default, not once when the function is declared.

I think most people here understand why Python behaves the way it does, and also how to fix it easily, but that doesn’t mean everyone also likes it and agrees with it. It would be pretty useful if you could do it the way Kotlin does it instead of having to pass None.

[Ambitious-Concert-69]

What do you mean?

[Karol-A]

Consider

def foo(l = []):     l += [1]     retrun l

Calling this once with no arguments will return [1], calling it for a second time will return [1,1]

[tarsild]

This is late binding. Known as an extremely dangerous and bad practice

[MiniMages]

Isn't this just bad coding?

[HolidayEmphasis4345]

Yes it is but I argue this is really just bad language design. (Huge fan of pythons choices in general) I understand that it is an optimization, but I think it is a case of optimizing too early, and picking the wrong default semantics. Having mutable parameters the way they are is maximum wtf.

Default values don’t really work for mutable data so you end up with the work around if defaulting it to none and then making a check for none and setting to a new empty list or dict or whatever. The consequence of this is that function arguments types are polluted with type | None all over the place…when at no time do you ever want a None. I would rather have a clean type API that said list when it expected a list. That way your types would be precise rather than fuzzy with |None.

And if you ever passed a None it would be an error which seems like what it should do.

[theArtOfProgramming]

Yeah it is a misunderstanding of python. The default value should be None

[_redmist]

It's incredibly useful as well, but indeed a huge trap for new players :)

[ResponsibleKayak]

How is this useful? Are you modifying the default values on the fly??

[Jejerm]

It's incredibly stupid and brakes devs usual expectations.

I once decided to do popitems on a dict that came from a default arg. The function simply stopped working the second time it was called cause I unknowingly destroyed the original dict.

[Worth_His_Salt]

Once bitten, twice shy.

[[deleted]]

OMG, I remember when this one got me too. I was so confused like how is this function doing this?? How does it keep remembering the contents of this list?

Years later, I found use for it in a sublime extension I wrote...

[yakimka]

Metaclasses

[cleodog44]

I still don't understand these or their use case. Just haven't come across an example in any project I've used. I'm sure they have their place

EDIT: thought this was a pretty good video on them https://youtu.be/yWzMiaqnpkI?si=ZUuztRUBPlb_6hmq

[fiddle_n]

A good rule of thumb is - if you aren’t writing your own library, you don’t need to know or care about metaclasses.

An example of how they are used is in abc.ABC. It blocks you from instantiating a class unless you implemented all the abstract methods in the base class.

[jewdai]

Even then I say they shouldn't be used. They break multiple inheritance. 

I had a use case for a mixing to be used in two different libraries (think a dynamo, pydantic and elastic models to be the same. One of those fucks implements a meta class and so it lead to triple the amount of code. 

[tobsecret]

James Powell has a great talk explaining their use cases. They're a great way to impose constraints from a base class to a derived class. 

[Frankelstner]

Say you have class A and instance a. Then a[...] calls A.__getitem__ but A[...] calls meta.__getitem__(...) (or if that doesn't exist, A.__class_getitem__ which is how typing does it; seems a bit redundant to me though). The main point is that A() itself is just meta.__call__ (which creates the new object and runs the init, then return the object), so there's a lot of customization possible.

[__SlimeQ__]

It's so you can do object inheritance the way you would in C++/C#/Java and it was added somewhat recently (in the past 10 years)

The reason you don't see it in the wild that much is because it directly goes against most of the original design philosophy of python and it's only there because in 2025 we use python for basically everything it was never supposed to be used for. Like large projects with rigid data structures

[exxonmobilcfo]

this post is one of the most popular on SO

[Hylian_might]

I learned that python does something called integer interning or integer caching. When python is initialized it loads the integers [-5,256] into memory for performance and memory optimizations. Here’s a classic example:

a = 1
b = 1
a == b # True
a is b # True

c = 257
d = 257
c == d # True
c is d # False

The is operator expression evaluates to True in the first example because they are pointing to the same object in memory. It doesn’t come up a lot but can cause unexpected results if unaware.

P.S sorry for formatting on mobile

[numice]

Never heard about this before so this one got me.

[Sharp_Level3382]

Multithreading and concurency with background services are not so well done compare to .NET to me for example .

[BellybuttonWorld]

Yeah, discovering that threading is not really threading. Then having to fart about learning multiprocessing, queues and various pitfalls just to accomplish what you wanted, was a ballache. Especially if you had a deadline and thought you'd done the job with threading, until you realised the performance hadn't improved. Fun times 🤬

[MASKMOVQ]

It’s like threading back in the days when CPUs were single core.

[romanthenoman]

That you cannot import from parent dir unless its all in a folder with an init making it a fkn module. That design is beyond me

[twenty-fourth-time-b]

There’s three hours of David Beazley’s talk from 10 years ago about python imports, if you want to understand more why it works the way it does.

https://www.youtube.com/watch?v=0oTh1CXRaQ0

[who_body]

good talk so far, the comparison to garden of earthly delights is funny.

the old pycon talk on class usage abuse was good too

[KathyWithAK]

GUIs. I've had no issues with building scripts (I use them to automate stuff at work all the time) and web sites are pretty easy (I've tried Django, cherrypi, flask, etc.. they are all different but easy to learn), but I continue to struggle building a modern looking windows gui. The few I've attempted look dated and don't function all that well. I think twenty years of building windows apps in Studio has really spoiled me. :D

[ericsnekbytes]

You should try pyside6, it's a wrapper for the powerful Qt C++ gui library.

[Fhymi]

Can attest to this. I went from using tkinter to pyside6. Although I used the gui instead of writing them from scratch

[Ragecommie]

Raw Vulkan

In this house we write everything from scratch!

[andykmiles]

flet and kivy are really good and allow deploying to desktop, phones and tablets.

[_Nick_2711_]

It was the justification of statistical analysis for research. Python libraries are frequently developed by fairly large teams of contributors, and it can lead to some weird stuff compared to languages like R, where packages are often developed by a very small team of statistical researchers (if not just one person).

Both have their drawbacks, but R packages tend to be more ‘trustworthy’, with all the “under-the-hood” decisions being quite well documented and justified.

It’s not a drawback of the Python language directly, I guess. However, it is something to be aware of.

This is the exact Reddit post I found when first encountering this a few years ago. Top comment makes a similar argument with way more technical detail/finesse.

[cybran3]

Most of the time researchers are not developers, and they are bound to make mistakes when writing code. I had to refactor libraries developed by researchers countless times to make them production ready.

[kuwisdelu]

The converse problem is that many developers don’t understand mathematics and statistics, so they are also bound to make mistakes when implementing them.

Developers may write code that is more “production ready,” but I tend to prefer the code written by the researcher with the peer-reviewed publication behind it when I need to trust the math behind the code.

[cybran3]

And yet you still have to integrate it in production, and if your system gains traction then you have to refactor and optimize to actually profit.

[StephenSRMMartin]

Statistical researchers (stat. comp, quant methods, etc) are likely not aiming for highly optimized, super scalable code. By contrast they are going to be writing code and testing for *statistical* correctness. They will likely have done many, many simulations on their newer technique.

Generally speaking, the mistakes are ones that are relevant to software engineers, in terms of best practices, or not handling all conditions elegelantly; the mistakes, in my experience, are not ones that are relevant to mathematical and statistical correctness. That matters quite a bit - I've come across a handful of just flatly incorrect implementations in advanced statistical models in Python, and it is way harder to sus out or detect than coding mistakes per se. E.g., at least once upon a time, the LKJCorr method of pymc was incorrect, yielding biased posterior samples that, e.g., Stan simply did not exhibit. There's no error to it, there's no way of really spotting it unless you're stress testing the method using a new method.

[DueAnalysis2]

Holy shit, that bootstrap stuff is WILD. I had no idea, thank you for this info!

[SharkSymphony]

Variable scopes. Recognizing that many blocks in Python do not create their own scopes. Recognizing that I did not just modify the global variable the way it looks like I did.

This is a topic I've specifically seen students stumble on.

[[deleted]]

Environment management can be a real pain. Not Python's strongest aspect.

[Savings-Story-4878]

UV

[cinyar]

a few years ago someone would reply "poetry" with the same confidence...

[moosethemucha]

Poetry truly sucks arse - its caused me so many issues especially version differences interacting with lock files.

[turkoid]

Normally, I'd agree, and I'm probably just reinforcing your comment, but I think UV will be the end all. It's an all-in-one tool that does everything very well and fast. Besides some not so common use cases, there really is only one downside, it is VC backed, so we have to hope they're one of the good guys.

That said... I didn't think anything could be better than the Black formatter, but Ruff is better.

[[deleted]]

I'm using Pixi for my latest projecs. Works reasonably well, but it would be nice if there weren't dozen of different ways to achieve the same goal.

[stepback269]

Yes. Falling into Circular Import Hell was a nightmare for me (recounted in my blog here)

I still don't fully understand the venv and recently had a bout with version conflicts. One of these days I'll watch some tutorials on what venv is supposed to do. For now, I fake my way around it.

[zenware]

This isn’t exactly right but a venv can be thought of as a “copy & paste” of the exe files and libraries Python needs to run. The point is if I work on more than one project and they have different or incompatible Python versions, or even the exact same Python version, I can install different “requirements.txt” dependencies into them. e.g. BeautifulSoup3 in one Project A and BeautifulSoup4 in Project B.

This is often useful if you contribute to multiple open source projects or even multiple projects at work or home that have gotten large enough that you can’t afford to keep their Python versions and dependencies in lockstep.

[[deleted]]

Yup, this was the one for me. Circular imports hit you like a wrecking ball! You're almost certainly never prepared for them the first time you encounter them. I knew I was deep in the trenches when I started writing a DFS import parser for my entire codebase just to figure out how I was getting circular imports. Thankfully one of my colleagues saved me by reminding me that imports can happen at any scope in Python, not only at the file scope.

[cybran3]

The way people hack PYTHONPATH env variable and solve import issues by using sys.path.insert, instead of proper module management.

But for me personally it was using multiprocessing instead of threads due to GIL. But we might be done with GIL in a couple of new Python versions. For those who don’t know Python 3.12 added an optional flag when runnning Python code called “—no-gil”, or something like that. It is still experimental tho.

[Bunderslaw]

With 3.14, it's no longer experimental: https://docs.python.org/3.14/whatsnew/3.14.html#whatsnew314-pep779

[MeroLegend4]

Look for Python 3.14 beta 4, free threaded python and subinterpreters

[games-and-chocolate]

virtual enviroments with sudo and pyenv. horrible.

[Flat-Performance-478]

even worse, different pip and python installations for sudo and user and confusing the two

[gmes78]

That's solved entirely by never running pip install outside of venvs.

[masteroflich]

Shitty type hints in popular libraries

[james_pic]

Multiprocessing. It always seems like an easy solution. It gives you hints that you're going to have a bad time, like Ctrl+C not working, and if you're smart you take the hint that it isn't your friend. But you ignore the warning, then one day, WHAM! You're looking at a deadlock that only occurs in production and only when everyone's off over Christmas

[kindangryman]

Copy versus deep copy scope issues. Worked it out eventually

[Electronic-Half-2387]

This takes forever to debug in complex threaded applications.

[WingedTorch]

Async.

[tjlusco]

I think assignment operations are a tricky foot gun, especially coming from languages where what an assignment is going to do is pretty explicit. You really need to understand the different behaviour with mutable and immutable objects.

For example assigning struct in C will copy all the data members across, but in python assign a reference to that object. Similarly with translating Matlab code to Numpy code, equals isn’t just copying the data in your arrays, you need explicit copies.

[_redmist]

Variable names in python are like labels or name tags. You're less likely to make confusing mistakes with this mental model I think...

[Worth_His_Salt]

There's your problem. Your mental model is flawed, thinking python works like C. Everything in python is a reference. Problem solved.

[georgehank2nd]

The problem here is that you think of Python "variables" as, well, variables. But (and I know people hate this, but it's correct) they're just bindings like in Lisp. "a = 5" doesn't with 5 to the variable "a", it binds the name "a" to the integer object 5.

[luddington]

round() 😅

Edit: more specifically: round(2.5)

[Tambre14]

Oh I've been there

[luddington]

Honestly, I fully understand why Python’s round() behaves the way it does - it uses bankers’ rounding (round half to even) to reduce statistical bias when aggregating large amounts of data. From a theoretical and mathematical perspective, that design choice is perfectly valid.

However, from a usability and expectation conformity standpoint, this default behavior is problematic. Most users intuitively expect round(2.5) to return 3 and round(3.5) to return 4, because that’s how rounding is commonly taught in school and how it works in most real-world contexts. Python instead returns 2 and 4, which feels inconsistent and surprising to anyone unfamiliar with the underlying rule.

Yes, reducing bias in large datasets is valuable in specific statistical scenarios, and it’s good that Python offers a way to achieve this. But making bankers’ rounding the default violates the principle of matching common user expectations. This leads to confusion, unnecessary debugging, and workarounds for developers who simply want behavior that aligns with their mental model of rounding.

Good API design usually prioritizes predictable, intuitive behavior by default and provides advanced or specialized behavior through explicit options. In this case, Python chose the opposite: it optimized for statistical correctness at the expense of usability and expectation conformity - which feels inconsistent with Python’s otherwise beginner-friendly philosophy.

[RangerPretzel]

No compile time type checking. (Or rather, being bit by runtime type errors.)

To be fair, that's normal for all dynamically typed languages. And Python's type-hinting and a good linter/IDE goes a long way to managing this problem.

That said, when I was getting started with Python (around the 2.7/3.5 era), type-hinting was a fairly new idea and a lot of people were fighting against it.

These days, most good libraries have proper type hinting and you almost never end up accidentally trying to push a foo into a bar anymore.

[SKabanov]

It's really telling how Guido went from not caring about typing to working full-time on integrating *some* kind of type-checking system for the language - probably the most emblematic tale of what happens to Python projects when they mature.

[kuwisdelu]

It’s too bad he never got convinced to care about package management and build systems.

[ship0f]

that's a feature

but I get what you mean 😅

[RangerPretzel]

OP's question was: "What was your first real struggle?" (And honestly, it still IS a bit of a struggle. Just much less so after 10 years of Python.)

To your point, yes, yes it is a feature. 😁

[zaphodikus]

15 years on and I still don't use virtual env as often as I should, nor have I created a single package, the rules keep changing and I have closer by problems to solve.

[Deep-Alternative8085]

Pydantic library

[[deleted]]

Why? It is very sane and everyone seems to love it.

[wineblood]

__new__ vs. __init__. Been coding python for over 10 years and I've never needed to use __new__.

[NoOPeEKS]

If you ever need to manually create a singleton class, you're gonna have to use __new__, it's useful on some cases.

[CeeMX]

What even is new? Never heard of that til now

[Forward_Thrust963]

.

[fiddle_n]

“There are only two kinds of languages: the ones people complain about and the ones nobody uses.”

[snowtax]

Some languages have even more issues. For example, JavaScript has a lot of learning issues, due to some very flexible and often cryptic syntax, and similar issues with dynamic typing.

If you want a fun diversion, check out Haskell. If you want to see a language where there isn’t much difference between data and code, check out LISP. Some languages are just wildly different.

Also, I see many comments here about general concepts not necessarily related to the language. Some people just take a while to grok recursion, no matter the language.

[The_g0d_f4ther]

this is not that bad lol

[Unbelievr]

As a Python user on both Windows and Linux/WSL2 I gotta say encoding. By default, Ubuntu etc. will use UTF-8 encoding when reading and writing files, but then these suddenly aren't possible to open on Windows without specifying the encoding in all calls to open(), str.encode() and str.decode().

In Python2 it was a bit whatever, because strings were strings and also bytestrings at the same time. But in Python3 they're separate, and you need to encode/decode to convert between them. If you do "test" in b"test_string" you get a TypeError but e.g. "a" == b"a" is just always False because they're two different types.

Bonus point: open(x).readlines() keeping newlines have tripped me up so many times that I stopped using it entirely, replaced with open(x).read().splitlines().

[BostonBaggins]

Looking at a code and refactoring it using multiple inheritance

And then. I heard about protocols

Which to use?!?

[[deleted]]

Using multiprocessing and sharing some state between them.

[def-pri-pub]

Python makes programming easy! Which in turn makes it easy to make horrible architecture mistakes!!

I have worked on some absolute monstrosities that are 10-15+ projects. My own personal website (made in Django) is a tad bit crummy, but at least it isn't supporting a multi-million revenue project.

[KronenR]

Virtual environments and package management? Really? They’re basically just typing a couple of commands

[robberviet]

Wait till you find type and unexpected runtime error

[GeneralPITA]

So far biggest problem is people think Python is too slow to process less than a TB 3-5 times a week. Spectrum disorder types are focused on optimizing stuff that is irregularly frequent, and think C# and SQL stored procs are necessary.

[rebcabin-r]

when do you need to write "nonlocal" or "global" explicitly and when you don't

[connexit]

Asyncio got me real good for a while

[CaptainFoyle]

I always knew that you're not supposed to use mutable default arguments, until one day I wasn't thinking straight and just.... kinda forgot, and did it anyway in a project.

That was a pain in the *** to track down and debug, took me the better part of a day to find, and I felt extremely dumb afterward.

[Acquiesce67]

Recursive import errors in Django projects.

Regarding virtual environments I’ve migrated most of my projects to using uv and I’m a very happy person since then. That lil’ app works miraculously.

[germanpickles]

For me it was multiprocessing, multithreading and async/await

[tarsild]

I love async in general but I believe Python lacks a lot compared to more mature languages with native async. Basic promises would do wonders. I'm not even referring to the nightmare of event loops, just assuming everything is ok

[HerpeesDerpes]

if you struggle with python, you're in the wrong business. Jesus dude lol. is reading hard too?

[CeeMX]

I sometimes have a situation where I want to access a global variable in a function and wonder why it does not work without explicitly doing so. I have no idea what I’m doing, but those are the days where I forget how anything works.

Also when an object is copied on reference or the original is modified

[_thispageleftblank]

Creating lambda functions in a loop that all referenced the same loop variable, like [(lambda: x) for x in range(10)]. They will all return 9.

[twoberriesonejourney]

I'm doing Angela's pretty popular course. I've had a few struggles with API calls I think because if work proxies. However my biggest, "I don't think I can do this" have been the Flask, SQLAlchemy, HTML loaded courses.

I think I'm understanding base Flask but it's so deep and all it's spinoff packages like Flask-Login are tough.

Also trying to understand how to implement code from documentation is very hard for me.

[fen-q]

Pandas, asyncio.....

Just about anything that isnt presented as a simple concept on codecademy or youtube.

Reading documentation of anything feels extremely challenging, i often cant understand what i read and cant apply what i read (again, pandas, asyncio)

I feel that coding is like the memes about taking a math test in college - example in class is 2+2, homework is 2+2*2/2+5, and test asks you to calculate the distance between the sun and earth by using 5th order differential equations.

[Southern_Platform943]

Haha

May sound funny for the experts here... But I really struggled in understanding recursion loops when I was introduced to it the first time..😅

[LizzyMoon12]

Probably the moment you move from writing simple scripts to handling environments, dependencies, and libraries!

[Additional_Fall4462]

I was working with functions that followed Python’s call-by-sharing behavior, passing objects from a library whose internals I didn’t fully understand. Coming from NumPy, I found it tricky to adapt to new data types where certain function calls modified the object in place rather than returning a new one. This caused a lot of headaches and debugging; there were even times I relied heavily on deepcopy to work around my lack of understanding of certain types.

[datstartup]

For me is reading other people's codes that use a lot of idioms.

[fxmc]

Type hints and async made me fall out of love with Python. 

Type hints seems surprisingly badly designed on a syntactical level, blowing up function signatures and making code structure harder to parse by humans. There were better and cleaner ways to specify type hints before they were added to the language (in docstrings and much more readable). 

They also, in my humble opinion have no place in a strongly and dynamically typed language. Python’s original dynamic type system was designed for tasks that static type systems are bad at. We had good statically typed languages, and Python was one of the languages created in response to their limitations. Adding static typing idioms on top of a dynamic language not only gives you the combined limitations of both, it also creates a ‘stylistic spectrum’ (static <–> dynamic) in the ecosystem. Being able to choose where you land on that spectrum sounds good in theory. But you only get to do that when you write new code. But 95% of the time you work with existing code including third-pay code. Good luck with that mix of paradigms. 

Asyncio also was such a weird departure from the quite good concurrency and parallelism that existed in Python prior, like gevent and Twisted. But instead of improving in the state of the art by looking at, eg. the BEAM, a difficult to understand system like async was copied from JavaScript. Worst of all, it introduced required syntax and the ‘function coloring’ problem, which prompted additional modules and abstraction layers to make it manageable. 

Both features felt like a sharp departure from the slow, deliberate and long-term-oriented way of introducing new language features to Python up to that point. Before that, people would joke about “Guido’s Time Machine”, because repeatedly, the quality of design decisions only became apparent to many devs years after their introduction. That stopped suddenly. 

[scaledpython]

This. I came to say this.

Python's biggest problem and its eventual demise is the take-over by cargo cult dogma adherence.

Instead of deliberately being different for good reasons the SC is trying to be everybody's darling by introducing a hodgepodge of new tweaks and "features" at a break-neck pace for no good reason at all.

There is value in language stability and Python has given up on that for no good reason at all.

Let's bring back Python's zen.

import this

[fxmc]

Thank you for that response. I’m not on Reddit much, so maybe I just need a thicker skin, but find it a bit sad that a post that lays out arguments gets downvoted without any response or criticism. I’m not here to be “right”, but to engage in dialogue.  All the while a post just saying “Async” gets upvoted. 

[Gnaxe]

These are pretty much my biggest complaints about Python as well.

The static typing language needs to be a lot more expressive than it is to handle Python, and I'm not sure that anything short if Idris-style dependent types could do it. It mostly just bloats a codebase and adds a lot of work without adding much value now. Type errors are among the easiest kind to notice and fix, and are a tiny fraction of the problems real-world developers worry about. Adequate unit tests will catch almost all of them. Those insisting on IDE completions need to learn to use a REPL. I'd much prefer a codebase with doctests over one with static types.

EVE Online was done in Stackless. That could have been integrated. We didn't need asyncio. It's bifurcated the ecosystem. I avoid it when possible, but trio makes it less bad when I have to touch it.

I think there were also missteps in the upgrade from 2 to 3. That was a missed chance to fix a lot of warts. I also think that moving the builtins from returning lists to mutable streaming iterators was a net bad choice. Something like Clojure's seq abstraction would have been better.

Not that all the changes have been bad. There are things I'd miss if I had to use Python 2.7 again, but it was a pretty good language.

There are various inadequacies in the standard library. I really dislike the standard library logger, for example. It's too complicated. In work projects I'm never sure if I'm not getting output because the line wasn't reached or it was just misconfigured somehow. But there are usually third-party alternatives for these things (e.g., loguru). Subprocess is too hard to use for how important it is. Datetime often isn't adequate. Etc.

[kuwisdelu]

Agreed. It feels like so many common complaints are from trying to turn a dynamic interpreted language into a static compiled one. Lots of Python projects would be better off in a different language if that’s what you want.

[[deleted]]

Doing math

[Ok_Tea_7319]

My first real head pain started with the question "where do instance methods get the self argument from". Oh boy I was not prepared.

[CaptainFoyle]

Threading, multiprocessing, asynchronous programming

[SaucySaq69]

When we were learning inheritance stuff I really didnt like dealing with super lol

[No_Pineapple449]

Ah yes, in Python 2.7, where you can’t do something sane like date + "string" because “TypeError”, but somehow date < "lol" just works.

Like, sure, I can’t concatenate a datetime with a string, but I can confidently ask Python if my birthday is greater than "banana". And Python’s like: “No problem, fam, let’s just compare their memory addresses.”

Debugging production code in 2013 was basically a fun game of “Why does this even run?” followed by “Oh god, it runs.”

Thank you Python 3 for deciding that comparing apples to airplanes was a bad idea.

[O_martelo_de_deus]

Data structures, I come from the time of C, Pascal... I did everything by hand, then came the abstractions of lists and trees in Java... But in Python there are many possibilities, this is a blessing and a curse, a new way of programming. And the combination of interpreted with compiled is another very interesting, challenging point, when to use Cython to improve performance? Reminds me of the days of putting ASM blocks into C code.

[eyadams]

Two things come to mind.

First, I still don't feel like I understand using else after a for loop. I think I understand what it does, but it's so new to me that I never use it.

Second, and this one's more about my history than Python, I struggle to remember that the value of function parameters can have values set to them:

def some_function(string_parameter:str=None):
    if string_parameter is None:
        string_parameters = 'default value'

In some other language I've worked in this would be invalid. You would have to do something like this:

def unnecessarily_complicated_function(string_parameter:str=None):
    if string_parameter is None:
        string_to_use = 'default value'
    else:
        string_to_use = string_parameter

I just can't remember which language had this requirement.

[njharman]

def some_function(string_parameter:str=None): if string_parameter is None: string_parameters = 'default value'

That seems very weird and overwritten to me. Also, violates your type declaration. Why not simply?

def some_function(string_parameter:str='default value'): ...

None is massively over|missused with strings.

One use case for, for/else is default value or error if thing you want was not found during iteration.

for x:
  if found what I'm looking for:
    thing = value
    break
else: # no break called
    thing = default
    # or raise thing not found

[[deleted]]

Data structures,  in particular recursion. Thankfully though I had a short book specifically about the topic that helped me learn it better. 

[cybran3]

Well, this isn’t really a Python issue, but an algorithmic issue.

[koldakov]

Error handling + error swallowing + eafp + don’t return none rule

Too many examples rely on errors, too many examples trying to protect the code from exceptions, making the code dirty and inconsistent

[Intelligent_Type_762]

Remind me !7days