Forem: Biplov

Django: What, Why, When ?

Biplov — Mon, 13 Jul 2020 14:37:24 +0000

In this article will take a look at Django-"The Web framework for perfectionists with deadlines". We will outline some of its feature and discuss why using Django is a good choice. We will also point out when to use django and when not to.

What is Django?

Django is an open source web application framework written in Python that encourages rapid development and pragmatic, clean design. It follows the "batteries-included" philosophy, meaning that Django comes with common functionality for building web applications, reducing much of the hassle of Web development.

Django supports the Model-View-Template (MVT) pattern, which is slightly different from Model-View-Controller (MVC) pattern. In MVT pattern:

Model is a data access layer that helps to handle database.
View executes the business logic and interact with a model to carry data and render the appropriate template.
Template is a presentation layer that defines how something should be displayed on a Web page .

Why use Django ?

It is Fast

Django is ridiculously fast and helps to turn your idea into product in no time. It follows DRY philosophy, which means we can reuse existing code, thus no unnecessary duplication.

It is Secure

Security is a high priority for Django and helps developers avoid many common security mistakes including SQL injection, cross-site scripting, cross-site request forgery and clickjacking.

It is Scalable

Some of the busiest sites on the Web leverage Django’s ability to quickly and flexibly scale.Some examples of websites that are running on Django are:

Instagram
Disqus
Bitbucket
Spotify

It is Versatile

Django can be used to build almost any type of website, from simple website to high-end web application. Django is used to build all sorts of things — from content management systems to social networks to scientific computing platforms.
It is compatible with most major databases and allows using a database that is more suitable in a particular project.

When use Django?

Choosing a framework for your project depends on a lot of factors. It is better to make an informed choice before you start rather than regret it halfway. Selecting an appropriate framework depends on type of project and desired outcomes.

Some of the situations when Django is a good choice:

building a highly customizable app, such as a social media website.
when security is a top priority.
your app might scale up/down at any point of time.
building apps that are entirely back-end.

Just because you can use Django to develop almost any type of website doesn't mean you should always use them. Django is not the best option when building a basic web applications as it’s a heavy framework with a lot of features. Micro framework, such as Flask works better in such situations.

Getting started with Django

Congratulations, now you have a basic understanding about Django and its use cases.
Here is a great article from @wsvincent to get started.

How to Learn Django (2020)

William S. Vincent ・ Jun 21 ・ 4 min read

#django #python #tutorial #beginners

17 Popular Python Opensource Projects on GitHub

Biplov — Thu, 21 May 2020 16:43:28 +0000

Python is a popular programming language, so it is no surprise that it has a large opensource presence with many powerful projects that receives contribution from developers around the world. Here is a list of some of the popular python open-source projects.

TensorFlow

⭐ 145K
TensorFlow is a Machine Learning Framework that has a comprehensive, flexible ecosystem of tools, libraries, and community resources that lets researchers push the state-of-the-art in ML and developers easily build and deploy ML-powered applications.

youtube-dl

⭐ 66.4K
Command-line program to download videos from YouTube and other video sites

thefuck

⭐ 53.6K
It is an app which corrects your previous console command.

Flask

⭐ 53.6K
Flask is a micro web framework written in Python. It is designed to make getting started quick and easy, with the ability to scale up to complex applications.

Django

⭐ 49.4K
Django is a free and open-source Python web development framework that follows the Model–Template–View (MTV) pattern. It comes with most of the libraries and tools required for common use cases.

Keras

⭐ 48.3K
Keras is an Open Source Neural Network library written in Python that runs on top of TensorFlow, CNTK, or Theano.

HTTPie

⭐ 46.8K
HTTPie is a command line HTTP client that makes CLI interaction with web services as human-friendly as possible.

Ansible

⭐ 43.2K
Ansible is an open source IT Configuration Management, Deployment & Orchestration tool that makes your applications and systems easier to deploy.

Requests

⭐ 42.5K
Requests is a Python HTTP library that makes HTTP requests simpler and more human-friendly.

Scikit-learn

⭐ 40.8K
Scikit-learn is an open source Python library built on top of SciPy that has powerful tools for data analysis and data mining.

PyTorch

⭐ 38.8K
PyTorch is an open source machine learning library based on the Torch library, used for applications such as computer vision and natural language processing.

Scrapy

⭐ 37.2K
Scrapy is a fast high-level web crawling and web scraping framework, used to crawl websites and extract structured data from their pages.

Face Recognition

⭐ 34.2K
Recognize and manipulate faces from Python or from the command line with the world's simplest face recognition library.

Pandas

⭐ 25K
Pandas is a Python package providing fast, flexible, and expressive data structures designed to make working with "relational" or "labeled" data both easy and intuitive.

Sentry

⭐ 24.9K
Sentry is a service that helps you monitor and fix crashes in realtime. Although written in Python, Sentry works with most languages and frameworks.

Pipenv

⭐ 20.3K
Pipenv is a dependency manager for Python projects that simplifies dependency management for common use cases.

fastai

