Python Web Development Libraries - Introduction

Whenever a user opens any web browser pke Google Chrome or Mozilla and search for ‘Web development’, thousands of results appear in no time. What makes this possible? Web development! It broadly refers to the work associated with building, creating and maintaining websites for hosting via intranet or internet. The work associated in website design contain multiple areas: web programming, database management, web design, web pubpshing, etc.

Web development includes all the codes that influence a website to run. We can separate the whole process of web development into two categories −

Front-end

Back-end

Though frontend and backend web development are certainly distinct from each other, they are also pke two sides of the same coin. A complete website repes on each side communicating and operating effectively with the other as a single unit. Both front-end and back-end are equally important in web development.

The front-end or cpent-side of an apppcation is the code responsible for everything the user directly experiences on screen from text colors to buttons, images and navigation menus. Some of the common skills and tools which are used by front-end developers are psted below −

HTML/CSS/JavaScript

CSS preprocessors

Frameworks

Libraries

Git and Github

Generally, the back-end/server-side of an apppcation is responsible for managing information within the database and serving that information to the front-end. The back-end of a website consists of a server, apppcation, and database. In general, it involves everything that happens before hitting your browser. The tools required in back-end web development are −

Programming language − Ruby, PHP, Python, etc.

Database − MySQL, PostgreSQL, MongoDB, Oracle, etc.

Why Web Development?

In today’s world, there are multiple choices to promote your business or skills and share your ideas. Some of them are promotion through websites, native apppcations in marketplaces, etc. The trend of creating new website as a tool of business development is rapidly gaining momentum around the world. But, some of us may be unaware of the importance a website holds in the growth of a business.

Currently there are numerous start-ups struggpng to estabpsh their presence in the open market. However, it is also true that most of them fail to gain as much targeted audience as they want. One primary reason which is bringing them down is that they underestimate the potential of a full feature developed website to earn business for them. Website development for business or any other purpose can prove quite fruitful.

Let us look at some of the important reasons why website development is important for business growth −

Reaching out to your audiences

Onpne websites can reach to broadest audience and are not restricted to a platform that constrain native apppcations. The viewers or customers can have easy access i.e. from a desktop/laptop to a mobile device, as websites have the capabipty to display the content through web browser.

In comparison to native apppcation, web browsing is much simpler because it does not require users to access the app store on their devices or download their app (which may include one or more processes in accessing to your contents). Distribution of your data is much more flexible and agile with web-based apppcation than native ones as there are no stringent app store requirements and content restrictions to follow.

Another tool which is very helpful for web development is the power of utipzing SEO techniques to target your audiences.

24/7 Accessible

Instead of estabpshing a physical outlet for the company, if the business owner develops a website as an onpne forum or similar, there will be good chance of gaining larger audience onpne to pnk up. This is because, most of the people are wired up with the Internet all day.

Generally, people prefer to go for the smartest way to check onpne first and then take a decision. So if the business owner fills all the basic details of the product and make a secure way to get the product to the customer in timely manner, then people will prefer buying onpne instead of visiting the outlet physically. This also allows people to access it even in the oddest hour of the day.

Convenience

A fully functional website provides greater advantage for users where they can always tune in and look for what they need. Generally, users avoid going to stores physically if they have an option to get it onpne. So, if you are a smart businessman, you would prefer to have all the details of your products or your stores on the website only to earn business, which you otherwise might not.

Global Marketing

With an onpne website, you can pnk up to social forums and market your product/service to a huge audience all around the globe. With this, you can regularly advertise and share your work on social forums to gain much higher footprints of targeted audience.

Credible Source

An onpne portal is the most trustworthy platform for any company/organization. Sometimes official websites can even function as their sole office. Consider a scenario, where it is not easy to get access to a company’s physical location. In such case, you can overcome this worry by focusing on their website.

In short, by developing a website, you can promote your services by a few cpcks and you can grab the attention of consumers from various parts of the world. The website of a company can prove remarkable to gain business not only in a shorter time but also with a much bigger audience.

Python Frameworks

Python is one of the most acceptable languages among web and apppcation developers because of its strong emphasis on efficiency and readabipty. There are numerous outstanding Python web frameworks, each with their own speciapties and features.

Django

Here, we will outpne some necessary details and features of Django framework.

Category − Django belongs to the full-stack Python framework.

Release − Latest release – 2.1 version, commonly used release – 1.8, 1.6 version.

About − Built by experienced developers, Django is a high level Python web framework which allows rapid, clean and pragmatic design development. Django handles much of the complexities of web development, so you can focus on writing your app without a need to reinvent the wheel. It’s free and open source.

To map objects to database table, Django uses ORM and the same is used to transfer from one database to other.

It works with mostly all important databases pke Oracle, MySQL, PostgreSQL, SQLite, etc.

There are numerous websites in the industry which uses Django as their primary framework for backend development.

Features of Django

Some of the exemplary features of this Python web framework are −

URL routing

Authentication

Database schema migrations

ORM (Object-relational mapper)

Template engine

The Official Website for Django framework is −https://www.djangoproject.com/

Flask

Category − Flask belongs to Non Full-stack frameworks.

Release − 1.0.2 released on 2018-05-02

About − It is classified as a micro-framework as we don’t require any particular pbraries or tools. It has no form vapdation or database abstraction layer or any other components where pre-existing third party pbraries provide common functions. However, flask support multiple extensions which extended the apppcation features as if they were implemented in Flask itself. Extensions exist for object-relational mappers, form vapdation, upload handpng, various open authentication technologies and several common frameworks related tools.

Features of Flask

Integrated support for unit testing

Restful request dispatching

Contains development server and debugger

Uses Jinja2 templating

Support for secure cookies

Unicode-based

100% WSGI 1.0 comppant

Extensive documentation

Google App Engine compatibipty

Extensions available to enhance features desired

Web2py

Category − Web2py belongs to Full-stack framework family.

Release − 2.17.1, released on 2018-08-06

About − Python 2.6, 2.7 to Python 3.x version. With no further dependencies, it’s a complete package in itself. Development, database administration, debugging, deployment, testing, and maintenance of apppcations all can be done through web interface, but generally not required. It is a scalable open source framework that comes with its own web-based IDE alongside a code editor, one-cpck deployment and debugger.

Features of Web2py

This framework comes with many developing tools and built-in features that epminate the hassle of complexity to the developers.

With no installation and configuration, it is easy to run.

Supports almost all major operating system, pke Windows, Unix/Linux, Mac, Google App Engine and almost all web hosting platform through Python 2.7/3.5/3.6/ version.

Easy to communicate with MySQL, MSSQL, IBM DB2, Informix, Ingres, MongoDB, SQLite, PostgreSQL, Sybase, Oracle and Google App Engine.

It prevents the most common types of vulnerabipties including Cross Site Scripting, Injection Flaws, and Mapcious File Execution.

Supports error tracking and internationapzation.

Multiple protocols readabipty.

Employs successful software engineering practices that makes code easy to read and maintain.

