I made this Python Matplotlib Plotting tutorial for beginners.

Source codes can be downloaded from the link below

• Complete Matplotlib Library Graphing Tutorial using Python in under 1 Hour

The tutorial is designed for beginners who want to learn Matplotlib for building Data Acquisition and Data Logging applications using Arduino, Raspberry Pi, and other embedded systems. Learn how to create a Line Graph using Python and Matplotlib for visualizing data coming from an Arduino, Raspberry Pi, or other Embedded Systems.

Things Covered in This Video

• Installing Matplotlib
• Understanding the main concepts like Figure,Axes behind Matplotlib
• Creating a simple Line Chart using Matplotlib
• Understanding and using the subplots() method
• Using the .plot() method to plot graphs
• Changing graph line thickness and line style
• Controlling marker shape and marker size
• Naming the plot and creating a Legend
• Setting the names of the X and Y axis
• Setting Gridline color and visibility
• Changing the properties of a single Gridline
• Controlling Ticks in Matplotlib
• Understanding how Matplotlib chooses Ticks
• Working with Major and Minor Ticks

By the end of this tutorial, you will have a better understanding of how Matplotlib works and how its different components can be used to create customized line graphs.

A while ago, I developed a small multiplayer TRON-style lightcycle game in Python as a demo and potential student project for one of my university courses.

Rather than using an existing game networking framework, I implemented the client-server architecture myself, including:

• A custom TCP server with a simple text-based protocol
• Server-side game state management and collision detection
• A 2D client showing the arena from above, much like the spectators in the original TRON movie
• A 3D OpenGL client showing the game from the rider's perspective, including a minimap and views looking 90 degrees left and right

Both clients connect to the same server and can compete against each other.

The project was written the old-school way, without AI assistance. :)

I haven't had much time over the past year to polish it into a fully end-user-friendly application, but it's already quite fun to play.

I've now updated the README with screenshots and some details about the architecture and network protocol, and released the code under GPLv3.

Perhaps someone will find it interesting, want to experiment with it, or even use it as inspiration for a student project.

GitHub: https://github.com/michael-lehn/tron

Feedback and contributions are welcome!

Hi I’m learning coding with PY and I’ve just published my first “serious” project on GitHub, I would really appreciate suggestions and opinions about it!

https://github.com/kkoket

Hey r/PythonProject2! 👋

Esolang Translator is an open-source IDE for 43 esoteric and regular languages. It translates code between any pairs, features 2D visual editors for Piet/Rivulet, and includes a code sandbox. It’s a WIP project, so expect bugs—feedback is highly welcome!

Features:

· Multilingual UI – fully (and possibly badly!) translated into 6 languages: English, Русский, Deutsch, Español, Français, Italiano. · 43 languages – regular (Python, C++, JavaScript, etc.) and esoteric (Brainfuck, Piet, Whitespace, Malbolge, LOLCODE, etc.).

Links:

· GitHub: https://github.com/SuperCat-0877/esolang-translator-app · Releases (.exe + SHA256): https://github.com/SuperCat-0877/esolang-translator-app/releases · ChangeLog: https://github.com/SuperCat-0877/esolang-translator-app/blob/main/CHANGELOG.md

Known limitations:

· Some translation pairs are simplistic and produce awkward output. · BlockPiet and BrainPiet are project-internal variants, not official languages.

Feedback welcome! I wrote this code over the last 2 months. I'm sure there are small errors I couldn't find, so please don't be angry at my first project. I would really appreciate any feedback or advice! (Sorry I if wrote bad)

I built fracmem, an open-source package for approximating fractional-order memory with a fixed-length recursive filter.

Fractional-order methods can model long-memory behaviour, but directly computing from the full signal history can become expensive in both memory and computation.

fracmem uses a compressed approximation designed to keep memory usage and per-step computational cost bounded as a system runs. It also provides a C export path for resource-constrained embedded systems.

I'm exploring applications in UAV flight control, where onboard compute and memory are limited.

Install:
pip install fracmem

PyPI: https://pypi.org/project/fracmem/
Source: https://github.com/edith-lang/fracmem

I'd welcome technical feedback, contributions, and suggestions for validation on embedded hardware.

Hey everyone! I’ve been working on a project that organizes AI tutoring prompts into a structured learning path. I think AI has a lot of potential for education, and I wanted to explore how much more useful it could be with a clear curriculum and specific teaching instructions.

The current catalog covers Python in 28 learning blocks, from installing Python and writing your first program to testing, databases, APIs, and deployment. Each block has learning objectives and a prompt you can use with an AI assistant.

The prompts ask the AI to explain concepts, check your understanding through open-ended questions, give you practical exercises, and review your work. Based on your answers, it should revisit anything you’re struggling with and adapt to your pace. For more complex exercises, the AI guides you through the problem without solving it for you.

My goal is to make a thorough Python learning path available for free. I believe AI tutoring could offer new learning experiences, and I’d like to test how well this approach works in practice.

