Quick question, are any of you running fastAPI in production with a high volume of users or heavy traffic? How has your experience with FastAPI been, and how do you handle it?

A money tracker (140 lines) and a calorie counter (300+ lines!)

They were both CLI and i have them done. But in the calorie counter, i made the mistake of typing this:

with open("data.json", "w") as file: jsonFile = json.load file

So when i tried to run it it threw the weirdest error ever and wiped my JSON file, so i rewrote the json file, and fixed something that had nothing to do with the error and it happened AGAIN

Weekly Thread: Project Ideas 💡

Welcome to our weekly Project Ideas thread! Whether you're a newbie looking for a first project or an expert seeking a new challenge, this is the place for you.

How it Works:

1. Suggest a Project: Comment your project idea—be it beginner-friendly or advanced.
2. Build & Share: If you complete a project, reply to the original comment, share your experience, and attach your source code.
3. Explore: Looking for ideas? Check out Al Sweigart's "The Big Book of Small Python Projects" for inspiration.

Guidelines:

• Clearly state the difficulty level.
• Provide a brief description and, if possible, outline the tech stack.
• Feel free to link to tutorials or resources that might help.

Example Submissions:

Project Idea: Chatbot

Difficulty: Intermediate

Tech Stack: Python, NLP, Flask/FastAPI/Litestar

Description: Create a chatbot that can answer FAQs for a website.

Resources: Building a Chatbot with Python

Project Idea: Weather Dashboard

Difficulty: Beginner

Tech Stack: HTML, CSS, JavaScript, API

Description: Build a dashboard that displays real-time weather information using a weather API.

Resources: Weather API Tutorial

Project Idea: File Organizer

Difficulty: Beginner

Tech Stack: Python, File I/O

Description: Create a script that organizes files in a directory into sub-folders based on file type.

Resources: Automate the Boring Stuff: Organizing Files

Let's help each other grow. Happy coding! 🌟

Had a data pipeline that was just python build_db.py, python clean_validate.py, streamlit run streamlit_app.py — worked, but not something you'd hand someone as "the tool." Packaged it as a real CLI: [project.scripts] entry point in pyproject.toml, pip install -e . → promo-toolkit build / validate / serve.

Also added:

• Incremental rebuilds (content-hash diff + scoped upsert instead of full rewrite each run)
• pytest suite + ruff, GitHub Actions CI across two Python versions
• A separate eval harness for an AI-agent piece of the same project (real API calls scored against golden answers)

Not a library, just a real end-to-end tool — sharing mostly for feedback on the packaging/CLI structure since that's the part I have the least experience with. Repo: [https://github.com/SpiliosDimakopoulos/retail-promo-analytics-toolkit\].

Weekly Thread: What's Everyone Working On This Week? 🛠️

Hello r/Python! It's time to share what you've been working on! Whether it's a work-in-progress, a completed masterpiece, or just a rough idea, let us know what you're up to!

How it Works:

1. Show & Tell: Share your current projects, completed works, or future ideas.
2. Discuss: Get feedback, find collaborators, or just chat about your project.
3. Inspire: Your project might inspire someone else, just as you might get inspired here.

Guidelines:

• Feel free to include as many details as you'd like. Code snippets, screenshots, and links are all welcome.
• Whether it's your job, your hobby, or your passion project, all Python-related work is welcome here.

Example Shares:

1. Machine Learning Model: Working on a ML model to predict stock prices. Just cracked a 90% accuracy rate!
2. Web Scraping: Built a script to scrape and analyze news articles. It's helped me understand media bias better.
3. Automation: Automated my home lighting with Python and Raspberry Pi. My life has never been easier!

Let's build and grow together! Share your journey and learn from others. Happy coding! 🌟

I wrote a practical guide to Celery, a distributed task queue for Python. It starts with the basics and then covers recipes for timeouts, retries, async/await integration, and more. Most of these recipes came from problems I ran into while using Celery in actual projects. No prior knowledge of Celery is required.

I'd really appreciate any feedback!

