So the dirty secret is that project type is largely independent of programmer ability. Many absurdly ambitious projects are executed by relative beginners. They often function. I went from zero language knowledge to writing several large line-of-business applications in C# inside a year, including software with accountancy/tax responsibilities. Looking back at those projects I was barely beginner level, but they still worked and kept the company happy. It's the future developer who needs to maintain them that will pay the cost of my inexperience. Of course, this is considering domain knowledge - including specific algorithms, cloud architecture, databases and many other things - as independent of language ability. Someone might be a beginner at Python but able to quickly use machine learning or statistical analysis libraries, based on knowledge they already have. Other programmers might be able to pick up topics quickly enough that such skills still outstrip their Python experience, so they can learn by doing basically any project. Others may be very experienced Python developers, but can never get their heads around server management or cloud architecture, so certain projects remain out of their reach. The changes that come from Python "level" are broadly; Code style. Beginner Python devs either don't know language idioms, still have tics from other languages (or their teachers who came from other languages) or simply write excessively verbose code. Comments are either excessive or entirely absent. Intermediate devs will largely write idiomatic Python and be familiar with at least PEP 8 style. Some at this level will be dogmatic about style. Redundant comments are eliminated, while functions and classes generally have descriptive docstrings. Advanced devs will be familiar with a range of style approaches, know the trade-offs of each and be able to express and defend their preferences, while flexible to adapt to the style of any given project. Comments are high quality documentation on public APIs and eliminated by good naming selection where relevant. Project architecture Beginner devs often start from a single, fully imperative script. Even when things get broken into functions and classes, each entity tends to be huge and do several things, often operating on global variables or other shared state. Code is hard to read and harder to reason about. New features can't be added without a significant rewrite. Intermediate devs work with some concept of the single-responsibility principle (although the first principle of the Unix philosophy is more relevant) and a strict adherence to DRY . Code components become much easier to reason about. Project architecture is emergent rather than planned. Tests may or may not exist and are often trivial. Debugging eats a majority of project time. Advanced developers can plan out an architecture in advance to keep the project well structured, knowing what components need to exist and their relationship. Can write relevant tests for components based on their interactions and interfaces. Apply type hints and tests to streamline development cycle. Can focus on clean functionality additions. Core familiarity Beginner devs will know the basic built in types and usually how to work with them. Likely familiar with a some modules in the standard library and one or two of the major external libraries based on their initial goals (usually numpy/pandas or one of the web frameworks) and following tutorials with basic customisation. Can install additional libraries with pip, but may not be able to reliably debug issues if encountered. Intermediate developers will be familiar with a significant percentage of the standard library and able to properly select data structures and tools suited to a given task. Good familiarity with several external libraries, able to apply them to novel tasks. Enough knowledge of the wider ecosystem to select libraries and frameworks for new projects. Used to learning and adopting new features and frameworks. Able to manage project requirements and venvs, and handle common Python install issues (configuring path, managing multiple installs). Advanced developers will have knowledge of how language features are implemented in at least the standard interpreter - including implications for performance and feature choice - and know the broad strokes of alternate implementations such as PyPy and their relative advantages. Some capacity with Python bytecode and C/C++ for native compiled modules. Can properly manage public packages, familiar with the relevant tooling and tasks for dealing with such published software. FWIW, I still consider myself intermediate largely because I haven't used Python long term on anything large scale enough to say my advanced tier skills have been tested. I also haven't spent enough time in the internals in the last few years to be familiar with the latest developments. Mostly because I've been living in the DotNet world and working mostly with C#/F#. Probably written more C# classes than Python lines some months. I'd still consider myself able to pick up and implement nearly anything that comes up in Python, if required of me. More on reddit.com

Its not bad to experiment. Well we learn programming throught projects mainly. But i would recommend getting learning the basics of tkinter before trying. More on reddit.com

Blog The Invent with Python: "I Need Practice Programming": 49 Ideas for Game Clones to Code More on reddit.com

Any project your passionate about really, think of something you'd wanna create whether it be a pygame code for a game, a website with Django or Flask, a code that simplifies some repeative task your always doing? The best projects to learn from are the ones your passionate about and that interest you. Figure out what type of project would make you happy to learn, put together a roadmap of what you'd like to see implemented into that project and build your knowledge by building it into existence 😎 More on reddit.com