⭐ 17.9K
The fastai library simplifies training fast and accurate neural nets using modern best practices.

15 Fun APIs For Your Next Project

Biplov — Mon, 04 May 2020 18:09:41 +0000

Maybe you want to make something cool for the web using some APIs. Maybe you are tired from building all the to-do lists and calculators and want to try something different. Whatever be the case you can use these API and build something creative.

Fun Translations

Translate regular English to 50+ languages from Yoda speak to Dorthraki to Klingon. Some fun stuff with this one, you can build.

This for That

Need a new idea for startup? This for That generates new ideas by supplying two random parameters. You can visit their website here if you just need some new startup ideas.

Chuck Norris Jokes API

If you are a fan of Chuck Norris this one is for you, a free JSON API for hand curated Chuck Norris facts.

Deck of Cards API

This API allows you to simulate a deck of cards. You can build some cool card games without worrying much aboaut the back-end stuff.

jService

Maybe it’s time for you to build your own trivia app.This API provides Jeopardy trivia data including the questions and answers. There are over 156,800 Trivia Questions to choose from.

GIPHY API

GIPHY's API makes it dead simple for developers to incorporate GIPHY's vast library right inside of their apps.

OMDb API

OMDb is the API for all the movie information you need. Maybe this is all you need to build somehing cool like letterboxd.

International Space Station API

Ever wondered where the ISS could be right about now? Well, wonder no more. This api returns the current location of the ISS. Now you can build your own ISS tracker.

Tronald Dump

If you want to find the dumbest things Donald Trump has ever said this one is for you.

Advice Slip

Need some advice? Why not create an advice generator? You can use this API to generate a random piece of advice.

Nasa API

Outer space has always been fascinating to humans.Now you can explore more with NASA’s incredible data, including its spectacular imagery through NASA API.

Spotify API

Spotify's web API allows you to query data about music artists, albums, and tracks, directly from the Spotify Data Catalogue.

Recipe API

With over 360k recipes and 90k products, you can build a great food app using this API.

BreweryDB

BreweryDB is the most complete database of breweries and beers.

Marvel Comics API

Fan of comics? This API allows you to access information about Marvel's vast library of comics—from what's coming up, to 70 years ago.

You can also check out this github repository for an extensive list of public APIs.

How to Paginate with Django?

Biplov — Fri, 17 Apr 2020 03:20:16 +0000

Pagination is a common navigation technique of dividing content into discrete pages. It helps make the content more organized, and thus improving user experience.

So, how do we paginate data in Django?
First thing we need to do is update our views to paginate the data.
We will look at both Function-Based Views and Class-Based Views.

Function-Based View

We need to import paginator from django.core.paginator which splits a Query-Set into Page objects.
Consider we have 45 blog posts and we want to display at most 10 posts per page.

from django.shortcuts import render
from django.core.paginator import Paginator
form .models import Blog

def blogposts(request):
    blogs = Blog.objects.all()
    paginator = Paginator(blogs, 10)

    page_number = request.GET.get('page')
    page_obj = paginator.get_page(page_number)
    return render(request, 'index.html', {'page_obj': page_obj})

The above example will Paginate the blogs Query-Set in pages of 10. This will create a 5 pages result. The first 4 pages with 10 blog posts each and the last page with 5.

Class-Based View

In class based views we can use paginate_by attribute to specify the number by which to paginate the queryset.

from .models import Blog
from django.views.generic import ListView

class blogposts(ListView):
    model = Blog
    paginate_by = 10

Template

After updating the views we need to update our template.
To be able to navigate between posts we need to add links in our template.

<!--
 code to display blog posts ...
-->
<div class="pagination">
    <span class="step-links">
        {% if page_obj.has_previous %}          
            <a href="?page={{ page_obj.previous_page_number }}">previous</a>
        {% endif %}

        <span class="current">
          {{ page_obj.number }}
        </span>

        {% if page_obj.has_next %}
            <a href="?page={{ page_obj.next_page_number }}">next</a>
        {% endif %}
    </span>
</div>

This displays a previous-next links with current page number.

This is a simple example of pagination but you can get more creative with it. You can follow this link for more information about Paginator class.

How to Deploy a Django Application to Heroku

Biplov — Tue, 31 Mar 2020 02:42:48 +0000

Introduction

Heroku is a cloud platform as a service(PaaS) that facilitates the deployment of web applications that supports several programming languages, including Python.
So let's look at how we can deploy a Django application to Heroku easily in no time.

Getting Started

The first thing you need to do is to create an account on heroku. You can create one from here. Once you have created an account you need to install the Heroku Command Line Interface (CLI) that will be used manage and scale your applications, view your application logs, and run your application locally. You also need to have git installed on your machine.

After the Heroku CLI is installed, open your terminal and log in to your heroku account using the following command:

$ heroku login

Managing the Application

Now CD into your project folder. We need to add a few files to be able to deploy the app in heroku. The first file you need is a requirements.txt file. If you have your virtual environment setup and active you can just type the following command on terminal to create your requirements file.

$ pip freeze > requirements.txt