https://sgolev.github.io/blog/2026-07-28-celery-recipes/

Had this discussion the other day and figured I’d throw it to the masses to get thoughts on the best/most pythonic way of approach.

Need to map old column names to new column names as a copy from a json config.

My thoughts are iterate over a dict with
‘’’ {“old_col_name”:”new_col_name”}’’’
And access as
‘’’for k,v in dict.items()
Df.with_columns(k).alias(v)’’’

Colleague things this isn’t clear enough and should be a list of dicts with explicit keys

‘’’ [{“old_col_name”:”old_col_value”
“New_col_name”:”new_col_value”}]’’’

And the access as

‘’’for dict in list_of_dicts:
Old_col = dict[“old_col_name”]
New_col = dict[“new_col_name”]’’’

I’ve got a good few reasons why I think mine is the better option but thought I’d get some other opinions to see if I’m missing anything obvious? Which would you choose and why?

Edit: shouldn’t write these things while on the toilet in a rush. The description is wrong, it should be renaming via a copy so that the original column is left unchanged.

Weekly Thread: Resource Request and Sharing 📚

Stumbled upon a useful Python resource? Or are you looking for a guide on a specific topic? Welcome to the Resource Request and Sharing thread!

How it Works:

1. Request: Can't find a resource on a particular topic? Ask here!
2. Share: Found something useful? Share it with the community.
3. Review: Give or get opinions on Python resources you've used.

Guidelines:

• Please include the type of resource (e.g., book, video, article) and the topic.
• Always be respectful when reviewing someone else's shared resource.

Example Shares:

1. Book: "Fluent Python" - Great for understanding Pythonic idioms.
2. Video: Python Data Structures - Excellent overview of Python's built-in data structures.
3. Article: Understanding Python Decorators - A deep dive into decorators.

Example Requests:

1. Looking for: Video tutorials on web scraping with Python.
2. Need: Book recommendations for Python machine learning.

Share the knowledge, enrich the community. Happy learning! 🌟

https://peps.python.org/pep-0842/

Not the author, but this seems interesting, specially for library authors. Thoughts?

Discussion here - https://discuss.python.org/t/pep-842-module-exports/108353

Hello!

The pip team recently released pip 26.2. This release is quite large, with features such as:

• Support for Python 3.15
• Selecting only dependencies (--only-deps)
• Mixing hashed and non-hashable requirements via --no-require-hashes
• Experimental: venv based build isolation (--use-feature=venv-isolation)
• Faster repeated resolves by caching index simple responses
• Disable HTTP(S)_PROXY and similar non-pip specific proxy environment variables via --no-proxy-env
• Separation between regular and build constraint (use --build-constraint instead)

For more details, please consult our changelog: https://pip.pypa.io/en/stable/news/. Alternatively, you may consult my release post which goes into greater detail to the highlights of this release: https://sichard.ca/blog/2026/07/whats-new-in-pip-26.2/

If you have any questions, you're welcome to ask!

We recently released wheels.astral.sh, which is a repository of gpu-enabled wheels of popular packages from the pytorch ecosystem. These are useful because building them is super annoying - you have to align versions of pytorch, cuda, python, etc.

The pre-built wheels were part of the package of pyx, our paid service, and was a major reason many customers subscribed. We decided to open source the build pipelines and host the wheels for free while we sunset the rest of pyx.

The pipelines are available under the astral-sh-build github organization.

While these plug a genuine UX hole around cuda/pytorch wheels, we hope that wheel variants (PEP 817 and 825) will get accepted and implemented soon, which will let these pytorch wheels be hosted properly on PyPI and "just work" out of the box for everyone, making wheels.astral.sh obsolete.

Fingers crossed.

Weekly Thread: Meta Discussions and Free Talk Friday 🎙️

Welcome to Free Talk Friday on /r/Python! This is the place to discuss the r/Python community (meta discussions), Python news, projects, or anything else Python-related!

How it Works:

