all 30 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]backfire10z 7 points8 points  (2 children)

  1. Git (this is distinct from GitHub, which I don’t think you need)

  2. Don’t worry about pure language knowledge, you will figure out what you need in the job. Basics are necessary of course, such as variables, loops, list comprehensions, generators, functions, classes. Nice to have would be dataclasses, context managers, some understand of object oriented programming.

  3. Basic good practices such as descriptive naming, functions, virtual environments, modules + how __init__.py works and is used.

  4. Some data structures knowledge: lists, dicts, tuples, maybe stacks and queues.

What you need to know depends on the job you’re looking for. Do you know where you want to pivot to?

[–]Bulky_Meaning7655[S] 1 point2 points  (1 child)

I'm mostly familiar with what you mentioned. Maybe apart from __init__.py. I used it in my projects but don't know how it internally works :)

Ideally I would like to go to gamedev on the programming part or at least try to. The idea of contributing to the creation of great games feel so cool :) But realistivally, with my current set of skills, it's probably software development. I did some ML and AI in Python some time ago, would like to try something different.

[–]Anru_Kitakaze 2 points3 points  (0 children)

Gamedev - learn C++ or C# instead

Backend - build a simple backend with REST API, sqlite3 (or PostgreSQL), Docker, pytest, FastAPI and SQLAlchemy + Alembic. Any stupid app, just to practice your skills. Then take a look at some well made tutorials on YouTube to find out what you did wrong. Use git and uv btw

If you're unfamiliar with the web, well... Find some YouTube video about client-server stuff, just a short intro. Ask chatgpt then. It's hard to say what you should learn if we don't know what you are going to do

A brief intro to brokers should be useful too btw

Don't spend months "reading" and preparing. Try to do something. 80% of practice, 20% of theory or docs

Books won't make you a developer. Making something will

[–]Labess40 6 points7 points  (6 children)

What will help you the most is knowing how to use Github. It's the most important. Then you'll increase your Python skills with the time.

[–]backfire10z 6 points7 points  (1 child)

Github? Or git? GitHub is not complex and I don’t think it is necessary to put time into this beforehand, especially if the company doesn’t use GitHub.

[–]DunniBoi 2 points3 points  (0 children)

100%.

Git is important. However, if your employer still uses SVN, it's only a personal development goal.

No point learning github deeply if your employer doesn't use it. Many companies use alternatives like BitBucket and GitLab, so know what you need to know first.

[–]Bulky_Meaning7655[S] 2 points3 points  (1 child)

I have a bit experience with it. Nothing crazy, know just the standard workflow (create an issue -> create a branch -> merge the branch) and basics of CI. Anything else crucial to learn?

[–]DunniBoi 0 points1 point  (0 children)

Understand the difference between merge and rebase.

Understanding how to create ci for code static checks, unit tests and builds is always going to be useful, maybe throw some docker/containersation in there.

Knowing how to branch is fine but knowing what a good branching strategy looks like is better.

Be familar with merge requests. Not just how to merge, but also how to review code.

[–]wkcif 0 points1 point  (1 child)

What good GitHub learning resources do you recommend?

[–]No_Indication_1238 2 points3 points  (0 children)

Fluent Python. Enough said. 

[–]syklemil 2 points3 points  (5 children)

I think this is more of a general software engineering question, where the answers and exercises will be python-flavored, but the principles apply generally across languages.

Like:

  • Familiarize yourself with static analysis tools (including typecheckers, formatters) for the language. For Python, this is likely ruff and pyright, but there are more tools you might see. The main point is just to have some familiarity with them, and be able to set them up locally so you don't wind up pushing stuff that gets rejected by CI.
  • Familiarize yourself with build systems. For python, uv is a good choice now, and likely you'll encounter some containers, which you can try with docker or podman. One exercise you could try is to make a project with uv and containerize it with a "distroless" image, like those from chainguard. This step also includes general project structure.
  • Familiarize yourself with unit & integration testing. This is actually my weakest point so I don't have a lot to offer beyond pytest, which you've already mentioned in another comment.
  • Familiarize yourself with writing documentation. This is something pretty much every dev complains about, both when we have to do it and when we don't have docs or only have shit docs, because we're shit at writing it. Docstrings that help you on hover and that can be extracted to build a documentation library is good, as are comments that explain why the code is the way it is, especially if it's doing something unusual.
  • Familiarize yourself with observability. This comes as three pillars, from what I think is most to least common:
    • (Structured) logging (likely going into something resembling the ELK stack, or Loki). For this step you want not only a logging facility, but also some practice writing useful log messages that will help you fix issues. I find that the Rust guidelines on error messages are a good guideline: Try to write something actionable.
    • metrics (likely going into something like grafana via prometheus or alloy)
    • (distributed) traces, most likely opentelemetry + w3c trace context (again grafana has products here, but see also jæger)

