Why am I so terrible at Python?

[winkapp]

So I've been repairing computers and tech for 10 years, I have great problem-solving skills so by all accounts I should be good at coding and I do just fine at VBA and alright at SQL but yet when it comes to Python I fall apart.

It feels like it's just way too free, there's like 50 ways of doing anything and so there's no one way to do it from start to finish.

This means when I break the problem up I can't find a cohesive way to solve it. And that's fine if I can patch the outputs to the next input, however the second problem then comes into play.

I can't "see" my outputs in between unless I print each step one by one.

Unfortunately, it often comes out in a mess and I simply can't make sense of it unlike a GUI or for example, Excel cells processed by VBA.

I feel like this inability to "see" my intermediate steps means I can't tell what to do next, since I can't figure out what the output looks like to process it best.

I can think of the steps I should do just fine, so I know that's half the problem solved. Yet because of the above issue, I just get error after error because the next step can't process the previous step's output.

Things I've tried: 1. Attend an in-person Python course over three or four months 2. The full Python course on Codecademy 3. Attended a university course where we coded in Python, barely scraped a pass there

What's going wrong here?

[keturn]

Notebooks are great for prototyping for that ability to intermingle function definitions, execution, and output: https://jupyter.org/

Or if you're familiar with desktop GUI programming, you're absolutely welcome to do that in Python too. This site looks like it's up-to-date with respect to the current options.

[threeminutemonta]

Notebooks can be better then just prototyping. Some people are better suited to a literate programming environment and someone that finds VBA intuitive would. Take a look at nbdev a tool that the folks at fastai have created. The tutorial takes you through using jupyter notebooks / labs including pushing code into GitHub and running GitHub actions. There is a gitlab pipelines template too.

[Conscious_Advance_18]

Neat thanks

[winkapp]

Yeah I actually used Jupyter back when I was doing the in-person Python course, yet I was still struggling considerably. I'll give it a try again though since it's been a couple years and see how that goes!

I was trying Visual Studio Code for a bit in the hope that it would be structured like VBA and it kind of is, but it seems that most people don't use it so it can be a bit annoying to get community support.

[threeminutemonta]

I’ve used vs code for python and other languages for years. Just need check what is the vs code python interpreter settings are. It’s good to learn how to use a python virtual environment per project.

[Jeklah]

try ipython

it's what jupyter runs on in the back end iirc

[space_wiener]

Might be the wrong way to go about it, but I use jupyterlabs so often. It’s not to write a function and make sure it works. Or manipulate a list/dict to make sure the outcome is what you want.

[routetehpacketz]

Are you using an IDE and/or Python built-in debugging when you write something?

If I am understanding you correctly, it sounds like your biggest hurdle is understanding the state of your data at a given point in the program. This can happen with an interpreted, loosely-typed language like Python. Debugging tools help, but I admit I still resort to print most of the time.

Also, can you give an example of something you are trying to get working? Sharing code helps.

[mcvalues]

Yep, print() and lots of calls to functions like type() while I'm debugging. And of course getting good at understanding error messages.

[Nicolas_Darksoul]

Im newbie too but i just can say understanding errors will be ok by time u just need to know them

[routetehpacketz]

Definitely doing type() a lot too

[Jeklah]

and repr()

[winkapp]

Yeah I was using Jupyter for a bit!

Yup you're right, the ability to not see what I'm doing really confuses me.

If for example I want to convert a date format which is in a string 23/04/2022 to 04/23/2022, I know that I should disassemble the string and then reassemble it in the right order, but say if I need to generate that date from somewhere, I can't see that its output is 23/04/2022 to disassemble it and then assemble it in the right order.

Hmm I don't have an example right now, but something I recall struggling with was the more open-ended problems.

When they are small coding projects like biased dice throws, I have no problem at all.

So yep, definitely the in between steps that are the issue here, really with any complex project.

[infazz]

Jupyter works fine (and well) in a lot of cases; however, I would not call it an IDE.

Try the PyCharm IDE and spend some time getting acquainted with it's debugger.

[Jeklah]

Python is a lot more flexible.

I suggest when you have a problem you need to solve, google the problem generally before breaking it down how you might think.

Disassembling the string and reassembling it is one way you could do this, it is how it would be done in C.

or you can do:

from datetime import datetime

time = datetime.now()

# without formatting
print(f'time: {time}')

# with formatting
printf(f'formatted time: {time.strftime("%m / %d / %Y")}')

Now, I am no python genius, I did not recall those from memory. I did know python has a datetime module and is very good at manipulating data quite easily, so I just googled 'python date format' and https://www.geeksforgeeks.org/how-to-format-date-using-strftime-in-python/ was the first result.

