Built a Student Marks Evaluation System using Python 📊

Hi everyone! I recently completed a Student Marks Evaluation System as a practice project and would love to get some feedback.

Features:

Enter student details and marks

Calculate total marks and percentage

Automatically assign grades

Display results in a table

Generate a percentage bar chart

Visualize marks using a heatmap

Tech Stack:

Python

Pandas

NumPy

Matplotlib

Seaborn

Jupyter Notebook

This project helped me improve my Python programming, data analysis, and data visualization skills.

I'd appreciate any suggestions on how I can improve the project or make it more useful. You can also check out the GitHub repository here: [Your GitHub Link].

Thanks!

Hi everyone! I built a Fake News Detection System using Machine Learning, NLP, and Streamlit. The project classifies news articles as real or fake using text preprocessing and a trained ML model.

Features:

Text preprocessing with NLP

Fake/Real prediction

Interactive Streamlit web interface

Machine Learning classification

I'd appreciate any feedback or suggestions for improvement. If anyone wants to see the source code, I'd be happy to share it.

Hey guys please go and check the my first app which is pylife go can get it on playstore please check it , everything is there please check once give me suggestions what i can improve in it

Hey Everyone!

This project was proudly developed by DevX-Dragon (Abbadh), a 14-year-old developer from Sri Lanka!

Excited to announce the release of BetterQR v2.0.0, a huge update to our pure-Python QR code generation library! We've been working hard to bring you more features, better performance, and rock-solid stability. If you're generating QR codes, especially for advanced use cases, you'll definitely want to check this out.

What's New & Improved in v2.0.0?

This isn't just a minor patch; v2.0.0 introduces some game-changing features and critical fixes:

• Full Micro QR Support: Generate compact Micro QR codes (M1-M4) with correct auto-version selection. Perfect for small data payloads where space is critical.

• New Output Formats: Beyond PNG, JPG, SVG, and GIF, you can now export your QR codes as PDF and EPS! Ideal for high-quality print and vector graphics.

• Structured Append: Need to encode a lot of data? Split your message across up to 16 linked QR symbols that can be scanned sequentially. (Standard QR only).

• Kanji Mode & ECI (UTF-8): Improved support for international text with dedicated Kanji mode (Shift-JIS) and ECI (UTF-8) declarations for non-ASCII byte-mode payloads.

• Massive Performance Boost: PNG generation is now ~40% faster for common cases, thanks to indexed-mode rendering and optimized mask-pattern caching. We've also streamlined SVG output.

• Critical Bug Fixes: We squashed a severe bug in the Reed-Solomon block table that could silently corrupt QR codes at versions 30-40 (ECC M). Also fixed Micro QR data truncation, KeyError in logo rendering, and various data helper validation issues.

• Enhanced Reliability: Our test suite has expanded from ~56 to 172 focused tests, and we've switched to zxing-cpp for robust Micro QR decode verification.

Why Upgrade?

If you've been using BetterQR, v2.0.0 offers unparalleled stability and speed. If you're looking for a Python QR library, BetterQR now stands out with its unique combination of advanced features (like structured append, Micro QR, and vector outputs) and deep customization, all while remaining pure Python for core generation.

Installation

Upgrade or install BetterQR easily via pip:

bash pip install betterqr --upgrade

Check it out

GitHub

We'd love to hear your feedback and see what you build with BetterQR v2.0.0!

Salut r/PythonProjects2,

J'avais cette idée en tête depuis un moment : transformer n'importe quelle vidéo en vidéo ASCII (comme dans Matrix mais en pire qualité). Résultat : un petit projet fun.

Ce que ça fait :

- Lit une vidéo frame par frame avec OpenCV

- Convertit chaque frame en niveaux de gris

- Mappe chaque pixel vers un caractère ASCII selon son intensité

- Redessine tout ça avec Pillow et réassemble une vraie vidéo .mp4 en sortie

- Le tout avec une petite GUI Tkinter (parce que le terminal c'est bien mais un bouton "Convertir" c'est mieux) avec preview intégrée pour voir le résultat direct sans ouvrir un lecteur externe

Stack : opencv-python, pillow, numpy, tkinter (donc zero dépendance exotique)

Rien de révolutionnaire techniquement, mais c'était un bon exercice pour bosser le traitement d'image frame par frame + threading pour pas freezer l'UI pendant la conversion.

Le code est sur GitHub : https://github.com/KPRII/video-to-ascii

Curieux d'avoir vos retours, notamment sur la partie performance (le rendu Pillow caractère par caractère est clairement le goulot d'étranglement, si vous avez des idées d'optimisation je suis preneur)

I'm sharing xor-image-encryption, an open-source tool designed for rapid visual dataset obfuscation in computer vision and ML pipelines.

Repository: Yigtwxx/xor-image-encryption

Key Features:

• Strict Reproducibility: A specific seed consistently generates the exact same masking key, crucial for maintaining consistency across ML pipelines.
• Lossless Reversibility: The original image is perfectly restored by reapplying the XOR operation with the identical seed.
• Cascaded Encryption: Layer multiple seeds (e.g., 11 22 33) for enhanced obfuscation.
• Zero Bloat: Built purely on Python, NumPy, and Pillow. Includes built-in histogram analysis tools.

Target Use Case & Scope:

This utility is tailored for deterministic visual anonymization of sensitive datasets prior to cloud storage, third-party processing, or cross-team distribution. Note: It is meant for practical ML preprocessing and visual obfuscation, not as a replacement for cryptographic standards like AES.

Quickstart:

Bash

# Single-seed encryption & decryption
python xor_single.py --input sample.jpg --seed 42 --outdir outputs

# Multi-seed cascaded encryption
python xor_multi.py --input sample.jpg --seeds 11 22 33 --outdir outputs

I'd highly appreciate your feedback, PRs, or ideas for benchmarking!

**What My Project Does**

A command-line tool that converts files locally on your machine — images, PDFs (merge), audio, and video — without uploading anything to a third-party server. It also supports batch converting an entire folder at once. Built with Pillow, pypdf, pydub, and ffmpeg under the hood.

**Target Audience**

Anyone who wants a quick, privacy-friendly way to convert files without dealing with ad-riddled conversion websites. Also useful as a small, readable codebase if you're learning how to structure a multi-module Python CLI tool (argparse, subprocess calls to ffmpeg, etc).

**Comparison**

Most free online converters require uploading your file to their servers, show ads, or limit file size/format. This runs 100% locally, is open-source (MIT), and there's also a standalone .exe in the Releases for people without Python installed.

Repo: https://github.com/KPRII/convertisseur-fichiers

First real public project like this for me — feedback (positive or negative) is welcome!

Hi everyone!

I'm a first-year Computer Science student at the University of Exeter, and I've recently been learning about graph algorithms. To practice implementing them, I built a small packet routing simulator in Python that models a computer network as a weighted graph.

What My Project Does

The program models routers, switches, and servers as nodes in a directed weighted graph and uses Dijkstra's Algorithm to determine the lowest-cost route between two devices.

Features include:

• Computing the shortest packet route
• Calculating the total routing cost
• Visualizing the network with NetworkX
• Highlighting the optimal route in red
• Displaying edge weights for every network connection

One of my favourite parts was adding the visualization so that the algorithm's chosen path is immediately visible instead of only being printed to the console.

Libraries used

• Python
• networkx
• matplotlib
• heapq

📷 Screenshot

I've included screenshots and a visualization in the GitHub README:

https://github.com/johnsonnyabicha-alt/wilken_group

GitHub:
https://github.com/johnsonnyabicha-alt/wilken_group

Target Audience

This is primarily a learning and portfolio project rather than a production-ready networking simulator.

I built it to better understand graph algorithms, Python, and network visualization, and I'd especially appreciate feedback from more experienced Python developers on ways to improve the code structure or visualization.

Comparison

This isn't intended to compete with professional networking software or routing simulators. Instead, it's an educational implementation of Dijkstra's Algorithm that focuses on showing how shortest-path routing works through a clear visual representation of the selected path.

I'd really appreciate any suggestions for improvements or ideas for extending the project further.

Hello I built a front-end for cmake in Python, it allows you to write your build script in pure Python and get CMakeLists.txt for free, and I don't know which subreddit is the best to Ask for feedback.

https://github.com/bbalouki/cmakeless

A few weeks ago I posted here about pkgprint, a small library for print/packaging math (unit conversions, CMYK↔RGB, paper sizes, bleed calcs) built from my background in print/packaging tech, while learning Python this year.

Just shipped v0.2.0 with three new modules:

• check – inspect an actual image file and check if it's print-ready: effective DPI at your target print size, RGB vs CMYK color mode, and physical dimensions. Only real dependency (Pillow) is scoped to this module.
• accessibility – WCAG 2.1 contrast ratio checking for text/background color pairs, plus a function that suggests an adjusted color (same hue) that meets a target contrast ratio.

• dieline – flat sheet size + named panel layout math for RSC and tuck-mailer box styles, so you know your artwork canvas size before folding.

  import pkgprint

  report = pkgprint.full_report("artwork.tif", 210, 297) report.passed # True/False, plus a .summary with per-check diagnostics

  pkgprint.contrast_ratio((0,0,0), (255,255,255)) # 21.0 pkgprint.rsc_flat_size(300, 200, 150) # (1035.0, 350)

One thing worth sharing: while writing tests for the DPI checker, I asserted that "2480×3508 px" (the commonly cited pixel count for "A4 at 300 DPI") should pass a min_dpi=300 check. It failed. 2480 / (210mm / 25.4) = 299.97 DPI — a hair under 300 due to mm→inch rounding. The correct value is 2481×3508. Tiny in practice, but a good reminder that popular rounded numbers don't always hold up against the actual math.

• PyPI: https://pypi.org/project/pkgprint/
• Source: https://github.com/Rishabh55122/pkgprint