If you’re learning Python, whether you’re starting from scratch or filling gaps in your knowledge, I’d love for you to give it a try. I’m looking for people to use it and help me find out how well it works in practice.

If you try it, I’d appreciate hearing how it goes: what helped, what was confusing, or what could be better. But you don’t have to give feedback if you don’t want to; you’re welcome to just use it to learn.

Web: Click here and start learning Python with your AI tutor

i have created my first github project for my college mini project.
your review will help us a lot.

Apex Driver Lab

Qubit-007/Apex-Driver-Lab
A procedural driving simulator and reinforcement-learning sandbox built with Python and PyTorch. Train a policy against generated roads and traffic, inspect its behavior in a live GUI, and resume from versioned local checkpoints.

This project is an educational simulation. It is not designed, validated, or safe for controlling real vehicles.

Capabilities

I made a Ratio class in Python. It wasn't too hard, in fact this is very easy and can be done by anyone with a basic understanding of OOP.

import math


class Ratio:
    def __init__(self, numerator: float, denominator: float):
        self.numerator: float = numerator
        self.denominator: float = denominator

    def __str__(self) -> str:
        return f"The numerator is {self.numerator}, the denominator is {self.denominator}\nIts result is {self.calculate} \nThe lowest form is {self.lowest_form}"

    def __repr__(self) -> str:
        return f"Ratio(numerator = {self.numerator}, denominator = {self.denominator})"

    def __add__(self, ratio2: Ratio) -> Ratio:
        """Adds two ratios together, handles both same
        denominator and different denominators"""

        if self.denominator == ratio2.denominator:
            sum_numerator = self.numerator + ratio2.numerator
            return Ratio(sum_numerator, self.denominator)
        else:
            # Gets LCM of numerator and denominator
            main_lcm = self.lcm(self.denominator, ratio2.denominator)

            new_ratio1_numerator = self.numerator * (
                main_lcm / self.denominator
            )  # Gets the new numerator, e.g 1:2 + 1:3 now u get 3:6

            new_ratio2_numerator = (
                ratio2.numerator * (main_lcm / ratio2.denominator)
            )  # Gets the new numerator of thee second ratio, e.g(Following the above example) 2:6

            # Sums the two numerators
            sum_numerator = new_ratio1_numerator + new_ratio2_numerator

            return Ratio(sum_numerator, main_lcm)

    def __sub__(self, ratio2) -> Ratio:
        """Subtracts two ratios, handles both same
        denominator and different denominators"""

        if self.denominator == ratio2.denominator:
            diff_numerator = self.numerator - ratio2.numerator
            return Ratio(diff_numerator, self.denominator)
        else:
            # Gets the denominator LCM of both fractions
            main_lcm = self.lcm(self.denominator, ratio2.denominator)

            # New numerator, same logic here
            new_ratio1_numerator = self.numerator * (
                main_lcm / self.denominator
            )

            new_ratio2_numerator = ratio2.numerator * (
                main_lcm / ratio2.denominator
            )

            diff_numerator = new_ratio1_numerator - new_ratio2_numerator

            return Ratio(diff_numerator, main_lcm)

    def __mul__(self, ratio2) -> Ratio:
        """Very self explanatory"""
        prod_numerator = self.numerator * ratio2.numerator
        prod_denominator = self.denominator * ratio2.denominator
        return Ratio(prod_numerator, prod_denominator)

    def __truediv__(self, ratio2) -> Ratio:
        """For the division of two ratios, e.g 3:4/5:6"""
        # Fractional divison is very simple, (x / y) / (z / a) = xa / yz
        # The same principle has been applied here

        quo_numerator = self.numerator * ratio2.denominator
        quo_denominator = self.denominator * ratio2.numerator

        return Ratio(quo_numerator, quo_denominator)

    def __eq__(self, ratio2) -> bool:
        """Checks if two ratios are equal(in proportion)"""

        if not isinstance(ratio2, Ratio):
            return False

        return (
            self.numerator * ratio2.denominator
            == self.numerator * ratio2.numerator
        )


    def calculate(self) -> float:
        # Just returns the value of the ratio e.g 3:5 = 0.6
        return round(self.numerator / self.denominator, 12)


    def lowest_form(self) -> str:
        # Returns the lowest form, e.g 10:15 = 2.0, doesn't return Ratio to avoid recursion
        hcf = self.hcf(self.numerator, self.denominator)

        lowest_numerator = self.numerator / hcf
        lowest_denominator = self.denominator / hcf

        # If-else block so that 10:15 doesn't output 2.0:3.0
        if lowest_numerator.is_integer() and lowest_denominator.is_integer():
            return f"{int(lowest_numerator)} : {int(lowest_denominator)}"
        else:
            return f"{lowest_numerator} : {lowest_denominator}"

    def get_multiplier(self, a: str, b: str) -> tuple[int, int]:
        from_index_a = (
            a.index(".") + 1
        )  # Finds out how much you need to 10 ** to make a an int
        mul1 = 10 ** len(
            a[from_index_a:]
        )  # Figures out the 10 **, e.g for 0.05 this equals 10 ** 2 or 100

        from_index_b = b.index(".") + 1  # Same as "a"
        mul2 = 10 ** len(b[from_index_b:])

        mul_tuple = (mul1, mul2)  # Returns a tuple for easier unpacking
        return mul_tuple

    def lcm(self, a: float, b: float):
        # If two numbers are co-prime, i.e HCF(a, b) = 1, then their lcm is a * b
        if self.hcf(a, b) == 1:
            return a * b
        # Fun fact: a * b = hcf(a, b) * lcm(a, b) so lcm(a, b) = ab/hcf(a, b)
        else:
            return a * b / self.hcf(a, b)

    def hcf(self, a: float, b: float):
        # If both are ints, why go through the trouble?
        if isinstance(a, int) and isinstance(b, int):
            return math.gcd(a, b)
        elif a.is_integer() and b.is_integer():
            return math.gcd(int(a), int(b))
        # A bit tricky but easy enough
        else:
            # What to multiply with to make both floats ints
            greatest_mul = max(self.get_multiplier(str(a), str(b)))

            # Making the floats into ints
            big_a = int(a * greatest_mul)
            big_b = int(b * greatest_mul)

            # Dividing to return it back as a float and give an accurate hcf
            return math.gcd(big_a, big_b) / greatest_mul