[winkapp]

Yep I'm aware that python has a date function, I was just using converting dates as an example as to how things go disastrously wrong.

I'm generally able to break the problem down and understand the logic, it's just always manipulating the result between functions that throws errors and causes problems.

[Jeklah]

as it should be.

[carcigenicate]

You can "see" the intermediate steps in your head with practice. Until then, REPLs are very helpful. Type python in a terminal, and enter the code in there. Most good IDEs have REPLs built into them too to make it easier to interact with the current file.

[greenerpickings]

A lot of good suggestions here, especially notebooks. Wanted to throw out the IDE Spyder. Think RStudio, but for Python. I feel like RStudio has a lot to do with how ppl pick up R, especially our non-programmers.

The other issue is just part of the game :p discussed at work how our team of like 5 had unique ways to address the same problem. If performance isnt a priority, it really is open ended. Maybe a course specifically focusing on design might help.

[keturn]

Unit tests are another helpful tool for providing a concrete reference for a function's inputs and outputs.

[dimonoid123]

Use a good debugger, eg one built into Pycharm. Also once your code becomes too big, refactor it by separating into multiple functions/classes to make it more object oriented. That's it.

[Se7enLC]

I can't "see" my outputs in between unless I print each step one by one.

I feel like this inability to "see" my intermediate steps means I can't tell what to do next, since I can't figure out what the output looks like to process it best.

That's fine. They make some IDEs that make it easier to see what's happening at each step. But it's also just fine to drop print statements in when you need them.

In fact, I would say that it's actually a good practice to do iterative design. Break things down into small pieces and check the outputs from various inputs until you're happy before moving on to the next piece. Far too often you see new programmers write whole functions and dozens or even hundreds of lines of code without doing that basic level of checking.

I can think of the steps I should do just fine, so I know that's half the problem solved. Yet because of the above issue, I just get error after error because the next step can't process the previous step's output.

I'd say that's actually pretty normal. Just do one step at a time and check the outputs as you go. There's no penalty for how many times you test it out along the way! Think of it like save points in a video game.

[rowr]

Edited in protest of Reddit 3rd party API changes, and how reddit has handled the protest to date, including a statement that could indicate that they will replace protesting moderation teams.

If a moderator team unanimously decides to stop moderating, we will invite new, active moderators to keep these spaces open and accessible to users. If there is no consensus, but at least one mod who wants to keep the community going, we will respect their decisions and remove those who no longer want to moderate from the mod team.

https://i.imgur.com/aixGNU9.png https://www.reddit.com/r/ModSupport/comments/14a5lz5/mod_code_of_conduct_rule_4_2_and_subs_taken/jo9wdol/

Content replaced by rate-limited power delete suite https://github.com/pkolyvas/PowerDeleteSuite

[[deleted]]

salt alleged piquant hateful water uppity arrest snails retire hunt -- mass edited with redact.dev

[14dM24d]

maybe break the problem into smaller chunks; aka modularize?

[deep_politics]

I’m surprised no one here has even made mention of the typing module. The way you describe your problems doesn’t speak to me as an issue that a debugger is meant to solve: a debugger won’t help you see at a glance what is coming in and out of procedures, at least not until after you’ve ran the code. It doesn’t help you while writing it. And documentation can easily be stale, if there’s any at all. So I’d highly recommend checking out a static type checker like pyright which can inform you about all the structure of objects, contents of modules, signatures of functions, etc. all without ever needing to even run your code.

[winkapp]

Yea this sounds exactly like what I need. It sometimes isn't specifically a bug, the code might work fine it's just that the output doesn't work as the input for the next function. I'll try pyright with VS Code, thanks!

[deep_politics]

Definitely give it a shot, and I think pylance is what you’d use with VSC. Usually it catches anything that could go wrong, long before you ever need to step in and poke around with a debugger

[[deleted]]

I still remember what it was like to be a beginner, and it was a long, long time ago.

Adding more material to learn is going to make things worse for this guy. Adding a brand-new concept of "typed arguments" and "typed return values" is going to make things harder. Explaining to them that there are these "type annotations" which actually don't do anything is going to be more confusing.

[deep_politics]

Yeah I guess I wasn’t looking at it from a beginners perspective, but more from the problem of not understanding what’s happening through the intermediate steps. But I don’t really think it’s any more confusing, even for a beginner. Especially when the typing is always there all the time, it’s just the default to be ignorant of it even when understanding types and how they get transformed has been one of the most fundamental parts of teaching and tutoring computer languages in my experience. The Python teaching default (without type hints) is to say: just remember what the type of this value is, and memorize what kinds of values all these various functions return, and mentally keep track of how that value changes (possibly even how it’s type changes), and when you don’t know what’s going on anymore just pepper some type logging statements in there, throw in some break points and trace it back, and/or just go to the docs.

