Python, Django, Flask & MongoDB Blogs

Python 3.14 came out on October 7, 2025, and it has a lot of useful and powerful features that make coding easier, faster, and more fun.This version has something for everyone, whether you’re a beginner, a data scientist, or a backend developer. Let’s dive into what’s new and why it matters 1. Template Strings (t-Strings) You’ve seen f-strings (f”Hello {name}”) for formatting text, right?Now meet t-strings — written as t”…”. Instead of directly turning into a string, a t-string keeps the template information.This means you can safely inspect or reuse the placeholders before final formatting. Why it’s cool: Think of it like f-strings with superpowers. 2. Lazy Type Hints (No More Import Errors) If you’ve ever faced annoying “circular import” issues when using typing, rejoice!Python 3.14 now delays evaluation of type hints — they’re stored as expressions, not immediately executed. That means: Why it’s great:Cleaner code, fewer import headaches, and faster app startup. 3. Free-Threaded Python (No More GIL) This is huge. The Global Interpreter Lock (GIL) — Python’s long-time concurrency bottleneck — is now optional.Python 3.14 introduces an official free-threaded build, allowing true multi-threading. That means your threads can finally run in parallel on multiple CPU cores. Why it matters: Tip: If you use C extensions or NumPy, test compatibility before switching builds. 4. A Smarter, Colorful REPL Say hello to a more modern interactive shell! Python 3.14’s built-in REPL (the prompt you get by typing python in your terminal) now has: Example: Why you’ll love it:No need for extra tools like IPython to enjoy a colorful, beginner-friendly shell. 5. Cleaner Error Messages Errors in Python keep getting more human-friendly. Now, Python can suggest corrections when you mistype keywords or module names.It also shows clearer hints when exceptions happen in tricky spots. Example: No more head-scratching moments over simple typos. 6. New Syntax Options Python gets some subtle syntax polish this time: Shorter exception handling You can now write multiple exceptions without parentheses: Warnings for risky finally: blocks If you use return, break, or continue inside a finally: clause, Python 3.14 warns you — since it can silently skip cleanup code. 7. Standard Library Upgrades Lots of small but awesome library updates: Example: Why it’s useful:You get smarter CLI tools, better file management, and more modern compression built right in. 8. Performance Boosts Under the Hood You may not notice dramatic speed jumps, but overall Python feels snappier — especially for import-heavy apps. 9. Developer Quality-of-Life Tweaks Final Thoughts Python 3.14 feels like a developer-focused release — combining practical improvements with exciting groundwork for the future. Top highlights: If you haven’t upgraded yet, now’s the time.Run: Comment below if you like this post

Python 3.14 Is Here: The Most Exciting Update Yet! Read More »

Master Python OS Module: Simple Guide to Powerful System Control

Leave a Comment / python / Tarun