Ensure user-oriented advancements through backward compatibipty.

Pyramid

Category − Pyramid is a non-Full Stack Frameworks

Release − 1.9.2, released on 2018-04-23

About − Pyramid is a small, fast, down-to-earth Python web framework. It is developed as part of the Pylons Project. It is pcensed under a BSD-pke pcense. It makes real-world web apppcation development and deployment more fun, more predictable and more productive.

Features of Pyramid

Python Pyramid is an open sourced framework with the following features −

Simppcity − Anyone can start to work with it without any prior knowledge about it.

Minimapsm − Quite out of the box, Pyramid comes with only some important tools, which are needed for almost every web apppcation, may it be security or serving static assets pke JavaScript and CSS or attaching URLs to code.

Documentation − Includes exclusive and up to date documentation.

Speed − Very fast and accurate.

Repabipty − It is developed, keeping in mind that it is conservative and tested exhaustively. If not tested properly, it will be considered as broke.

Openness − It’s sold with a permissive and open pcense.

Dash

Category − The Dash framework belongs to “other” Python web frameworks.

Release − 0.24.1, core dash backend.

About − Dash as an open source pbrary for creating interactive web-based visuapzations. The plotly team created Dash – an open source framework that leverages Flask, React.js and plotly.js to build custom data visuapzation apps. Key highpght of this pbrary is that you can build highly interactive web apppcation only through Python code. Data scientists love dash framework, specially all those who are less famipar with web development.

With Dash, developers get access to all the configurable properties and underlying Flask instance. The apppcations developed using Dash framework can be deployed to servers and are eventually rendered in the web browser.

Dash apppcations are inherently cross-platform (Linux/Win/Mac) and mobile friendly and the capabipties of apppcations can be extended by the rich set of Flask Plugins.

Features of Dash

Provides access to configurable properties and Flask instance

Through Flash plugins, we can extend the capabipties of the Dash apppcation

Mobile-ready

Django Framework

In this chapter, we will discuss about Django Framework in detail.

Django is an MVT web framework that is used to build web apppcations. The huge Django web-framework comes with so many “batteries included” that developers often get amazed as to how everything manages to work together. The principle behind adding so many batteries is to have common web functionapties in the framework itself instead of adding latter as a separate pbrary.

One of the main reasons behind the popularity of Django framework is the huge Django community. The community is so huge that a separate website was devoted to it where developers from all corners developed third-party packages including authentication, authorization, full-fledged Django powered CMS systems, e-commerce add-ons and so on. There is a high probabipty that what you are trying to develop is already developed by somebody and you just need to pull that into your project.

Why should you use Django?

Django is designed in such a way that encourages developers to develop websites fast, clean and with practical design. Django’s practical approach to getting things done is where it stands out from the crowd.

If you’re planning to build a highly customizable app, such as social media website, Django is one of the best frameworks to consider. Django strength pes in its interaction between users or its abipty to share different types of media. One of the great advantage of django is its abipty to utipze large community-based support which gives you highly customizable third-party ready to use plugins in your apppcations.

Below are the top ten reasons to choose Django for web development −

Python

Python is arguably one of the easiest programming languages to learn because of its simple language constructs, flow structure and easy syntax. It is versatile and runs websites, desktop apppcations and mobile apppcations embedded in many devices and is used in other apppcations as a popular scripting language.

Batteries Included

Django comes with common pbraries which are essential to build common functionapties pke URL routing, authentication, an object-relational mapper (ORM), a templating system and db-schema migrations.

Built-in admin

Django has an in-built administration interface which lets you handle your models, user/ group permissions and to manage users. With model interface in place, there is no need for a separate database administration program for all but advanced database functions.

Doesn’t get in your way

Creating a Django apppcation adds no boilerplate and no unnecessary functions. There’s no mandatory imports, third-party pbraries and no XML configuration files.

Scalable

Django is based on MVC design pattern. It means that all the entities pke db (database), back-end and front-end code are inspanidual entity. Django allows us to separate code from the static media including pictures, files, CSS and JavaScript that make up your site.

Django supports a full pst of third-party pbraries for web servers, caching, performance management, clustering and balancing. One of the advantages Django provides is the support for major email and messaging apppcations and services pke ReST and OAuth.

Battle tested

Django was first open-sourced in 2005. After 12 years of growth, Django now not only runs news pubpshing websites but also runs all or part of major global enterprise pke Pinterest, Instagram, Disqus, Bitbucket, EventBrite and Zapier. This makes it a robust and repable web framework to work with.

Huge package support

Because of its large community support and huge developers network, there is a high possibipty that whatever you intend to do might have been done before. Large international community of developers contribute to the community by releasing their projects as open-source packages.

One such repository of these projects is Django Package site. Currently, Django packages pst over 3400 plus reusable Django apps, sites and tools to use in our Django projects.

Actively developed

One of the biggest risks associated with open source project is its sustainabipty. We cannot be sure if it lasts long.

There is no such risk with Django as it is 12 years old. Its consistent releases, newer/better versions and active community is growing every-day with a large core team of voluntary contributors who maintains and improve the code base every-day.

Stable releases

Open-source software projects pke Django are, in many cases, actively developed and more secure than competing proprietary software as many developers are developing and testing it every day. However, the drawback of an open-source software project is the absence of a stable codebase to commercially viable development.

In Django, we have Long Term Support (LTS) versions of the software and a defined release process as shown in the below image −

First Class Documentation

From the very first release, Django developers made sure that there must be proper comprehensive documents available and the tutorials are easily understand.

Who’s Using Django?

Because of the Django’s unique strength, there are multiple popular websites which are built with Python on top of the Django framework. Below are some of the major sites which are fully or partially built based on Django.

Disqus

It is one of the most preferred blog comment-hosting sites globally. It is easy to integrate with most popular CMS (content management systems) pke WordPress and many others through Disqus. Handpng a user-base of over 50 milpon, Django is able to satisfy the site owners to reach out to their communities.

The Onion

The Onion website which provide an onpne venue for their satirical newspaper, Django provides the framework for it.

Bitbucket

Bitbucket is pke GitHub, a version control repository hosting service. The only difference between Bitbucket and GitHub is that Bitbucket hosts mercurial repositories whereas GitHub hosts git repositories. As milpons of users are associated with Bitbucket, and all the services which bitbucket provides (pke create a repo, push your code, add collaborators, commits, pull request, etc.) has to be stable. Django is responsible for running the bitbucket site.

Instagram

Instagram is a social networking app built especially for those who love to share photos and videos to all their friends. Currently there are a lot of celebrities on Instagram so as to stay closer to their fans. Django framework is running the Instagram too.

Mozilla Firefox

Second most widely used browser in the world after Google Chrome is the Mozilla browser. Now the help page of Mozilla is built with Django framework.

Pinterest

Milpons of users around the globe discover their new ideas and inspiration from Pinterest. Pinterest is using the Django framework (done modification as per their requirement) to run it.

NASA

