Forem: Cindy Achieng

Laughing Blog Tutorial Part 3 - Send Alternative Content Type Emails in Django

Cindy Achieng — Fri, 14 Jun 2019 06:03:47 +0000

Html emails can be formatted well and include pictures, unlike plain text emails. However, some email clients (mostly older ones) cannot read html. Therefore It may be useful to send plain text emails a alongside html email because we want all our subscribers receiving their emails.

To achieve sending multiple email content, we are going to use Django email library called EmailMultiAlternatives. For a much cleaner code, we will create a function.

We will also cover django message framework to display user notifications Instead of printing notification to console see documentation

Let's get started!

Create a new file on newsletter app and name it emails.py.

def send_multiple_email(name, receiver):
    subject = 'Welcome to Laughing Blog Tutorial'
    sender = 'test@achiengcindy.com'
    text_template = render_to_string(
        'newsletter/email-subscribe.txt', {'name': name})
    html_template = render_to_string(
        'newsletter/email-subscribe.html', {'name': name})
    message = EmailMultiAlternatives(
        subject, text_template, sender, [receiver])
    message.attach_alternative(html_template, 'text/html')
    message.send()

In the above code, we created a function send_multiple_email taking two parameters. Define the subject of the email and sender. Use the render_to_string function and pass the templates for the email body.

We can now create the email template

newsletter/templates/email-subscribe.html

<h2>Hello {{name}}</h2> 
Welcome to Laughing Blog Newsletter and thank you for signing up. 
You will find the most exciting news about Python, Django, Programming tips and web development tools that will go along way to see you grow your skills

newsletter/templates/email-subscribe.txt

Hello {{name}}
Welcome to Laughing Blog  Newsletter and thank you for signing up. 
You will find the most exciting news about Python, Django,Programming tips and web development tools that will go along way to see you grow your skills

Now is a good time to make a few changes in views.py.Change your views to look like this:

newsletter/views.py

def newsletter_subscribe(request):
    if request.method == 'POST':
        form = NewsUserForm(request.POST)
        if form.is_valid():
            instance = form.save(commit=False)
            # we dont want to save just yet
            if NewsUsers.objects.filter(email=instance.email).exists():
                print('your email Already exists in our database')
            else:
                instance.save()
                print('your email has been submitted to our database')
                send_multiple_email(instance.name, instance.email)
    else:
        form = NewsUserForm()
    context = {'form': form}
    template = 'newsletter/subscribe.html'
    return render(request, template, context)

First ,import the function we just created

from .emails import send_multiple_email

Then instead of send_mail call send_multiple_email
Run Server and test

Django messages Framework

Edit your views with the following:
First import messages framework

from django.contrib import messages

and next replace these line of codes

print('your email Already exists in our database') 
print('your email has been submitted to our database')

with these lines respectively

 messages.warning(request, 'your Email Already exists in our database') 
 messages.success(request, 'your Email has been submitted to our database')

To display messages edit subscription template to look like this:

<ul class="messages">
{% for message in messages %}
<li{% if message.tags %} class="{{ message.tags }}"{% endif    %}>{{ message }</li>
{% endfor %}
</ul>
{% else %}
<form action="{% url 'newsletter:subscribe' %}" method="post">
{% csrf_token %}
{{ form.as_p }}
<button type="submit">Submit</button>
</form>
{% endif %}

Conclusion

We are now able to send alternative emails and have a more readable code.The source code for this tutorial is available on Github .Connect with me on Twitter

This post was originally posted on achiengcindy.com

Laughing Blog Tutorial Part 1-Project Structure

Cindy Achieng — Fri, 30 Nov 2018 09:32:45 +0000

My journey as a programmer has taught me one valuable lesson: To effectively learn how to write and understand programming concepts, never underestimate the value of building real-life applications. I remember staying up late trying to grasp the concepts of programming. But to make the concepts stick, I embarked on a journey to create achiengcindy.com and share my journey with you all.

The aim of this tutorial series, The laughing blog, is to create a fully functional blog in Django.

Overview

We will implement functionalities such as :

Registration and Authentication
Newsletter
Sending Emails
Comment system
Social media share

The code can be found on github.

If you follow through, you too can create your own blog or even earn from it.

Prerequisites

Basic Git Knowledge
A github or bitbucket account.If you dont have,create one for free on github or bitbucket
Django basics.If you are new to django check my previous tutorial on Django Environment in Linux .
Text Editor of choice.I will be using Sublime Text.You can download it here.

Setting up the laughing-blog project

In this tutorial, you will learn how to create Django project structure, learn git and some very useful python libraries such as whitenoise and python decouple.

I will use pip and virtualenv to create the project structure however, you can use pipenv

let's get started

Create a folder and name it tutorial where our project will be stored.

 mkdir tutorial && cd tutorial

Nice, next we have to create a Virtual Environment for our project

 virtualenv env -p python3

specify the python version .We will use python3

To use our virtual environment we must activate it

 source env/bin/activate

After activating the virtual environment. Install Django using the command below:

$ pip3 install django

We are going to create the project named laughing_blog by using the command below:

 $ django-admin startproject laughing_blog

If you change Directory to laughing_blog, you should have a structure like this:

laughing_blog
--laughing_blog
----__init__.py
----settings.py
----urls.py
----wsgi.py
--manage.py

Change the outer laughing_blog to src ( it is just a container that holds our project).
To make sure that django is successfully installed run server using the command

python manage.py runserver

and if all went well,you should see this page:

Now we are all set to start writing codes.However, there are some configurations and libraries I want to introduce.

Python-decouple

Python Decouple will help us separate sensitive settings from the project .Storing passwords and other sensitive information such as secret key in settings.py is not a great idea and that is why we will use python-decouple. Install it using the following command:

$ pip3 install python-decouple

After successfully installing Python-decouple, create a .env text file on your project's root directory.

Using Python Decouple
.env

This is the file where all the sensitive information are stored.So far,we need to store our secret key and debug status.It should look like this:

SECRET_KEY = your key

DEBUG = True

settings.py

Import config object and place it below import os.

  from decouple import config

This is a snippet from my settings.py.

import os
from decouple import config

Replace the secret key and debug with the following:

SECRET_KEY = config('SECRET_KEY'')
DEBUG = config('DEBUG', cast=bool)

Git

It is important to push your changes to a remote repository. Initialize git using:

 $ git init// Initializes git

Next, we want git to ignore some files with secret information such as the settings, database, etc.Now,create a gitignore file and add the .env, *.pyc ,db.sqlite3 and any other text file in it.To create gitignore use the command:

 $ touch .gitignore

Next, let's add all our changes, commit and push

 git add *    //adds all changes
 git commit -m "initial commit"
 git remote add origin https://github.com/<your username>/laughing_blog.git 
 git push -u origin master

Templates

Html is used to display data on the browser and not python.
Django is a web framework offers a way to display HTML dynamically by using the powerful in-built template tags. Remember HTML is static while python is dynamic.
Django templating enable us to separate the presentation of a document from its data.
We could embed HTML on python code, but it is not a good idea because:

In large projects, it is common to have front-end developers handling HTML and back-end developers handling python. If HTML is hard-coded in python code, it would be difficult for both developers to edit the same file at the same time without interference.
In a single application, you may need to write many lines of HTML codes and troubleshooting the code can be messy if HTML is hard-coded in the python code.

Setting up Django Templates

We want to create the templates directory in the projects' root directory. We can achieve this by modifying the settings.TEMPLATE-DIRS by adding this:

"DIRS": [os.path.join(BASE_DIR, 'templates')],

The DIRS defines a list of directories where Django should look for template source files.

let's create the templates directory and then create a file called base.html to include the project's main html structure

$ mkdir templates
$ cd templates
   base.html

snippet for base.html

    {% load staticfiles %}
    <!Doctype html>
    <html>
    <head>
        <title> Laughing blog</title>
    </head>
    <body>
       {% block content %}{% endblock %}
    </body>
    </html>

How to Serve Static Files in Django

Web applications will need additional files like CSS, scripts, and Images for the application and user-uploaded content such as profiles pictures. These files can be categorized as:

Static files: Resource used by the application such as scripts, images
Media files: These are the content uploaded by the user, say user profile picture. We will talk about this later.

Configuring Static Files

Managing static files in django can be complicated especially if you are not familiar with Django.In settings.py make sure django.contrib.staticfiles in INSTALLED_APPS.In, Most cases,it is already defined.

STATIC_URL

In settings.py you will find this line of code

   STATIC_URL = '/static/'

This is where Django serves static files for a particular app in your project. Django allows you to have several static folders in a project. For this project, we will create just one static folder in the root project directory so let's configure staticfiles-dirs

STATICFILES_DIRS

Let's say you have a project and most apps share static assets like styling or images, or in addition to the static files tied to a particular app, you require additional static assets then defineSTATICFILES_DIRS.

The STATICFILES_DIRS tuple tells Django where to look for static files that are not tied to a particular app.

  STATICFILES_DIRS = [
 os.path.join(BASE_DIR, "static"),
]

In this case, we just told Django to also look for static files in a folder called static in our project's root folder, not just in our apps.

Then create the static directory in the project's root folder

$ mkdir static

Serving Static Files in Development

When django.contrib.staticfiles is installed,running runserver command automatically serve the static files otherwise serve them manually by:

Project's urls.py

from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
     ... 
 ] 
 + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)

