Flask is a lightweight and flexible web framework forPython. It's designed to make getting started withweb development quick and easy, while still being powerful enough to build complex web applications. It is an API of Python that allows us to build web applications.

It was developed by Armin Ronacher. Flask's framework is more explicit than Django's framework and is also easier to learn because it has less base code to implement a simple web application. Flask Python is based on the WSGI(Web Server Gateway Interface) toolkit and Jinja2 template engine.

Advantages of Flask

• Flask is alightweight backend framework with minimal dependencies.
• Flask iseasy to learn because its simple and intuitive API makes it easy to learn and use for beginners.
• Flask is aflexibleFramework because it allows you to customize and extend the framework to suit your needs easily.
• Flask can be used withany database like:- SQL and NoSQL and withany Frontend Technology such asReactorAngular.
• Flask isgreat for small to medium projects that do not require the complexity of a large framework.
• Flask Documentation.

Getting Started With Flask

Python3 is required for the installation of the Python Web Framework Flask. You can start by importing Flask from the Flask Python package on any Python IDE. For installation on any environment, you can execute the command "pip install flask" on your terminal. Let's look at an example of a basic flask app.

fromflaskimportFlaskapp=Flask(__name__)# Flask constructor# A decorator used to tell the application# which URL is associated function@app.route('/')defhello():return'HELLO'if__name__=='__main__':app.run(debug=True)

Explanation:

• Flask(__name__): Creates the Flask app.
• @app.route('/'): Defines the home route (/).
• def hello(): creates a function that is bound with '/' route and returns "HELLO" when the root page is accessed.
• app.run(debug=True): runs the app in debug mode. It ensure that app is not need to restart manually if any changes are made in code.

Build Flask Routes in Python

Web frameworks provide routing technique so that user can remember the URLs. It is useful to access the web page directly without navigating from the Home page. It is done through the followingroute() decorator, to bind the URL to a function.

# decorator to route URL@app.route(‘/hello’)# binding to the function of routedefhello_world():return‘helloworld’

Explanation: If a user visitshttp://localhost:5000/helloURL, the output of thehello_world()function will be rendered in the browser.

One alternate way of doing this is by using "add_url_rule()" function of an application object, it can also be used to bind URL with the function similar to the above example.

defhello_world():return‘helloworld’app.add_url_rule(‘/’,‘hello’,hello_world)

Variables in Flask

Variables in flask are used to build a URL dynamically by adding the variable parts to the rule parameter. It is passed as keyword argument. Here's an example.

fromflaskimportFlaskapp=Flask(__name__)@app.route('/hello/<name>')defhello_name(name):return'Hello%s!'%nameif__name__=='__main__':app.run(debug=True)

Output:

Explanation: parameter ofroute() decorator contains the variable part attached to the URL '/hello' as an argument. Hence, if URL like "http://localhost:5000/hello/GeeksforGeeks" is entered then "GeeksforGeeks" will be passed to thehello() function as an argument.

Besides the default string type, Flask also supports int, float, and path (which allows slashes for directories). Flask's URL rules useWerkzeug’srouting module, ensuring unique URLs following Apache's conventions. Here's an example.

fromflaskimportFlaskapp=Flask(__name__)@app.route('/blog/<int:postID>')defshow_blog(postID):return'Blog Number%d'%postID@app.route('/rev/<float:revNo>')defrevision(revNo):return'Revision Number%f'%revNoif__name__=='__main__':app.run(debug=True)

Run the application and type the following URLs in a browser-

http://127.0.0.1:5000/blog/555

http://127.0.0.1:5000/rev/1.1

Explanation:

• /blog/555 captures 555 as an integer and returns "Blog Number 555".
• /rev/1.1 captures 1.1 as a float and returns "Revision Number 1.100000" (default float format).

Build a URL in Flask

Dynamic Building of the URL for a specific function is done usingurl_for()function. The function accepts the name of the function as first argument, and one or more keyword arguments. See this example