220+ tests, MIT licensed, zero-dependency core. Feedback welcome, especially if you work in print/packaging tooling and see something off — a few of the dieline formulas are flagged in the docs as approximations rather than supplier-verified exact geometry, and I'd rather know if something needs fixing.

Hi everyone!

I've been working on Vid2Scribe, an open-source project that automatically converts long videos into organized notes.

The goal is to make it much easier to learn from lectures, conference talks, tutorials, and other long-form videos without having to manually take notes.

Some of the current features include:

• Slide detection and extraction
• AI-generated structured notes
• Automatic speech transcription
• Markdown export
• Designed to work with modern LLM workflows

Python is the core of the project. It powers the entire processing pipeline, including video processing, transcription, OCR, note generation, and orchestration of the AI components.

I'm still actively developing it and would really appreciate feedback from the Python community.

Some questions I'm especially interested in:

• Are there features you would find useful?
• Any suggestions for improving the processing pipeline or project architecture?
• What would make this more useful for your own workflow?

GitHub:
https://github.com/China-WenboZhao/Vid2Scribe

I'd love to hear your thoughts and suggestions. Thanks!

Hi everyone,

A while ago, I noticed that there weren't many free or open-source tools for developers to evaluate how well someone speaks a sentence, given a piece of audio. To my knowledge, there were really only paid APIs such as SpeechSuper, Microsoft Azure AI Foundry, etc.. So I decided to make my own. After iterating through 5 versions of this feature, I finally made a tool that detects and evaluates pronunciation accuracy in real-time (given that you have GPU). I'm quite proud of it and so I released it as a standalone library on PyPI, so hopefully it will be useful to other people as well.

https://github.com/superasymmetry/pronounce-assess

Feel free to try it out and let me know what you think! I'm open to hearing any sort of comments. Or if you could kindly star my repo that would also be greatly appreciated. Thank you!

I graduated with a degree in Printing and Packaging Technology and spent the last few years doing freelance graphic design — branding, packaging, visual identity work. A few weeks ago, I started learning Python from scratch.

Somewhere around the "variables and f-strings" stage of my learning, I had an idea: every print/packaging designer I know does the same tedious math by hand, over and over — converting units, calculating bleed, translating CMYK to RGB for screen previews. There wasn't a clean Python library for any of it.

So I decided to build one — and publish it to PyPI as a way to actually use what I was learning instead of just doing tutorial exercises.

The result is pkgprint — a small, zero-dependency library for print and packaging math.

What it does

bash

pip install pkgprint

python

import pkgprint

# Standard paper sizes, no more googling "A4 size in mm"
w, h = pkgprint.paper_size("A4")
print(w, h)
# → 210 297

# Add bleed to a business card before sending to print
bleed_w, bleed_h = pkgprint.add_bleed(89, 51, bleed_mm=3)
print(bleed_w, bleed_h)
# → 95 57

# Convert a brand color from CMYK to RGB for a screen mockup
rgb = pkgprint.cmyk_to_rgb(0, 100, 100, 0)
print(rgb)
# → (255, 0, 0)

# Or straight to hex
print(pkgprint.rgb_to_hex(*rgb))
# → #FF0000

It covers four areas:

• Unit conversions — mm ↔ inches ↔ points, DPI/PPI
• Color conversions — CMYK ↔ RGB, hex ↔ RGB
• Standard sizes — ISO paper sizes, US sizes, common packaging box dimensions
• Print production math — bleed, safe margins, trim size calculations

What I learned building it

This was my first time going through the entire pipeline of shipping software, not just writing code that runs once:

• Modules and packages — how a folder of .py files with an __init__.py becomes one importable unit
• Testing — I wrote 100+ tests with pytest, including round-trip tests (e.g. converting RGB → CMYK → RGB and checking I get back roughly what I started with) — these caught real edge cases I hadn't thought about, like pure black in CMYK causing a division-by-zero in my first draft of the RGB-to-CMYK formula
• Packaging — pyproject.toml, building with python -m build, and the difference between a source distribution and a wheel
• The publish pipeline — TestPyPI first (to catch mistakes safely), then the real PyPI

The most surprising part: writing the tests actually forced me to think harder about the domain logic than writing the functions did. A test like "business card size + 3mm bleed on each side should equal exactly this" makes you notice ambiguity you didn't know was there — like the fact that "business card" means a different physical size in the US vs. ISO/European standards. That's a bug I only caught because a test forced me to be specific.

Try it / feedback welcome

• PyPI: https://pypi.org/project/pkgprint/
• Source: https://github.com/Rishabh55122/pkgprint

It's early (0.1.0), so if you work with print, packaging, or design-adjacent tooling and see something missing or wrong, I'd genuinely appreciate an issue or PR. And if you're also learning Python and thinking about building something — my honest takeaway is: pick a problem you already understand deeply from a non-coding background. It made the "why" of testing and structuring code obvious in a way tutorials hadn't.

Please check this out

m new in programming, idk what should I use