STATIC_ROOT

This is the storage folder for every static files after running the collectstatic command.It collects all the static files in one place.
Let us tell django to collect all our static files in a folder called staticfiles

STATIC_ROOT = os.path.join(BASE_DIR, 'staticfiles')

This is very important in production andwhitenoise handles this very well.

Whitenoise

Managing static files in production is even more complicated,at-least it was for me! To manage our static files with less hustle,we will install a 3rd party library whitenoise

To install whitenoise, run:

 pip3 install whitenoise

To use whitenoise in Django.We edit settings.py by adding it to MIDDLEWARE_CLASSESbelow the django SecurityMiddleware

MIDDLEWARE = [
    #'django.middleware.security.SecurityMiddleware',
    'whitenoise.middleware.WhiteNoiseMiddleware',
    ...
]

To enable compression to add the following :

STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'

Conclusion

We created Virtual Environment, Installed Django, installed Python-decouple and created our template and static files directory. We also create gitignore file and added the .env text file we created. Meet you in the next tutorial!

My journey so far as a Software Developer

Cindy Achieng — Wed, 11 Jul 2018 20:57:34 +0000

This is a story about resilience, determination and passion.

It started way back in August 2011 when I got admitted to study Applied Computer Science.To be totally honest,I didn’t know what it was all about.I always saw myself as a mathematician because numbers make sense but missed the chance to study statistics.

At the time I had a mini laptop which I had bought with my HELB money(Higher Education Loans Board).I still remember vividly when my favorite lecturer Oops! not sure if he will appreciate me mentioning his name, but yes kengere kibwage saying, "Give that toy to your baby sister”, and continued talking about common java compilers.(Sir, you shaped my skills)

“what is a compiler?”, I could ask myself but kept silent to mask my ignorance.The class seemed just fine.I felt stupid and my mind told me to quit.you are not creative enough,you don’t get it like the rest.I wish I asked though.

Long story short,I managed to graduate and the impostor syndrome still stuck with me. In my mind, programming was for a certain kind of people, way out of this world.

It was not until I joined Andela bootcamp that my dimensions changed.It was the all female bootcamp edition,in that room was 40 intelligent women including 'myself'.I was inspired.The practicality and relating software to solving real life problems motivated me to go on.I saw a future in solving problems through writing codes,It was not easy but I knew that I wanted to be programmer more than ever that I did quit my job as an IT technician and embarked on this awesome journey to becoming a world class developer as Andeleans like to say it.

I didn't make it to the end of the bootcamp, but something changed.I came out fierce and I was willing to put in the time and effort and nothing could stop me.I was reborn and left behind the misconceptions. Acheng cindy blog was born to document my journey and inspire anyone who wanted to code and didn't know where to start.

I applied for the google Africa Challenge Scholarship in partnership with Udacity and ALC 3.0 and was lucky to be enrolled on Intermediate mobile-web track. The first phase of the scholarship is a 3 month challenge course and only 500 scholars get selected for a nanodegree based on many factors such as participation, completing tasks on time, helping peers among others.