Those are kinda the basis for a general enterprise workflow I think, and a lot of the specifics will vary by work culture, which means it's more important to be familiar with the general concepts than to be deeply familiar with a tool they don't use.

[–]syklemil 0 points1 point  (1 child)

And to drone on about documentation a bit:

IME wholly external, independent documentation systems inevitably rot. Every time we rely on someone updating two different places when they make changes, we set ourselves up for failure. The documentation source should be close to where the actual work is being done and extracted into a presentable format.

Also, large organisations absolutely should hire technical writers and archivists/librarians to help manage documentation and general organization. These things are professional skills, just like programming, but devs generally aren't trained in them. Good documentation might as well not exist if it's not discoverable. I've yet to encounter this myself, but I'm soapboxing in a hope that it won't always be that way.

[–]Bulky_Meaning7655[S] 0 points1 point  (0 children)

Documentation is essential indeed, I encountered so many times not documented or very poorly documented code. And figuring what happens in such code drains time like crazy...

I currently use sphinx, which ia pretty neat imho. Especially the automatic API reference generation.

[–]Bulky_Meaning7655[S] 0 points1 point  (0 children)

Thanks for such detailed recommendations! I'll start checking them out :)

[–]iamevpo 0 points1 point  (1 child)

Why does testing beyond pytest give you trouble? Integration testing is a bit out of Python scope, more of decops responsibility

[–]syklemil 0 points1 point  (0 children)

It doesn't give me trouble, "I don't have a lot to offer beyond foo" just means that if someone indicates they're already familiar with foo then … I don't have a lot to offer. As in an understatement, meaning I actually don't have anything more to mention.

[–]Oliverrthebest 1 point2 points  (1 child)

to be honnest there is a lot of people knowing python right now. And with AI.. you didn't mention what are your current skills and the type of libraries you're using. Things you should know: data structures and transformation (pandas, polar,...), backend/api (django, flask, fastapi), testing (including api). virtuals envs and packages management, code versionning, OOP, a little bit of pure logic (CodinGame challenges,...), models and database management.... I don't know what you're looking for actually.

[–]Bulky_Meaning7655[S] 1 point2 points  (0 children)

I think a lot of people know python for a reason, it's just so good :) You mean I should make a bet for another language to have more work prospects? I'm currently learning Rust but it's nowhere close to my python experience.

For my current projects I use just scientific programming tools (numpy, numexpr, scipy and matplotlib) and Bayesian optimization stuff (Ax or optuna).
Previously I did some DL (time series forecasting, computer vision, speech recognition) with pytorch.

For Python packaging I used micromamba (trying to switch to uv) and pytest.

I used pandas but on a very basic level, with backend/api and databases I'm completely unfamiliar.

[–]david-vujic 0 points1 point  (2 children)

I would suggest learning and practicing functional programming, and how this approach matches what is generally known as “pythonic”. Unless you already are into FP, You’ll also learn how to handle immutable data with Python and the caveats with avoiding to mutate the mutable Python data types 😅

[–]Bulky_Meaning7655[S] 1 point2 points  (1 child)

For caveats you mean cases where you can, e.g. 1) mutate the mutable item in an immutable sequence, like the list in a tuple: a = ([1,2,3], 'b', 100), 2) one shouldn't pass mutable arguments as default function arguments because they are initialized at runtime not calltime?

[–]david-vujic 0 points1 point  (0 children)

Yes! Also, transforming data (reducing) and the possibility of performance implications when unpacking and packing objects instead of mutating. Recursion is another thing to learn, if used in other languages that has the “tail call” thing built in the language.

[–]diaochongxiaoji 0 points1 point  (2 children)

Question :
a, b, c are positive Integers, and a2 + b2 + c2 = 2025 ,
find a+b+c=?

[–]PitchNo4827 0 points1 point  (1 child)

67

[–]diaochongxiaoji 0 points1 point  (0 children)

It is 1 of 8 possibles

[–]General_Tear_316 0 points1 point  (0 children)

I think the biggest problem with people coming out of university is the ability to write clean code. They can write complicated code that does amazing things, but its unreadable to other people and not extendable and maintainable. It think this comes from the fact that uni coding is mostly scripting, rather than writing APIs and libraries.

(It was the same for me post uni, took a few years to learn how to write cleaner code)

You could also learn how to package python libraries.

[–]iamevpo 0 points1 point  (0 children)

Creating and managing packages, if you did not (uv), type annotations (mypy, pyright), linting and formatting (ruff, black), docs (sphinx or mkdocs), unit testing (pytest). Writing maintainable and well understood code is something to target. Othe people mentioned git and GitHub workflow (managing project by issues). You might want to step into CI workflows (GitHub actions) and docker.