▎Asynchronous Programming in Python

Asynchronous programming allows applications to handle multiple tasks simultaneously without blocking. This is especially useful for I/O-bound operations, such as web requests, where waiting can lead to inefficiencies.

▎Key Concepts

• Event Loop: Manages and dispatches events or tasks.
• Coroutines: Functions defined with async def that can pause execution.
• Tasks: Wrappers for coroutines that run concurrently.

▎Benefits

1. Improved Performance: Handles more requests in less time.
2. Better Resource Utilization: Non-blocking I/O optimizes system resource use.
3. Responsive Applications: Keeps user interfaces responsive during background processing.

▎Getting Started with asyncio

The asyncio library provides the tools for asynchronous programming. Here’s a simple example simulating data fetching from multiple URLs:

import asyncio
import random

async def fetch_data(url):
    print(f"Fetching data from {url}...")
    await asyncio.sleep(random.uniform(1, 3))  # Simulate network delay
    print(f"Data fetched from {url}")
    return f"Data from {url}"

async def main():
    urls = ["http://example.com", "http://example.org", "http://example.net"]
    tasks = [fetch_data(url) for url in urls]
    results = await asyncio.gather(*tasks)
    print("All data fetched:", results)

# Run the main function
asyncio.run(main())

▎Explanation

• fetch_data(url): An asynchronous function simulating data fetching.
• asyncio.sleep(): A non-blocking sleep that allows other tasks to run.
• asyncio.gather(): Runs multiple coroutines concurrently.

▎Real-World Application: Web Scraping

Using aiohttp, you can perform asynchronous HTTP requests efficiently. Here’s an example:

import aiohttp
import asyncio

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def scrape(urls):
    tasks = [fetch(url) for url in urls]
    return await asyncio.gather(*tasks)

urls = ["http://example.com", "http://example.org", "http://example.net"]

# Run the scraping function
results = asyncio.run(scrape(urls))
print("Scraped data:", results)

🐍 How to Learn Python Fast (Even If You've Never Coded Before)

Python is everywhere. Web dev, data science, automation, AI…
But where should YOU start if you're a beginner?

Don’t worry. Here’s a 6-step roadmap to master Python the smart way (no fluff, just action)👇

🔹 𝗦𝘁𝗲𝗽 𝟭: Learn the Basics (Don’t Skip This!)
✅ Variables, data types (int, float, string, bool)
✅ Loops (for, while), conditionals (if/else)
✅ Functions and user input
Start with:
Python.org Docs
YouTube: Programming with Mosh / CodeWithHarry
Platforms: W3Schools.com / LearnDevs.com / FreeCodeCamp.org
Spend a week here.

Practice > Theory.

🔹 𝗦𝘁𝗲𝗽 𝟮: Automate Boring Stuff (It’s Fun + Useful!)
✅ Rename files in bulk
✅ Auto-fill forms
✅ Web scraping with BeautifulSoup or Selenium
Read: “Automate the Boring Stuff with Python”
It’s beginner-friendly and practical!

🔹 𝗦𝘁𝗲𝗽 𝟯: Build Mini Projects (Your Confidence Booster)
✅ Calculator app
✅ Dice roll simulator
✅ Password generator
✅ Number guessing game

These small projects teach logic, problem-solving, and syntax in action.

🔹 𝗦𝘁𝗲𝗽 𝟰: Dive Into Libraries (Python’s Superpower)
✅ Pandas and NumPy - for data
✅ Matplotlib - for visualizations
✅ Requests - for APIs
✅ Tkinter - for GUI apps
✅ Flask - for web apps

Libraries are what make Python powerful. Learn one at a time with a mini project.

🔹 𝗦𝘁𝗲𝗽 𝟱: Use Git + GitHub (Be a Real Dev)
✅ Track your code with Git
✅ Upload projects to GitHub
✅ Write clear README files
✅ Contribute to open source repos

Your GitHub profile = Your online CV. Keep it active!

🔹 𝗦𝘁𝗲𝗽 𝟲: Build a Capstone Project (Level-Up!)
✅ A weather dashboard (API + Flask)
✅ A personal expense tracker
✅ A web scraper that sends email alerts
✅ A basic portfolio website in Python + Flask

Python Assignment Operators

⚠️ __pycache__ is not your enemy, but it will lie to you

You delete a module. The import still works. You rename a class. Old bytecode still runs. You spend an hour asking “why is this line still executing?”

👉 Python caches compiled bytecode in __pycache__. That’s great for speed. But when you delete a .py file, the .pyc stays forever. Python finds it and imports it like nothing happened. No warning. No error.

✅ The idea: clear __pycache__ before you debug import issues. Or set PYTHONDONTWRITEBYTECODE=1 in development. Or just accept that Python will gaslight you once a month and move on.

super() is linear. Your brain is not.

You have class A, B, C. Multiple inheritance. You call super().method() inside B. Which method runs? Not necessarily the parent of B. It depends on the Method Resolution Order of the instance.

Most developers learn MRO once, forget it, then get confused when super() jumps sideways instead of up.

Take this:

class A:
    def f(self): print("A")

class B(A):
    def f(self): print("B"); super().f()

class C(A):
    def f(self): print("C"); super().f()

class D(B, C):
    def f(self): print("D"); super().f()

D().f() prints D, B, C, A. Not B then A. Because super() in B calls next in MRO which is C, not A.

This is not a bug. It's cooperative multiple inheritance. It allows mixins and dependency injection. But if you don't understand it, you will spend hours wondering why super().f() skipped a generation.

✔️ The rule: super() follows the MRO, not the parent hierarchy. Print ClassName.__mro__ before you debug.

Python Syllabus