Andela Learning community brought together all learners across Africa ,interacting with each offer, offering emotional support and collaborating (it's what good programmers do).

It has been an intriguing journey learning from some of the best developers including jakearchibald.Knowledge gained during the 3 month challenge course is immeasurable. Have you ever imagined having offline first web apps? Saying goodbye to this:

If you enjoy the game like I do , on the plus side you will still get to play it when you want to .Thanks to the web Technologies Service Worker , Catch API ,Indexed db and fetch API.

The climax was 7DaysofCodeChallenge to create a currency converter app that can work both online and offline.

Today (11th july 2018) , I am lucky again to be among the few 500 scholars to be offered a nanodegree on Udacity and I cant keep quiet.Thank you to everyone who supported me. mckabue and all my peers from the scholarship, andela, udacity and googleafrica

Asanteni sana!

More About ALC

Understanding The Service worker LifeCycle

Cindy Achieng — Thu, 17 May 2018 16:11:10 +0000

The desired user experience is to access information on the internet without interruptions.Unfortunately, even with high speed connectivity we still experience delays.

Let me explain briefly, to get the information we need on our screen we send requests over the network and wait for that response.But what if, just what if the network is busy, or there is a mis-configured proxy somewhere, or you can't access the internet for whatever reason, It could be anything really, and we have to wait for a very long time?

This can be frustrating for most users.

But there is a solution , Building Offline First web Apps.

But How Do achieve Offline Experience ?

To achieve offline experience we need to take care of:

Caching Assets. The browser stores static assets such as html,css,Images.Such that when needed next,they are fetched from the browser cache.Big deal when the network fails.
Storing data on the client side.Html 5 came bearing good news with offline technologies such as Web Storage, indexed databases among others enabling you store data locally on the users device.

Application Cache

Application Cache (Warning: It is being deprecated)
tried resolving the caching by allowing you to specify the set of resources you'd like the browser to cache and enjoy offline browsing,Improved speed by caching resources locally( no need for network trips), and reduced server load (the browser only downloads resources that have changed from the server.)

Useful when the user is disconnected from the network, but did it deliver its promise? read API is A douchbag

Service workers

Service worker is a script (javascript file), that the browser runs in the background, acting like a proxy between application and the network.

Service worker enable applications intercept requests and then modify response,cache those requests to improve performance and provide offline access to cached data which makes it reliable.

Service worker is a type of web worker,runs on a separate thread from the web pages and UI ,enabling them to work without an active browser session.

It has no access to DOM, instead Communicates with the pages through post message ,those pages can then manipulate DOM if needed.

It offers you complete control over your app behavior especially when network is unavailable or slow.

This kind of control is the reason service workers run only on https,to avoid man in the middle attacks,though an exception for local requests-not necessary during development

The intended use is to create offline first experiences
Intercept network requests and handle response based on network availability,
Great benefits online when experiencing slow connection
Allow access to push notification and background sync

Service workers let you handle network requests differently from caching.
Service worker revolves around recent WebAPI

Fetch A fetch event is fired when resource is requested over the network. Perform standard request i.e Offers us the ability to look in the cache before making network requests.Inside a service worker,allows for intercepting requests and then modify the content other than the object requested.Use respondWith() to tell the browser we will handle the requests
Cache API. Cache API is independent from network status or browser cache. It gives you control on how and when to cache.It will not update items in the cache unless explicitly requested.Items in cache do not expire, they are gone when you delete the old cache.

Service worker lifecycle

Registration
Install
Activate

Registration

To use a service worker you must register and define its scope.

Registration will tell a browser the location of the service worker and start installing it on the background.

code to register Service worker placed in sw.js

    navigator.serviceWorker.register('/sw.js').then(function(){
      console.log('Registration worked!');
    }).catch(function() {
      console.log('Registration failed!');
      });
    };

A Service Worker returns a promise.If the Promise resolves,the registration is successful otherwise the registration of the new service worker failed.

Browser Support

Since some browsers don't support service workers yet Is Service Worker Ready,perform a feature check by wrapping the service worker in an if statement .

if (!navigator.serviceWorker) return;
navigator.serviceWorker.register('/sw.js').then(function() {
    console.log('Registration worked!');
}).catch(function() {
    console.log('Registration failed!');
});
};

Scope

The scope define the pages that a service worker controls.The default scope is defined by the location of a service worker script.
This means if you register a service worker at the root folder,it is not necessary to define its scope because it controls all the pages.

navigator.serviceworker.register('/sw.js', {
    scope: '/'
});

The browser wont re-register an existing service worker on call ,but return a promise for existing registration

Installation

Once the browser has registered the service worker,it is immediately downloaded if the browser considers a service worker new either by

The Service Worker has never been registered before. or
You altered the Service Worker Script,byte differences.

install event is fired.

This is a perfect opportunity to fetch for resources that make the application shell from the network and cache them.Ideal for the static resources that our site depends on such as Html,Css,Fonts, Javascript etc.

If there is a previous version of service worker already running, it will still continue to serve pages.
The browser wont let the new service worker take control until the installation phase is complete.Instead it becomes the next version in waiting .

To delay the installation process and determine its success,we pass a promise to event.waitUntill method.

If the promise resolves,the browser knows the Installation has completed.If it fails,well then it is discarded.No cause of alarm because the previous version of the service worker is still working.

This ensures only one version of your script is running at any given time.

self.addEventListener('install', function(event) {
  event.waitUntil(
     );
   });

Activation

Once a service worker has successfully completed the installation phase,it enters activation stage.

In the case of the browser first encounter with a Service Worker, the service worker becomes active upon successfully completing the installation phase and will be able to control new page loads.However,It cannot control pages that were already loaded.To control the already loaded pages,a reload is required.

In the case where the service worker is updated, (Not the browser first time interacting with a service worker ), the newly installed service worker cannot take control until all the pages the previously installed service worker are closed.

Once all pages using the old (previously installed) service worker are gone,the new one activates,firing an activate event.

you can take control of of uncontrolled pages by calling clients.claim() within your service worker once its activated

self.addEventListener('activate', function(event){
});

Since the previous version is out of the way,it is a perfect time to delete the old cache so that all users can have the current version of our site.

gotcha

We change files all the time! When we make changes in our file say a css file, this can become a 'problem' .A page reload wont help much because we still using the cache with the old css.

Despite the changes in our css file,our site remain the same.Meaning, to see the changes, we make a change to the service worker script,you can simply add a comment ,remember its just a byte difference and the browser will consider it as 'new'

Notes