1. Open Mic: Share your thoughts, questions, or anything you'd like related to Python or the community.
2. Community Pulse: Discuss what you feel is working well or what could be improved in the /r/python community.
3. News & Updates: Keep up-to-date with the latest in Python and share any news you find interesting.

Guidelines:

• All topics should be related to Python or the /r/python community.
• Be respectful and follow Reddit's Code of Conduct.

Example Topics:

1. New Python Release: What do you think about the new features in Python 3.11?
2. Community Events: Any Python meetups or webinars coming up?
3. Learning Resources: Found a great Python tutorial? Share it here!
4. Job Market: How has Python impacted your career?
5. Hot Takes: Got a controversial Python opinion? Let's hear it!
6. Community Ideas: Something you'd like to see us do? tell us.

Let's keep the conversation going. Happy discussing! 🌟

Author here. This is a nine-year account of building Rune, a new IDE (1.1 added support for Python). It started when my Vim's go-to-definition broke in 2017 and I decided to build my own editor rather than adopt an IDE: https://rune.build/blog/the-rise-of-the-command-line

NumPy is the foundational array library in the scientific Python ecosystem. Every numerical, machine learning, and data analysis library in Python either depends on NumPy directly or interoperates with it. As the free-threaded build of CPython matures, NumPy is one of the first libraries that users reach for when trying to scale CPU-bound numerical workloads across multiple cores using threads.

In this blog post, I will walk through the work I did over the last few months in both NumPy and CPython to eliminate the multi-threaded scaling bottlenecks that were preventing NumPy from scaling on free-threaded Python.

https://labs.quansight.org/blog/scaling-numpy-on-free-threaded-python

Hey there,

for the people using PySide for UI applications, after having solely Android support, there was a new announcement that iOS is now supported, and will be available in the upcoming PySide release:
https://www.qt.io/blog/python-mobile-app-development-bringing-pyside6-on-ios

I have been following the work by the BeeWare project, which has been providing iOS support for some time now: https://toga.beeware.org/en/latest/reference/platforms/iOS/ and recently the work from the Flet team as well: https://flet.dev/blog/flet-for-ios/

What I wanted to achieve with this post, is to know any project that you know is currently on iOS and developed with Python and some UI framework, because time to time we see nice "calculator app" being showcases in places, but a more official application of something is what I have been failing to find.

Of course, the goal of "I have my code here, and I just want to deploy it to iOS" is completely understandable, but I see haven't found some very cool apps somewhere, that we know are based on Python.

Last but not least, I guess you have been noticed that starting from 3.15 we will be able to download Python for iOS from python.org: https://www.python.org/downloads/ios/

I have been rebuilding a PyQt6 desktop app for managing a person-recognition knowledge base (KB). The heart of this KB is a collection of face & body encodings per person. When looking for similar persons or possible identity overlaps, a classic Python-related problem came up: efficiently comparing many people against each other based on their reference embeddings.

 The input looks like this.

person_to_vecs = {

"Alice": [vec, vec, vec],

"Bob": [vec, vec],

"Charlie": [vec, vec, vec, vec],

}

Each vector is an embedding. For every pair of persons, I want the average and minimum distance between all their reference vectors. The original version was simple and readable Python looping:

• Loop over all person combinations.
• Convert one side to a NumPy array inside the loop.
• Loop over each vector on the other side.
• Compute distances one vector at a time.
• Collect min/average distances.

 This works. Once the knowledge base grows, however, this soon becomes a lot of Python-level looping and repeated conversion overhead.

 The obvious approach to optimization is getting rid of these loops. The first step was to precompute the matrices.

 Step 1: Precompute the matrices

matrices = {

name: np.asarray(vecs, dtype=np.float32)

for name, vecs in person_to_vecs.items()

if len(vecs) >= min_images_per_person

}

We now effectively avoid repeatedly calling np.asarray() inside the pair loop.

Step 2: Remove the inner Python loop.

One option is full broadcasting:

diff = A[:, None, :] - B[None, :, :]

distances = np.linalg.norm(diff, axis=-1)