fromflaskimportFlask,redirect,url_forapp=Flask(__name__)@app.route('/admin')# decorator for route(argument) functiondefhello_admin():# binding to hello_admin callreturn'Hello Admin'@app.route('/guest/<guest>')defhello_guest(guest):# binding to hello_guest callreturn'Hello%s as Guest'%guest@app.route('/user/<name>')defhello_user(name):ifname=='admin':# dynamic binding of URL to functionreturnredirect(url_for('hello_admin'))else:returnredirect(url_for('hello_guest',guest=name))if__name__=='__main__':app.run(debug=True)

To test this, save the above code and run through python shell and then open browser and enter the following URLs-

http://localhost:5000/user/admin

http://localhost:5000/user/ABC

Explanation:

The above code has a function named user(name), accepts the value through input URL. It checks that the received argument matches the 'admin' argument or not. If it matches, then the function hello_admin() is called else the hello_guest() is called.

HTTP method are provided by Flask

Python Web Framework Flask support various HTTP protocols for data retrieval from the specified URL, these can be defined as:-

Serve HTML and Static Files in Flask

A web application often requires a static file such as javascript or a CSS file to render the display of the web page in browser. Usually, the web server is configured to set them, but during development, these files are served as static folder in your package or next to the module. See the example in JavaScript given below:

fromflaskimportFlask,render_templateapp=Flask(__name__)@app.route("/")defindex():returnrender_template("index.html")if__name__=='__main__':app.run(debug=True)

HTML File (index.html)

Create aTemplatefolder "templates" in your project directory. This Template folder will contain all theHTMLfiles of the project and they will be rendered through our flask app usingrender_templatemethod (we will learn about it in detail later).

<html><head><scripttype="text/javascript"src="{{ url_for('static', filename = 'hello.js') }}"></script></head><body><inputtype="button"onclick="sayHello()"value="Say Hello"/></body></html>

JavaScript file (hello.js)

Create astaticfolder that will contain all thejavascriptandCSSfiles. It will be sibling of the templates folder.

functionsayHello(){alert("Hello World")}

To serve this javascript code in a flask app, link it with a HTML file (index.html in this case) in the template folder using this line of code in the head section -

<script type = "text/javascript" src = "{{ url_for('static', filename = 'hello.js') }}" ></script>

Run the application by executing "python app.py" in the terminal and visit the development URL-http://127.0.0.1:5000

Output:

Cookies in Flask

A Cookie is a form of text file which is stored on a client's computer, whose purpose is to remember and track data pertaining to client's usage in order to improve the website according to the user's experience and statistic of webpage.

The Request object contains cookie's attribute. It is the dictionary object of all the cookie variables and their corresponding values. It also contains expiry time of itself. In Flask, cookie are set on response object. See the example given below:

app.py code

fromflaskimportFlask,request,render_template,make_responseapp=Flask(__name__)@app.route('/')defindex():returnrender_template('index.html')@app.route('/setcookie',methods=['POST','GET'])defsetcookie():ifrequest.method=='POST':user=request.form['nm']resp=make_response(render_template('cookie.html'))resp.set_cookie('userID',user)returnresp@app.route('/getcookie')defgetcookie():name=request.cookies.get('userID')return'<h1>welcome '+name+'</h1>'if__name__=="__main__":app.run()

HTML code ( index.html )

<html><body><formaction="/setcookie"method="POST"><p><h3>Enter userID</h3></p><p><inputtype='text'name='nm'/></p><p><inputtype='submit'value='Login'/></p></form></body></html>

HTML code ( cookie.html )

<html><body><ahref="/getcookie">Click me to get Cookie</a></body></html>

Run the application and visit http://127.0.0.1:5000 in your browser. The form submits to '/setcookie', where the set function stores a cookie named userID. The cookie.html page includes a link to the getcookie() function, which retrieves and displays the cookie value in the browser. Output snippets are below:

Enter user ID into the form and click "Login".

Click on "Click me to get Cookie"

"/getcookie" route takes the User ID from cookies and renders welcome along with it.

