How To Install Django On Mac

Setting upwardly a Django development environment

Previous
Overview: Django
Side by side

At present that you know what Django is for, nosotros'll show you how to set and exam a Django development environment on Windows, Linux (Ubuntu), and macOS — whatever common operating arrangement you are using, this commodity should requite you what y'all need to be able to start developing Django apps.

Django development surround overview

Django makes it very easy to prepare your own estimator so that you tin start developing web applications. This section explains what yous become with the development surroundings, and provides an overview of some of your setup and configuration options. The residue of the article explains the recommended method of installing the Django evolution environment on Ubuntu, macOS, and Windows, and how you tin test information technology.

What is the Django development environment?

The development environment is an installation of Django on your local computer that you tin can apply for developing and testing Django apps prior to deploying them to a production surround.

The main tools that Django itself provides are a set of Python scripts for creating and working with Django projects, forth with a simple development webserver that you lot can use to test local (i.e. on your computer, non on an external spider web server) Django web applications on your computer's spider web browser.

At that place are other peripheral tools, which grade role of the evolution surroundings, that we won't be roofing hither. These include things like a text editor or IDE for editing code, and a source control management tool like Git for safely managing different versions of your code. We are assuming that you've already got a text editor installed.

What are the Django setup options?

Django is extremely flexible in terms of how and where information technology can be installed and configured. Django tin can be:

Installed on dissimilar operating systems.
Installed from source, from the Python Parcel Index (PyPi) and in many cases from the host estimator's bundle manager application.
Configured to use i of several databases, which may as well need to be separately installed and configured.
Run in the main system Python environment or within separate Python virtual environments.

Each of these options requires a slightly dissimilar configuration and setup. The post-obit subsections explain some of your choices. For the rest of the article, nosotros'll bear witness you lot how to setup Django on a small number of operating systems, and that setup will be assumed throughout the rest of this module.

Note: Other possible installation options are covered in the official Django documentation. We link to the appropriate documents beneath.

What operating systems are supported?

Django web applications can be run on well-nigh any machine that tin run the Python 3 programming language: Windows, macOS, Linux/Unix, Solaris, to name just a few. Almost any reckoner should accept the necessary performance to run Django during evolution.

In this article, we'll provide instructions for Windows, macOS, and Linux/Unix.

What version of Python should be used?

You can apply whatever Python version supported by your target Django release. For Django 3.i.ii the immune versions are Python 3.6 to 3.8 (see FAQ:Installation).

The Django project recommends (and "officially supports") using the newest bachelor supported Python release.

Where can we download Django?

At that place are iii places to download Django:

The Python Bundle Repository (PyPi), using the pip tool. This is the best way to go the latest stable version of Django.
Utilize a version from your computer's package manager. Distributions of Django that are bundled with operating systems offering a familiar installation machinery. Note however that the packaged version may be quite old, and can only exist installed into the organization Python environment (which may non be what you want).
Install from source. You can get and install the latest bleeding-edge version of Django from the source. This is not recommended for beginners just is needed when you're gear up to start contributing back to Django itself.

This article shows how to install Django from PyPi, in order to get the latest stable version.

Which database?

Django officially supports the PostgreSQL, MariaDB, MySQL, Oracle, and SQLite databases, and in that location are community libraries that provide varying levels of support for other popular SQL and NoSQL databases. We recommend that you select the same database for both production and development (although Django abstracts many of the database differences using its Object-Relational Mapper (ORM), there are still potential issues that are better to avert).

For this article (and most of this module) we will be using the SQLite database, which stores its data in a file. SQLite is intended for use as a lightweight database and can't back up a loftier level of concurrency. It is, however, an excellent selection for applications that are primarily read-just.

Note: Django is configured to use SQLite by default when you get-go your website project using the standard tools (django-admin). It'south a peachy pick when you're getting started because it requires no additional configuration or setup.

Installing organisation-wide or in a Python virtual environment?

When you lot install Python3 you go a unmarried global environment that is shared by all Python3 code. While yous can install whatever Python packages you like in the environment, you can only install ane item version of each package at a time.

Note: Python applications installed into the global environment can potentially conflict with each other (i.eastward. if they depend on different versions of the same bundle).