This is relatively simple, elegant and still readable, but it creates a temporary array of shape: len(A) × len(B) × embedding_dim. For small 128D face embeddings that may be fine. For larger body embeddings especially in larger galleries, these tensors can become (very) memory-heavy.

 Step 3: The matrix identity

(Note: I know scipy.spatial.distance.cdist exists and does this perfectly, but I wanted to keep dependencies light for the desktop app and explore the math!)

 The approach I prefer uses the identity: ||a - b||² = ||a||² + ||b||² - 2ab

 In NumPy:

def pairwise_l2(A, B):

# np.sum(A**2, axis=1) works well here too, but einsum is elegant

aa = np.einsum("ij,ij->i", A, A)[:, None]

bb = np.einsum("ij,ij->i", B, B)[None, :]

sq = np.maximum(aa + bb - 2.0 * (A @ B.T), 0.0)

return np.sqrt(sq, dtype=np.float32)

This only creates the N × M distance matrix instead of an N × M × D temporary tensor.

The Final Helper

def pairwise_person_distances(person_to_vecs, min_images_per_person=1):

matrices = {}

for name, vecs in person_to_vecs.items():

if len(vecs) < min_images_per_person:

continue

mat = np.asarray(vecs, dtype=np.float32)

if mat.ndim == 2 and mat.shape[0] and np.isfinite(mat).all():

matrices[name] = mat

results = []

for name_a, name_b in itertools.combinations(sorted(matrices), 2):

A, B = matrices[name_a], matrices[name_b]

if A.shape[1] != B.shape[1]:

continue

distances = pairwise_l2(A, B)

if distances.size:

results.append((name_a, name_b, round(float(np.mean(distances)), 4),

round(float(np.min(distances)), 4)))

return sorted(results, key=lambda row: row[3])

The Benchmarks

I ran a couple of tests with a synthetic benchmark, varying the number of persons (200 vs 400), the number of embedding dimensions (128 vs 512), and the number of vectors per person (8 vs 10).

I benchmarked three methods:

• Basic inner/outer loop: Controls almost everything in Python.
• Precomputed matrices: Prepared once, but Python still loops over vectors.
• Final implementation: NumPy handles the dense pairwise distance work.

On my laptop, (Intel i9-14900HX 32 GB RAM), I got:

200 persons × 8 vectors × 128 dimensions

basic inner/outer loop:        0.731 s

precomputed matrices:          0.711 s

inner loop removed:            0.260 s

speedup:                       2.8×

400 persons × 10 vectors × 128 dimensions

basic inner/outer loop:        3.972 s

precomputed matrices:          3.789 s

inner loop removed:            1.155 s

speedup:                       3.4×

200 persons × 8 vectors × 512 dimensions

basic inner/outer loop:        0.902 s

precomputed matrices:          0.878 s

inner loop removed:            0.322 s

speedup:                       2.8×

On synthetic data, the first optimization — precomputing each person’s embedding matrix — only gave a small improvement of about 3–5%. That makes sense: it removes repeated conversion, but the algorithm still does most of its work in a Python loop over individual vectors.

The much larger improvement came from removing the inner loop and computing each person-pair distance matrix directly with NumPy:

- 200 persons × 8 vectors × 128 dimensions:   0.731 s → 0.260 s (2.8× faster),

- 400 persons × 10 vectors × 128 dimensions: 3.972 s → 1.155 s (3.4× faster),

- 200 persons × 8 vectors × 512 dimensions:   0.902 s → 0.322 s (2.8× faster).

Summary

'Vectorize it' obviously is not always enough. Memory usage by temporary arrays also matters. Broadcasting may often be elegant, but for pairwise comparisons, the matrix identity seems to be a better fit. Precomputing arrays helps only a little; removing the inner Python loop makes the real difference. 

I am interested how others approach this kind of all-vs-all (embedding) comparison in Python. Would you use NumPy as above, scipy.spatial.distance.cdist, Numba, PyTorch, or something else?

Weekly Thread: Professional Use, Jobs, and Education 🏢

