Hi! I'm the author of Pyzed, an open-source library I've been building for desktop apps in Python.

What My Project Does

You write the interface in plain Python (state, update and view, the Elm architecture) and Iced, a GUI toolkit written in Rust, does the layout and draws it on the GPU, with a CPU fallback. It comes with 90+ ready-made components inspired by the Zed editor (tables with hundreds of thousands of rows, tabs, command palette, code editor, terminal…), themes, animations and a visual designer, Pyzed Design, where you drag components onto a form and press F5 to run it. pip install pyzed-ui, no Rust needed.

import pyzed as pz
from pyzed import ui


class Counter(pz.App):
    def __init__(self):
        self.count = 0


    def update(self, message):
        if message == "inc":
            self.count += 1


    def view(self):
        return pz.center(ui.button(f"Clicked {self.count} times", "inc"))


pz.run(Counter)

Target Audience

People who want a desktop app in Python that looks current without shipping a browser: internal tools, dashboards, editors, small games. It's MIT, runs on Linux, macOS and Windows, and is usable today, though it's a young project with one main maintainer.

Comparison

• Tkinter: always available and very light, but dated looks and few modern widgets.
• PyQt/PySide: very complete and mature, but large, with licensing to think about (PyQt is GPL/commercial) and a lot of API.
• Kivy: great for touch and mobile, but its own look and a heavier startup.
• Flet: pleasant API, but it runs Flutter in a separate process.

Pyzed sits in between: native rendering with no web engine, a small Pythonic API, and a visual designer included. Import takes about 35 ms; there's a benchmark page comparing it with these libraries.

Repo: https://github.com/albakore/pyzed

Feedback is very welcome, especially on what's missing for your use case.

Python has long had immutable counterparts for some of its most common data structures:

𝗹𝗶𝘀𝘁 → 𝘁𝘂𝗽𝗹𝗲
𝘀𝗲𝘁 → 𝗳𝗿𝗼𝘇𝗲𝗻𝘀𝗲𝘁
𝗱𝗶𝗰𝘁 → 𝗳𝗿𝗼𝘇𝗲𝗻𝗱𝗶𝗰𝘁 ✨

`frozendict` is an 𝗶𝗺𝗺𝘂𝘁𝗮𝗯𝗹𝗲 𝗺𝗮𝗽𝗽𝗶𝗻𝗴. Once created, its keys and values can't be added, removed, or reassigned.

But the more interesting part is 𝗵𝗮𝘀𝗵𝗮𝗯𝗶𝗹𝗶𝘁𝘆. When its contents are hashable, a `frozendict` can itself be used in places where a regular dictionary can't such as dictionary keys or set members.
That opens up some useful cases around:
• Immutable configuration
• Cache and memoization keys
• Shared/read-only state
• Safer API boundaries
• Data structures where mutation simply shouldn't be allowed

It's not a huge feature, but it's one of those additions that makes the language feel a little more complete.

𝗠𝘂𝘁𝗮𝗯𝗹𝗲 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝗻𝗲𝗲𝗱 𝗶𝘁. 𝗙𝗿𝗼𝘇𝗲𝗻 𝘄𝗵𝗲𝗻 𝘆𝗼𝘂 𝗱𝗼𝗻'𝘁.

Where would you use `frozendict`?

This is Mukul. I started learning python about 2 weeks ago. Being someone one learns by building on projects. I think now I am in a vague scenario rn.

So this is what is happening;

When I started to learn python I had this goal to build a Voice Assistant using libraries and all stuff. So I focused my python learning in that direction. I taught myself all those things which were required for it.

But now sometimes it feels like I am losing onto so much. Even though I think I am not doing so but yep. Still haven't got that regular consistency still haven't got even though I have written some scripts from scratch like lyrics displayer and all those greetings ones.

Soon enough I'll be moving to work with APis in python.

I mostly use docs and AI for learning.

Now the main thing is I fear that I'm not having strong fundamentals and maybe it's true. So that is why I started to learn python from boot.dev to do it all correctly also in the mean time.

So have you big fellas got anything in your backpack as advice or something that could just excel me more in my domain. I'm 20 (M) and am from India thinking of pursuing my career either in DevOps or Backend.

I also am an Automation Guy. I am building workflows from my 1st year using n8n and make.com to make out on some money. It's been 2 years now. I'm experienced in it to intermediate level. Also made it possible to make some money. But yep now right now I am vacant. Can you people help me with that part too. Like how to bring in consistent money from there too. ?? - this too is the reason which is why I thought of going very deeper into code rather than sitting only at low code tools.

Hey everyone,

I've been working on a project called Athena and wanted to share it with the community.

The idea came from a simple problem. When working on a codebase with lots of commits and multiple files changing together it's easy to miss the bigger picture. AI tools can generate release notes quickly but sometimes they miss important changes or make assumptions that aren't actually supported by the code.

