Python is a widely-used programming language that’s known for being beginner-friendly. Created by Guido van Rossum and first released in 1991, it has become one of the most popular languages in the world. Python is commonly used for: What can you do with Python? Why choose Python? Important things to know How Python syntax differs from other languages How do we define a function? Simple Class creation.
Hey everyone! Today I want to talk about something that’s been bugging me for a while – the Global Interpreter Lock, or GIL as everyone calls it. If you’ve ever wondered why your multi-threaded Python program doesn’t run as fast as you expected, well, the GIL is probably the culprit. So What Exactly is This GIL Thing? Okay, so here’s the deal. The Global Interpreter Lock is basically a mutex (a lock) that protects access to Python objects. It prevents multiple threads from executing Python bytecode at the same time. Even if you have multiple CPU cores, only ONE thread can execute Python code at any given moment. Why Does Python Even Have This? When I first learned about the GIL, my immediate reaction was “Why would anyone design it this way?” But there’s actually a good reason behind it. Python uses reference counting for memory management. Every object keeps track of how many references point to it, and when that count hits zero, the memory gets freed. The problem is that this reference count needs to be protected from race conditions where two threads try to modify it simultaneously. The GIL was the simple solution – just make sure only one thread runs at a time, and boom, no race conditions. It made the CPython implementation simpler and actually made single-threaded programs faster because there’s less overhead. When Does the GIL Actually Slowdown Performance? Here’s where it gets interesting. The GIL is only a problem for CPU-bound tasks. If your program is doing heavy calculations, processing data, or anything that keeps the CPU busy, the GIL will throttle your performance because threads can’t run in parallel. But here’s the good news – if you’re doing I/O-bound work (reading files, making network requests, waiting for database queries), the GIL isn’t really an issue. That’s because when a thread is waiting for I/O, it releases the GIL so other threads can run. I’ve worked on web scrapers and API clients where threading worked perfectly fine because most of the time was spent waiting for responses, not actually processing data. How I Deal With the GIL When I need actual parallelism for CPU-intensive tasks, I use the multiprocessing module instead of threading. Each process gets its own Python interpreter and its own GIL, so they can truly run in parallel. The downside? Processes are heavier than threads, and you can’t share memory as easily. But when you need real parallel processing, it’s worth it. Is There Hope for a GIL-Free Future? There have been attempts to remove the GIL over the years, but it’s tricky. Removing it would require massive changes to CPython’s internals and could break many existing C extensions that depend on the GIL’s behavior. That said, there are Python implementations, such as Jython and IronPython, that don’t have a GIL at all. And lately, there’s been renewed interest in making CPython work without the GIL, so who knows what the future holds? My Final Thoughts The GIL is one of those things that seems annoying at first, but once you understand it, you learn to work with it. For most of my day-to-day Python programming, it’s honestly not a problem. And when it is, I’ve got workarounds. The key is knowing what kind of problem you’re solving. CPU-bound? Use multiprocessing. I/O-bound? Threading works great. Once you’ve got that down, the GIL becomes just another quirk of Python that you deal with.
What is Global Interpreter Lock in Python? Read More »
Everyone is curious about how large companies manage their SaaS-based software. In this blog post, I will guide you through how to use the django-tenants library to implement multi-tenancy in Django. Multi-tenancy is a software architecture where a single application instance serves multiple customers (tenants), with each tenant’s data securely isolated from others. Django-tenants is a powerful and widely used library that makes implementing multi-tenancy in Django simple and scalable. In this complete guide, you’ll learn everything you need to get started with Django Tenants—from basic concepts to practical implementation. What is Multi-Tenancy? Multi-tenancy allows you to run multiple organizations or clients on a single application deployment. Each tenant has its own isolated database schema, ensuring complete data separation while sharing the same codebase and infrastructure. Common use cases include SaaS applications, HRMS, e-learning platforms, e-commerce marketplaces, and enterprise management systems, where each client needs their own isolated environment. Real-World Companies Using Multi-Tenancy Many leading companies rely on multi-tenant architecture, including Salesforce (CRM), Shopify (e-commerce), and Slack (team communication).Internally, what they use the company didn’t do to reveal, but django Tenancy provides the same architecture Why Django-Tenants? Django-tenants provides schema-based multi-tenancy using PostgreSQL schemas. Each tenant gets their own database schema, providing strong data isolation while being more efficient than separate databases. The library handles tenant identification, routing, and database operations automatically. Prerequisites Before starting, ensure you have Python 3.8 or higher, PostgreSQL 10 or higher installed, and basic knowledge of Django. Django-tenants works best with PostgreSQL due to its schema support. Installation First, install the required packages: Create a new Django project if you haven’t already: Configuration Update your settings.py file with the following configurations. Start by modifying the database settings to use PostgreSQL: Add django-tenants to your installed apps. The order is crucial here: Configure the tenant model and middleware: Specify which apps are shared across all tenants and which are tenant-specific: Set the public schema name: Creating Tenant Models Create your tenant and domain models in tenants/models.py: The TenantMixin provides essential fields like schema_name and is_active. The auto_create_schema attribute automatically creates the database schema when a new tenant is created. Running Migrations Django-tenants requires a special migration process. First, create migrations: Run migrations for the shared apps (public schema): This creates the public schema and shared tables. Now you’re ready to create tenants. Creating Your First Tenant Create a management command or use the Django shell to create tenants. Here’s an example using the shell: Testing Your Multi-Tenant Setup Start the development server: To test different tenants, you’ll need to modify your hosts file or use different domains. For local development, add entries to your hosts file: Now you can access different tenants at tenant1.localhost:8000 and tenant2.localhost:8000. Creating Tenant-Specific Views Create views that automatically work with the current tenant’s data: The request object includes a tenant attribute that gives you access to the current tenant information. Best Practices Keep tenant-specific data in TENANT_APPS and shared data like user authentication in SHARED_APPS. Use descriptive schema names that are URL-safe and unique. Always test tenant isolation to ensure data doesn’t leak between tenants. Implement proper error handling for missing or invalid tenants. Use database connection pooling to handle multiple tenant connections efficiently. Consider implementing tenant creation workflows with proper validation. Advanced Features Django-tenants supports custom tenant routing, allowing you to use subdomains, custom domains, or path-based routing. You can implement tenant-specific settings by overriding settings based on the current tenant. The library also supports tenant cloning for quickly setting up new tenants with existing data structures. Common Pitfalls Avoid forgetting to run migrate_schemas for both shared and tenant apps. Don’t use absolute imports that bypass tenant middleware. Be careful with static files and media files, ensuring they’re properly scoped per tenant when needed. Always test migrations on a copy of your production database before deploying. Conclusion Django-tenants provides a robust solution for building multi-tenant Django applications. By following this guide, you’ve learned how to set up schema-based multi-tenancy, create and manage tenants, and build tenant-aware applications. The library handles the complexity of tenant routing and database isolation, allowing you to focus on building great features for your users. Read More on official docs.
Django Tenants Complete Guide: Build Scalable Multi-Tenant Applications Read More »
Are you ready to start your Python programming journey? I’ve found something exciting to share with you – two completely free Python courses from Cisco that will help you master Python fundamentals and earn valuable badges to showcase your skills! Why Learn Python? Python is one of the most popular and beginner-friendly programming languages in the world. Whether you want to build websites, analyze data, automate tasks, or dive into artificial intelligence, Python is your perfect starting point. The best part? You can learn it for free and get certified along the way! Free Python Courses with Badges Cisco Networking Academy offers two comprehensive Python courses that are completely free and provide you with official badges upon completion: 1. Python Essentials 1 Perfect for: Absolute beginners with no programming experience This course covers the fundamentals of Python programming and helps you build a strong foundation. You’ll learn: Get Started: Python Essentials 1 Course 2. Python Essentials 2 Perfect for: Those who’ve completed Python Essentials 1 or have basic Python knowledge This intermediate course takes your skills to the next level with: Get Started: Python Essentials 2 Course What You’ll Get 100% Free – No hidden costs or subscription fees Official Badges – Showcase your achievements on LinkedIn and your resume Self-Paced Learning – Study whenever and wherever you want Hands-On Practice – Real coding exercises and projects Industry Recognition – Cisco is a globally recognized technology leader How to Get Started Why I Recommend These Courses Unlike many other free resources that leave you wandering without direction, these Cisco courses provide structured learning paths with clear goals. The interactive exercises help you practice what you learn immediately, and the badges give you something tangible to show potential employers or clients. Whether you’re looking to switch careers, enhance your current job skills, or simply explore programming as a hobby, these courses are an excellent starting point. Ready to Start? Don’t wait! Your Python programming journey begins today. Click on the course links, enroll for free, and start earning those valuable badges. The skills you gain will open doors to countless opportunities in the tech world. Remember: Every expert programmer started exactly where you are now. Comment below if you get any other free resource, I will make a post
Learn Python and Earn Free Badges with Cisco NetAcad Read More »
I can’t tell you how many times I’ve run into this scenario: I’m working on a Python project, confidently accessing an object’s attribute, and boom—AttributeError crashes my program. Sound familiar? This happens all the time when you’re dealing with different object types. Maybe you’re working with user accounts where some users have premium features and others don’t. Or perhaps you’re building an API that receives varying data structures. Whatever the case, knowing how to safely check for attributes is essential. Let me walk you through the different ways I handle this in my own code. Why Bother Checking for Attributes? Here’s a real scenario I dealt with recently: I was building a user management system where regular users had basic info (name, email), but premium users had additional fields like subscription_type and discount_rate. If I tried to access user.subscription_type a regular user object, Python would throw an AttributeError and my whole application would crash. Not ideal, especially in production! That’s why we need to check first. The Different Ways to Check (And When I Use Each) 1. hasattr() – My Go-To Method Honestly, this is what I use 90% of the time. It’s clean, simple, and does exactly what you need: I love hasattr() because it’s readable. When someone else looks at my code, they immediately understand what I’m doing. 2. getattr() – Check and Grab in One Go Sometimes you don’t just want to check if an attribute exists—you want to use it right away. That’s where getattr() shines: I find this super useful when I’m setting up configuration objects or dealing with optional features. Instead of writing an if-statement, I just provide a sensible default. 3. Try-Except – When You Need More Control Sometimes I need to do something more complex when an attribute doesn’t exist. That’s when I reach for try-except: This approach is great when the attribute access itself might trigger some side effects, or when you want to log the missing attribute for debugging. 4. dir() – For When You’re Exploring To be honest, I mostly use dir() When I’m debugging or exploring an unfamiliar library: It’s not something I put in production code, but it’s invaluable during development. A Real Example from My E-commerce Project Let me show you how I used these techniques in an actual project. I was building a shopping cart system with different user tiers: The beauty here is that process_order() it doesn’t need to know what type of cart it’s dealing with. It just checks for the capability and acts accordingly. Works for Methods and Properties Too By the way, these techniques aren’t just for regular attributes. They work perfectly with methods and properties: What I’ve Learned Over Time After years of Python development, here are my rules of thumb: When to use what: Things to avoid: Here’s a mistake I made early on: Wrapping Up Learning to check for attributes properly has saved me countless hours of debugging and prevented so many crashes. The key takeaway? Choose the right tool for the job: Start with hasattr() For most cases, it’s Pythonic, readable, and gets the job done. You can always refactor to something more complex if you need to. What’s your preferred method? Have you run into any tricky situations with attribute checking? I’d love to hear about them in the comments!
How to Check if an Object Has an Attribute in Python Read More »
Hey there! If you’ve been working with Django for a while, you’ve probably used many-to-many relationships. They’re great, right? But have you ever felt like you needed more control over that relationship? Like, you want to store extra information about the connection between two models? That’s exactly where the through parameter comes in, and trust me, once you get the hang of it, you’ll wonder how you ever lived without it. What’s a Many-to-Many Relationship Anyway? Before we dive into the through stuff, let’s quickly recap. A many-to-many relationship is when multiple instances of one model can be related to multiple instances of another model. Think about it like this: You get the idea! The Basic Many-to-Many Setup Usually, you’d set up a many-to-many relationship like this: Django automatically creates an intermediate table behind the scenes to handle this relationship. Easy peasy! But here’s the thing – what if you want to store more information about the enrollment? Like when the student enrolled, what grade they got, or whether they’ve completed the course? Enter the ‘through’ Parameter This is where the magic happens. The through The parameter lets you create your own intermediate model with whatever extra fields you want. Here’s how it works: See what we did there? We told Django: “Hey, use this Enrollment model to manage the relationship between Student and Course.” Why Would You Want to Do This? Here are some real-world scenarios: 1. Social Media App: You have Users and Groups. The membership can have a role (admin, moderator, member) and a join date. 2. E-commerce Platform Products and Orders. The intermediate table stores quantity, price at time of purchase, and any discounts applied. 3. Project Management Employees and Projects. You want to track the role of each employee in each project and the hours they’ve worked. 4. Recipe App: Recipes and Ingredients. The intermediate table holds the quantity and measurement unit for each ingredient. How to Work with Through Models Creating Relationships You can’t use the simple add() method anymore. You need to create instances of your “through” model directly: Querying Relationships You can query in both directions: Filtering with Extra Fields Here’s where it gets really cool: Important Things to Remember 1. ForeignKey Fields are Required. Your through model MUST have foreign keys to both models in the relationship. 2. unique_together. Usually, you want to prevent duplicate relationships, so use unique_together in the Meta class. 3. No Direct add(), create(), or set(). When using a through model, you can’t use these shortcuts. You have to create instances of the through model directly. 4. Removal Still Works. You can still use remove() and clear(): Complex Example Let’s say you’re building a music streaming app: Now you can do cool stuff like: Common Problems to Avoid 1. Forgetting to Create the Through Instance. Don’t try to use add() – it won’t work! 2. Not Using unique_together. You might end up with duplicate relationships, which can cause weird bugs. 3. Making the Through Model Too Complex: Keep it focused on the relationship. If you’re adding tons of fields, maybe they belong in one of the main models instead. 4. Circular Import Issues. If you reference models as strings (like through=’Enrollment’), make sure the model is defined in the same file or properly imported. When NOT to Use Through You don’t always need a through model! Use the simple many-to-many if: Remember: premature optimization is the root of all evil. Don’t overcomplicate things if you don’t need to! Wrapping Up The through parameter in Django’s many-to-many relationships is super powerful. It gives you complete control over intermediate tables and lets you model complex real-world relationships accurately. Start simple, and add complexity only when you need it. Your future self (and your teammates) will thank you for keeping things as straightforward as possible while still meeting your requirements. Now go ahead and build something awesome! And remember, every complex relationship in your database is just a bunch of simple relationships working together.
Many-to-Many Relations with ‘through’ in Django Read More »
Hi guys, recently I gave an interview at a startup company. I can’t reveal their name, but I am posting the questions they asked me. It was a Python Developer interview, but they also asked questions from Django, MySQL, and JavaScript. 1. What is a Django Signal? A Django signal is a messaging system that allows certain parts of your application to send notifications (signals) when an action occurs, and other parts of the app can listen and react to those events automatically. In Other words:Signals let you run some code whenever something happens in Django (like after a user is saved, deleted, or logged in). 2. How does map() work in JavaScript? map() is an array method that loops through each element, applies a function, and returns a new array without modifying the original. Example: 3. What is Django ORM? Django ORM is Object Relational Mapper that lets you interact with the database using Python instead of SQL. Example: 4. What is a Trigger in SQL? A trigger is an automatic block of SQL code that runs when you insert, update, or delete data in a table. Used for logs, validation, and audits. 5. Example of One-to-Many relationship in Django ORM 6. Difference between REST API and SOAP API SOAP is a strict, XML-based protocol with built-in security REST is a lightweight, flexible API style using JSON. REST SOAP Flexible Strict JSON/XML XML Only Lightweight Heavy No WSDL Uses WSDL Quick Slower Keep it short in interviews. 7. How do you authenticate a REST API? You can authenticate REST APIs using: Mention JWT, it’s the most popular. 8. DDL – Data Definition Language DDL (Data Definition Language) is a type of SQL command used to define, create, modify, and delete database structures such as tables, indexes, schemas, and views. Commands: Deals with tables, columns, and schemas. 9. DML – Data Manipulation Language DML (Data Manipulation Language) is a set of SQL commands used to insert, update, delete, and retrieve data from a database. Commands: Changes data, not structure. 10. How you write a custom SQL query in django Django provides a connection.cursor() functionality, and by using this cursor, we can write and execute custom SQL queries directly. For example:
Interview Questions I Faced for a Python Developer Read More »
When I first started working with FastAPI, I was blown away by how quickly I could get a simple API up and running. But as my projects grew from proof-of-concepts to production systems serving thousands of requests per second, I learned that writing scalable FastAPI applications requires more than just decorating functions with @app.get(). Today, I want to share the patterns and practices I’ve developed over the past few years building APIs that actually scale in the real world. Why FastAPI? Before diving deeper, let me quickly justify why FastAPI has become my go-to framework. It’s not just hype—FastAPI genuinely delivers on its promises: But speed and features mean nothing if your codebase becomes unmaintainable at scale. The Layered Architecture Pattern The first mistake I made was putting everything in a single main.py file. It worked great for tutorials, but became a nightmare in production. Here’s the architecture I now use for every project: This structure separates concerns clearly: API endpoints handle HTTP, services contain business logic, and models represent data. It’s not over-engineering—it’s sustainable engineering. Dependency Injection: Your Best Friend FastAPI’s dependency injection system is powerful, but it took me a while to appreciate it fully. Here’s how I use it for database sessions: But dependencies aren’t just for databases. I use them for: The beauty is that dependencies are testable and composable. You can mock them easily in tests without touching your endpoint code. Configuration Management Done Right Hard-coded configuration is a recipe for disaster. I use Pydantic’s BaseSettings for environment-based config: This pattern gives you: Async All the Way (But Wisely) FastAPI supports async endpoints, but mixing sync and async code incorrectly can kill performance. Here’s what I learned: Use async when: Stick with sync when: Don’t make everything async just because you can. Profile and measure. Error Handling and Custom Exceptions Early on, I let exceptions bubble up and relied on default error messages. Bad idea. Now I use custom exception handlers: This gives you consistent error responses across your API and makes debugging much easier. Request Validation with Pydantic Pydantic schemas are more than just data containers—they’re your first line of defense against bad data: The validation happens automatically before your endpoint code runs. Invalid requests never reach your business logic. Background Tasks for Better Response Times Don’t make users wait for tasks that don’t need to be completed before responding: For heavier workloads, integrate with Celery or RQ, but background tasks are perfect for lightweight async operations. Testing Strategies That Work I use TestClient for integration tests and dependency overrides for mocking: The ability to override dependencies makes testing incredibly clean—no monkey patching required. Database Session Management One of the trickiest aspects is managing database sessions correctly. Here’s my pattern: Never create global database sessions. Always use dependency injection and let FastAPI handle the lifecycle. Monitoring and Observability You can’t improve what you don’t measure. I add middleware for request logging and timing: For production, integrate with proper monitoring tools like Prometheus, DataDog, or New Relic. Rate Limiting for Protection Protect your API from abuse with rate limiting. I use slowapi: Caching for Performance For expensive operations or frequently accessed data, implement caching: For distributed caching, Redis is your friend. Use libraries like aioredis for async support. Final Thoughts Building production-grade APIs with FastAPI isn’t about following every pattern blindly—it’s about understanding which patterns solve real problems in your specific context. Start simple, profile your application, identify bottlenecks, and apply these patterns where they make sense. Over-engineering early is just as bad as under-engineering. The patterns I’ve shared here have saved me countless hours of debugging and refactoring. They’ve helped me build APIs that handle millions of requests per day with confidence. FastAPI gives you the tools, but it’s up to you to use them wisely. Happy coding!
Building Real-World APIs with FastAPI Read More »
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 »
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 »