Hey there! So you want to work with files and folders in Python? Maybe automate some boring stuff? Well, the OS module is going to be your new best friend. Trust me, once you get the hang of it, you’ll wonder how you ever lived without it. What’s This OS Module Anyway? Think of the OS module as Python’s way of talking to your computer. Want to create a folder? Move files around? Check if something exists? The OS module has got your back. And the best part? It works the same whether you’re on Windows, Mac, or Linux. Write once, run anywhere! That’s it. One line and you’re ready to go. Let’s Start Simple – Working with Folders Where am I right now? Ever get lost in your terminal? Yeah, me too. Here’s how to check where you are: Moving around Making new folders That second one is super handy. It creates all the folders in the path if they don’t exist yet. What’s in this folder? Simple, right? This shows everything in your current directory. Dealing with Files and Paths Does this thing even exist? Before you try to open or delete something, you probably want to make sure it’s actually there: Is it a file or a folder? Joining paths the smart way Here’s a rookie mistake I used to make – hardcoding paths with slashes: Breaking paths apart Moving and Deleting Stuff Renaming files Getting rid of things Environment Variables – Super Useful! Your computer has these things called environment variables. They’re like settings that programs can read: Some Real-World Examples Example 1: Walking through all your files This is one of my favorites. It lets you go through every file in a directory and all its subdirectories: Example 2: Organizing a messy downloads folder We’ve all been there – a downloads folder full of random files. Let’s organize them by file type: Example 3: Getting file info Quick Tips I Wish Someone Told Me Earlier 1. Always use os.path.join() Seriously. Even if you’re only working on one operating system right now, your future self (or your teammates) will thank you. 2. Check before you wreck Always verify a file or folder exists before trying to do something with it. Trust me, you’ll save yourself a lot of headaches: 3. Use try-except blocks Things can go wrong. Permissions issues, files in use, you name it: 4. Consider pathlib for newer projects If you’re using Python 3.4 or newer, check out the pathlib module. It’s more modern and object-oriented. But the OS module is still super useful, and you’ll see it everywhere in older code. Wrapping Up Look, the OS module might seem a bit overwhelming at first, but once you start using it, you’ll realize how powerful it really is. Start small maybe just list some files or check if something exists. Then gradually build up to more complex tasks. I’ve included some of the basic features of the OS module here. It has many extensive capabilities that I can’t cover in a single post, but in general, you can use it to interact deeply with your system. If you guys explore more, please share it with me. You can even create an OS controller using Python modules.

Master Python OS Module: Simple Guide to Powerful System Control Read More »

Unlocking Python Dictionaries: A Beginner’s Guide to Adding New Keys

How I made my Django project almost as fast as FastAPI

Leave a Comment / django, python / Tarun

