How to check Django version


I have to use Python and Django for our application. So I have two versions of Python, 2.6 and 2.7. Now I have installed Django. I could run the sample application for testing Django succesfuly. But how do I make sure whether Django uses the 2.6 or 2.7 version and what version of modules Django uses?

Asked By: maheshgupta024



Django 1.5 supports Python 2.6.5 and later.

If you’re under Linux and want to check the Python version you’re using, run python -V from the command line.

If you want to check the Django version, open a Python console and type

>>> import django
>>> django.VERSION
(2, 0, 0, 'final', 0)
Answered By: bcoughlan

Django will use the version of Python specified by the PYTHONPATH environment variable. You can use echo $PYTHONPATH in a shell to determine which version will be used.

The module versions used by Django will be the module versions installed under the version of Python specified by PYTHONPATH.

Answered By: George Cummins

Basically the same as bcoughlan’s answer, but here it is as an executable command:

$ python -c "import django; print(django.get_version())"
Answered By: Brady Emerson

If you have pip, you can also do a

pip freeze

and it will show your all component version including Django .

You can pipe it through grep to get just the Django version. That is,

josh@villaroyale:~/code/djangosite$ pip freeze | grep Django
Answered By: Josh Brown

If you have installed the application:

$ django-admin --version
Answered By: justi

For checking using a Python shell, do the following.

>>>from django import get_version
>>> get_version()

If you wish to do it in Unix/Linux shell with a single line, then do

python -c 'import django; print(django.get_version())'

Once you have developed an application, then you can check version directly using the following.

python runserver --version
Answered By: kmario23
>>> import django
>>> print(django.get_version())

I am using the IDLE (Python GUI).

Answered By: Mtech

Go to your Django project home directory and do:

./ --version
Answered By: nik7

You can do it without Python too. Just type this in your Django directory:

cat | grep VERSION

And you will get something like:

VERSION = (1, 5, 5, 'final', 0)
Answered By: Alex Babak

For Python:

import sys

For Django (as mentioned by others here):

import django

The potential problem with simply checking the version, is that versions get upgraded and so the code can go out of date. You want to make sure that ‘1.7’ < ‘1.7.1’ < ‘1.7.5’ < ‘1.7.10’. A normal string comparison would fail in the last comparison:

>>> '1.7.5' < '1.7.10'

The solution is to use StrictVersion from distutils.

>>> from distutils.version import StrictVersion
>>> StrictVersion('1.7.5') < StrictVersion('1.7.10')
Answered By: James Bradbury

If you want to make Django version comparison, you could use django-nine (pip install django-nine). For example, if Django version installed in your environment is 1.7.4, then the following would be true.

from nine import versions

versions.DJANGO_1_7 # True
versions.DJANGO_LTE_1_7 # True
versions.DJANGO_GTE_1_7 # True
versions.DJANGO_GTE_1_8 # False
versions.DJANGO_GTE_1_4 # True
versions.DJANGO_LTE_1_6 # False
Answered By: Artur Barseghyan

The most pythonic way I’ve seen to get the version of any package:

>>> import pkg_resources;
>>> pkg_resources.get_distribution('django').version

This ties directly into

Also there is distutils to compare the version:

>>> from distutils.version import LooseVersion, StrictVersion
>>> LooseVersion("2.3.1") < LooseVersion("10.1.2")
>>> StrictVersion("2.3.1") < StrictVersion("10.1.2")
>>> StrictVersion("2.3.1") > StrictVersion("10.1.2")

As for getting the python version, I agree with James Bradbury:

>>> import sys
>>> sys.version
'3.4.3 (default, Jul 13 2015, 12:18:23) n[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)]'

Tying it all together:

>>> StrictVersion((sys.version.split(' ')[0])) > StrictVersion('2.6')
Answered By: Javier Buzzi

There is an undocumented utils versions module in Django:

With that, you can get the normal version as a string or a detailed version tuple:

>>> from django.utils import version
>>> version.get_version()
... 1.9
>>> version.get_complete_version()
... (1, 9, 0, 'final', 0)
Answered By: yellowcap

As you say you have two versions of Python, I assume they are in different virtual environments (e.g. venv) or perhaps Conda environments.

When you installed Django, it was likely in only one environment. It is possible that you have two different versions of Django, one for each version of python.

In from a Unix/Mac terminal, you can check your Python version as follows:

$ python --version

If you want to know the source:

$ which python

And to check the version of Django:

$ python -m django --version
Answered By: Alexander

Run pip list in a Linux terminal and find Django and its version in the list:

Run pip freeze on cmd on Windows.

Answered By: Avinash Bakshi
django-admin --version
python --version
pip freeze | grep django
Answered By: Vishnu Kiran