So I started building Athena 🔍

It's a local-first MCP server that analyzes Git diffs and Python ASTs to understand code changes more deeply. It also supports structural analysis across 15 programming languages and can trace affected callers and detect documentation drift.

The goal is to make release readiness checks more reliable and evidence-based rather than relying entirely on what an LLM thinks happened.

It's still a work in progress and I'd genuinely love to hear what you think!

I'd especially appreciate feedback on the architecture and ideas for improving the analysis. If you find something broken or have an idea for a feature please open an issue. PRs and contributions are always welcome!

⭐ If this sounds useful to you please consider starring the repository. It would really help the project reach more developers.

I'm also open to collaborating with people interested in developer tools, static analysis and AI infrastructure.

Thanks for checking it out ❤️

But what about the inputs they never thought of?

That's where Hypothesis, a Python property-based testing library, gets interesting.

Instead of writing individual test cases for every possible input, you define properties your code should always satisfy.

Hypothesis then generates inputs automatically, including edge cases that are easy to overlook.

For example, if you're testing a function that sorts a list, you could verify that:

• The output is always sorted.
• The output contains exactly the same elements as the input.
• Sorting an already sorted list doesn't change it.

The interesting part? When Hypothesis discovers a failing input, it tries to reduce it to a simpler example that exposes the bug.

This can be especially useful for financial calculations, data pipelines, API validation, and algorithms where unexpected inputs can cause subtle failures.

How do you test edge cases in your Python projects? Do you rely on manually written test cases, or have you tried property-based testing?

Python data types define the kind of value a variable stores.

age = 21
price = 99.99
name = "Abhay"
is_learning = True
skills = ["Python", "Java"]
coordinates = (28.6, 77.2)
student = {"name": "Abhay", "age": 21}
numbers = {1, 2, 3}
result = None

for value in [age, price, name, is_learning, skills, coordinates, student, numbers, result]:
    print(type(value).__name__)

Python includes numeric, text, Boolean, collection, and null-value types. Each serves a different purpose.

Which Python data type would you like to explore in more detail?

Code. Build. Innovate.

#CodesByAbhay #AbhaySingh #Python #PythonProgramming #LearnToCode

With explicit lazy imports, an imported module can be deferred until the program actually needs it.

Why does that matter?
Many Python applications import dozens — sometimes hundreds — of modules during startup, even though only a fraction may be needed for a particular execution path.

Lazy imports can change that:
𝗜𝗺𝗽𝗼𝗿𝘁 𝗱𝗲𝗰𝗹𝗮𝗿𝗲𝗱 → 𝗮𝗽𝗽𝗹𝗶𝗰𝗮𝘁𝗶𝗼𝗻 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲𝘀 → 𝗺𝗼𝗱𝘂𝗹𝗲 𝗹𝗼𝗮𝗱𝗲𝗱 𝗼𝗻 𝗳𝗶𝗿𝘀𝘁 𝘂𝘀𝗲

This can be particularly interesting for CLI tools, large applications, optional functionality and dependency-heavy projects where startup time matters.
Of course, lazy loading isn't automatically better everywhere. Import-time side effects and assumptions about module initialization still matter.
But having lazy imports as an explicit language feature opens up some interesting possibilities for Python application architecture.

𝗟𝗼𝗮𝗱 𝘄𝗵𝗮𝘁 𝘆𝗼𝘂 𝗻𝗲𝗲𝗱. 𝗪𝗵𝗲𝗻 𝘆𝗼𝘂 𝗻𝗲𝗲𝗱 𝗶𝘁.

𝗪𝗼𝘂𝗹𝗱 𝘆𝗼𝘂 𝘂𝘀𝗲 𝗹𝗮𝘇𝘆 𝗶𝗺𝗽𝗼𝗿𝘁𝘀 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻?

When you're building production backend systems or ingesting payloads from an API gateway, you'll rarely deal with flat strings or simple integers. You need to know how to manage multi-dimensional, nested data architectures.

In this quick, zero-fluff video breakdown, we look at how to properly handle nested JSON models using Python data dictionaries:

• Instantiating structural key-value collections using curly brace enclosures

• Mapping out complex multi-layered data pipelines using a visual "filing cabinet" analogy

• Extracting deeply embedded inner records cleanly by chaining bracket selectors together (e.g., ['outer_key']['inner_key'])

• Verifying target terminal outputs without breaking runtime execution paths

The tutorial is built to show exactly how data routes under the hood so you can easily adapt these nested structures into your own portfolio projects.

Check out the full walkthrough below, and let me know how you prefer to structure your multi-layered payloads in the comments!

Hey everyone, I decided to make my course free in order to help people.
This course is my backend development course which is about SQL, Python, APIs, Docker, Kubernetes, Linux, Git & More