FastAPI runs on Uvicorn, an ASGI server made for Python code that runs at the same time. Django is older and has more features, but from version 3.0, it can also operate on ASGI with Uvicorn. Once you set up Django on Uvicorn and make queries and caching work better, you can get the same speed for most things. 1. Start Django with Uvicorn The best way to improve performance is to switch to an ASGI server. Install Uvicorn Make sure your project has a asgi.py file, which is made automatically in Django 3+. Then turn on the server: uvicorn myproject.asgi:application –host 0.0.0.0 –port 8000 –workers 4 Why Uvicorn If you use a process manager like Supervisor or systemd, you can add: 2. Use async views where possible Why use httpx instead of requests: It lets you send HTTP requests (GET, POST, etc.) and handle responses, similar to requests, but it also supports asynchronous programming (async/await). That means you can make many API calls at once without blocking your Django or FastAPI app, ideal for performance and concurrency. import httpx from django.http import JsonResponse async def price_view(request): async with httpx.AsyncClient() as client: r = await client.get(‘https://api.example.com/price’) return JsonResponse(r.json()) For ORM queries, still use sync code or wrap it with sync_to_async: from asgiref.sync import sync_to_async from django.contrib.auth.models import User @sync_to_async def get_user(pk): return User.objects.get(pk=pk) async def user_view(request): user = await get_user(1) return JsonResponse({‘username’: user.username}) 3. Optimize your database Example: posts = Post.objects.select_related(‘author’).all() 4. Enable caching with Redis Install Redis and configure Django: pip install django-redis Add this to settings.py: CACHES = { ‘default’: { ‘BACKEND’: ‘django_redis.cache.RedisCache’, ‘LOCATION’: ‘redis://127.0.0.1:6379/1’, ‘OPTIONS’: { ‘CLIENT_CLASS’: ‘django_redis.client.DefaultClient’, } } } Cache heavy views: from django.views.decorators.cache import cache_page @cache_page(60) def home(request): return render(request, ‘home.html’) 5. Offload background work Use Celery or Dramatiq to handle slow tasks like emails or large file uploads asynchronously. 6. Serve static files efficiently Use WhiteNoise for small deployments or a CDN (Cloudflare, S3 + CloudFront) for large ones. MIDDLEWARE = [ ‘django.middleware.security.SecurityMiddleware’, ‘whitenoise.middleware.WhiteNoiseMiddleware’, # … ] 7. Monitor performance Example Benchmark Running the same Django app under Uvicorn vs Gunicorn (WSGI): Server Avg Latency Req/s Gunicorn (WSGI) 90 ms 700 Uvicorn (ASGI) 40 ms 1400 Final Thoughts FastAPI may always win in pure async benchmarks, but Django + Uvicorn can be nearly as fast for most production workloads — and you keep Django’s ORM, admin, and ecosystem. Checklist:

How I made my Django project almost as fast as FastAPI Read More »

How to Flatten a List of Lists in Python

How to Merge Dictionaries Efficiently in Python

Python’s yield Keyword: From Theory to Real-World Magic

Leave a Comment / python / Tarun

Today, we’re going to break down yield into simple, digestible pieces. By the end of this article, you’ll not only understand what it does but also why it’s such a powerful tool for writing efficient and elegant Python code. The Problem: Why Not Just Use return? Let’s start with what we know. The return statement is straightforward: a function runs, computes a value, and return sends that value back to the caller. The function’s state is then completely wiped out. If you call it again, it starts from scratch. But what if you’re working with a massive dataset—like a file with millions of lines, or a continuous stream of data from a sensor? Using return to get all the data at once would mean loading everything into your computer’s memory. This can be slow, or worse, it can crash your program if the data is too large. We need a way to produce a sequence of results one at a time, on the fly, without storing the entire sequence in memory first. This is exactly the problem that generators and the yield keyword solve. The Simple Analogy: A Book vs. A Librarian Think of a function with return as printing a book. Now, think of a function with yield a helpful librarian who reads the book to you, one line at a time. This “lazy” or “on-demand” production of values is the core idea behind generators. Let’s see the example, Look at a traditional function using return: def create_squares_list(n): result = [] for i in range(n): result.append(i*i) return result # Using the function my_list = create_squares_list(5) # The ENTIRE list is built in memory here for num in my_list: print(num) # Output: 0, 1, 4, 9, 16 This works fine for n=5, but if n were 10 million, the result The list would consume a massive amount of memory. Now, let’s rewrite this as a generator function using yield: def generate_squares(n): for i in range(n): yield i*i # <– The magic keyword! # Using the generator function my_generator = generate_squares(5) # Nothing is calculated yet! print(my_generator) # Prints: <generator object generate_squares at 0x…> What’s happening here? The key takeaway is state suspension. The function doesn’t die after yield; it simply goes to sleep, waiting to be woken up again. This makes it incredibly memory-efficient. If you are Reading Large Files This is perhaps the most common and critical use case for generators. Imagine you have a massive server log file that is 50 GB in size. You can’t possibly load it all into memory. The Inefficient Way (Avoid this!): with open(‘huge_log_file.log’, ‘r’) as file: lines = file.readlines() # Loads all 50 GB into RAM! for line in lines: if ‘ERROR’ in line: print(line) The Efficient Generator Way (The Pythonic Way): def read_large_file(file_path): with open(file_path, ‘r’) as file: for line in file: # file objects are already generators! yield line # Now, we can process the file line by line for line in read_large_file(‘huge_log_file.log’): if ‘ERROR’ in line: print(line) In this efficient version, only one line is ever in memory at a time, no matter how big the file is. The for line in file idiom itself uses a generator under the hood, and our function just wraps it for clarity. While Generating an Infinite Sequence You can’t create an infinite list in memory—it’s impossible! But you can create a generator that produces values from an infinite sequence forever. Need a simple ID generator? def generate_user_ids(): id = 1000 while True: # This loop runs forever… but it’s a generator! yield id id += 1 id_generator = generate_user_ids() print(next(id_generator)) # 1000 print(next(id_generator)) # 1001 print(next(id_generator)) # 1002 # This can go on indefinitely, using almost no memory. Need a stream of Fibonacci numbers? def fibonacci(): a, b = 0, 1 while True: yield a a, b = b, a + b fib_gen = fibonacci() for i, num in enumerate(fib_gen): if i > 10: # Let’s not loop forever in this example! break print(num) # Output Key Takeaways Remember the helpful librarian the next time you face a memory-heavy task in Python. Don’t print the whole book—just yield one page at a time! Comment below if you like

Python’s yield Keyword: From Theory to Real-World Magic Read More »

Create a CLI Tool with Python: From Zero to Hero

Leave a Comment / python / Tarun

Command-line tools are essential for developers—they’re fast, lightweight, and automate repetitive tasks. In this tutorial, we’ll build a File Organizer CLI tool in Python from scratch. By the end, you’ll have a working CLI tool that organizes files by type and is ready to share or package for others. Why Build CLI Tools with Python? Before we dive into the code, it’s important to understand why Python is an excellent choice for building command-line tools. 1. Simplicity and Readability Python’s clean and intuitive syntax allows you to focus on functionality, rather than worrying about complex language constructs. You can write concise, readable code that’s easy to maintain—perfect for small utilities or large projects alike. 2. Rich Ecosystem Python comes with a powerful standard library for file handling, argument parsing, and more. On top of that, third-party packages like Click, Rich, and argparse make building robust and user-friendly CLI tools even easier. 3. Cross-Platform Compatibility Python runs seamlessly on Windows, macOS, and Linux. The same CLI tool you develop on your local machine can be deployed anywhere without major changes—saving you time and headaches. 4. Rapid Development Python is an interpreted language, which means you can write, test, and iterate on your code quickly. This rapid feedback loop is ideal when building CLI tools where functionality and usability matter. Setting Up Your Development Environment First, let’s prepare our folder. I recommend creating a virtual environment to keep dependencies isolated: mkdir my-cli-tool cd my-cli-tool python -m venv venv source venv/bin/activate # On Windows: venv\Scripts\activate Install the essential rich-click we’ll use: pip install click rich I am using click for argument parsing and rich for beautiful terminal output. While Python’s built-in argparse is powerful, click offers a more intuitive approach for complex CLI applications. Building Your First CLI Tool: A File Organizer Let’s create something practical – a tool that organizes files in a directory by their extensions. This example will demonstrate core CLI concepts while solving a real problem. Create a file called file_organizer.py: import os import shutil from pathlib import Path import click from rich.console import Console from rich.table import Table from rich.progress import Progress console = Console() @click.command() @click.argument(‘directory’, type=click.Path(exists=True, file_okay=False, dir_okay=True)) @click.option(‘–dry-run’, is_flag=True, help=’Show what would be done without making changes’) @click.option(‘–verbose’, ‘-v’, is_flag=True, help=’Show detailed output’) def organize_files(directory, dry_run, verbose): “”” Organize files in DIRECTORY by their extensions. Creates subdirectories for each file type and moves files accordingly. “”” directory = Path(directory) if dry_run: console.print(“[yellow]Running in dry-run mode – no changes will be made[/yellow]”) # Scan directory and group files by extension file_groups = {} total_files = 0 for file_path in directory.iterdir(): if file_path.is_file(): extension = file_path.suffix.lower() or ‘no_extension’ if extension not in file_groups: file_groups[extension] = [] file_groups[extension].append(file_path) total_files += 1 if total_files == 0: console.print(“[red]No files found in the specified directory[/red]”) return # Display summary table if verbose or dry_run: table = Table(title=f”Files to organize in {directory}”) table.add_column(“Extension”, style=”cyan”) table.add_column(“Count”, style=”green”) table.add_column(“Files”, style=”white”) for ext, files in file_groups.items(): file_names = “, “.join([f.name for f in files[:3]]) if len(files) > 3: file_names += f” … and {len(files) – 3} more” table.add_row(ext, str(len(files)), file_names) console.print(table) if dry_run: return # Create directories and move files with Progress() as progress: task = progress.add_task(“[green]Organizing files…”, total=total_files) for extension, files in file_groups.items(): # Create directory for this extension ext_dir = directory / extension.lstrip(‘.’) ext_dir.mkdir(exist_ok=True) for file_path in files: destination = ext_dir / file_path.name # Handle naming conflicts counter = 1 while destination.exists(): name_parts = file_path.stem, counter, file_path.suffix destination = ext_dir / f”{name_parts[0]}_{name_parts[1]}{name_parts[2]}” counter += 1 shutil.move(str(file_path), str(destination)) if verbose: console.print(f”[green]Moved[/green] {file_path.name} → {destination}”) progress.advance(task) console.print(f”[bold green]Successfully organized {total_files} files![/bold green]”) if __name__ == ‘__main__’: organize_files() Understanding the Code Structure Let’s break down the key components: my-cli-tool/ │── file_organizer.py # Main CLI code │── text.py # Test file generator │── README.md # Documentation │── setup.py # Installation script │── assets/ │ └── banner.png # Optional banner for README │── venv/ # Local virtual environment Making Your Tool Installable To make your CLI tool easily installable and distributable, create a setup.py file: from setuptools import setup setup( name=”file-organizer”, version=”0.1.0″, py_modules=[“file_organizer”], # because you have file_organizer.py install_requires=[ “click”, “rich”, ], entry_points={ “console_scripts”: [ “file-organizer=file_organizer:organize_files”, ], }, author=”Tarun Kumar”, description=”A Python CLI tool to organize files by extension”, long_description=open(“README.md”).read() if open(“README.md”, “r”, encoding=”utf-8″) else “”, long_description_content_type=”text/markdown”, python_requires=”>=3.8″, ) Install your tool in development mode: pip install -e . Now you can run your tool from anywhere using the organize command! Testing Your CLI Tool Testing CLI applications is more important because it requires special consideration. Here’s how to test your file organizer: import os # Folder where test files will be created TEST_DIR = “test_files” # Make the directory if it doesn’t exist os.makedirs(TEST_DIR, exist_ok=True) # List of test files with different extensions files = [ “document1.pdf”, “document2.pdf”, “image1.jpg”, “image2.jpg”, “image3.png”, “script1.py”, “script2.py”, “archive1.zip”, “archive2.zip”, “notes.txt”, “readme.md” ] # Create empty files for file_name in files: file_path = os.path.join(TEST_DIR, file_name) with open(file_path, “w”) as f: f.write(f”Test content for {file_name}\n”) print(f”Created {len(files)} test files in ‘{TEST_DIR}’ folder.”) Run your tests with: python text.py Best Practices for CLI Development Clear Documentation: Always provide helpful docstrings and command descriptions. Users should understand your tool’s purpose at a glance. Graceful Error Handling: Anticipate common errors and provide meaningful error messages. Never let users see raw Python stack traces. Progress Feedback: For long-running operations, show progress bars or status updates. Silent tools feel broken. Configurable Behavior: Allow users to customize your tool’s behavior through configuration files or environment variables. Follow Unix Philosophy: Make tools that do one thing well and can be easily combined with other tools. Deployment and Distribution Once your CLI tool is ready, you have several distribution options: PyPI Publication: Upload your package to the Python Package Index for easy installation via pip. GitHub Releases: Distribute your tool through GitHub with pre-built executables using PyInstaller. Docker Container: Package your tool in a Docker container for consistent deployment across environments. Download code Advanced Topics to Explore As you become more comfortable with CLI development, consider exploring: Conclusion Building CLI

Create a CLI Tool with Python: From Zero to Hero Read More »

Building Real-World APIs with FastAPI

ChatGPT Atlas: The Browser That Actually Talks Back

Python 3.14 Is Here: The Most Exciting Update Yet!

Master Python OS Module: Simple Guide to Powerful System Control

Unlocking Python Dictionaries: A Beginner’s Guide to Adding New Keys

How I made my Django project almost as fast as FastAPI

How to Flatten a List of Lists in Python

How to Merge Dictionaries Efficiently in Python

Python’s yield Keyword: From Theory to Real-World Magic

Create a CLI Tool with Python: From Zero to Hero