Flask Tutorial For Beginners – Flask Quick Start Tutorial

Flask Tutorial – A minimum application

A minimal application looks like this:

From  flask  import  Flask 
app  =  Flask ( __name__ )

@app.route ( '/' ) 
def  hello_world (): 
    return  'Hello World!'

If  __name__  ==  '__main__' : 
    app . run ()

Save it as hello.py (or a similar file) and run it with the Python interpreter. Make sure your application is not called flask.py, because of this conflicts with Flask itself.

$ python hello.py
 * Running on https://127.0.0.1:5000/

Now browse https://127.0.0.1:5000/ and you will see your Hello World greeting.

So what did this piece of code do?

1. First we imported the class Flask. The instantiation of this class will be our WSGI application. The first parameter is the name of the application module. If you are using a single module (as in this example), the first parameter should use __name__ .
2. Because it depends on if it is started as a separate application or imported as a module, the name will be different ( '__main__'corresponding to the actual imported name). For more information, please read Flaskthe document.
3. Next, we create an instance of this class. We pass it the name of the module or package. This way Flask will know where to look for templates, static files, and so on.
4. We use the decorator route()to tell Flask what URL to trigger our function.
5. Define a function that is also used to generate URLs for a particular function and return information that we want to display on the user’s browser.
6. Finally, we use the function run()to start a local server to run our application. Make sure that the server will only run when the script is executed directly by the Python interpreter, not when imported as a module.if __name__ =='__main__':

Press Control-C to stop the server.

App . run ( host = '0.0.0.0' )

Flask Tutorial – Debug Mode

run()The method is very suitable for starting a local development server, but you need to restart the server manually after modifying the code. This is not a good thing. Flask can do better. If debugging support is enabled, the server will automatically load when the code is modified, and it will provide a useful debugger if an error occurs.

There are two ways to turn on the tuning mode. One is to set the flag on the application object:

App . debug  =  True 
app . run ()

Or passed as a parameter to run:

App . run ( debug = True )

The effect of the two methods is the same.

Screenshot of the running debugger:

Routing 

Modern Web applications have elegant URLs. This helps people remember URLs, which is useful for applications that use slow-networking mobile devices. If the user does not have to directly access the desired page by clicking on the home page, it is likely that they will like this page and visit again the next time.

As mentioned above, route()decorators are used to bind a function to a URL. Here are some basic examples:

@app.route ( '/' ) 
def  index (): 
    return  'Index Page'

@app.route ( '/hello' ) 
def  hello (): 
    return  'Hello World'

But not only that! You can construct a specific part of a URL dynamically, or you can attach multiple rules to a function.

@app.route ( '/user/<username>' ) 
def  show_user_profile ( username ): 
    # show the user profile for that user 
    return  'User %s '  %  username

@app.route ( '/post/<int:post_id>' ) 
def  show_post ( post_id ): 
    # show the post with the given id, the id is an integer 
    return  'Post %d '  %  post_id

@app.route ( '/projects/' ) 
def  projects (): 
    return  'The project page'

@app.route ( '/about' ) 
def  about (): 
    return  'The about page'

>>> from  flask  import  Flask ,  url_for 
>>> app  =  Flask ( __name__ ) 
>>> @app.route ( '/' ) 
... def  index ():  pass 
... 
>>> @app.route ( '/login' ) 
... def  login ():  pass 
... 
>>> @app.route ( '/user/<username>' ) 
... def  profile ( username ):  pass 
...
>>> with  app . test_request_context (): 
...  print  url_for ( 'index' ) 
...  print  url_for ( 'login' ) 
...  print  url_for ( 'login' ,  next = '/' ) 
...  print  Url_for ( 'profile' ,  username = 'John Doe' ) 
... 
/ 
/login 
/login?next=/ 
/user/John%20Doe

@app.route ( '/login' ,  methods = [ 'GET' ,  'POST' ]) 
def  login (): 
    if  request . method  ==  'POST' : 
        do_the_login () 
    else : 
        show_the_login_form ()

Static files

Dynamic web applications also require static files. CSS and JavaScript files usually come from this. Ideally, your web server is already configured to serve them, but Flask can do it during development. Simply create a folder named static in your package or next to the module, and use /static in your application to access it.

To generate static files URL, use a special 'static'endpoint name:

Url_for ( 'static' ,  filename = 'style.css' )

This file should be stored on the file system called.static/style.css

Rendering template

Generating HTML in Python is not fun, and it’s actually quite cumbersome because you have to make HTML escape yourself to keep your application safe. For this reason, Flask automatically configures the Jinja2 template for you.

You can use the method render_template()to render the template. All you need to do is provide the name of the template and the variables you want to pass into the template as keyword arguments. Here is a simple example of rendering a template:

From  flask  import  render_template

@app.route ( '/hello/' ) 
@app.route ( '/hello/<name>' ) 
def  hello ( name = None ): 
    return  render_template ( 'hello.html' ,  name = name )

Flask will look for templates in the templates folder. So if your application is a module, this folder is next to the module. If it is a package, then this folder is in your package:

Case 1 : One module:

/application.py
/templates
    /hello.html

Case 2 : A package:

/application
    /__init__.py
    /templates
        /hello.html

For templates, you can use the full functionality of the Jinja2 template. See the official Jinja2 Template Documentation for details.

Here is an example of a template:

<!doctype html> 
<title> Hello from Flask </title> 
{%  if  name  %} 
  <h1> Hello {{  name  }} ! </h1> 
{%  else  %} 
  <h1> Hello World! </h1> 
{%  endif  %}

You can also use templates,request sessionand objects, as well as functions.gget_flashed_messages()

Template inheritance is very useful. If you want to know how to work the inherited template, please read the document template inheritance. Basic template inheritance makes certain specific elements (such as titles, navigation, and footers) possible on each page.

Auto-escaping is turned on, so if the name contains HTML, it will be automatically escaped. If you trust a variable, and you know it is secure (for example, a module to convert wiki markup to HTML), you can use Markupthe class or |safefilter tags it is safe in the template. In the Jinja 2 document, you will see more examples.

This is a Markupbasic introduction to what type of work:

>>> from  flask  import  Markup 
>>> Markup ( '<strong>Hello %s !</strong>' )  %  '<blink>hacker</blink>' 
Markup(u'<strong>Hello <blink>hacker< ;/blink>!</strong>') 
>>> Markup . escape ( '<blink>hacker</blink>' ) 
Markup(u'<blink>hacker</blink>') 
>>> Markup ( ' <em>Marked up</em> » HTML' ) . striptags () 
u'Marked up \xbb HTML'

For web applications, it is important to respond to the data sent from the client to the server. In Flask by the global object request to provide such information. If you have some Python experience, you will wonder how this object may be global, and how Flask can also guarantee thread safety. The answer is the context scope:

From  flask  import  request

With  app . test_request_context ( '/hello' ,  method = 'POST' ): 
    # now you can do something with the request until the 
    # end of the with block, such as basic assertions: 
    assert  request . path  ==  '/hello' 
    Assert  request . method  ==  'POST'

From  flask  import  request

With  app . request_context ( environ ): 
    assert  request . method  ==  'POST'

From  flask  import  request

@app.route ( '/login' ,  methods = [ 'POST' ,  'GET' ]) 
def  login (): 
    error  =  None 
    if  request . method  ==  'POST' : 
        if  valid_login ( request . form [ 'username' ], 
                       request . form [ 'password' ]): 
            return  log_the_user_in ( request . form [ 'username' ]) 
        else :
            Error  =  'Invalid username/password' 
    # the code below this is executed if the request method 
    # was GET or the credentials were invalid 
    return  render_template ( 'login.html' ,  error = error )

Searchword  =  request . args . get ( 'key' ,  '' )

From  flask  import  request

@app.route ( '/upload' ,  methods = [ 'GET' ,  'POST' ]) 
def  upload_file (): 
    if  request . method  ==  'POST' : 
        f  =  request . files [ 'the_file' ] 
        f . save ( '/var/www/uploads/uploaded_file.txt' ) 
    ...

From  flask  import  request 
from  werkzeug  import  secure_filename

@app.route ( '/upload' ,  methods = [ 'GET' ,  'POST' ]) 
def  upload_file (): 
    if  request . method  ==  'POST' : 
        f  =  request . files [ 'the_file' ] 
        f . save ( '/var/www/uploads/'  +  secure_filename ( f . filename )) 
    ...

From  flask  import  request

@app.route ( '/' ) 
def  index (): 
    username  =  request . cookies . get ( 'username' ) 
    # use cookies.get(key) instead of cookies[key] to not get a 
    # KeyError if the cookie is Missing.

From  flask  import  make_response

@app.route ( '/' ) 
def  index (): 
    resp  =  make_response ( render_template ( ... )) 
    resp . set_cookie ( 'username' ,  'the username' ) 
    return  resp

Flask – Redirection and error

You can use redirect()the function to redirect users elsewhere. It can be used abort()in advance function and an interrupt request with an error code. Here is an example of how they work:

From  flask  import  abort ,  redirect ,  url_for

@app.route ( '/' ) 
def  index (): 
    return  redirect ( url_for ( 'login' ))

@app.route ( '/login' ) 
def  login (): 
    abort ( 401 ) 
    this_is_never_executed ()

This is a rather pointless example because the user will be redirected from the home page to an inaccessible page (401 means no access), but it shows how the redirection works.