Sessions in Flask

A session is the time between a userlogging in andlogging out of a server. Session data is stored on the server in a temporary folder, and each user is assigned a unique session ID.

Session ID

The Session object is a dictionary that contains thekey-value pair of the variables associated with the session. ASECRET_KEY is used to store the encrypted data on thecookies.

Example:

Session[key] = value // stores the session value
Session.pop(key, None) // releases a session variable

Other Important Flask Functions

redirect

It is used to return the response of an object and redirects the user to another target location with specified status code.

Syntax: Flask.redirect(location, statuscode, response)

Parameters:

• location: The URL to redirect to.
• statuscode (optional): HTTP status code (default is 302, which means "Found" or temporary redirect).
• response (optional): Used to modify the response before sending.

abort

It is used to handle the error in the code.

Syntax: Flask.abort(code)

The code parameter can take the following values to handle the error accordingly:

• 400 - For Bad Request
• 401 - For Unauthenticated
• 403 - For Forbidden request
• 404 - For Not Found
• 406 - For Not acceptable
• 425 - For Unsupported Media
• 429 - Too many Requests

File-Uploading in Flask

File Uploading in Flask needs an HTML form with enctype attribute and URL handler, that fetches file and saves the object to the desired location. Files are temporary stored on server and then on the desired location. The HTML Syntax that handle the uploading URL is :

form action="http://localhost:5000/uploader" method="POST" enctype="multipart/form-data"

Example:

fromflaskimportFlask,render_template,requestfromwerkzeug.utilsimportsecure_filenameapp=Flask(__name__)@app.route('/upload')defupload_file():returnrender_template('upload.html')@app.route('/uploader',methods=['GET','POST'])defupload_file():ifrequest.method=='POST':f=request.files['file']f.save(secure_filename(f.filename))return'file uploaded successfully'if__name__=='__main__':app.run(debug=True)

Sending Form Data to the HTML File of Server

A Form in HTML is used to collect the information of required entries which are then forwarded and stored on the server. These can be requested to read or modify the form.

fromflaskimportFlask,render_template,requestapp=Flask(__name__)@app.route('/')defstudent():returnrender_template('student.html')@app.route('/result',methods=['POST','GET'])defresult():ifrequest.method=='POST':result=request.formreturnrender_template("result.html",result=result)if__name__=='__main__':app.run(debug=True)

Explanation:

• '/' URL loads student.html, which contains a form.
• form submits data to /result.
• result() function:
  • Retrieves form data from request.form.
  • Stores it in a dictionary.
  • Sends it to result.html for rendering.

HTML Code ( result.html )

<!doctype html><html><body><tableborder=1>         {% for key, value in result.items() %}<tr><th> {{ key }}</th><td> {{ value }}</td></tr>                     {% endfor %}</table></body></html>

HTML Code ( student.html )

<html><body><formaction="http://localhost:5000/result"method="POST"><p>Name<inputtype="text"name="Name"/></p><p>Physics<inputtype="text"name="Physics"/></p><p>Chemistry<inputtype="text"name="chemistry"/></p><p>Maths<inputtype="text"name="Maths"/></p><p><inputtype="submit"value="submit"/></p></form></body></html>

Alert messages in Flask

Alert can be defined as apop-up or a dialog box that appears on the web-page or like alert inJavaScript, which are used to inform the user. This in flask can be done by using the method flash() in Flask. It passes the message to the next template.

Syntax: flash(message, category)

Prameters:

• message-actual text to be displayed
• category(optional)- to render any error or info.

Example

fromflaskimportFlaskapp=Flask(__name__)# /login display login form@app.route('/login',methods=['GET','POST'])# login function verify username and passworddeflogin():error=Noneifrequest.method=='POST':ifrequest.form['username']!='admin'or \request.form['password']!='admin':error='Invalid username or password. Please try again !'else:# flashes on successful loginflash('You were successfully logged in')returnredirect(url_for('index'))returnrender_template('login.html',error=error)

Similar Reads