Before everything. I’d like to share some amazing moments with you. Three months ago, I began mentoring sessions on FastAPI and its async capabilities. Those were the best moments I owed in my whole career as a Tech fanatic. creating connections with diamond like personas fighting with fellow Django developers, taking caffeine talking hours and hours about ricing. I know fellows those might sounds bit nerdy 🥸 but for a developers it’s more like finding their own species😂😂
In the last three months, I’ve given over five presentations about FastAPI, and at the end of each one, I’ve received a few valuable LinkedIn connections and a plethora of questions. So I decided to write an article to share what I know and understand about FastAPI. Once I started writing, I realized it wouldn’t end because I wanted to say more and more. As a beginner writer, I try to keep the article short and understandable for developers. Hope that works :)
I have a secret confession😶: when I first discovered FastAPI 🚀, I didn’t think much of it. As a software engineer who is heavily invested in learning best practices and investigating parallel computation for performance gains, I approached it with skepticism. I skimmed the documentation, ran some sample code, and quickly abandoned it, convinced that my trusty DRF (Django Rest Framework) was more than adequate for my needs.
But then I met my fellow Athul Nandaswaroop and faced thousands of challenges 😵💫, everything changed. FastAPI, with his expertise, completely changed my perception. This framework totally changed my development style! It allows me to experiment with new design structures and much more. The greatest part? No more bothering with those annoying boilerplate's! 🎉
Behold, when developers happen upon a new framework or solution, there emerges a tendency to lean upon it for the resolution of all challenges — known as the “lazy developers’ policy” (16:21)✝️.
FastAPI, however, wasn’t just a passing trend. It played a crucial role in a personal project that seemed challenging: creating a complex and beautiful backend within a tight 12-day deadline, with only a two-member team. Despite our initial worries, we managed to surpass expectations and complete the project on time without compromising quality.
My team was like 🤯 what? How was the job completed? Jaws dropped🤣
Now, I must let you in on a little secret 🤫 we worked more than 14 hours every day 🫣.
This experience turned my coding world upside down. It’s like the moment when my ex💃, DRF (Django Rest Framework), and I decided to see other frameworks. FastAPI👰 swooped in and became the unexpected crush I didn’t know I needed. Now, don’t tell FastAPI, but DRF and I occasionally have secret meetups behind its back. Shh, it’s our private coding meeting! 😄🤫
As a technical advisor and freelance developer, I’ve noticed a hilarious trend among developing companies in India — the slow crawl towards FastAPI. Picture this: some are scratching their heads in confusion, while others are clinging to their ancient software🐌 like it’s their long-lost childhood blanket. “Why switch to FastAPI when our current setup moves slower than a snail on a lazy Sunday afternoon?” they ask, with a raised eyebrow that practically screams, “Change? Nah, we’re good with our prehistoric tech, thank you very much!”
Now, I’m not here to poke fun😏 (okay, maybe just a little😋), but it’s like watching a sitcom unfold in the office. The drama, the resistance to change — it’s comedy gold!
But fear not, my tech-savvy pals, because I’m here to tell you that FastAPI isn’t just a rocket ship; it’s a freaking time machine! Whether it’s for production, development, or handling requests faster than you can say “supercalifragilisticexpialidocious,” 🫣FastAPI is the way to go
So, let’s spread the joy and share our FastAPI tales with the world. Who knows? Maybe we’ll even get a chuckle out of those stubborn old-timers stuck in their software time warp. 😂
FastAPI stands as one of the finest and fastest frameworks in the market today. From my personal experience, I can confidently assert that FastAPI is:
- Fast: It outpaces popular frameworks like Django, Flask, and Falcon by a significant margin, clocking in at 3 times faster than Django alone.
- Easy to Learn: Its intuitive design and comprehensive documentation make it a breeze for developers to pick up and utilize effectively.
- Purely Asynchronous: Leveraging asynchronous programming, FastAPI ensures efficient handling of requests, enabling seamless scalability.
- Feature-Rich: Packed with an array of features, FastAPI offers developers a plethora of tools to streamline development processes.
😤😤😤😤
Lets see how fast is fast api:
FastAPI’s speed is nothing short of incredible. It is not just slightly quicker than Django and Flask; it is three times faster than Django and fifteen times faster than Flask. This huge difference allows us to manage a considerably larger amount of requests with the same resources. In other words, FastAPI enables us to service more requests in less time, making it highly efficient and applicable to real-world applications. It is a game changer in terms of performance optimization and resource use, with demonstrable productivity benefits.
I can hear some old buns blabbering, maybe they think it gives speed, but
- What about the complexity? 🧑🏼🦰
- What about the learning curve? 🧗🏾
- Are we gonna need a GPS to navigate through this or what? 🤔
Complexity:
- Complexity to code
API POINTS
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"Hello": "World"}Only five lines of code, and you’re done! You’ve created a REST API point in FastAPI. It’s like waving a magic wand and seeing your desires come true. Who said that development had to be complex? FastAPI focuses on reaching excellence with simplicity. ✨
Explanation 👨🏼🏫
Here’s the breakdown of what’s happening:
- First off, when we call FastAPI(), we’re essentially creating an instance of the FastAPI application. It’s like setting up the foundation for our web application.
- Now, onto the exciting stuff! When we utilize the @application.Using the get(“/”) decorator, we instruct FastAPI to execute a function named read_root whenever a GET request is submitted to our application’s root (“/”). Consider it as enabling a certain action for a given URL.
- Finally, consider the read_root function itself. This function accomplishes its task and returns a dictionary. But here’s where things become more cooler: FastAPI immediately turns this dictionary into a JSON response. It’s like magic! So, when a client performs a GET request to our application’s root, they’ll get a nice JSON response provided by our read_root method.
Web Sockets
Creating a socket connection with FastAPI is as easy as pie! All you need is a library like Starlette or WebSockets that offers WebSocket support. Check out this quick and dirty example of a FastAPI app setting up a WebSocket endpoint:
from fastapi import FastAPI, WebSocket
app = FastAPI()
@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
await websocket.accept()
while True:
data = await websocket.receive_text()
await websocket.send_text("Bluefox")Explanation 👨🏼🏫
Here’s the breakdown of what’s happening:
- @app.websocket(“/ws”): This nifty decorator tells FastAPI to direct requests with the path “/ws” straight to the websocket_endpoint function.
- await websocket.accept(): This line graciously accepts the incoming WebSocket connection, rolling out the red carpet for our client.
- while True:: Ah, the classic infinite loop! Here, we’re patiently waiting for a message from our dear client.
- data = await websocket.receive_text(): Ah-ha! Our client has spoken! This line receives a text message from them, letting us know what’s on their mind.
- await websocket.send_text(“Bluefox”): Time to respond! We’re sending a text message back to our client, acknowledging their message with a witty reply.
Learning Curve:🧗🏾
Python coders have almost no challenges! 😂. Learning to ride a bike with training wheels is similar to using Python frameworks such as FastAPI. And hey, if you’re coming from Starlette, this is like deja vu! FastAPI borrows the majority of its functionality from Starlette, making it a breeze to use.
Now, let me tell you about your new bedtime story: FastAPI documentation. It’s so easy to absorb, it’s like reading a bedtime story. Simply relax with your favorite beverage, click the link below, and watch the magic happen: FastAPI documentation 🚀🌟.
What’s the secret behind FastAPI’s lightning speed? What’s the magic ingredient that makes it zoom past the competition? 🚀🔍
Starlette, Uvicorn, and Pydantic — the heroes behind FastAPI’s magic!
Starlette [Mr.Legend]:
Starlette, the unsung hero of the FastAPI saga, is not your average ASGI framework. It’s the agile performer, the silent force behind FastAPI’s lightning-fast asynchronous capabilities. With its lightweight design and efficient request handling, Starlette ensures that FastAPI operates seamlessly even under the most demanding workloads.
What makes Starlette truly exceptional is its ability to handle asynchronous tasks with unparalleled efficiency. By embracing asynchronous programming principles, Starlette empowers FastAPI to juggle multiple requests simultaneously, delivering unparalleled performance and scalability.
In the realm of FastAPI, Starlette is the steadfast companion, the reliable engine that propels applications to new heights of speed and responsiveness. From handling HTTP requests to managing WebSocket connections, Starlette does it all with finesse, making it the backbone of FastAPI’s direct-to-production approach.
Uvicorn [Flash in the Python Universe]:
Uvicorn, the swift conqueror of the ASGI world, stands as FastAPI’s trusty steed, carrying applications to victory with unmatched speed and agility. As FastAPI’s chosen ASGI server, Uvicorn embodies the spirit of rapid deployment and performance optimization.
With its lightning-fast event loop and efficient HTTP handling, Uvicorn ensures that FastAPI applications race to production without breaking a sweat. Whether it’s serving static files or handling WebSocket connections, Uvicorn does it all with remarkable efficiency, making it the go-to choice for FastAPI’s direct-to-production approach.
In the realm of ASGI servers, Uvicorn reigns supreme, leading the charge towards faster, more responsive web applications. With Uvicorn by its side, FastAPI conquers the digital landscape with unparalleled speed and reliability, making it the ultimate choice for developers seeking a direct path to production.
Pydantic[Light Yagami on my notebook]:
Pydantic, the guardian of data validation and serialization, stands as FastAPI’s stalwart defender, ensuring the integrity and reliability of applications on their journey to production. With its robust validation capabilities and seamless integration with FastAPI, Pydantic serves as the cornerstone of data integrity and security.
What sets Pydantic apart is its ability to enforce data validation and serialization with unparalleled precision. By leveraging Python’s type hinting system, Pydantic ensures that data is validated and serialized with utmost accuracy, guarding against potential vulnerabilities and ensuring the stability of FastAPI applications in production.
In the realm of data validation, Pydantic is the unwavering sentinel, the vigilant guardian that protects FastAPI applications from data-related pitfalls. With Pydantic at the helm, FastAPI developers can rest assured that their applications are fortified against data breaches and inconsistencies, paving the way for a smooth and secure journey to production.
Conclusion
So, that’s pretty much it! If you’ve made it this far, it means a lot to me. I hope this journey has given you a glimpse into how FastAPI works and how it can tackle your challenges head-on. FastAPI’s efficiency can help you break through the resource barriers that often hold back performance-oriented developers. Think of this as just the tip of the iceberg — there’s so much more to explore and learn about FastAPI! 😊
Please let me know your thoughts on this article. I’d love to hear your feedback! 🚀👋🤔