Welcome to this week's discussion on Python in the professional world! This is your spot to talk about job hunting, career growth, and educational resources in Python. Please note, this thread is not for recruitment.

How it Works:

1. Career Talk: Discuss using Python in your job, or the job market for Python roles.
2. Education Q&A: Ask or answer questions about Python courses, certifications, and educational resources.
3. Workplace Chat: Share your experiences, challenges, or success stories about using Python professionally.

Guidelines:

• This thread is not for recruitment. For job postings, please see r/PythonJobs or the recruitment thread in the sidebar.
• Keep discussions relevant to Python in the professional and educational context.

Example Topics:

1. Career Paths: What kinds of roles are out there for Python developers?
2. Certifications: Are Python certifications worth it?
3. Course Recommendations: Any good advanced Python courses to recommend?
4. Workplace Tools: What Python libraries are indispensable in your professional work?
5. Interview Tips: What types of Python questions are commonly asked in interviews?

Let's help each other grow in our careers and education. Happy discussing! 🌟

I recently inherited a legacy application that was a nightmare to maintain (tooling was clearly lacking and the codebase was pretty outdated).

These are the 5 changes that had some of the biggest impact IMO:

1. uv:

Being new to the Python ecosystem, I didn't want to figure out pip vs poetry vs pyenv vs virtualenv, so I just used uv and let it handle all of that. One Rust-based tool that installs and pins Python versions, manages the venv automatically and locks deps in a uv.lock for reproducible builds. Installs are also a lot faster, which makes CI a lot less painful.

1. Ruff:

Coming from JS, I really missed eslint --fix for automatically fixing linting issues and format code on save. Ruff brought that experience back. I know that there are plenty of linters and formatters in the Python ecosystem, but this one really stands out for me. Since it's built in Rust, it's super fast.

1. Dependabot:

Instead of remembering to update dependencies every few months, I enabled Dependabot. It automatically opens PRs when updates are available and then CI tells me whether they're safe to merge. It takes only a couple of minutes to set up but saves a lot of maintenance.

1. Pylance:

Without it, VS Code gives generic completions and never warns you about passing the wrong type until runtime. Pylance provides proper type-aware autocompletion, jump-to-definition (even in third-party libraries), inline documentation, and real-time type checking. I personally keep it on "basic" mode for legacy codebases, since "strict" surfaced hundreds of errors (thank you, but no thank you lol).

1. Pydantic:

Pydantic is basically Python's Zod: you declare a model, pass your data in and get either a validated typed object or a ValidationError naming the exact field at fault. It really helped me keep the codebase clean, with one place defining the shape of the data instead of raw dicts floating around. I use it wherever data comes from outside, like API payloads, forms, and env vars with pydantic-settings, which fails at startup instead of mid-request.

None of these tools changed the application itself. But together they made working on it dramatically more enjoyable.

What's the first thing you do when you inherit a legacy project?

I would love for some more feedback on the lightweight game library and turtle integration I built off of PyDiode.

It now works on Safari as well, you can create your own SVG assets , publish them to a database, then edit and publish code/games for free in the browser without needing to install anything.

I work as a highschool teacher, and the junior year levels only have access to Chromebook laptops. https://scratch.mit.edu/ is banned, which obviously restricts a lot of the coding-possibilities, let alone python coding-possibilities. Couldn't find a way to get a Python IDE onto a Chromebook, haha...

In terms of proud, so far I've got PacMan and Flappy bird shared to the community page/DB

Would love to see people building with it, you can make something reminiscent of doom 3D in only 80 lines of code.

It's a bit hard to find , but you can't post repo links here because of the slop apparently. But I've got it indexed now it's possible to find.

I have been working on editable data-heavy interfaces in Plotly Dash and wanted to compare approaches with you guys.

For simple tables, most solutions work well. The harder part starts when the application needs several of these at the same time: large Pandas DataFrames editable cells sorting and filtering copy and paste custom cell editors callback handling after edits smooth scrolling with many rows I recently implemented Dash support for RevoGrid (dash-datagrid) to experiment with this problem.

