In this article, we will learn about the enriched parts of a Flask application. The initially and most imperative decision that we will ever make for our project is how can organize it. We should ask ourselves following questions;
- What the best Flask project structure is?
- What will our project need?
- Is it changed from other project’s we’ve done already?
- How can we have one single project structure that will make sure our project will not have a problem?
- How can that project at the same time will likewise permit us to develop and keep emergent?
- Altogether Flask applications need to create an application instance.
- The web server clearances all requests it obtains from clients to this object.
- Those are for controlling and using a protocol called Web Server Gateway Interface (WSGI).
- The application instance is created as an object of class Flask.
- That is commonly created as follows:
from flask import Flask app = Flask(__name__)
- The first necessary argument to the Flask class constructor is the name of the main module or package of the application.
- For best applications, Python’s __name__ variable is the right value.
- Flask practices this argument to regulate the root path of the application.
- Therefore that it far along may find resource files relative to the location of the application.
Routes and View Functions
- Clients for example web browsers send requests to the web server.
- That in sequence sends them to the Flask application instance.
- The application instance requires to identify what code needs to run for each URL requested.
- Therefore it saves a mapping of URLs to Python functions.
- The relationship between a URL and the function that grips it is named a route.
- The most suitable method to define a route in a Flask application is via the app.route decorator.
- That is unprotected by the application instance.
- That registers the decorated function as a route.
- The following illustration demonstrates how a route is stated using this decorator:
@app.route('/') def index(): return '<h1>Hello World!</h1>'
- The preceding illustration registers the function index () by way of the handler for the application’s root URL.
- Navigating to http://www.example.com on our browser would trigger index () to run on the server if this application were set up on a server related with the www.example.com domain name.
- The return value of this function the client receives is known as the response.
- The response is the document that is showed to the user if the client is a web browser.
- Functions corresponding index () are named view functions.
- A response returned with a view function may be a simple string with HTML content. It may also take extra difficult forms.
- Some URLs for services have variable sections. For instance, the URL for our Facebook profile page is http://www.facebook.com/<our-name>.
- Therefore our username is part of it.
- Flask supports these types of URLs by a special syntax in the route decorator.
- The below example describes a route that has a vibrant name component.
@app.route('/user/<name>') def user(name): return '<h1>Hello, %s!</h1>' % name
- The part bounded in angle brackets is the dynamic part.
- Consequently any URLs matches the static portions will be mapped to this route.
- Flask sends the forceful component as an argument when the view function is raised.
- This argument is used to make a personalized greeting as a response in the prior example view function.
- The active components in routes are strings by default.
- On the other hand may also be defined with a type.
- For instance, route /user/<int:id> will match only URLs that have an integer in the id active segment.
- Flask provisions type’s int, float, and path for routes.
- The path type similarly indicates a string.
- That consider slashes as part of the forceful component.
- The application instance has a run method.
- That presents Flask’s integrated development web server.
if __name__ == '__main__': app.run(debug=True)
- The __name__ == ‘__main__’ Python idiom is used to make sure that the development web server is started only when the script is performed openly.
- It is expected that the parent script will launch a different server when the script is imported by another script.
- Therefore, the app.run() call is missed.
- The server goes into a loop.
- That waits for requests and services them when starts up.
- This loop continues up to the application is stopped.
- For instance by hitting Ctrl-C.
- There are many option arguments that may be given to app.run() to configure the mode of operation of the web server.
- It is suitable to allow debug mode during development.
- That between other things activates the debugger and the reloader.
- This is completed by passing the argument debug set to True.
A Complete Application
- We have learnt about the different parts of a Flask web application up till now.
- Currently, we will write those parts.
- The complete hello.py application script is associated with three parts defined prior joint in a single file.
- The application is shown in the following example.
Example: hello.py: A complete Flask application
from flask import Flask app = Flask(__name__) @app.route('/') def index(): return '<h1>Hello World!</h1>' if __name__ == '__main__': app.run(debug=True)
- Make assure the earlier created virtual environment is activated to run the application and has Flask installed.
- At the present open the web browser and type http:// 127.0.0.1:5000/ in the address bar.
- Below figure displays the web browser after linking to the application.
- At that time launch the application with the following command:
(venv) $ python hello.py * Running on http://127.0.0.1:5000/ * Restarting with reloader
- The application will not recognize how to handle it if we type any other URL.
- That will return an error code 404 to the browser.
- That is used to error that we get when navigate to a web page that does not exist.