Thoughts? Anyways no AI was used. You are free to use this code however you want.

Thanks!

Edit: Yes I do know that the Fraction class exists, this is just a project I made for fun.

Hey everyone,

Most process anomaly detection systems either trigger overwhelming alert fatigue or rely on black-box AI models that don't explain why an alert fired.

To study process-behavior detection from first principles, I built KERNEL SENTINEL — a Python-first research and detection platform.

Core Architecture & Engineering Highlights:

Since native eBPF requires a Linux kernel, I designed this environment-agnostic Python MVP to validate detection mathematics, streaming telemetry, and process correlation cleanly on Windows/Cross-platform first, while maintaining a strict interface for future native Linux sensor integration.

If you’ve ever wired up an LLM call just to pick a category and then fought with parsing its output, this might be useful.

Fri Oct 30, 9:30 AM to 12:30 PM ET, online, led by Ben Auffarth. It’s code first and the notebooks are runnable:

• fine tuning an encoder with SetFit on 8 examples per class
• split conformal prediction implemented from scratch
• Wilson score intervals and clustered standard errors for honest evaluation
• LangGraph state machine wrapping the whole thing

Intermediate Python is enough. Laptop or free Colab.

Full details and the agenda are here

Hi everyone,

I’ve been working on an open-source Python project called chatflow-agent.

The project started from a practical problem I had while building a contextual assistant: 
I wanted a relatively lightweight way to define and orchestrate agents, tools, handoffs, session state, and multi-agent workflows without introducing a large amount of infrastructure.

The main idea is to keep the API simple while still supporting things like:

- agents with tools
- tool calling
- agent-to-agent handoffs
- conversation and session memory
- SQLite-backed sessions
- async execution
- multiple LLM providers
- multi-agent workflows

The goal is to provide the core building blocks for agent workflows without requiring a large orchestration stack or locking the application into a single LLM provider.

Recently I’ve also been focusing on making the project easier for other developers to understand and contribute to.

The repository now includes:

- contributor documentation
- architecture documentation
- CI across multiple Python versions
- good first issues
- help wanted issues
- external contributions and pull requests

Receiving external contributions has already helped uncover edge cases and improve parts of the library.

At this point I’d be especially interested in feedback from other Python developers on:

- the public API
- architecture and separation of responsibilities
- tool and schema introspection
- session and memory design
- multi-agent handoffs
- multi-provider support
- documentation and examples
- anything that feels unnecessarily complex or unclear

I’m not trying to position chatflow-agent as a replacement for every existing agent framework.

The idea is to keep it relatively small, understandable, and useful for projects that want agent workflows without adopting a very large orchestration layer.

Repository:
https://github.com/GustavoBaranda/chatflow-agent

Technical feedback is very welcome. I’d be especially interested in what you would change before considering a library like this for a real project.

Ese sería el que publicaría en r/Pyt

**PDF → GP5** is a local web app (Python + FastAPI, vanilla JS) that:

* Parses tablature PDFs: text tabs, vector PDFs from notation editors, and raster pictures via OCR (OpenCV + RapidOCR/ONNX, all on-device).

* Rebuilds rhythm, techniques, repeats and lyrics, then writes Guitar Pro 5 files (PyGuitarPro).

* Plays them back in the browser with alphaTab, plus a three.js Rocksmith-style 3D highway.

* Is bilingual (English/Portuguese) and has a strict CSP. Conversions run in a sandboxed child process with time and memory limits.

Repo: [https://github.com/F100Pilot/PDF-to-GP5\](https://github.com/F100Pilot/PDF-to-GP5) (MIT)

Contributions welcome. Tuplets in pictures and section names are on the to-do list.