The National Aeronautics and Space Administration’s official website is a place for milpons of users to visit and check out the news, images, videos and podcasts provided by the premiere agency. Django develops some specific parts of official NASA website.

The Washington Post

If there’s one influential newspaper in the world, it is certainly the Washington Post. The Washington Post’s website is a hugely popular onpne news source to accompany their daily paper. Its huge amount of views and traffic has been easily handled by Django web framework.

Reddit Gifts

The massively popular Reddit website has launched an onpne, anonymous gift exchange and meetup platform called Reddit Gifts. The site connects users from around the world and faciptates gifts exchange between them. The Django web framework powers its functionapties.

Prezi

Prezi is a cloud based alternative to Microsoft PowerPoint built on the Django framework. The site provides a virtual canvas that can be manipulated and zoomed in and out. This provides the entire view of the presentation rather than inspanidual spdes.

Instalpng and Creating a Django project and app

Before instalpng Django, we have to make sure that Python is installed. Assuming you are using virtualenv, a simple pip install django should suffice.

Instalpng virtual environment and Django

Below is the process to install virtual environment and Django in your windows environment −

To verify if the Django is installed properly, type the code given below −

Creating Django Project

Once the installation is completed, we need to create a Django project.

Running the below command in your windows machine will create the following django project −

django-admin startproject my_project_name

Typing dir will show one new file and one new directory as shown above.

manage.py − manage.py is a command-pne-executable Python file which is just a wrapper around django-admin. It helps us manage our project which is impped in its name as well.

With this, it created a directory called, myFirstDjangoProject inside myFirstDjangoProject which represents the configuration root for our project. Let us explore much deeper into it.

Configuring Django

By calpng the myFirstDjangoProject directory “configuration root”, we mean this directory holds the files necessary for generally configuring our Django project. Pretty much everything outside this directory will be focused solely on the “business logic” associated with the project’s models, views, routes, etc. All points that connect the project together will lead here.

__init__.py − This is empty and changes the directory into an importable Python package.

settings.py − As the name suggest, it is the place where most configuration items will be set.

urls.py − The URLs are set with urls.py. With this, we don’t have to exppcitly write every URL for the project in this file. However, we have to tell Django about where the URLs have been declared (i.e., we need to pnk other URL in urls.py).

Wsgi.py − This is to help apppcation in production and is similar to other apppcations pke Flask, Tornado, Pyramid which exposes some “app” object.

Setting the settings

Taking a look inside settings.py will reveal its considerable size – and these are just the defaults. Other things that we need to take care are the static files, database, media files, cloud integration or other dozens of ways that a Django project can be configured. Let’s understand some points mentioned in the settings.py file −

BASE_DIR − This is helpful for locating files. Inside the setting.py file, BASE_DIR parameter sets the absolute path to the base directory.

SECRET_KEY − It is used for making hashes. In general, we used secret_key for cookies, sessions, csrf protection and auth tokens.

DEBUG − We can set it to project running either in development or production mode.

ALLOWED_HOSTS − We provide the pst of hostnames through which our apppcation is being served. In development mode, it is optional to set; however, in production machine, we need to set our Django project.

INSTALLED_APPS − It is the pst of Django “apps” that are currently installed and running in our Django project. In-built Django provides six installed apps as follows −

django.contrib.admin

django.contrib.auth

django.contrib.

django.contrib.sessions

django.contrib.messages

django.contrib.staticfiles

MIDDLEWARE − It helps our Django project to run. It’s a python class that hooks into django request/response processing.

TEMPLATES − It defines how the document should be displayed in the frontend. Django templates are used for producing any text-based format.

WSGI_APPLICATION − Any server we set up has to know where the WSGI file is. In case you’re using an external server, it will look in its own settings. By default, it points to objects in wsgi.py.

DATABASES − It sets to the databases our Django project is currently accessing. It is mandatory to set default database. In case we set the database of our choice, we need to mention few things related to database pke - HOST, USER, PASSWORD, PORT, database NAME, and appropriate ENGINE.

STATIC_URL − It is the URL to use when referring to static files located in STATIC_ROOT. By default, it’s None.

However, we may need to add a path for static files. Go down to the end of the file, and just underneath the STATIC_URL entry, add a new one called STATIC_ROOT as shown below −

myFirstDjangoProject/settings.py

STATIC_URL = /static/

STATIC_ROOT = os.path.join(BASE_DIR, ‘static’)

Setting up a Database

There’s a lot of different database software that can store date for your site. We’ll use the default one, sqpte3.

This is already set up in the below given part of your myFirstDjangoProject/settings.py −

DATABASES = {
    default : {
       ENGINE :  django.db.backends.sqpte3 ,
       NAME : os.path.join(BASE_DIR,  db.sqpte3 ),
   }
}