Or you can manually list all dependencies on the requirements.txt file.

The next thing Heroku web applications require is a Procfile. Inside your project root folder, create a new file called Procfile and add the following content:

web: gunicorn myproject.wsgi

You need to change my-application with the name of your Django project.

Now you need to install something called Gunicorn. If you want to know more about Gunicorn you can follow this link. Use the following command to install Gunicorn:

$ pip install gunicorn

Add gunicorn to your requirements.txt file as well.

In addition you can also add a runtime.txt file to your app’s root directory that declares the exact version number to use. For example, you can create a new file runtime.txt and add the following content:

python-3.7.2

`settings.py` changes

Now you need to make some changes to your settings.py file. The first thing to do is install django-heroku. It is a package that automatically configures your Django application to work on Heroku.

$ pip install django-heroku

Be sure to add django-heroku to your requirements.txt file as well.

Now, add the following statement to the top of settings.py file:

import django_heroku

Then add the following to the bottom of settings.py:

# Activate Django-Heroku.
django_heroku.settings(locals())

Creating heroku app

Now we will create a new heroku app. Type the following command on your terminal:

$ heroku create my-app

Change my-app with your app name. It should be unique and not taken by anyone. Heroku will inform you if the name already exists.

This command will create your heroku app with the name you provided. Now you can visit your heroku dashboard on your browser to see your app. You can also see the default page of your application by using the link in the terminal. The link looks something like this:

https://my-app.herokuapp.com

Deploying the Django project

We will use git to deploy our project to heroku. CD to your project root folder and initialize the git using following command:

$ git init

You can add .gitignore file to your project. You can visit .gitignore.io to create .gitignore file for your project
Now add and commit the files to git:

$ git add --all
$ git commit -m 'initial commit'

Before you can push your project, you need to set your remote to heroku.

$ heroku git:remote -a my-app

Replace my-app with your app name.
Now, you can push your project to heroku:

$ git push heroku master

Then, migrate the database:

$ heroku run python manage.py migrate

Congratulations!! The deployment is complete. Your project is now live on heroku.

Conclusion

So, we deployed our project to heroku with not-so-good-looking domain name. Well, we can change that too. Heroku allows you to add a custom domain to your application. You can go through the Heroku Python docs for more information.

Function-Based Views Vs Class-Based Views - Django

Biplov — Sat, 28 Mar 2020 13:48:49 +0000

A view is a place where you put the logic of the application. The Views are used to perform activities like fetching objects from the database, modifying those objects if needed, rendering forms and so on.

The Django official documentation describes views as:
"A view function, or view for short, is a Python function that takes a Web request and returns a Web response. This response can be the HTML contents of a Web page, or a redirect, or a 404 error, or an XML document, or an image . . . or anything, really. The view itself contains whatever arbitrary logic is necessary to return that response. "

In the earlier days of Django there was only the function based views. They were easy to implement and very useful, but while working on a large project, the views were often crowded with similar functions. This was one of the reasons for the creation of class based views.

Function Based Views

Function based views are the views in Django that are defined by functions. These python functions take a web request and returns a web response.
Function based views are most of the time based on 'What you see is what you get approach'. This is because all the logic of the view must be included.

The biggest disadvantage of this approach is the length and repetition of codes. Writing a same block of code over and over is never a good practice.

 def example_fbv(request):
    items = Item.objects.all()
    context = {
        'items' : item
    }

    return render(request, 'app/index.html', context)

This example of FBVs is easy to implement and understand, but if it was a part of a larger Django project we would see a lot of similar functions. This causes code repetition and views become long and hard to read.

Class Based Views

Class based views are Django views based on Python classes. As mentioned in the Django official documentation, 'class based views do not replace function-based views, but have certain differences and advantages when compared to function-based views'. CBVs are very easy to use in simple cases, but extending them with increasing project complexity becomes more and more difficult.

Class based views may be easy to begin with but you need to understand Python classes along with Django views to master them.

class example_cbv(View):
    model = Item
    template_name = 'app/index.html'

This class based view does the exact same thing as the function based view above. It makes code relatively shorter and reduce code duplication, but it makes code harder to understand due to implicit code flow.

Conclusion

As stated earlier class based views do not replace function-based views and there is no right or wrong. Function based views can be a better choice in some cases, whereas class based views in another. It all depends on context and need of the project.

Forem: Biplov

Django: What, Why, When ?

What is Django?

Why use Django ?

It is Fast

It is Secure

It is Scalable

It is Versatile

When use Django?

Getting started with Django

How to Learn Django (2020)

William S. Vincent ・ Jun 21 ・ 4 min read

17 Popular Python Opensource Projects on GitHub

15 Fun APIs For Your Next Project

How to Paginate with Django?

Function-Based View

Class-Based View

Template

How to Deploy a Django Application to Heroku

Introduction

Getting Started

Managing the Application

settings.py changes

Creating heroku app

Deploying the Django project

Conclusion

Function-Based Views Vs Class-Based Views - Django

Function Based Views

Class Based Views

Conclusion

`settings.py` changes