You can get django version by running the following command in a shell prompt

python -m django –version

If Django is installed, you should see the version otherwise you’ll get an error telling “No module named django”.

Answered By: Amit Baderia

Type the following command in Python shell

import django
Answered By: Baishakhi Dasgupta

After django 1.0 you can just do this

$ django-admin --version
Answered By: Mark White

There are various ways to get the Django version. You can use any one of the following given below according to your requirements.

Note: If you are working in a virtual environment then please load your python environment

Terminal Commands

  1. python -m django --version
  2. django-admin --version or version
  3. ./ --version or python --version
  4. pip freeze | grep Django
  5. python -c "import django; print(django.get_version())"
  6. python runserver --version

Django Shell Commands

  1. import django
  2. from django.utils import version
    OR version.get_complete_version()
  3. import pkg_resources

(Feel free to modify this answer, if you have some kind of correction or you want to add more related information.)

Answered By: Vishal Nagda

you can import django and then type print statement as given below to know the version of django i.e. installed on your system:

>>> import django
>>> print(django.get_version())
Answered By: Sonia Rani

Python version supported by Django version

Django version        Python versions
1.0                   2.3, 2.4, 2.5, 2.6
1.1                   2.3, 2.4, 2.5, 2.6
1.2                   2.4, 2.5, 2.6, 2.7
1.3                   2.4, 2.5, 2.6, 2.7
1.4                   2.5, 2.6, 2.7
1.5                   2.6.5, 2.7 and 3.2.3, 3.3 (experimental)
1.6                   2.6.5, 2.7 and 3.2.3, 3.3
1.11                  2.7, 3.4, 3.5, 3.6, 3.7 (added in 1.11.17)
2.0                   3.4, 3.5, 3.6, 3.7
2.1, 2.2              3.5, 3.6, 3.7

To verify that Django can be seen by Python, type python from your shell. Then at the Python prompt, try to import Django:

>>> import django
>>> print(django.get_version())
>>> django.VERSION
(2, 1, 4, 'final', 0)
Answered By: shafik

Django version or any other package version

Open the terminal or command prompt


pip show django


pip3 show django

You can find any package version…


pip show tensorflow

pip show numpy


Answered By: Muhammad Shabin

Simply type python -m django --version or type pip freeze to see all the versions of installed modules including Django.

Answered By: swami

Type in your CMD or terminal:

python -m django --version
Answered By: Anubhav Madhav

go the setting of the Django Project. there find your Django Version.

Answered By: benzene

Open your CMD or Terminal and run any of the following commands

django-admin --version
python3 -m django --version
pip freeze
Answered By: kirankumar

enter image description hereIt’s very simple open the CLI(command line or any IDE) wherever you installed python and Django just type,

django-admin –version

see here I have installed the latest Python and Django in my system and the result is shown in fig.

Answered By: Manukumar

There are two more methods to get the Version (of Django and other packages).
Both of them need a version variable for the package to get the version.
According to PEP-396 the __version__variable should be set for every Python module.

Method 1 – Get version from filesystem

With that in mind, you know how to get the version for almost every Django/Python package. Look inside the of the package root.
So if you are a fast at navigating through the filesystem, this can be a very universal way of getting the Version of any package inside your site-package (virtual environment).

Method 2 – Django Debug Toolbar

There is a very helpful tool that is called django debug toolbar.
If you use it (very recommendable for Django development) you can list the versions of all apps that have a package.__version__.


Answered By: Frank

From your code, you can get the version of Django by using any of the two below.

import django
# '3.1.5'
# (3, 1, 5, 'final', 0)

or from your terminal, you can run

django-admin --version
Answered By: Oluwafemi Tairu

Official Documentation


python -m django --version


import django
Answered By: Amit pratap singh

The yield keyword is used in the body of a function like a return statement, but instead of returning a value and terminating the function, yield produces a value and suspends the function’s execution. The function can then be resumed later on from where it left off, allowing it to produce a series of values over time, rather than computing them all at once and returning them in a list, for example.

Here is an example of a simple generator function that uses the yield keyword:

def count_up_to(max):
   count = 1
   while count <= max:
       yield count
       count += 1

for number in count_up_to(5):

This code will output the numbers 1 through 5, because the count_up_to function yields each number as it counts up to the specified maximum.


Generator functions are useful for producing large sequences of values, because they allow you to produce the values one at a time, rather than generating all of the values at once and storing them in memory. This can be more efficient when dealing with large data sets.

Answered By: Ahmed Elgammudi
Categories: questions Tags: ,
Answers are sorted by their score. The answer accepted by the question owner as the best is marked with
at the top-right corner.