If you install Django into the default/global environment so you will merely be able to target one version of Django on the estimator. This can be a problem if you desire to create new websites (using the latest version of Django) while still maintaining websites that rely on older versions.

As a result, experienced Python/Django developers typically run Python apps within contained Python virtual environments. This enables multiple different Django environments on a single computer. The Django developer team itself recommends that you use Python virtual environments!

This module assumes that you've installed Django into a virtual environment, and we'll prove you lot how below.

Installing Python 3

In order to use Django you will take to install Python on your operating system. If you're using Python three and then you will also demand the Python Package Index tool — pip3 — which is used to manage (install, update, and remove) Python packages/libraries used by Django and your other Python apps.

This section briefly explains how you can bank check what versions of Python are present, and install new versions as needed, for Ubuntu Linux xx.04, macOS, and Windows 10.

Note: Depending on your platform, you may too be able to install Python/pip from the operating arrangement's own bundle director or via other mechanisms. For most platforms, you can download the required installation files from https://www.python.org/downloads/ and install them using the appropriate platform-specific method.

Ubuntu xx.04

Ubuntu Linux 20.04 LTS includes Python 3.8.ten by default. You can ostend this by running the post-obit command in the bash final:

Still, the Python Package Index tool (pip3) you'll need to install packages for Python 3 (including Django) is not available by default. You can install pip3 in the fustigate concluding using:

                                  sudo                  apt                  install                  python3-pip

macOS

macOS "El Capitan" and other more recent versions exercise not include Python iii. You can confirm this by running the following commands in the zsh or fustigate terminal:

                $ python3 -V   python3:                  command                  not plant

You can easily install Python 3 (along with the pip3 tool) from python.org:

Download the required installer:
1. Become to https://world wide web.python.org/downloads/macos/
2. Download the near recent supported version that works with Django three.1.2. (at fourth dimension of writing this is Python 3.8.12).
Locate the file using Finder, and double-click the package file. Following the installation prompts.

Y'all can now confirm successful installation by checking for the Python 3 version equally shown below:

You can similarly cheque that pip3 is installed by listing the available packages:

Windows ten

Windows doesn't include Python by default, but you can easily install it (along with the pip3 tool) from python.org:

Download the required installer:
1. Become to https://www.python.org/downloads/windows/
2. Download the most recent supported version that works with Django 3.one.2. (at time of writing this is Python three.8.12).
Install Python by double-clicking on the downloaded file and post-obit the installation prompts
Be sure to cheque the box labeled "Add Python to PATH"

Yous can then verify that Python 3 was installed by entering the following text into the command prompt:

The Windows installer incorporates pip3 (the Python packet manager) past default. You can list installed packages as shown:

Notation: The installer should set up up everything you lot need for the above control to piece of work. If however you get a message that Python cannot be found, you may accept forgotten to add it to your system path. You lot tin can practise this by running the installer again, selecting "Modify", and checking the box labeled "Add together Python to surround variables" on the 2d folio.

Using Django inside a Python virtual environment

The libraries we'll use for creating our virtual environments are virtualenvwrapper (Linux and macOS) and virtualenvwrapper-win (Windows), which in turn both use the virtualenv tool. The wrapper tools creates a consistent interface for managing interfaces on all platforms.

Installing the virtual environment software

Ubuntu virtual surround setup

After installing Python and pip y'all can install virtualenvwrapper (which includes virtualenv). The official installation guide can be found here, or follow the instructions beneath.

Install the tool using pip3:

                                  sudo                  pip3                  install                  virtualenvwrapper

Then add the following lines to the cease of your beat out startup file (this is a hidden file name .bashrc in your habitation directory). These ready the location where the virtual environments should live, the location of your evolution project directories, and the location of the script installed with this package:

                                  consign                  WORKON_HOME                  =                  $Domicile/.virtualenvs                  export                  VIRTUALENVWRAPPER_PYTHON                  =/usr/bin/python3                  export                  VIRTUALENVWRAPPER_VIRTUALENV_ARGS                  =                  ' -p /usr/bin/python3 '                  export                  PROJECT_HOME                  =                  $Habitation/Devel                  source                  /usr/local/bin/virtualenvwrapper.sh