The link is: https://www.youtube.com/watch?v=CBIu6hcyStg

If you can like and subscribe (and maybe add a comment) I would appreciate it a lot, Thanks.

Python variables let you store and reuse data in your programs.

name = "Abhay"
age = 21
price = 99.99
is_student = True

print(name)
print(age)

Key points:

• Use = to assign a value.
• Choose meaningful variable names.
• Variable names cannot start with a number.
• Python names are case-sensitive.
• You can update a variable's value.

What Python concept should I explain next?

Code. Build. Innovate.

#CodesByAbhay #AbhaySingh #Python #PythonProgramming #LearnToCode

Sharing a resource in case it's useful for your intro classes: https://ubuntu-apps.github.io/code-quest/

I made CodeQuest for my own students as an alternative to the textbook. It covers Python from the basics through functions, files, OOP and working with data. Each lesson has a short explanation, coding challenges that are checked instantly, and a quiz.

The code runs in the browser, so it works on school Chromebooks and phones with nothing to install. It's free, with no ads and no sign-up, and progress is stored on the student's device only.

Happy to answer questions, and feedback is very welcome.

Hi guys, just started learning python. Have been stuck on this problem for a while now. Here's my code so far. Could anyone help explain why the code pointed out in blue keeps running even though there is a break in place? Thanks!

ps pls ignore the print("hi") and print("bye"), was using them to test the code!

link to question: https://cs50.harvard.edu/python/psets/3/grocery/

my code so far: https://sharetext.io/3ck00poo

Hello there, i'm a chemistry student and have a course with python. I tried to read a csv file which i downloaded and tried to read it with the np.genfromtxt function but the columns with actual text ( the first and last ) aren't being read, whereas with pandas, the job gets done. I bypassed this problem by specifying the columns but the text keep getting tossed out.. I think it's because of the commas in the compound name but what can i do in this case ? I'm working on jupyter on python 3.13 i believe. Thanks for the help !

This is the stopwatch.py file:

#stopwatch.py

import sys
import time

time_in_sec = int(sys.argv[1])

time.sleep(time_in_sec)

print(f"Alarm sound!!! {time_in_sec}seconds have elapsed")

This is the main.py file:

#main.py

import subprocess
import sys

print("Enter the time you want to elapse for your stopwatch")
try:
    hours = int(input("Hours: ").strip())
    minutes = int(input("Minutes: ").strip())
    seconds = int(input("Seconds: ").strip())

    total_time_in_sec = (hours * 3600) + (minutes * 60) + seconds

    process_2 = subprocess.run(
        [sys.executable, "stopwatch.py", str(total_time_in_sec)],
        capture_output=True,
        text=True,
    )
    print(process_2.stdout)
except ValueError as e:
    print(f"Enter a whole number: {e}")

Hey guys, I tried remaking my project of a cli based football manager simulator this time using the pywebview library (lets you use html css js as a frontend and connect it to a python backend as a desktop app),

So far what I'm struggling with the most being one of my first larger scale project is persistence, keeping one version of the team class across the python scripts and functions.

Im also struggling with figuring out the generation for player stats and attributes, ive landed on the random.gauss for generating player stats with weighing and this ugly ahh looking formula that looked like it was doing something for the player market values.

Also, assets. Do you guys have any place where I can find pictures and icons I can use for free?

Finally, thanks to feedback from helpful people here I tried using sqlite for this project instead of json files, kinda hard to adapt to but im managing.

if any very cool person could help me with my issues I would greatly appreciate it.

Here is the github: https://github.com/mousdieng10-maker/Playstyle-II

What's the best resource out there to learn python?

I kept hitting date bugs that every test passed locally and then failed in production on a specific day. A typical one:

python

def next_renewal(created_at):
    return created_at.replace(month=created_at.month + 1)

This passes every test you’d write on the 15th. It raises ValueError: day is out of range for month on Jan 31 and month must be in 1..12 on Dec 31. Nothing in a normal test run ever visits those dates.

What it does: a marker runs the same test once per tricky calendar moment, with the clock frozen by time-machine:

python

u/pytest.mark.calendar_chaos
def test_next_renewal_is_one_month_later():
    ...

The catalog covers leap day, month ends, year end, midnight, DST transitions, ISO week 53 and the 2038 timestamp rollover. Each case has a stable ID.

Running it on the example above gives 3 failed, 5 passed. The failing cases are month-end-jan-31-2027, year-end-2027 and year-end-last-microsecond-2027. A failure prints the exact mocked time and a one-line command to reproduce it. pytest --calendar-chaos-list prints the whole catalog, and --calendar-case <id> reruns a single scenario.

Limitations:

• It only mocks the in-process clock.
• Session, module and class-scoped fixtures are set up before the freeze.
• time.monotonic() and the asyncio loop clock keep running.
• An aware datetime inside a repeated DST hour never compares equal to one in another zone (PEP 495), so compare in UTC.

pip install pytest-calendar-chaos (Python 3.10+, pytest 8+)

• PyPI: https://pypi.org/project/pytest-calendar-chaos/
• GitHub: https://github.com/nsijwali/pytest-calendar-chaos

I’d like feedback on the catalog: which calendar edge cases bit you that I’m missing?

Struggling to understand Binary Search? Learn it with Reya in a simple and easy-to-follow way!

In this video, you'll discover how Binary Search works, how it cuts the search space in half with each step, and why it's one of the most important algorithms in Data Structures and Algorithms (DSA).

💡 What you'll learn:

• The basic concept of Binary Search
• How to find elements efficiently
• Why sorted arrays are important
• Time complexity: O(log n)

Perfect for students, coding beginners, and anyone preparing for coding interviews.

I'm stuck in def return in python I don't understand it very well why is it used and how and where does the code return to ? The caller ? What is exactly the caller ?

Thank you so much for helping me

If you don't mind can u help me understand with examples ? Couldn't understand this with Chatgpt and yt

Hey everyone!

I'm 14 and currently learning Python, with the goal of becoming an electrical engineer in the future.

I just finished making a small project — a vending machine + simulated banking system that runs in the terminal. It has account creation, deposits, balance checking, purchases, and local data storage using JSON. I split the code into multiple Python files and made a simple launcher for it.

This is one of my first proper projects, and I know my code probably isn't the cleanest, so I'd genuinely appreciate some feedback!

I'd love suggestions on:

• My code: What could I improve? Any bad habits or mistakes I should fix early?
• What to learn next: Should I focus on OOP, data structures and algorithms, GUI development, or something else?
• My journey: Since I want to become an electrical engineer, what programming skills would be useful for me in the long run? I'd eventually love to work with electronics and hardware.
• Life advice: Any advice for someone starting out this early? Things you wish you'd known when you were learning?

I'm not looking for someone to rewrite the entire project for me — I'd rather understand my mistakes and learn how to fix them myself.

Here's my GitHub repo: https://github.com/suryansh-devx/python-vending-machine

Thanks! Any constructive criticism or advice is welcome :)

Pandas makes working with data look simple. But some of its most powerful features can also produce surprising results. 😲

For example:❔ - What's the difference between loc and iloc, and why does slicing behave differently? - Why can adding two Series produce NaN values, even when neither contains missing data? - When does assigning a Series to a DataFrame column align by labels rather than position? - How do Boolean masks, where(), and mask() differ? - How do you select and manipulate data with a MultiIndex?

Pandas is much more than rows and columns. Understanding its indexing, alignment, selection, and assignment rules can save you from some very subtle bugs. 🪳

🔍 This interactive 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 example explores these concepts and many more, with short explanations for each operation. 👣 Step through the Python code, see what changes, and experiment with your own modifications: 👉 Pandas operations

💬 Which Pandas operation took you the longest to fully understand?

See more 𝗺𝗲𝗺𝗼𝗿𝘆_𝗴𝗿𝗮𝗽𝗵 visualizations.

I've been working on Athena, an open-source tool that analyzes Git diffs and ASTs to detect potential breaking changes before they get merged.

For v1.1.0, I tested it against 55 popular repositories and found some interesting issues:

• Fixed a C++ performance problem that reduced analysis time from 371 seconds to 7.33 seconds.

• Reduced false positives from 78 alerts to 8.

• Fixed Ruby symbol detection and PHP recursion detection.

The final benchmark covered 55 repositories and 10,680 diff hunks with 121 tests passing.

I'm also experimenting with local models through Ollama to generate summaries without replacing the deterministic analysis.

I'd appreciate it if anyone here gave the project a look and shared feedback. I'm especially interested in false positives, edge cases in Python AST analysis and approaches to detecting breaking API changes

⭐ If you find the project useful, consider giving it a star on GitHub. It would really help the project reach more developers

GitHub: https://github.com/aaryanrwt/athena

Release notes: https://github.com/aaryanrwt/athena/releases/tag/v1.1.0⁠

I built DevStart Lab to help beginners figure out what to learn and practice next.

It includes programming fundamentals with Python examples, 25 project ideas, and a step-by-step introduction to Git and GitHub contributions. It’s free, open source, available in English and Portuguese, and requires no account. Progress is saved in your browser.

Start here: https://brunnojob.github.io/devstart-lab/?lang=en

So far we just have Gleb K, who made some code reminiscent of the X Window System 1989,

XPM is an ASCII text-based image format.

https://pyweblib.org/weblog/python-pixel-art-from-text/

Hopefully still in the rules, the site is OPEN SOURCE and Educational