After covering the basics of FastAPI, it is now time to do something more elaborate. For that purpose, we create a minimalistic to-do task tracker that let us work against an in-memory data store. To save us the time to constantly click in the browser, we will do this exercise by first writing a test and then create the implementation using the test-first approach.
With our API, the tests, and the models we get deeper and deeper into FastAPI. It is now a good moment to check what FastAPI suggests on how to structure our application before we start a more complex example.
So far, we used the GET method to ask FastAPI for data. Now it is time to send data to FastAPI and do some work with it.
FastAPI offers us two main options to specify what data we want: as part of the path or as query parameters. In this post we expand on our minimalistic example and dig a bit deeper into the basic concepts of FastAPI.
If we do not want to keep starting our API and manually click through the endpoints to see if everything still works, we need to put a little effort into testing. Thanks to the underlying Starlette toolkit, we can test our FastAPI application in-memory and do not need a dedicated server. Let us explore how that helps us with testing our API.
While our application waits on IO (Input / Output), our CPUs idle around. If we would have a way to let the program step aside and let other code run while we wait on a file or a response, we could get more work done at the same time. That is the basic idea behind asynchronous programming that we can do with coroutines and the async and await keywords in Python.
There are many projects in Python that we can use to create an API. After exploring a few options, I decided to go with FastAPI and explore it over the next few weeks. FastAPI is not only fast when it comes to serving requests, but also when it comes to writing code for it. Let us explore the many features we can use while we create our API.
The Garbage Collector (GC) in Python frees the memory from no longer needed objects. This usually works without any problem in the background and prevents us from memory leaks. However, for certain tasks we may pay a performance penalty that we can prevent by tuning the GC. Let us explore the options we have.
Last week we worked with the main methods of the re module. However, when we need to be specific about the text parts we search, we miss a lot of the flexibility we can get from regular expressions. In this post we look at metacharacters and how they make regular expressions so powerful.
I waited a long time to explore regular expressions, then they tend to get complicated in no time. But for some problems there is simply no way around. Let us explore the basics and how we can use them in our Python code.