Annotation: The VIRTUALENVWRAPPER_PYTHON and VIRTUALENVWRAPPER_VIRTUALENV_ARGS variables signal to the normal installation location for Python3, and source /usr/local/bin/virtualenvwrapper.sh points to the normal location of the virtualenvwrapper.sh script. If the virtualenv doesn't work when you test information technology, i thing to bank check is that Python and the script are in the expected location (and so modify the startup file appropriately).

You tin find the correct locations for your organization using the commands which virtualenvwrapper.sh and which python3.

Then reload the startup file past running the following command in the final:

At this indicate you should see a bunch of scripts being run as shown beneath:

                virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/premkproject virtualenvwrapper.user_scripts creating /dwelling house/ubuntu/.virtualenvs/postmkproject                  ... virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/preactivate virtualenvwrapper.user_scripts creating /home/ubuntu/.virtualenvs/postactivate virtualenvwrapper.user_scripts creating /dwelling house/ubuntu/.virtualenvs/get_env_details

Now you tin can create a new virtual surround with the mkvirtualenv command.

macOS virtual environs setup

Setting up virtualenvwrapper on macOS is virtually exactly the same every bit on Ubuntu (again, y'all can follow the instructions from either the official installation guide or below).

Install virtualenvwrapper (and bundling virtualenv) using pip as shown.

                                  sudo                  pip3                  install                  virtualenvwrapper

And then add the following lines to the stop of your beat startup file (these are the same lines as for Ubuntu). If you lot're using the zsh shell then the startup file volition be a subconscious file named .zshrc in your dwelling directory. If y'all're using the bash shell and then it volition be a subconscious file named .bash_profile. Yous may need to create the file if it does not yet exist.

                                  export                  WORKON_HOME                  =                  $Domicile/.virtualenvs                  consign                  VIRTUALENVWRAPPER_PYTHON                  =/usr/bin/python3                  consign                  PROJECT_HOME                  =                  $Domicile/Devel                  source                  /usr/local/bin/virtualenvwrapper.sh

Annotation: The VIRTUALENVWRAPPER_PYTHON variable points to the normal installation location for Python3, and source /usr/local/bin/virtualenvwrapper.sh points to the normal location of the virtualenvwrapper.sh script. If the virtualenv doesn't work when you test it, one matter to check is that Python and the script are in the expected location (and then change the startup file appropriately).

For example, one installation exam on macOS ended up with the post-obit lines being necessary in the startup file:

                                      export                    WORKON_HOME                    =                    $Home/.virtualenvs                    consign                    VIRTUALENVWRAPPER_PYTHON                    =/Library/Frameworks/Python.framework/Versions/3.7/bin/python3                    export                    PROJECT_HOME                    =                    $HOME/Devel                    source                    /Library/Frameworks/Python.framework/Versions/3.seven/bin/virtualenvwrapper.sh

You can find the correct locations for your arrangement using the commands which virtualenvwrapper.sh and which python3.

Then reload the startup file by making the post-obit call in the concluding:

At this signal, you may see a bunch of scripts beingness run (the same scripts as for the Ubuntu installation). You should now be able to create a new virtual environment with the mkvirtualenv command.

Note: If you can't find the startup file to edit in the finder, you can also open up this in the last using nano.

Assuming you're using bash, the commands look something like this:

                                      cd                    ~                    # Navigate to my dwelling directory                    ls                    -la                    #List the content of the directory. YOu should see .bash_profile                    nano                    .bash_profile                    # Open the file in the nano text editor, within the terminal                    # Scroll to the end of the file, and copy in the lines above                    # Use Ctrl+Ten to exit nano, choose Y to save the file.

Windows ten virtual environment setup

Installing virtualenvwrapper-win is even simpler than setting up virtualenvwrapper because you don't need to configure where the tool stores virtual surroundings information (there is a default value). All yous need to practise is run the following control in the control prompt:

                pip3                  install                  virtualenvwrapper-win

Now you can create a new virtual surroundings with the mkvirtualenv command

Creating a virtual environment

Once you've installed virtualenvwrapper or virtualenvwrapper-win then working with virtual environments is very like on all platforms.

Now you can create a new virtual surround with the mkvirtualenv command. Equally this command runs you'll see the environment being ready (what you see is slightly platform-specific). When the control completes the new virtual environs will be active — you tin see this considering the offset of the prompt will exist the name of the environment in brackets (below we bear witness this for Ubuntu, only the final line is similar for Windows/macOS).

                $ mkvirtualenv my_django_environment  Running virtualenv with interpreter /usr/bin/python3                  ... virtualenvwrapper.user_scripts creating /dwelling/ubuntu/.virtualenvs/t_env7/bin/get_env_details                  (my_django_environment)                  ubuntu@ubuntu:~$

Now you're inside the virtual environment you lot can install Django and start developing.

Notation: From now on in this article (and indeed the module) delight presume that any commands are run within a Python virtual environs like the i nosotros gear up higher up.

Using a virtual environment

In that location are simply a few other useful commands that you should know (there are more in the tool documentation, but these are the ones yous'll use regularly):

deactivate — Exit out of the electric current Python virtual surround
workon — Listing bachelor virtual environments
workon name_of_environment — Activate the specified Python virtual environment
rmvirtualenv name_of_environment — Remove the specified surroundings.

Installing Django

In one case yous've created a virtual environment, and chosen workon to enter information technology, you can use pip3 to install Django.

You can exam that Django is installed by running the following control (this just tests that Python tin can find the Django module):

                                  # Linux/macOS                  python3 -m django --version                  three.1.two                  # Windows                  py -3 -thou django --version                  three.1.2

Annotation: If the above Windows command does non testify a django module nowadays, try:

In Windows Python 3 scripts are launched by prefixing the command with py -3, although this tin vary depending on your specific installation. Endeavor omitting the -3 modifier if y'all encounter whatsoever problems with commands. In Linux/macOS, the command is python3.

Warning: The rest of this module uses the Linux command for invoking Python three (python3) . If you're working on Windows replace this prefix with: py -iii

Testing your installation

The above test works, but it isn't very much fun. A more interesting test is to create a skeleton projection and see information technology working. To do this, first navigate in your command prompt/terminal to where you lot want to store your Django apps. Create a folder for your exam site and navigate into it.

                                  mkdir                  django_test                  cd                  django_test

You can then create a new skeleton site chosen "mytestsite" using the django-admin tool as shown. After creating the site you can navigate into the folder where y'all will find the main script for managing projects, called manage.py.

                django-admin startproject mytestsite                  cd                  mytestsite

We can run the development web server from inside this folder using manage.py and the runserver command, as shown.

                $ python3 manage.py runserver Watching                  for                  file                  changes with StatReloader Performing system checks...  System bank check identified no issues                  (                  0                  silenced).  You have                  eighteen                  unapplied migration(s). Your project may non work properly                  until                  you utilise the migrations                  for                  app(southward): admin, auth, contenttypes, sessions. Run                  'python manage.py migrate'                  to apply them. Oct                  27,                  2020                  - 03:00:01 Django version                  3.1.ii, using settings                  'mytestsite.settings'                  Starting development server at http://127.0.0.ane:8000/ Quit the server with CONTROL-C.

Note: The above command shows the Linux/macOS control. You can ignore the warnings about "xviii unapplied migration(s)" at this point!

In one case the server is running you can view the site by navigating to the following URL on your local web browser: http://127.0.0.1:8000/. Yous should come across a site that looks similar this:

The home page of the skeleton Django app.

Summary

Y'all now have a Django development environs up and running on your computer.

In the testing department you also briefly saw how we can create a new Django website using django-admin startproject, and run information technology in your browser using the development spider web server (python3 manage.py runserver). In the next commodity, we expand on this procedure, building a simple but complete web application.

In this module

Django introduction
Setting up a Django evolution environment
Django Tutorial: The Local Library website
Django Tutorial Part 2: Creating a skeleton website
Django Tutorial Part 3: Using models
Django Tutorial Part 4: Django admin site
Django Tutorial Part 5: Creating our dwelling page
Django Tutorial Office half-dozen: Generic listing and detail views
Django Tutorial Part 7: Sessions framework
Django Tutorial Part 8: User authentication and permissions
Django Tutorial Office 9: Working with forms
Django Tutorial Part 10: Testing a Django spider web application
Django Tutorial Function 11: Deploying Django to product
Django web application security
DIY Django mini blog

Source: https://developer.mozilla.org/en-US/docs/Learn/Server-side/Django/development_environment

Posted by: grahamfackably.blogspot.com