By default, each error code displays a black and white error page. If you want to customize error pages, you can use the errorhandler()decorator:

From  flask  import  render_template

@app.errorhandler ( 404 ) 
def  page_not_found ( error ): 
    return  render_template ( 'page_not_found.html' ),  404

Notice 404is render_template()after the call. Tell Flask that the error code for this page should be 404, ie not found. The default 200 is assumed to be: Everything is OK.

About response

The return value of a view function is automatically converted to a response object. If the return value is a string, it is converted into a string of the subject is a response with the error code, the media type of the response object. Flask converts the return value into the response object’s logic as follows:200 OKtext/html

1. If it returns a valid response object, it will be returned directly from the view.
2. If a string is returned, the response object is created with string data and default parameters.
3. If you return a tuple and the elements in the tuple provide additional information. Such tuple must form and contain at least one element. The status value will override the status code, headers can be a list or an additional header value dictionary.(response, status, headers)
4. If none of the above conditions are met, Flask assumes that the return value is a valid WSGI application and converts it to a request object.

If you want to get the response object you get in the view, you can use functionmake_response()

Imagine you have a view like this:

@app.errorhandler ( 404 ) 
def  not_found ( error ): 
    return  render_template ( 'error.html' ),  404

You only need to make_response()package the return expression, get the results and modify the object, and then return it:

@app.errorhandler ( 404 ) 
def  not_found ( error ): 
    resp  =  make_response ( render_template ( 'error.html' ),  404 ) 
    resp . headers [ 'X-Something' ]  =  'A value' 
    return  resp

Session

In addition to the request object, there is referred to a second sessionobject allows you to store requests between different user-specific information. This is based on cookies and uses encrypted signatures in cookies. This means that the user can view the contents of the cookie but cannot modify it unless it knows the key of the signature.

To use the session, you need to set a key. Here’s how the session works:

From  flask  import  Flask ,  session ,  redirect ,  url_for ,  escape ,  request

App  =  Flask ( __name__ )

@app.route ( '/' ) 
def  index (): 
    if  'username'  in  session : 
        return  'Logged in as %s '  %  escape ( session [ 'username' ]) 
    return  'You are not logged in'

@app.route ( '/login' ,  methods = [ 'GET' ,  'POST' ]) 
def  login (): 
    if  request . method  ==  'POST' : 
        session [ 'username' ]  =  request . form [ 'username ' ] 
        return  redirect ( url_for ( 'index' )) 
    return  ''' 
        <form action="" method="post"> 
            <p><input type=text name=username>
            <p><input type=submit value=Login> 
        </form> 
    '''

@app.route ( '/logout' ) 
def  logout (): 
    # remove the username from the session if it's there 
    session . pop ( 'username' ,  None ) 
    return  redirect ( url_for ( 'index' ))

# set the secret key. keep this really secret: 
app . secret_key  =  'A0Zr98j/3yX R~XHH!jmN]LWX/,?RT'

It mentioned herein escape()may be escaped (as in this case) when you are not using a template engine.

>>> import  os 
>>> os . urandom ( 24 ) 
'\xfd{H\xe5<\x95\xf9\xe3\x96.5\xd1\x01O<!\xd5\xa2\xa0\x9fR"\xa1\ Xa8'

Note the use of cookie-based sessions: Flask serializes the values you place in the session object into cookies. If you try to find a value that does not persist across requests, cookies are enabled, and you do not get explicit error messages. Check the size of the cookies in your page request and compare them with the size supported by your web browser.

Message flashes

Good apps and user interfaces are all about feedback. If users do not receive enough feedback, they may become annoying about the application. Flask provides a really simple way to give users feedback via the message flash system. The message flashing system basically causes the information to be logged at the end of the request and is accessed in the next (and only next) request. Messages are usually displayed in conjunction with the template layout.

Using the flash()method to flash a message, use get_flashed_messages()can be obtained message, get_flashed_messages()it can also be used in the template. For a complete example please refer to the news flash.

Log

You may still want to record what is happening abnormally. At this time, the log is useful. Log records starting from Flask 0.3 are pre-configured.

Here are some examples of log calls:

App . logger . debug ( 'A value for debugging' ) 
app . logger . warning ( 'A warning occurred ( %d apples)' ,  42 ) 
app . logger . error ( 'An error occurred' )

That comes with loggera standard logging class Logger

WSGI middleware integration

If you want to add WSGI middleware to your application, you can encapsulate internal WSGI applications. For example, if you want to use one of the middleware in the Werkzeug package to handle bugs in Lighttpd, you can do this:

From  werkzeug.contrib.fixers  import  LighttpdCGIRootFix 
app . wsgi_app  =  LighttpdCGIRootFix ( app . wsgi_app )