Service workers does not provide cached data for offline use only,but also effective during slow connectivity online.
Service workers are programmable JavaScript "servants/workers"
They can not access DOM directly,instead communicate with the pages it controls through responding to messages via postmessage.
Require sites to be served over https. This is important because they intercepts request and can modify response ,to avoid hijacking by third parties
Stays idle when not in use,restarted when next needed
Make extensive use of promises

Further reading:

Conclusion

Thank you for reading, hope you are ready to give users an amazing experience both online and offline.Let me know if liked the article or if I missed something!

Connect with me on twitter

Introduction To Python Lists

Cindy Achieng — Mon, 30 Apr 2018 13:28:09 +0000

List is the most versatile python data structure and stores an ordered sequence of elements just like your shopping list or to-do-list.In Python, Lists are mutable,meaning that the elements can be altered unlike tuples or even strings.These elements of a list are called items and can be any data type.

Creating Lists in Python

Creating lists in python is quite simple, use square brackets [] and separate items in the list with commas.
A list can be empty or contain any number of items with different data types (integers,float,strings etc.).

mylist = [ ]  #empty list
mylist2 = [1,2]  # list containing 2 items with integers
mylist3 = [1, 2, 'hello']  # list with 3 items,mixed data types,integers and a string

Note : a list can also hold another list as an item,these are called nested lists. as show below.