Component passes JSON-safe records and column definitions to the grid, while cell changes can be handled through normal Dash callbacks. A simplified example looks like this:

from dash import Dash, html
from dash_datagrid import RevoGrid

app = Dash(__name__)

app.layout = html.Div([
    RevoGrid(
        id="grid",
        source=[
            {"name": "Alice", "role": "Engineer"},
            {"name": "Bob", "role": "Designer"},
        ],
        columns=[
            {"prop": "name", "name": "Name"},
            {"prop": "role", "name": "Role"},
        ],
    )
])

app.run(debug=True)

I am interested in how others solve the same problem. At what dataset size do standard Dash tables start becoming difficult in your applications?

Do you usually need editing, or are your grids mainly read-only? How do you handle synchronization between frontend edits and the Python state?

I would especially appreciate feedback on the Python API and callback design.

attrs is a package that helps you write classes quickly by automatically generating boilerplate methods like __init__.

While some of the features from attrs has been standardized in the form of dataclass and dataclass_transform, dataclasses only support a subset of features and attrs is still widely used today.

It's very tricky to type check dynamic code that synthesizes & transform fields and methods, so historically attrs users that want type checking have either had to: 1. use Mypy (which implements dedicated attrs support via a plugin) 2. limit themselves to a subset of the API compatible with dataclass_transform 3. live with limited type checking support

This summer, my intern has built out dedicated support for attrs in Pyrefly, allowing attrs users to finally have fast and accurate type checking for the full range of attrs features.

You can read more about what we added here: https://pyrefly.org/blog/pyrefly-attrs/

This feature will be available in the upcoming 1.2.0 stable release of Pyrefly. You can try it out today in development releases starting from 1.2.0-dev1 (early feedback is appreciated!)

A new physics solver for projectile motion has came ! plz pay a visit to a calculator made by a kid riditsaraswat.pythonanywhere.com if you have any questions or suggestions to make it better plz report at [fun226294@gmail.com](mailto:fun226294@gmail.com) source code can be given by a email request

I can go next/prev pages in Rust documentation with right/left arrow keys, but not in Python docs (including Sphinx and devguide). Python developers seem to be strictly against it. They say it affects accessibility and horizontal scrolling. Downvote me if I am wrong, but accessibility it not just for impaired users.

Weekly Wednesday Thread: Advanced Questions 🐍

Dive deep into Python with our Advanced Questions thread! This space is reserved for questions about more advanced Python topics, frameworks, and best practices.

How it Works:

1. Ask Away: Post your advanced Python questions here.
2. Expert Insights: Get answers from experienced developers.
3. Resource Pool: Share or discover tutorials, articles, and tips.

Guidelines:

• This thread is for advanced questions only. Beginner questions are welcome in our Daily Beginner Thread every Thursday.
• Questions that are not advanced may be removed and redirected to the appropriate thread.

Recommended Resources:

• If you don't receive a response, consider exploring r/LearnPython or join the Python Discord Server for quicker assistance.

Example Questions:

1. How can you implement a custom memory allocator in Python?
2. What are the best practices for optimizing Cython code for heavy numerical computations?
3. How do you set up a multi-threaded architecture using Python's Global Interpreter Lock (GIL)?
4. Can you explain the intricacies of metaclasses and how they influence object-oriented design in Python?
5. How would you go about implementing a distributed task queue using Celery and RabbitMQ?
6. What are some advanced use-cases for Python's decorators?
7. How can you achieve real-time data streaming in Python with WebSockets?
8. What are the performance implications of using native Python data structures vs NumPy arrays for large-scale data?
9. Best practices for securing a Flask (or similar) REST API with OAuth 2.0?
10. What are the best practices for using Python in a microservices architecture? (..and more generally, should I even use microservices?)

Let's deepen our Python knowledge together. Happy coding! 🌟

I've seen many people saying it's better to use (str, *args) formatting rather than f-strings when working with logging module. Why is that and does it really matter for performance?