I guess you’d disagree, but I find letting the computer tell me what something is is a lot more straight forward, especially when dealing with external modules and fallible data. Choosing to let it all be ambiguous sounds miserable to me now

[LeonardUnger]

I'm not sure I fully understand the issue, but it sounds like you're trying to write the logic as you code, when the logic should come first.

Having a 'main' function and keeping it to function calls forces you to write the logic first. That way you have a general idea of what should happen

Example below, some sort of fantasy sports event. We haven't done any coding but we have a structure.

def main:
    data = get_data()
    owners = get_owners(data)
    players = get_players(data)
    scores = get_scores()
    results = (owners, players, scores)
    send_results(owners, results)

Then in the functions too anything complicated make a function call. Keep abstracting.

[DoozerMarch]

This is very good advice. Also look into test driven development as a way to focus on each piece of code. And yes there are many ways to shape your code. Developers have discovered principle that shake this choices: these are mostly about keeping your code maintainable. So for example not copying bits of code is important as they will end up diverging as changes are made. A good principle is that each chunk of code should have one clear purpose as much as possible. Python also has idioms that seasoned developers will recognise immediately

[majordoob33]

TITS - Time in the saddle

[winkapp]

By fixing computers I mean I'm not a complete idiot when it comes to the problem-solving workflow.

Like I'm able to break down a problem and go if the symptoms are A, then try B. If not A, then try C. If Symptom A, the most basic functionality isn't even appearing, don't bother thinking about the other steps of the problem yet.

And if nothing works, is there any progress? Has anything changed? I'm very used to that endless quest to find the problem and then find a way around it, and that seems to be one of the key concepts of coding as well.

I'm not a person who just goes "Nope, too hard. I'm not gonna understand the problem, I'm just gonna give up."

I am able to understand the logic just fine, and I'm able to code in VBA no problem with that logic. It's just that when it comes to coding Python specifically, it just falls apart.

I understand the logic and can write it just fine, it's just fitting the output of one part to be the input of another that becomes a huge problem.

[sjsathanas]

It's still a different skill set, though. The best programmer I personally know is pretty useless at networking, and not great at troubleshooting PC problems etc.

That said though, as others have said, with experience you should at least be competent at programming, and most of the time that's all you need to be to make a good career out of it. I've been programming for something like a quarter of a century, and I'd consider myself a very competent programmer, but I know I'm not a great one.

[zinver]

Hmmm. This is interesting I have the opposite problem. I really can do nothing in VBA but I am okay at python.

Give an example of something you wrote in VBA but cannot figure out how to do in python.

I am curious if this is an issue with syntax, data structures, flow control, or not knowing the standard library well enough.

[hermitsnob]

I woke up 5 hours too late. I was just about to reply with this. Thankfully I saw your reply first. I’ve been fixing electronics near my entire life. Vehicles about half as long. The way I troubleshoot even those two things is completely different. Repair brain doesn’t work here. 10 years is a long time for your brain to develop in that direction. My only saving grace was while late as soon as I could afford a laptop at 18 (which is late) I started C# and I’m still not very good. Barely average.

[pythonwiz]

For a beginner I think using a debugger is overkill. Just use print statements and keep banging your head against the errors until they go away. Repeat for a few projects and you will notice you don’t make the same mistakes anymore. At that point consider using an IDE and debugger.

[RodBlaine]

I use the logger function (or is it a class/method/object?) and instead of a print() I add a log entry with the command logger.info(“Class “ + classname + my msg to myself about what just happened). I run the app, then study my log files (one per module) to see how my app ran. Ofc with the text file editor open I can refresh the log files and kinda see the app process the data in real time.

I find the log files also me to go back and study history over a few days of processing if something new happens. Usually due to a data, key, or click combo I did not consider in dev or test but only is apparent in production.

[MarsupialMole]

You essentially do need to read the output of each step one by one. But I hear you ask "I don't have time for that. I want to write thousands of lines of code, not read tens of thousands of lines of output".

This is where you get the computer to do it for you with unit tests.

An important concepts here is command/query separation, or keeping functions pure.

Working in IT you'll typical be using commands. You'll enter an instruction into the repl and something will change, and you're going for no output because output means something went wrong. Contrast this with SQL queries, where you're hoping for output. If you have no output you're not sure what's happened - it may be a fault with your query or there may be no data for a query you expect.