mylist4 = [['python','php'],[1,2,3]  # a nested list

Accessing items in a list

We can access items in a list by

Indexing.
We use the index operator [ ].Each item in a list has an assigned index value. It is important to Note that the index starts from 0 in python and must be an integer

java python perl ruby c#

0 1 2 3 4

Note :The first item of any non-empty list is [0].
```
Languages = ['java', 'python', 'perl' 'ruby', 'c#' ]   # define a list
print(Languages[0]) # Access the first item of a list at index 0
# Output:java which is the first item on the list.
```
Negative Indexing Python also supports negative indexing.The negative indexing is useful when you want to get the last item in a list because it start accessing a list from the end.

java python perl ruby c#

-5 -4 -3 -2 -1

Note:The last item of any non-empty list is [-1].
```
# define a list 
Languages = ['java', 'python', 'perl' 'ruby', 'c#' ] 
 print(Languages[-1) #Access the last item of a list
# Output:  C#
```

java	python	perl	ruby	c#
0	1	2	3	4

java	python	perl	ruby	c#
-5	-4	-3	-2	-1

length of list

Python has useful in-built functions that work with list.We will discuss them later but for now, len() function help us in returning the total number of elements in a list.

# define a list
languages = ['java', 'python' ,'perl', 'ruby', 'c#']
# print the length of the list
print(len(languages)) 
# output 5

Slicing of a List

Slices are good for getting a subset of items in a list.It uses the slicing operator : (colon) to extract part of the sequence.

Languages = ['java', 'python', 'perl','ruby', 'c#' ] # define a list 
# [:3] slicing everything up to but not including index 3
print(languages[:3])  
#Outputs: ['java', 'python', 'perl' ]

# define a list 
Languages = ['java', 'python', 'perl','ruby', 'c#' ]
# [3:] slicing everything from index 3 to the last item
print(languages[3:])
#Output: ['ruby', 'c#' ]


Languages = ['java', 'python', 'perl','ruby', 'c#' ]
#elements from beginning to end
print(languages[:])
#Output: ['java', 'python', 'perl','ruby', 'c#' ]

# define a list 
Languages = ['java', 'python', 'perl','ruby', 'c#' ]
# elements from 1st to 3rd
print(languages[0:3])
Output # ['java', 'python', 'perl']

How to change/add elements in a list

list.append(item)

The method list.append(item) will add the item at the end of a list.

   # define a list
   languages = ['java', 'python' ,'perl', 'ruby', 'c#']
   # append c
   languages.append('c') 
   print (languages)
  # Output : ['java', 'python', 'perl', 'ruby', 'c#', 'c']

list.insert(i, item)

This method will insert an item at the ith position in a list , shifting elements to the right.

# define a list
languages = ['java', 'python' ,'perl', 'ruby', 'c#']
# insert c
languages.insert( 0, 'php') 
print languages 
# Output :  ['php', 'java', 'python', 'perl', 'ruby', 'c#']

list.extend(items)

The extend method concatenates lists. Note that you do not call extend with multiple arguments;it takes in a second list as its argument.

# define a list
languages = ['java', 'python' ,'perl', 'ruby', 'c#']

Languages2=['c++', 'c'] # define a second list

languages.extend(Languages2)

print(languages)

# Output ['java', 'python', 'perl', 'ruby', 'c#', 'c++', 'c']

extend method does not return any value,instead it modifies the original list by adding the content of the second list

Deleting List Elements

Use the del keywords to delete an item at specific index

single item

 languages = ['java', 'python' ,'perl', 'ruby', 'c#'] # define a list
 del languages[2] # use del keyword
 print(languages)
 # Output removes perl ['java', 'python', 'ruby', 'c#']

Multiple items

 languages = ['java', 'python' ,'perl', 'ruby', 'c#'] # define a list
 del languages[1:3]  #delete Multiple items by slicing
 print(languages)

 # Output : ['java', 'ruby', 'c#']

list.remove(item)

It will search and remove only the first occurrence of an item

Languages = ['java', 'python', 'perl','python','ruby', 'c#' ]
Languages.remove('python')  # the first occurrence of python
print(languages) # outputs ['java', 'perl', 'python', 'ruby', 'c#']

It removes the python after java'.Note that the 'python' after perl is still present

list.pop()

Removes and returns the last item of a list

languages = ['java', 'python' ,'perl', 'ruby', 'c#']

print(languages.pop()) # print c#

print(languages)
# output ['java', 'python', 'perl', 'ruby']

list.pop(i)

Removes and returns the ith item of a list

Languages = ['java', 'python', 'perl','ruby', 'c#' ]
print(languages.pop(1)) # removes  index 1 item
#  Output returns Python

list.index(item)

When lists start to get long, it becomes more difficult for us to count out our items to determine at what index position a certain value is located. We can use list.index(item), to return the index in the list where that item is located.
If there is more than one item with value item, this method will return the first occurrence.

Summary of list methods

	Method Name	Description
1	alist.append(item)	Adds a new item at the end of the list
2	alist.insert(i, item)	Insert item at the ith position shifting other items to the right.
3	alist.extend()	Adds the elements of a second list to the original list
4	del alist[i]	Deletes the item at the ith position,it can also a range of items by the use of slicing
5	alist.remove(item)	Search and remove the first occurrence of an item,does not return a new list and throws an error if not found
6	pop()	Removes and returns the last item of a list
7	pop(i)	Removes and returns the i item of a list
8	alist.index(item)	Returns the index of first occurrence
9	alist.sort()	sort the items of a list
10	alist.reverse()	Reverses a List
11	alist.count(item)	Returns the count of occurrence of an item

Common List Operations

Concatenation

Concatenation uses the + Operator. It Combines lists.

# define a list
languages = ['java', 'python' ,'perl', 'ruby', 'c#']
print(languages +(['c++', 'c']))
# Output:  ['java', 'python' ,'perl', 'ruby', 'c#', c++, c]

Repetition

uses the * Operator. Concatenates a list a repeated number of times

 mylist = ['strings are  cool'] * 2
 print (mylist)
# output:  ['strings are  cool', 'strings are  cool']

Membership

Keyword In is used to test if an item is a member of a list.

languages = ['java', 'python' ,'perl', 'ruby', 'c#']
if 'python' in languages:
    print('right')

Iteration

For Loop is used to iterate through each element on a list with the keyword in.The for loop allows you to to perform an action for every element in the list.

illustration 1

languages = ['java', 'python' ,'perl', 'ruby', 'c#']
for i in languages:
   print(i)

This will print the all the items in the list one per line as shown below:

java
python
perl
ruby
c#

illustration 2

random_sum = [2,7,8,9]
total = 0
for i in random_sum:
    total +=i
print total

The above code will print 26,the sum of all the items of the list.
The for loop requires a variable to hold the items being iterated and the source.

While Loop will first check the condition .If the condition is true,it will keep iterating and terminates the loop once the condition turns false.

languages = ['java', 'python' ,'perl', 'ruby', 'c#']
i = 0
while i <len(languages):
    print(languages[i])
    i = i+3

The above codes will print

java

ruby

Conclusion

Now you know what lists are and how to manipulate them.For further understanding on list, read about list comprehension.

Pipenv, the new Python packaging tool

Cindy Achieng — Mon, 23 Apr 2018 16:40:45 +0000

Clearly,I have been living under a rock but not anymore! I shared an article about setting django environment using pip and virtualenv and M. Floering suggested I check pipenv. You guessed right , yes I did and I am loving it!
Pipenv is the official recommended python packaging tool acccording to pipenv.org.
It is a great tool for managing your project's dependencies as well as install and uninstall packages.

Seems like something pip and virtualenv did just well, but why pipenv?

Think of pipenv as a powerful combination of pip and virtualenv.
Goodbye to manually creating and managing you virtual environments pipenv does it for you!.
Great at managing project's dependencies.Instead of pip's requirements.txt, pipenv creates two files the pipfile for the packages you installed directly and pipfile.lock for the dependencies and the specific version of the packages based on your pipfile.

pipenv workfow

Create virtualenv if doesn't exist already.
Create pipfile to manage the packages installed by you
Finally, creates pipfile.lock to manage dependencies for the packages in pipfile

Let's get started!

We use pip to install pipenv,so ensure you have both python and pip installed.
To check if pip is installed run:

$ pip --version

.. and python:

$ python --version

Installing pipenv

$ pip install --user pipenv

Note: I have used the user installation otherwise just run $ pip install pipenv.

Using pipenv

Now that we have successfully installed pipenv, let's use it. Create the project directory and name it(I will call mine laughing-blog) and then change directory into the project's folder.
Let's Initiate pipenv by using the install command.

$ mkdir laughing-blog //projectname
$ cd laughing-blog
$ pipenv --three install

Note:Specify your python version by using $ pipenv --three for python 3 and $ pipenv --two for python 2.To use an abitrary python version do:
pipenv --python 3.6.4 or just $ pipenv install to use the default python version.

The above code creates a new virtual environment for your project if it doesn’t exist already and the two magic files, Pipfile and Pipfile.lock in your project directory.

Below is a breakdown of the pipenv install output.

virtualenv

Creating a virtualenv for this project…
Using /usr/bin/python3 (3.5.2) to create virtualenv
Virtualenv location: /home/cindy/.local/share/virtualenvs/laughing-blog-FpALE3CM

pipfile

Creating a Pipfile for this project…

Finally, pipfile.lock

Pipfile.lock not found, creating…
Locking [dev-packages] dependencies…
Locking [packages] dependencies…
Updated Pipfile.lock (711973)!
Installing dependencies from Pipfile.lock (711973)…
🐍   ▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉▉ 0/0 — 00:00:00

Activating Virtualenv

To activate virtualenv,simply run:

$ pipenv shell

To exit virtulalenv,run:

$ exit

Managing Packages

To install a package simply run:

$ pipenv  install <packagename>

... and to remove the package in the pipfile run:

$ pipenv  uninstall <packagename>

understanding pipfile and pipfile.lock

Pipfile

Pipfile manages the packages that you install,think of it as an upgrade of requirements.txt.

What makes pipfile superior to requirements.txt

Lets look at a sample of requirements.txt file

Note:simply run pip freeze > requirements.txt to generate the above file

...
certifi==2018.4.16
chardet==3.0.4
defusedxml==0.5.0
Django==2.0.4
django-allauth==0.35.0
idna==2.6
oauthlib==2.0.7
python3-openid==3.1.0
...

You will notice that requirements.txt list all the package we installed , version and the dependencies as well.
pipfile holds the packages we installed and spare the rest to pipfile.lock

pipfile.lock

This is the file that contains the dependencies based on the packages present in Pipfile, the specific version of the packages to be used avoiding the risks of automatically upgrading packages that depend upon each other and breaking your project dependency tree.

If pipfile.lock wasn't created for some reason, you can lock the currently installed packages by running:

$ pipenv lock

pipfile sample

 [packages]
 django = "*"
 django-allauth = "*"

 [requires]
 python_version = "3.5"

pipfile.lock sample

  "django-allauth": {

        "hashes": [

            "sha256:7b31526cccd1c46f9f09acf0703068e8a9669337d29eb065f7e8143c2d897339"

        ],

        "index": "pypi",

        "version": "==0.35.0"

    },

    "idna": {

        "hashes": [

            "sha256:2c6a5de3089009e3da7c5dde64a141dbc8551d5b7f6cf4ed7c2568d0cc520a8f",

            "sha256:8c7309c718f94b3a625cb648ace320157ad16ff131ae0af362c9f21b80ef6ec4"

        ],

        "version": "==2.6"

    },

    "oauthlib": {

        "hashes": [

            "sha256:09d438bcac8f004ae348e721e9d8a7792a9e23cd574634e973173344046287f5",

            "sha256:909665297635fa11fe9914c146d875f2ed41c8c2d78e21a529dd71c0ba756508"

        ],

        "version": "==2.0.7"

    },

    "python3-openid": {

        "hashes": [

            "sha256:0086da6b6ef3161cfe50fb1ee5cceaf2cda1700019fda03c2c5c440ca6abe4fa",

            "sha256:628d365d687e12da12d02c6691170f4451db28d6d68d050007e4a40065868502"

        ],

        "version": "==3.1.0"

    },

Conclusion

Now,you know the definition,advantages and how pipenv functions.And the difference between the two magic files pipfile and pipfile.lock.

This Post was originally posted on achiengcindy.com

Laughing Blog Tutorial Part 2 - Handling Django Forms

Cindy Achieng — Sat, 07 Apr 2018 20:09:37 +0000

Forms provide a rich way of interacting with users. However, the form handling process is complex. Forms accept user input which poses a major security threat. I like to think of it as an unlocked door. You definitely need some security measures. The rule of the thumb is to never trust a user input or worse malicious attackers taking advantage of unsuspecting users. Caution is required to ensure that the user's data is sanitized and field validation is taken into consideration.

From Class

Django has an inbuilt form Class that allows you to easily create forms. You define the fields of your form, specify the layout, display widgets labels, specify how they have to validate user input and the messages associated with invalid fields. It also provides methods for rendering itself in templates using predefined formats such as tables, list or paragraphs.

In this tutorial, we will focus on creating, processing forms and rendering to the template. The task is to create a form that enables users to subscribe to the newsletter app and then send the new subscribers a welcome email.

Creating Newsletter App

In Django, apps are small components used to build projects For an app to be active, add it to the list of settings.INSTALLED_APPS. .Apps perform a specific function and can be reused in various projects.
Since we are creating a newsletter, we will name it a newsletter. Make sure you are in the same directory as manage.py and type:

python manage.py startapp newsletter

When Django creates the newsletter app, it also creates some files and the structure look like this:

 newsletter/
        __init__.py
        admin.py
        apps.py
        migrations/
            __init__.py
        models.py
        tests.py
       views.py

In order to use the app, we must activate it by adding it to settings.INSTALLED_APPS

INSTALLED_APPS = [
        ...
        'newsletter',
    ]

Now our app is installed and activated, let make it do something!

Creating Models

Next, we going to create our model in models.py. For each model defined Django will create a table for it in the database. Let's define our model and name it NewsUsers and give it 3 fields name, email and date_added
write the following code in your newsletter/models.py

from django.db import models
class NewsUsers(models.Model):
    name = models.CharField(max_length = 30)
    email = models.EmailField()
    date_added = models.DateField(auto_now_add=True)
        def __str__(self):
            return self.email

import the models.
Next,I have defined 3 fields:name,email and the date_added

The __str__() method simply tell python to display a human-readable representation of the model

Make and Run Migrations.

python manage.py makemigrations newsletter
python manage.py migrate

Anytime you make changes to the models remember to run migrations

Adding Models to Admin Site

We will create a simple admin site to manage the newsletters users

from django.contrib import admin
from .models import NewsUsers
class NewsletterAdmin(admin.ModelAdmin):
    list_display =('email','date_added',)
admin.site.register(NewsUsers, NewsletterAdmin)

Create a Superuser and runserver

To Interact with the admin site, we must create a user with admin privileges

python manage.py createsuperuser

Then input the credentials. Below is a snippet

Username: laughing-blog
Email address: "email Adress"
Password: 
Password (again):

Run the server and navigate to http://127.0.0.1:8000/admin on the browser.Log in using superuser credentials you created above.

 python manage.py runserver

If you are successful then you will see an interface similar to this:

Note: Django is 'smart' and naturally pluralizes the model In admin

We have NewsUserss and that is not cool! To avoid such a scenario, define meta class in models and set the verbose _name=' singular' and verbose_name_plural.
Your models should look like this

from django.db import models
class NewsUsers(models.Model):
    name = models.CharField(max_length = 30)
    email = models.EmailField()
    date_added = models.DateField(auto_now_add=True)

    class Meta:
        verbose_name = "NewsUser"
        verbose_name_plural = "NewsUsers"
        def __str__(self):
            return self.email

always run migrations after modifying the models

After applying migrations, run the server again and navigate to the admin interface and the extra s should be gone and if you click to add the user, you should be able to add users in the newsletter list

Creating the Newsletter Form

Django has two base classes. The form class and modelForm for creating forms. With the form you get to create standard forms and the ModelForm allows you to build forms from the model's fields.

Depending on your needs you can choose either of the two methods. The standard forms are best in scenarios where the forms do not interact with the database directly.

Forms: Allows you to build Standard Forms

ModelForm: Allows you to build forms from a model by defining fields using the Meta class

In our case, we will create a form using the ModelForm
Create a new file called forms.py in newsletter app.

it's a general practice to create Django forms in a file called forms.py

Let's go ahead and declare the form. To create our ModelForm, import the form class and the model class

from django import forms
from .models import NewsUsers
class NewsUserForm(forms.ModelForm):
    class Meta:
        model = NewsUsers
        fields = ['name', 'email']

Import the forms library
derive from the ModelForm class
declare the Fields we need in the meta section

Handling Django forms in views

It's time for the heavy lifting

from django.shortcuts import render
from .forms import NewsUserForm
from . models import NewsUsers
def newsletter_subscribe(request):
  if request.method == 'POST':
    form = NewsUserForm(request.POST)
    if form.is_valid():
      instance = form.save()
      print('your email is already added to our database')
  else:
    form = NewsUserForm()
  context = {'form':form}
  template = "newsletter/subscribe.html"
  return render(request, template, context)

huh! what is all that?

First things first, let us deal with the importations. Import NewsUserForm from form.py and NewsUsers from models.

The first step in handling forms in Django is to display an empty form to the user. When our view is initially loaded with a GET request, we create a new form instance that will be used to display the empty form in the template.

form = NewsUserForm()

A form may be blank in the case where you creating a new record or may be pre-populated with initial values. At this stage, the form is unbound because it is not associated with any user input although it may have initial values. At this point, the form is unbound

The second step is to check if the user has filled the form and submit it via POST. So, If it is a POST request, we create a new form instance and populate it with data from the request. This process is called binding and the form is said to be bound

if request.method == 'POST':
    form = NewsUserForm(request.POST)

binding allows us to validate data. I mean it's meaningless validating a form with no data right?

Next, Check for form validation and clean the data. The method is_valid(), is used to check if the form is valid. Form validation means the data accepted is as specified when defining the fields. In our case, the name fieldaccepts up to a maximum of 30 characters only, theemail` field must be a valid email and so on. This method will return true if the fields contain valid data or false if invalid throwing errors.

If the form is valid, we clean the data. This means performing sanitization of the input i.e removing invalid characters that might be used to send malicious content to the server.

If we have a valid form as in our case, we process the form. To save the data we call save() method.

"save()method"
It is worth mentioning that only modelForms have this method and not form

Creating newsletter/urls.py

Okay, our data is saved in the database. We now want to create the url that will display the form we just created.
Create a new file in newsletter app and name it urls.py then place the code below:

python from django.urls import path from .views import newsletter_subscribe app_name = 'newsletter' urlpatterns = [ path('subscribe', newsletter_subscribe, name='subscribe'), ]
In the main urls.py include the uurl confi from the newsletter app

Main urls.py

python from django.contrib import admin from django.urls import path,include urlpatterns = [ path('admin/', admin.site.urls), path('newsletter/',include('newsletter.urls' , namespace='newsletter')), ]
To check if the form is being displayed, run the server using the command down below

bash python manage.py runserver

When you navigate to http://127.0.0.1:8000/newsletter on the browser, it will return an error that the template does not exist.

Do not panic just yet, we just need to create the template subscribe.html

Rendering the Form in Templates

Create a templates directory in newsletter app called templates and inside it create another directory called newsletter which will hold the file subscribe.html file. The structure should look like this:

python newsletter templates newsletter subscribe.html

subscribe.html

python {% extends "base.html" %} {% block content %} <form action="{% url 'newsletter:subscribe' %}" method="post"> {% csrf_token %} {{ form.as_p }} <button type="submit">Submit</button> </form> {% endblock %}

you must include cross-site request forgery {% csrf_token %} tag for POST requests

Run the Server again and navigate to http://127.0.0.1:8000/newsletter/subscribe

 $ python manage.py runserver

you should see the form below:

Fill in your name and email and when you hit submit, it saves
check the admin interface and you should see the user you just added.

Recap

So far we have created

Newsletter App
Creating Models
Adding Models to admin site
Creating forms from models
Writing views
Creating urls
Creating Superuser

newsletter/views.py

The above view will work just fine, but some custom validation on the email field is required to ensure that the same email is not used more than once!

try using the same email more than once and it will save

We do not want that to happen right? so let's add some queries to filter the email. If the email already exists we notify the user it already exists else save.
Update your views to look like this:

python from django.shortcuts import render from .forms import NewsUserForm from .models import NewsUsers def newsletter_subscribe(request): if request.method == 'POST': form = NewsUserForm(request.POST) if form.is_valid(): instance = form.save(commit=False) #we dont want to save just yet if NewsUsers.objects.filter(email=instance.email).exists(): print( "your Email Already exists in our database") else: instance.save() print( "your Email has been submitted to our database") else: form = NewsUserForm() context = {'form':form} template = "newsletter/subscribe.html" return render(request, template, context)
Create the model instance with the save() method, but don't save it to the database just yet by calling commit = False

The save() method creates an instance of the model that the form is linked to and saves it to the database.

If called with commit=False, it creates the model instance but doesn't save to the database just yet!

Then, we check if the email exists by using filter before we save. If it exists, we tell the user it already exists else save and display to the user it has been added to our database.

fill the form using a new email and check if it saves. We have added a notification message on the console, so check your console for guidance. Use the same email again and check the console

Now it validates our emails, Great Work!

Sending Emails

Sending Emails with Django is quite simple.All we need is an Email service Provider.You can use gmail or write to the console for testing .Refer to Sending Emails with mailjet because I will be using mailjet

Remember the .env file we created in Project Structure and update it with your smtp credentials

EMAIL_HOST=in-v3.mailjet.com
EMAIL_HOST_USER="Your Username"
EMAIL_HOST_PASSWORD="Your Password"
EMAIL_PORT=587
EMAIL_USE_TLS=True

Replace "Your Username" with the actual username and "Your Password" with your actual password.

settings.py

EMAIL_HOST = config('EMAIL_HOST')
EMAIL_HOST_USER = config('EMAIL_HOST_USER')
EMAIL_HOST_PASSWORD = config('EMAIL_HOST_PASSWORD')
EMAIL_PORT = config('EMAIL_PORT', cast=int)
EMAIL_USE_TLS = config('EMAIL_USE_TLS', cast=bool)
DEFAULT_FROM_EMAIL = config('DEFAULT_FROM_EMAIL')

newsletter/views.py

We want to start sending emails, Import send_mail .

python from django.shortcuts import render from .forms import NewsUserForm from . models import NewsUsers from django.core.mail import send_mail def newsletter_subscribe(request): if request.method == 'POST': form = NewsUserForm(request.POST) if form.is_valid(): instance = form.save(commit=False) #we do not want to save just yet if NewsUsers.objects.filter(email=instance.email).exists(): print('your email Already exists in our database') else: instance.save() print('your email has been submitted to our database') send_mail('Laughing blog tutorial series', 'welcome', 'mail@achiengcindy.com',[instance.email], fail_silently=False) else: form = NewsUserForm() context = {'form':form} template = "newsletter/subscribe.html" return render(request, template, context)

Conclusion

"What is the difference between Bound and Unbound Form?"
A bound form has data associated with it. Unbound form has no data associated with it.It is either empty or contain default values.To check if a form is bound use is_bound() method.In our case form.is_bound() return false while passing even an empty dictionary binds the form.form.is_bound({}) returns true

We have successfully created a basic newsletter app and managed to send a welcome message to new subscriptions.The code for this tutorial is available on Github .
In the next tutorial, we will continue to build our newsletter app by making it more readable! Connect with me on Twitter

This post was originally posted on achiengcindy.com

How to set up Django Environment in Linux for beginners

Cindy Achieng — Wed, 28 Mar 2018 15:53:48 +0000

When I started learning Django, finding a tutorial that had everything I needed was pretty hard So hopefully this tutorial will help you get started!

What you will learn

Create a virtualenv test
Create a sample project called HelloDjango
Create a demo Django app called accounts
Finally configure the settings.py
Let’s dive right in

Prerequisites

Make sure you have the following installed on your computer to follow-through.

You got Linux Os installed (ubuntu, Debian)
Python 3+
Django 2.0
Virtualenv

Django Introduction

According to djangoProject,Django is a python web framework for developers looking for a faster way to build web applications and with less code.Essentially, django is for perfectionists with deadlines

Why Consider Django?

Please refer to the django Documentation for more info.I will give a personal opinion why it is really cool.

Inbuilt Security features such as Cross site request forgery (CSRF) protection.
Great Documentation.
Faster because It has many inbuilt features such as Admin site, Authentication

Linux Installation

I recommend Ubuntu or Debian .For this specific tutorial, I had mint installed because its light and it’s just a personal preference.

Python Installation

Django is a python framework so first ensure you have python installed.The default installed in my Os is 2.7.Check the version of python installed by typing the following command into your shell:

$ python --version
$ python -V  (Mind the capital) 
$ python2 -V

The above outputs

 Python 2.7.12

To check the version of Python3

   $ python3 -V

The above outputs

 Python 3.5.2

In this tutorial ,we are using python 3.5 and higher.Type the command below to check which version 3 is installed

$ python3 --version

You should see something close to this:

Python 3.5.2 (default, Nov 23 2017, 16:37:01) 
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

You can type CTRL+D to exit the interactive shell for now.

Installing Python

If you do not have python installed,use this command:

$ sudo apt-get install python3.5

to install the latest version 3.6 check this tutorial

Setting up Virtual Environment

We could just create a Django application on our computer, but to control the packages unique for our application we will use Virtual Enviroment.Virtual Environment is useful when you want to create isolated environments, each running their own versions of packages.We can even create virtual environments with various python versions ! sounds cool.For this tutorial I am going to use virtualenv.

Virtualenv

We can install virtualenv using python’s package manager pip.use the command:

$ sudo pip install virtualenv

Pip is a useful python package tool that installs, updates, and remove Python packages/libraries used by Django and your other Python apps.Pip come installed with python 2.7+downloaded from python website.You just have to upgrade it using the command:
$ pip install -U pip

You should get something like this if virtualenvis already installed as in my case:

cindy@cindy-Veriton-M290 ~/Desktop $ pip install virtualenv
Requirement already satisfied: virtualenv in /home/cindy/.local/lib/python2.7/site-packages

Create and name virtualenv

Once you have successfully installed virtualenv,next we create the virtualenv test in shell.I like creating my project in documents Folder.So right-click and choose open a terminal here option.Once you open the terminal,type:

$  virtualenv -p python3 test

test is just a name,you could give it any name.The -p points to the python version you want to use ,in the above case python 3

Activate Virtualenv

Now that we have created our virtualenv test,we need to use it to install django and other packages we will need.In order to use our virtualenv,we mustactivate it. change directory to your virtual environment using:

$  cd test

Then once you are inside the virtualenv directory,activate it as shown below:

 $ source bin/activate

By now you should see your virtualenv in brackets

(test)

Below is a sample from my console:

(test) cindy@cindy-Veriton-M290 ~/test $

How to check packages installed in the virtualenv you just created

run:

 $  pip freeze

Django Installation

our virtualenv is running,let's install django .The version of django at the time of writing this article is 2.0.2.

$ pip install django

Run:

  $ pip freeze

your console should list the installed packages

(test) cindy@cindy-Veriton-M290 ~/test $ pip freeze
Django==2.0.2
pytz==2018.3

To specify django version,use:
$ pip install django==.For example to install django 1.11:
$ pip install django==1.11

Creating Django Project

Django is successfully installed so lets create our project Structure! Type this in your console:

django-admin startproject HelloDjango

This command creates a template for our project.

HelloDjango/
    manage.py
    HelloDjango/
        __init__.py
        settings.py
        urls.py
        wsgi.py

The outer HelloDjango is the container holding our project.Its okay to change the name to something else say ‘src'.

The inner HelloDjango contains your site's configurations.I Highly recommend you leave it as it is, at least for now.

Change to project directory

   cd  HelloDjango

The project directory is the outer HelloDjango containing manage.py file.If you changed its name to src,then change directory to src.

cd src

Make Migrations

We need to create a database and Django comes with sqlite .You are free to use any other databases of your choice.But for this tutorial we will use the sqlite. Change directory to the project root and make migrations by typing the command:

$ python manage.py makemigrations
 $ python manage.py migrate

Test development server

To test if your project is working well,go to your project root directory then type this : $ python manage.py runserver

You should see something like this:

Performing system checks...
System check identified no issues (0 silenced).
 February 28, 2018 - 18:58:33
 Django version 2.0.2, using settings 'achieng_website.settings'
 Starting development server at http://127.0.0.1:8000/
 Quit the server with CONTROL-C.

When you go to http://127.0.0.1:8000/,If django was successfully installed you should get a success message"congratulations"

Configuring Settings.py

We will make some changes on our settings.py.This file help us manage our static files such as css,js, and images.First we going to change Templates DIR

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [os.path.join(BASE_DIR, 'templates')],
        'APP_DIRS': True,
        'OPTIONS': {
            'context_processors': [
               ...
            ],
        },
    },
]

Add staticfiles_Dirs as well:

      STATICFILES_DIRS = (
         os.path.join(BASE_DIR, 'static'),
      )

Change time zone

Finally,lets go back to our settings.py and change our timezone.I come from Nairobi so my time zone is Africa/Nairobi.Check yours on: wikipedia

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'Africa/Nairobi'

Creating an App

 python manage.py startapp accounts

Your project structure should be like this:

 accounts/
    __init__.py
    admin.py
    apps.py
    migrations/
        __init__.py
    models.py
    tests.py
   views.py

The app creates modules such as models.py,admin.py,views.py,apps.py. Django implements MVC Pattern

For the app you have just created to be used,add it to INSTALLED_APPS in the settings.py.

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'accounts',
)

This Post was originally posted onachiengBlog