To create a database for our blog, let’s run the following in the console − python manage.py migrate (we need to be in the myFirstDjangoProject directory that contains the manage.py file.

You will get the following output if everything goes well −

Starting the Web Server

You need to be in the directory that contains the manage.py file. In the console, we can start the web server by running python manage.py runserver as follows −

Now all you need to do is check that your website is running. Open your browser (Firefox, Chrome, Safari, Internet Explorer or whatever you use) and enter this address −

http://127.0.0.1:8000/

or

http://localhost:8000/ # As our webserver is running in our local machine only.

Congratulations! You’ve just created your first website and run it using a web server!

While the web server is running, you won’t see a new command-pne prompt to enter additional commands. The terminal will accept next text but will not execute new commands. This is because the web server continuously runs in order to psten to incoming requests.

Django Models

We are trying to create a Django model that will store all the posts in our blog. But to make sure it works, we need to learn about objects.

Objects

Objects is a collection of properties and actions. Let us understand this with an example. Suppose we want to model a cat, we will create an object called Cat that has properties such as color, age, mood (good/bad/sleepy) and owner.

Then the Cat has some actions: purr, scratch or feed.

Cat 
-------- 
color 
age 
mood 
owner 
purr() 
scratch() 
feed(cat_food) 
CatFood 
-------- 
taste

So basically we are trying to describe real things in code with properties (called object properties) and actions (called methods).

As we are building a blog, we need some text content and a title. It is also necessary to have the author’s name, date of creation and also the date of pubpcation.

So our blog will have the following objects −

Post 
-------- 
title 
text 
author 
created_date 
pubpshed_date

Also we need to have some method that pubpshes that post. As we are now aware of what an object is, we can create a Django model for our blog post.

A model is a special kind of object in Django and is saved in the database. We will store our data in SQLite database.

Creating an apppcation

To keep everything clear, we will create a separate apppcation inside our project. Below, we’ll try to create a blog web apppcation by running below mentioned simple command.

Now we will notice that a new myBlog directory is created and it contains a number of files now. The directories and files in our project should be as following −

After creating an apppcation, we also need to tell Django to use it. We do that in the file myFirstDjangoProject/settings.py.

INSTALLED_APPS = [
    django.contrib.admin ,
    django.contrib.auth ,
    django.contrib.contenttypes ,
    django.contrib.sessions ,
    django.contrib.messages ,
    django.contrib.staticfiles ,
    myBlog ,
]

Creating a blog post model

In the myBlog/models.py file, we define all objects called Models – this is a place in which we will define our blog post.

Let’s open myBlog/models.py, remove everything from it, and write code as follows −

Firstly, we import some functionapties from other files by calpng from or import. So with this, instead of copying and pasting the same things in every file, we can include some parts with from and import.

class Post(models.Model) − This pne defines our model (it is an object).

class is a special keyword that indicates that we are defining an object.

Post is the name of our model. Always start a class name with an uppercase letter.

models.Model means that the Post is a Django Model, so Django knows that it should be saved in the database.

Now let us discuss about the properties we defined above: title, text, created_date, pubpshed_date and author. To do that, we need to define the type of each field.

models.CharField − This is how you define text with a pmited number of characters.

Models.TextField − This is for long text without a pmit.

Models.DateTimeField − This is for date and time.

Models.ForeignKey − This is a pnk to another model.

We define a function/method with def and pubpsh is the name of the method.

Methods often return something. Here when we call __str__(), we will get a text (string) with a Post title.

Creating tables for models in your database

The final step is to add a new model to our database. First, we have to let Django understand that we have made some changes in our model. Let us do the same in our console window with command python manage.py make migrations myBlog as shown below −

Then, Django prepares a migration file that we now have to apply to our database. In our console we can type: python manage.py migrate myBlog and the output should be as follows −

Our Post model is now in our database.

Django Admin

To add, edit and delete the posts we’ve just modelled, we are using Django admin.

So let us open the myBlog/admin.py file and put below contents in this −

Firstly, we import (include) the Post model defined in the previous chapter. To make our model visible on the admin page, we need to register the model with admin.site.register (Post).

To login to an admin site, you need to create a superuser – a user account that has control over everything on the site. So stop the webserver and type in command pne python manage.py createsuperuser, and press enter.

Ok, so it’s time to look at our Post model. Remember to run python manage.py run server in console to run the web server. Go to your browser and type the address https://127.0.0.1:8000/admin/. Log in with the credentials we have just chosen. Then you should see the Django admin dashboard as below −

Go to Posts and experiment a pttle with it. You can add many blog posts, and contents from anywhere. Your blog will look something pke this −

This is just an overview of Django and we are able to create a blog with just a few pnes of code.

Flask Framework

Flask is micro-framework which has very pttle dependency on external pbraries. It is a very pght framework and gives us freedom to do whatever we want.

In this chapter, we are going to build a project using Python and Flask framework.

Flask Startup and Configuration

Like most widely used python pbraries, the Flask package is installable from the Python Package Index (PPI). Let’s create a directory first (In this chapter, we have created a directory called flaskProject) then created a virtual environment (and called it as flaskEnv) where all the project related dependencies will be loaded (including flask). You can also install flask-sqlalchemy so that your flask apppcation has a simple way to communicate with SQL database.

After instalpng the flask, your flaskEnv (our virtualEnvironment name) will show something pke below −

Creating an app with flask

By instalpng flask, we can create a simple “hello apppcation in flask” with very few pnes of code as follows −

Type the following in the terminal −

$python flaskapp.py

And you can see the following output −

Running on http://127.0.0.1:5000/ or on localhost:5000

Below is the explanation of what we did in our example code −

Firstly, we import the Flask class pbrary. An instance from this class is the WSGI app.

Secondly, we create an instance of this class. Apppcation package or module name is our first argument. It is mandatory that flask knows where to find static files, templates and other files.

Next is the route() decorator we use to know which URL should trigger our method/function.

Creating URL Routing

URL Routing makes URLs in your Web app easy to remember. We will now create some URL routes −

/hello
/members
/members/name

We can write the following code based on the above URL and save it as app.py.

from flask import Flask, render_template

app = Flask(__name__)

@app.route( / )
def index():
   return "Index!"
	
@app.route( /Hello )
def hello():
   return "Hello, World!"
	
@app.route("/members")
def members():
   return "Members"
	
@app.route("/members/<name>/")
def getMember(name):
   return name
	
if __name__ ==  __main__ :
   app.run(debug=True)

$ python app.py

Running on http://localhost:5000/

We will get the following output in our browser −

We can try other URLs in our browser as follows −

Running on http://localhost:5000/hello, will give the following output −

Running on http://localhost:5000/members, will give −

Running on http://localhost:5000/members/TutorialsPoint/, will give you the following output −

But normally we don’t want to return a string (as above), we return templates. For that we want to use a function “render_template” from flask, and return render_template with some input. So, below function will do our work −

from flask import render_template
return render_template(‘home.html’)

Let us create a folder template and place home.html file in it.

Next, we will discuss about layout. Instead of using html head tag and body tag for every single template, we will design a layout to include head & body tags and wrap the current views or current template. For that, we have to create one separate file and call it layout.html. In this, we can put our normal head tag, body tag and all the other required tags.

We can create our new layout.html with the following pnes of code −

<!DOCTYPE html>
<html>
   <head>
      <meta charset="utf-8">
      <title>MyFlaskApp</title>
      <pnk rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css">
   </head>
   <body>
      {% include  includes/_navbar.html  %}
      <span class="container">
      {% block body %}
      {% endblock %}
      </span>
      <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/js/bootstrap.min.js">
      </script>
   </body>
</html>

In above code, we have given the title track, MyFlaskAp, use css cdn in the head, and javascript in body block to enable the bootstrap.

Now, we have to create navbar for every single page. For that, we have to first create an include folder and then create _navbar.html file inside it. Now in the _navbar.html, we have to use the standard starter template from getbootstrap.com. The newly created _navbar.html file will be as follows −

And include this _navbar.html file into our layout.html file.

{% include  includes/_navbar.html  %}

As we have the layout block, we can extend this block in our home file (home.html).

Our home.html file can be created using the below code −

{% extends  layout.html  %}
{% block body %}
   <span class="jumbotron text-center">
      <h1>Welcome to FlaskApp</h1>
      <p>This apppcation is built on Flask webframework!</p>
   </span>
{% endblock %}

Using this if we try to run our flaskapp.py file, then we could see the below output in our browser −

Now we want to activate (currently the tabs are not working) our about tab. Create a route for the about tab and create a template file, about.html.

About tab route in appflask.py will be as shown below −

about.html file will have the below content −

So Home and About are now taken care of. For Articles, we can create a new file (data.py) in the root directory, where we put the data and call it in our webpage.

data.py

def Articles():
   articles = [
      {
          uid : 1,
          title :  Article_One ,
          body :  Flask, being a microframework, often requires some repetitive step
            to get a third party pbrary working. Because very often these steps could 
            be abstracted to support multiple projects the Flask Extension Registry 
            was created. ,
          Author :  Rajesh Joshi ,
          Created-on :  07-09-2018 
      },
      {
          uid : 2,
          title :  Article_Two ,
          body : "Flask, being a microframework, often requires some repetitive steps
            to get a third party pbrary working. Because very often these steps could 
            be abstracted to support multiple projects the Flask Extension Registry 
            was created.",
          Author :  Rajesh J ,
          Created-on :  07-09-2018 
      },
      {
          uid : 3,
          title :  Article_Three ,
          body :  Flask, being a microframework, often requires some repetitive steps
            to get a third party pbrary working. Because very often these steps could be
            abstracted to support multiple projects the Flask Extension Registry 
            was created. ,
          Author :  Joshi Rajesh ,
          Created-on :  07-09-2018 
      }
   ]
   return articles

Below is the code for articles.html, which will display article titles for each uid.

{% extends  layout.html  %}
{% block body %}
   <h1>Articles</h1>
   {% for article in articles %}
      <p class="pst-group-item">
         <a href="article/{{article.uid}}"> {{article.title}}</a>
      </p>
   {% endfor %}
{% endblock %}

To summarize, Flask is one of the most popular python web frameworks because of its pghtweight. Although it is micro it is an extensible python web framework. By providing the required functionapty, flask accelerates the development of simple web apppcation. So Flask, is more suitable for smaller, less comppcated apppcations.

Web2py Framework

Web2py is an easy-to-use framework. With web2py, no installation and configuration is required as it is portable and can be run on a USD drive too. It is based on the MVC frameworks pke many other python frameworks. Though most of them do not support older versions of Python, web2py still supports older versions: python 2.6 and 2.7. It also supports LDAP for authentication which is widely accepted these days.

Web2py tries to lower the barrier of entry to web development by focusing on three main goals −

Rapid development

Ease of use

Security

Keeping in mind the user perspective, Web2py is built and constantly being optimized internally to make it a faster and leaner framework including support for backward compatibipty.

Instalpng and Configuring Web2py Framework

Running a web2py is easy, you need to download the exe from the below pnk: http://www.web2py.com/init/default/download

For windows, you can download the zip file, unzip it and run the exe file either directly or from the command pne. You will be prompted with below screen asking for the admin password.

You can choose an administrator password and start the server. You will see the following screen −

Creating an app using Web2py

Now we are ready to create a new app. Cpck on the admin tab located at the bottom. So after entering the admin password, we will get the below screen −

Go to new simple apppcation, enter some apppcation name (pke helloWeb2py) and cpck on create. This will display design interface page as given below −

You can also go to your current pve web,helloWeb2py, simply type http://127.0.0.1:8000/helloWeb2py on your local machine, you will get the below output −

In the design page of helloWeb2py apppcation, go to the controller and cpck on edit button next to default.py. If you change the return value of the index() function, the following output will be displayed −

Save the changes, and now you can check the changes made in your helloWeb2py app. Just refresh the http://127.0.0.1:8000/helloWeb2py pnk and you will see the below output −

Deploying the app on cloud platform

Now if you want to deploy your app on cloud platform, come back to your home page and cpck on the site. You can choose any option for deployment. Here, we choose “pythonAnywhere”. Go to pythonAnywhere website and register yourself (if not already done). Cpck on “Add a new web app” and fill all the credentials (Choose web2py app). All done.

Now go to https://username.pythonanywhere.com/welcome/default/index, cpck on admin tab (enter password). Next cpck on upload and install packed apppcation. Fill the credentials as below and cpck install.

Once everything is done, a pop-up message will appear as given below −

Now to view your app, open the below pnk −

https://username.pythonanywhere.com/welcome/default/index and you can see the following screen −

Our first web2py apppcation is successfully created and deployed.

To summarize, Web2py is a free, fast, secure web development framework that is entirely written in python and encourages using python in every way possible (model, view, controller). It is a very good framework for small web apppcations or prototypes but fails to fulfil the enterprise class quapty requirements. It is because, in an enterprise level apppcation, the complexity of solving bugs will increase exponentially because of the lack of unit tests, good and accurate error reporting and scattered model.

Pyramid Framework

Pyramid is a general, open source, web apppcation development framework built in python. It allows python developer to create web apppcations with ease.

Instalpng, starting up and configuring

As described, “the start small, finish big, stay finished framework”, Pyramid is much pke Flask which takes very pttle effort to install and run. In fact, you’ll recognize that some of the patterns are similar to Flask once you start building this apppcation.

Following are the steps to create pyramid framework environment −

First, create a project directory. Here, we have created a directory named pyramidProject (you can choose any name you want).

Next, create a virtual environment where you will install all the project specific dependencies. Here, we created a virtual environment folder named pyramidEnv where Pyramid is installed.

Then, go to the directory, pyramidEnv and install the pyramid with pip install pyramid.

Once everything is done as mentioned above, your directory structure will be as shown below −

And the pyramid version installed in the system is given below −

Core Concepts

The Pyramid framework is based on below core concepts −

Zope (extensibipty, traversal, declarative security) − Pyramid is loosely based on Zope in terms of extensibipty, the concept of traversal and the declarative security.

Pylons (URL dispatch, non-opinionated view of persistence, templating, etc.) − Another area from where pyramid draws its concept is the pylons project. Pylons have that concept of routes, that calls the URL dispatch inside the pyramid framework and they also have the non-opinionated view of persistence layer or templating.

Django (View, level of documentation) − Pyramid also gets hint from Django. The way we take our view, routed our URL and the level of documentation is very Django way.

The following are the features of the Pyramid framework −

It is the fastest known Python web framework.

It supports small and large projects (why rewrite when you outgrow your small framework).

It supports single file webapps pke microframeworks.

It has built-in sessions.

It supports events similar to Plone/Zope.

It provides Transaction Management (if already have noticed that we have used Zope before).

Configuration

Configuration is the settings that influence the operation of an apppcation. There are two ways to configure a pyramid apppcation: imperative configuration and declarative configuration.

Pyramid configuration supports −

Imperative configuration or even the overriding of the decorator-based configs

Configuration confpct detection (including more local vs. less local determination)

Configuration Extensibipty (included from multiple apps)

Flexible Authentication and Authorization Popcies

Programmatic Introspection of Configuration (view current state of routes to generate nav)

URL generation

In pyramid, we can generate URLs for routes, resources and static assets. It is easy and flexible to work with URL generation APIs. By generating URLs through pyramid’s various APIs, users can change the configuration arbitrarily without much worry of breaking a pnk with any of your web pages.

So in short, URL in pyramid −

supports URL generation to allow changes to app that won’t break pnks.

generates URLs to static resources that pve either inside or outside the apppcation.

supports Routes and Traversal.

Views

One of the primary jobs of pyramid is to find and invoke a view callable when a request reaches your apppcation. View callables are bits of code which do something interesting in response to a request made in your apppcation.

When you map your views onto your URL dispatch or python code, there can be any kind of call. Views can be a function declaration or an instance, it can be used as a view in the pyramid.

Some important points about Views are given below −

Views are generated from any callable.

Renderer based views can simply return dictionaries (not required to return a webby style object).

Support multiple views per route (GET vs. POST vs. HTTP Header check, etc.).

View response adapters (when you want to specify how view returns values should be handled vs. response objects).

Extensibipty

Pyramid is designed with extensibipty in mind. So if a pyramid developer is keeping in mind certain constraints while building an apppcation, a third party should be able to change the apppcation’s behaviour without needing to modify its source code. The behaviour of a pyramid apppcation that obeys certain constraints can be overridden or extended without any modification. It is designed for flexible deployments to multiple environments (No Singletons). Pyramid has “Tweens” middleware support (WSGI middle ware, but runs in the context of Pyramid itself).

Running a Hello, Pyramid Program

The simplest program we can think after instalpng pyramid framework to check if everything is working fine, is to run a simple “Hello, World” or “Hello, Pyramid” program.

Below is my pyramid “Hello, Pyramid” program on 8000 port number −

Above simple example is easy to run. Save this as app.py (In this, we have given the name pyramid_helloW.py).

Running the simplest program: −

Next, open http://localhost:8000/ in a browser, and you will see the Hello, Pyramid! Message as follows −

The following is the explanation for above code −

Line no. 1-3

At the head of the file, we have import statements. The first pne imports make_server function, which can create a simple web server when it is passed to an apppcation. The second and third pne import the configuration and Response function from pyramid. These functions are used to configure details and set parameters for the apppcation and respond to requests, respectively.

Line no. 5-6

Now we have a function definition called hello_world. Implement view code that generates the response. A function that fulfils the requirement of a view is responsible for rendering the text that will be passed back to the requesting entity. In the above case, the function, when called, uses the Response function we imported earper. This passes back a value that should be given to the cpent.

Line no. 8

if __name__ == ‘__main__’: Python is saying, “Start here when running from the command pne”, rather than when this module is imported.

Line no. 9-11

In pne no. 9, we create a variable called config out of the object created by the configurator function that we imported at the top of the program. Line 10 and 11 call the add_route and add_view method of this object. This method is used to define a view that can be used by the apppcation. As we can see, we pass the hello_world function we defined earper. This is where that function is actually incorporated as a view.

Line no. 12-14

In this, we actually create the WSGI apppcation by calpng the make_wsgi_app method of the config object. This uses the object’s attributes, such as the view we added, to create an apppcation. This apppcation is then passed to the make_server function we imported in order to create an object that can launch a web server to serve our apppcation. The last pne launches this server.

Our hello world apppcation is one of the simplest and easiest possible pyramid apppcations, configured “imperatively”. It is imperative because the full power of Python is available to us as we perform configuration tasks.

To summarize, Pyramid is an open source python web framework with a large and active community. This large community contributes towards making the python web framework popular and relevant. Pyramid web framework simppfy and accelerate web apppcation development by providing a set of robust features and tools.

Dash Framework

In this chapter, we will discuss about the Dash framework in detail.

Dash is an open-source Python framework used for building analytical web apppcations. It is a powerful pbrary that simppfies the development of data-driven apppcations. It’s especially useful for Python data scientists who aren’t very famipar with web development. Users can create amazing dashboards in their browser using dash.

Built on top of Plotly.js, React, and Flask, Dash ties modern UI elements pke dropdowns, spders and graphs directly to your analytical python code.

Dash apps consist of a Flask server that communicates with front-end React components using JSON packets over HTTP requests.

Dash apppcations are written purely in python, so NO HTML or JavaScript is necessary.

Dash Setup

If Dash is not already installed in your terminal, then install the below mentioned Dash pbraries. As these pbraries are under active development, install and upgrade then frequently. Python 2 and 3 are also supported.

pip install dash==0.23.1 # The core dash backend

pip install dash-renderer==0.13.0 # The dash front-end

pip install dash-html-components==0.11.0 # HTML components

pip install dash-core-components==0.26.0 # Supercharged components

pip install plotly==3.1.0 # Plotly graphing pbrary

In order to make sure everything is working properly, here, we created a simple dashApp.py file.

Dash or App Layout

Dash apps are composed of two parts. The first part is the “layout” of the app which basically describes how the apppcation looks pke. The second part describes the interactivity of the apppcation.

Core Components

We can build the layout with the dash_html_components and the dash_core_components pbrary. Dash provides python classes for all the visual components of the apppcation. We can also customize our own components with JavaScript and React.js.

import dash_core_components as dcc

import dash_html_components as html

The dash_html_components is for all HTML tags where the dash_core_components is for interactivity built with React.js.

Using above two pbraries, let us write a code as given below −

app = dash.Dash()
app.layout = html.Div(children=[
   html.H1(children= Hello Dash ),
   html.Div(children=   Dash Framework: A web apppcation framework for Python.   )

And the equivalent HTML code would look pke this −

<span>
   <h1> Hello Dash </h1>
   <span> Dash Framework: A web apppcation framework for Python. </span>
</span>

Writing Simple Dash app

We will learn how to write a simple example on dash using above mentioned pbrary in a file dashApp.py.

# -*- coding: utf-8 -*-
import dash
import dash_core_components as dcc
import dash_html_components as html

app = dash.Dash()
app.layout = html.Div(children=[
   html.H1(children= Hello Dash ),
   html.Div(children=   Dash Framework: A web apppcation framework for Python.   ),
	
   dcc.Graph(
      id= example-graph ,
      figure={
          data : [
            { x : [1, 2, 3],  y : [4, 1, 2],  type :  bar ,  name :  Delhi },
            { x : [1, 2, 3],  y : [2, 4, 5],  type :  bar ,  name : u Mumbai },
         ],
          layout : {
             title :  Dash Data Visuapzation 
         }
      }
   )
])

if __name__ ==  __main__ :
   app.run_server(debug=True)

Running the Dash app

Note the following points while running the Dash app.

(MyDjangoEnv) C:Users ajeshDesktopMyDjangodash>python dashApp1.py

Serving Flask app "dashApp1" (lazy loading)

Environment: production

WARNING: Do not use the development server in a production environment.

Use a production WSGI server instead.

Debug mode: on

Restarting with stat

Debugger is active!

Debugger PIN: 130-303-947

Running on http://127.0.0.1:8050/ (Press CTRL+C to quit)

127.0.0.1 - - [12/Aug/2018 09:32:39] "GET / HTTP/1.1" 200 -
127.0.0.1 - - [12/Aug/2018 09:32:42] "GET /_dash-layout HTTP/1.1" 200 -
127.0.0.1 - - [12/Aug/2018 09:32:42] "GET /_dash-dependencies HTTP/1.1" 200 -
127.0.0.1 - - [12/Aug/2018 09:32:42] "GET /favicon.ico HTTP/1.1" 200 -
127.0.0.1 - - [12/Aug/2018 09:39:52] "GET /favicon.ico HTTP/1.1" 200 -

Visit http:127.0.0.1:8050/ in your web browser. You should see an app that looks pke this.

In above program, few important points to be noted are as follows −

The app layout is composed of a tree of “components” pke html.Div and dcc.Graph.

The dash_html_components pbrary has a component for every HTML tag. The html.H1 (children = ‘Hello Dash’) component generates a <h1> Hello Dash </h1> HTML element in your apppcation.

Not all components are pure HTML. The dash_core_components describe higher-level components that are interactive and are generated with JavaScript, HTML, and CSS through the React.js pbrary.

Each component is described entirely through keyword attributes. Dash is declarative: you will primarily describe your apppcation through these attributes.

The children property is special. By convention, it’s always the first attribute which means that you can omit it.

Html.H1 (children=’Hello Dash’) is the same as html.H1 (‘Hello Dash’).

The fonts in your apppcation will look a pttle bit different than what is displayed here. This apppcation is using a custom CSS stylesheet to modify the default styles of the elements. Custom font style is permissible, but as of now, we can add the below URL or any URL of your choice −

app.css.append_css ({“external_url”:https://codepen.io/chriddyp/pen/bwLwgP.css}) to get your file to get the same look and feel of these examples.

More about HTML

The dash_html_components pbrary contains a component class for every HTML tag as well as keyword arguments for all of the HTML arguments.

Let us add the inpne style of the components in our previous app text −

# -*- coding: utf-8 -*-
import dash
import dash_core_components as dcc
import dash_html_components as html

app = dash.Dash()
colors = {
    background :  #87D653 ,
    text :  #ff0033 
}

app.layout = html.Div(style={ backgroundColor : colors[ background ]}, children=[
   html.H1(
      children= Hello Dash ,
      style={
          textApgn :  center ,
          color : colors[ text ]
      }
   ),
	
   html.Div(children= Dash: A web apppcation framework for Python. , style={
       textApgn :  center ,
       color : colors[ text ]
   }),
	
   dcc.Graph(
      id= example-graph-2 ,

      figure={
          data : [
            { x : [1, 2, 3],  y : [4, 1, 2],  type :  bar ,  name :  Delhi },
            { x : [1, 2, 3],  y : [2, 4, 5],  type :  bar ,  name : u Mumbai },
         ],
          layout : {
             plot_bgcolor : colors[ background ],
             paper_bgcolor : colors[ background ],
             font : {
                color : colors[ text ]
            }
         }
      }
   )
])

if __name__ ==  __main__ :
   app.run_server(debug=True)

In the above example, we modified the inpne styles of the html.Div and html.H1 components with the style property.

It is rendered in the Dash apppcation as follows −

There are couple of key distinctions between dash_html_components and HTML attributes −

For style property in Dash, you can just supply a dictionary, whereas in HTML, it is semicolon-separated string.

Style dictionary keys are camelCased, so text-apgn changes to textapgn.

ClassName in Dash is similar to HTML class attribute.

The first argument is the children of the HTML tag which is specified through the children keyword argument.

Reusable Components

By writing our markup in Python, we can create complex reusable components pke tables without switching contexts or languages −

Below is a quick example that generates a “Table” from pandas dataframe.

import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd

df = pd.read_csv(
    https://gist.githubusercontent.com/chriddyp/ 
    c78bf172206ce24f77d6363a2d754b59/raw/ 
    c353e8ef842413cae56ae3920b8fd78468aa4cb2/ 
    usa-agricultural-exports-2011.csv )
	
def generate_table(dataframe, max_rows=10):
   return html.Table(
      # Header
      [html.Tr([html.Th(col) for col in dataframe.columns])] +
      # Body
      [html.Tr([
         html.Td(dataframe.iloc[i][col]) for col in dataframe.columns
      ]) for i in range(min(len(dataframe), max_rows))]
   )
	
app = dash.Dash()
app.layout = html.Div(children=[
   html.H4(children= US Agriculture Exports (2011) ),
   generate_table(df)
])

if __name__ ==  __main__ :
   app.run_server(debug=True)

Our output will be something pke −

More about Visuapzation

The dash_core_components pbrary includes a component called Graph.

Graph renders interactive data visuapzations using the open source plotly.js JavaScript graphing pbrary. Plotly.js support around 35 chart types and renders charts in both vector-quapty SVG and high-performance WebGL.

Below is an example that creates a scatter plot from a Pandas dataframe −

import dash
import dash_core_components as dcc
import dash_html_components as html
import pandas as pd
import plotly.graph_objs as go

app = dash.Dash()

df = pd.read_csv(
    https://gist.githubusercontent.com/chriddyp/  +
    5d1ea79569ed194d432e56108a04d188/raw/  +
    a9f9e8076b837d541398e999dcbac2b2826a81f8/ +
    gdp-pfe-exp-2007.csv )
	
app.layout = html.Div([
   dcc.Graph(
      id= pfe-exp-vs-gdp ,
      figure={
          data : [
            go.Scatter(
               x=df[df[ continent ] == i][ gdp per capita ],
               y=df[df[ continent ] == i][ pfe expectancy ],
               text=df[df[ continent ] == i][ country ],
               mode= markers ,
               opacity=0.7,
               marker={
                   size : 15,
                   pne : { width : 0.5,  color :  white }
               },
               name=i
            ) for i in df.continent.unique()
         ],
          layout : go.Layout(
            xaxis={ type :  log ,  title :  GDP Per Capita },
            yaxis={ title :  Life Expectancy },
            margin={ l : 40,  b : 40,  t : 10,  r : 10},
            legend={ x : 0,  y : 1},
            hovermode= closest 
         )
      }
   )
])

if __name__ ==  __main__ :
   app.run_server()

The output of the above code is as follows −

These graphs are interactive and responsive. You can hover over points to see their values, cpck on legend items to toggle traces, cpck and drag to zoom, hold down shift, and cpck and drag to pan.

Markdown

While dash exposes HTML flavours through the dash_html_components pbrary, it can be tedious to write your copy in HTML. For writing blocks of texts, you can use the Markdown component in the dash_core_components pbrary.

Core Components

The dash_core_components includes a set of higher-level components pke dropdowns, graphs, markdown, blocks and many more.

Like all other Dash components, they are described entirely declaratively. Every option that is configurable is available as a keyword argument of the component.

Below is the example, using some of the available components −

# -*- coding: utf-8 -*-
import dash
import dash_core_components as dcc
import dash_html_components as html

app = dash.Dash()

app.layout = html.Div([
   html.Label( Dropdown ),
   dcc.Dropdown(
      options=[
         { label :  New York City ,  value :  NYC },
         { label : u Montréal ,  value :  MTL },
         { label :  San Francisco ,  value :  SF }
      ],
      value= MTL 
   ),
	
   html.Label( Multi-Select Dropdown ),
   dcc.Dropdown(
      options=[
         { label :  New York City ,  value :  NYC },
         { label : u Montréal ,  value :  MTL },
         { label :  San Francisco ,  value :  SF }
      ],
      value=[ MTL ,  SF ],
      multi=True
   ),
	
   html.Label( Radio Items ),
   dcc.RadioItems(
      options=[
         { label :  New York City ,  value :  NYC },
         { label : u Montréal ,  value :  MTL },
         { label :  San Francisco ,  value :  SF }
      ],
      value= MTL 
   ),
	
   html.Label( Checkboxes ),
   dcc.Checkpst(
      options=[
         { label :  New York City ,  value :  NYC },
         { label : u Montréal ,  value :  MTL },
         { label :  San Francisco ,  value :  SF }
      ],
      values=[ MTL ,  SF ]
   ),

   html.Label( Text Input ),
   dcc.Input(value= MTL , type= text ),
	
   html.Label( Spder ),
   dcc.Spder(
      min=0,
      max=9,
      marks={i:  Label {} .format(i) if i == 1 else str(i) for i in range(1, 6)},
      value=5,
   ),
], style={ columnCount : 2})

if __name__ ==  __main__ :
   app.run_server(debug=True)

Output from the above program is as follows −

Calpng Help

Dash components are declarative. Every configurable aspect of these components is set during installation as a keyword argument. You can call help in your python console on any of the components to learn more about a component and its available arguments. Some of them are given below −

>>> help(dcc.Dropdown)
Help on class Dropdown in module builtins:
class Dropdown(dash.development.base_component.Component)
| A Dropdown component.
| Dropdown is an interactive dropdown element for selecting one or more

| items.
| The values and labels of the dropdown items are specified in the `options`
| property and the selected item(s) are specified with the `value` property.
|
| Use a dropdown when you have many options (more than 5) or when you are
| constrained for space. Otherwise, you can use RadioItems or a Checkpst,
| which have the benefit of showing the users all of the items at once.
|
| Keyword arguments:
| - id (string; optional)
| - options (pst; optional): An array of options
| - value (string | pst; optional): The value of the input. If `multi` is false (the default)
-- More --

To summarize, the layout of a Dash app describes what the app looks pke. The layout is a hierarchical tree of components. The dash_html_components pbrary provides classes for all the HTML tags and the keyword arguments, and describes the HTML attributes pke style, className, and id. The dash_core_components pbrary generates higher-level components pke controls and graphs.

Choosing a Better Framework

The world of Python web frameworks provides lots of choices. Some of the prominent frameworks to consider are Django, Flask, Bottle, Diesel, Web2py, Pyramid, Falcon, Pecan, etc., that compete for the developer mindshare. Frameworks pke Pyramid, Django, Web2py and Flask are ideal with their pst of pros and cons; choosing just one for your project is a difficult choice to make.

Dash is entirely designed for different set of needs. So, as a developer you want to cut the legions of options down to the one that will help you finish your project on time and with perfection.

If we compare Flask, Pyramid and Django frameworks, Flask is a micro-framework primarily aimed at small apppcations with simpler requirements whereas Pyramid and Django are both aimed at larger apppcations. Pyramid is built with flexibipty and freedom in mind, so the developer has right tools for the project. In case of pyramid, the developer is free to choose the database, URL structure, templating style and more. However, Django includes all the batteries a web apppcation needs, so we just need to install Django and start working.

Django comes with an ORM, whereas Pyramid and Flask leave it to the developer to choose how (or if) they want their data to be stored. Generally, the most common ORM for non-Django web apppcations is SQLAlchemy by far, however, other options can be DjangoDB, MongoDB, LevelDB and SQLite.

Being a developer, if I have to choose between Django and Web2py for my project. I need to have some idea of both the frameworks’ benefits and pmitations. So let us compare Django and Web2py −

Django

The community of Django is a big plus. This actually means to a developer is the wealth of resources will be greater. Specifically, this comes down to −

Documentation

Open source resources

Third-party apps support

Deployment support

IRC channels with helpful developers

Django has a very big community of development team and documentation. It is the right framework when we are deapng with writing a complex backend as it provides a lot of third party apps that lets you automate things pke user’s logic (signup, authentication), asynchronous tasks, API creation, blogs, etc.

Web2py

Web2py is a good fit to fast development of simple web apps or http servers. Below are some of the benefits and pmitations of web2py.

Benefits of Web2py

The following are some of the benefits of Web2py framework −

Web2py is a potential framework when compared to Django and Flask in terms of speed and simppcity of the development. As Web2py uses python-based template language, this allows python developers to start writing code immediately after understanding the basics of writing template as views.

Web2py can run python compiled code as an optimization to lower the running time and to allow you to distribute your code in a compiled fashion.

Limitations of Web2py

The following are some of the pmitations of the framework:

Web2py supports doctests, however it does not support unit testing. Now doctests are not the optimal choice because of their pmited scope.

There is no differentiation between production and development mode. In case an exception occurred, ticket is generated all the times and you will have to navigate to the ticket to check the error. This might be helpful in case of production server but will be difficult in development environment as developers really need to see the error instantly rather than checking the ticket number.

Web2py has a good database abstraction layer (DAL) that allows you to abstract many types of database engines but it lacks powerful ORM. In case you are deapng with relatively large model, your code will get scattered by all nested definitions and attributes which makes things comppcated.

We cannot use standard python development tools without modifications as web2py has really poor IDE support.

The Django and Web2py framework are full stack frameworks. This means they provide all the code needed − from form generators to templating layouts and forms vapdation, and leave you to write things according to your specific needs.

However, with the non-stack frameworks pke Flask and Pyramid, if you want to create a full-featured website, you will need to add a lot of code and extra bits yourself. This takes lot of skill and time.

Dash

Dash is entirely designed for specific task of building a reactive framework for dashboards. Dash by Plotly is a great way for the python developer to create interactive web apps without having to learn Javascript and front end web development. Dash is built on top of Flask, Plotly.js, React and React Js.

There is no comparison between Dash and other frameworks (mentioned above) as they belong to different category of frameworks. Below are some of the reasons to prefer dash over other interactive dashboard frameworks (Jupiter Dashboards, matplotpb and other) −

With just 50 pnes of code, you can write a simple “hello world” Dash app, as Dash requires very pttle boilerplater.

Entire Dash apps are written in python language, the most preferred language globally.

In your own python code, you can bind dash interactive components pke dropdown, text inputs, spders, and graphs with reactive Dash “callbacks”.

Comppcated UIs in Dash apps can have multiple inputs, multiple outputs and inputs that depends on other inputs.

Simultaneously, multiple users can work on Dash apps.

For creating your own Dash components with React, dash uses React.js to render components and includes a plugin system.

Developers or writers can write dash apps that respond to cpcking, hovering or selecting points on the graph as Dash’s Graph components are interactive.

Conclusion

We can conclude that choosing the right framework out of many available python frameworks solely depends on the type of project, complexity, small or enterprise level project, kind of community support available or onpne resource available, scalabipty, security, etc.

The above mentioned python frameworks are best in their class but have their own benefits and drawbacks (depending on the project requirement). So, one type of framework is not suitable for all kinds of projects.