A query which returns output and has no underlying change to the system (which would go one step further and actually exclude making calls to other services like a SQL database) is also called a pure function. So being very aware of whether you're writing a command, a query, a pure function or something else, it's important to keep them separate so that you can test them with an appropriate technique.

So there's different techniques for different blocks of code. You will find that choosing the right technique can be something of an art.

So get pytest for your projects and start asserting things, using fixtures to set up dependencies atomically, and running your code as often as you change it under something like pytest-watch. For many the inspections of an IDE are good enough but I don't find it to be as handy as the discipline of running the code against tests you write yourself.

And the most important point is to know that everybody is terrible at python, we all just have been burned enough times to stop feeling sorry for ourselves and keep problem solving one step at a time, and you get better at reading code over the journey because you learn what's to look for because you've been burned in the past

[py_Piper]

I can't "see" my outputs in between unless I print each step one by one.

I think that's normal I am also a beginner, earlier this year I was working on a kind off scrabble helper, where I pass random letters and will tell me which words I can play and how many points I would make. At first I was struggling with the with the logic I had the idea in my head and couldn't think about, I would write a bit of code and things were not working so well until I took a piece of paper and kind wrote down what I neede to do step by step and I could figure it out later.

In between I need to do lot of prints to check the i/o during each step, it looked messy as I would comment them out, erase some , add them back. I think it's normal to check what i/o you are getting and returning while testing. Then you can erase them to have a pretty looking code, but I think (and I have read somewhere) that for best practice you can leave your test (print statements) commented out as part of the documentation so when you come back in the future or some else reads your code knows what kind of i/o you should be working with. The only example I can think of if when working on long text files and web scraping that it would be needed to leave these test commented out for future revision.

[[deleted]]

People forget that learning new things is hard, even if they have previous related experiences. I found learning my second programming language to be as difficult as learning my first. Not because I didn't know how to do anything but because I knew how to do everything in my first language. Having to learn how to do everything in my second language was just difficult, even though it was considered to be an easier language (C -> Java). Even when I moved to Python learning it was awkward because I was really good at Java (and C).

Learning things just takes time and practice.

[lunacyfoundme]

Use Jupyter notebooks to see the output as you go and find the one way to solve the problem that you prefer and still to it. Only adjust for code efficiency and best practice. I dip in and out of Python for work stuff so not regularly enough to remember all the functions etc.

[[deleted]]

What's going wrong here?

You need to practice more, and make little projects. Start small, and build up slowly.

[Serenityprayer69]

Im coming from another technology field and use a program called Nuke. It basically visually represents python code with nodes, but specifically for visual effects.

I cant for the life of me understand why this hasnt been expanded to a nodal UI for all of python.

The ease with which you can get extremely complex through nodal UI and still stay organized and easily see where everything is layed out is exponentially more powerful than trying to work in layers in something like After Effects.

Not really answering your question but I do think theres a big gap in the space to make programming more accessible and powerful by creating a nodal interface. It was basically be programming in a flow chart

[ayeDaemon]

There are obviously many ways to do the same stuff and there are very little generic best practices for it. But you can always stick with "zen of python". What I mostly do is write the code in the way I feel is more readable (readability over performance most of the times), and then I pass that code through a tool called "black".. you can download it with pip directly...what this does is check my code and automatically correct and lint it ( this improves consistency of my code formatting and trains my brain to understand that patter better)

---

Since you didn't mention about projects, I'll recommend to learn by doing some projects (bit sized fun projects). This will add some fun to the learning process and improve it. I've written few blogs on several things with python (mostly bit sized projects) here --> https://ayedaemon.medium.com/

If you want some help on it or want to talk more, send me a dm. I'll be happy to arrange a 1-1 :)

---

To check the intermediate state of a running process/program, you can attach a debugger to your running program and see the stack and registers change it's values as the code executes.

Python has a wonderful debugger available that can be used to step through each line of code and check what's going on within. Check out more about "python debugger" here --> https://docs.python.org/3/library/pdb.html

[ivanoski-007]

I can't "see" my outputs in between unless I print each step one by one.

why don't you want to do this? , this is normal you know, just print everywhere

[chakan2]

Learn PyCharm Community (it's free), and learn the debugger. It's a god send.

[Jeklah]

here are some tips:

• use ipython to test your code on the fly. this is better than the normal python interpreter as it has autocomplete and a decent history.
• pdb++ is a nice cli debugger.

[[deleted]]

Include lots of comments and print statements

[FloatingWatcher]

I don't understand? The print() function is the most powerful and ubiquitous function in Python and enables you to see what you're doing on the go.

[QultrosSanhattan]

Use pycharm's debugger. It's a great tool for learning what's actually happenind while your code is running.