In this post we&#8217;ll talk about the Atom editor which is, as they say, A hackable text editor for the 21st Century. It&#8217;s a [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/install-and-configure-atom-editor-for-python">Install and Configure the Atom Editor for Python</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

In this post we&#8217;ll talk about the <a href="https://atom.io/" target="_blank">Atom</a> editor which is, as they say, A hackable text editor for the 21st Century.
It&#8217;s a really nice, open source and modern editor, with a broad community that provides different and new packages and functionalities. Have you tried it yet?
Here, you&#8217;ll learn how to install it and how to configure it to write Python code. Let&#8217;s start! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />

First, download Atom from the <a href="https://atom.io/" target="_blank">official webpage</a>.
Once installed, if you have a Mac or Windows, you&#8217;ll have two commands available: <pre class="crayon-plain-tag">atom</pre> and <pre class="crayon-plain-tag">apm</pre>. The first one is for opening the Atom editor, and the second one for installing Atom packages. We&#8217;ll see an example of both in the following.
<h2>Edit a Python file and use Atom&#8217;s Autocomplete</h2>
Let&#8217;s start by creating a Python file with:<pre class="crayon-plain-tag">$ atom myfile.py</pre>
This will open the file in Atom, and you&#8217;ll see the containing folder with all its contents on the left sidebar.
In the new file, if you type <pre class="crayon-plain-tag">de</pre>, you&#8217;ll see that it suggests if you want to create a new function. This is because Atom has detected that the file extension is a Python extension.
<img class="aligncenter wp-image-969" src="http://www.marinamele.com/wp-content/uploads/2015/06/creaate-function.png" alt="creaate-function" width="245" height="133" srcset="https://www.marinamele.com/wp-content/uploads/2015/06/creaate-function.png 578w, https://www.marinamele.com/wp-content/uploads/2015/06/creaate-function-300x163.png 300w" sizes="(max-width: 245px) 100vw, 245px" />
If you type the <pre class="crayon-plain-tag">Tab</pre> key, you&#8217;ll see a template for a new function:
<img class="aligncenter wp-image-970" src="http://www.marinamele.com/wp-content/uploads/2015/06/create-function-2.png" alt="create-function-2" width="245" height="113" srcset="https://www.marinamele.com/wp-content/uploads/2015/06/create-function-2.png 566w, https://www.marinamele.com/wp-content/uploads/2015/06/create-function-2-300x138.png 300w" sizes="(max-width: 245px) 100vw, 245px" />
Note that you have the <pre class="crayon-plain-tag">fname</pre> highlighted. This is because you can now type the name of your function and it will replace <pre class="crayon-plain-tag">fname</pre>. Let&#8217;s name our function <pre class="crayon-plain-tag">product</pre>.
Next, if you hit the <pre class="crayon-plain-tag">Tab</pre> key again, the arguments of the function, <pre class="crayon-plain-tag">arg</pre>, will be now selected. Just write <pre class="crayon-plain-tag">x, y</pre>, as we need two different arguments for our function.
Finally, hit the <pre class="crayon-plain-tag">Tab</pre> key again to select the body of our function, <pre class="crayon-plain-tag">pass</pre>, and replace it for our code. The end function should be something like:<pre class="crayon-plain-tag">def product(x,y):
 return x * y</pre>
Also notice the blue circle next to the file name. This means that there are unsaved changes in your current file. You can save it just typing the usual cmd+c (or ctrl+c in windows).
<h2>Linter for Atom</h2>
<a href="https://github.com/AtomLinter/Linter" target="_blank">Linter</a> is an Atom package that provides a top level API so that there is a unification among all the linter atom plugins. This means that all the extra packages that you install, that highlight your code (for example to detect errors) will use a unified method.
To install it, just type:<pre class="crayon-plain-tag">$ apm install linter</pre>
Next, we&#8217;re going to install a Python Linter package, to help us detect errors in our Python code.
This package is called <a href="https://atom.io/packages/linter-flake8" target="_blank">linter-flake8</a> and it&#8217;s an interface to <a href="https://pypi.python.org/pypi/flake8" target="_blank">flake8</a>. To install it, you need to run:<pre class="crayon-plain-tag">$ pip install flake8
$ pip install flake8-docstrings
$ apm install linter-flake8</pre>
You must restart Atom to see the changes. For example, if we add the folling line of code in our file:<pre class="crayon-plain-tag">y = product(a, b)</pre>
without specifying what <pre class="crayon-plain-tag">a</pre> or <pre class="crayon-plain-tag">b</pre> are, we&#8217;ll see the following in our Atom screen:
<img class="aligncenter wp-image-972 " src="http://www.marinamele.com/wp-content/uploads/2015/06/atom-linter-flake8.png" alt="atom-linter-flake8" width="285" height="156" srcset="https://www.marinamele.com/wp-content/uploads/2015/06/atom-linter-flake8.png 534w, https://www.marinamele.com/wp-content/uploads/2015/06/atom-linter-flake8-300x164.png 300w" sizes="(max-width: 285px) 100vw, 285px" />
If you open Atom and you find an error that says<pre class="crayon-plain-tag">The linter binary flake8 cannot be found</pre>
You will need to open the Atom init script (Atom &#8211;&gt; Open your Init Script) and write the following:<pre class="crayon-plain-tag">process.env.PATH = ['/usr/local/bin/', process.env.PATH].join(':')</pre>
Restart Atom the apply these changes. It should work now <img src="https://s.w.org/images/core/emoji/72x72/1f609.png" alt="😉" class="wp-smiley" style="height: 1em; max-height: 1em;" />
Moreover, there are Linters for other languages like HTML, CSS or Javascript. You can find a list <a href="https://atom.io/packages/linter" target="_blank">here</a>.
<h2>Further customisation for Python to follow PEP8</h2>
Here I&#8217;ll show you how you can configure Atom to follow <a href="http://legacy.python.org/dev/peps/pep-0008/" target="_blank">PEP8</a>, the official Python styling guide.
First, open the Atom &#8211;&gt; Preferences window.
1. Use spaces instead of tabs.
Scroll down the Settings panel until you see the Soft Tabs option. Make sure it&#8217;s checked. This setting will convert tabs into spaces automatically.
<img class="aligncenter wp-image-971" src="http://www.marinamele.com/wp-content/uploads/2015/06/atom-settings-1024x950.png" alt="atom-settings" width="418" height="388" srcset="https://www.marinamele.com/wp-content/uploads/2015/06/atom-settings-1024x950.png 1024w, https://www.marinamele.com/wp-content/uploads/2015/06/atom-settings-300x278.png 300w, https://www.marinamele.com/wp-content/uploads/2015/06/atom-settings.png 1166w" sizes="(max-width: 418px) 100vw, 418px" />
2. Set the tab length to 4 spaces
A little below the Soft Tab setting, you&#8221;ll see the Tab Length. Set it to 4 spaces.
3. Automatic PEP8 validation.
If you installed the linter-flake8 package discussed in the previous section, you already have automatic PEP8 validation <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
<h2>Keybindings customisation</h2>
In the same Preferences panel, you can see the Keybindings menu on the left. There, you&#8217;ll find a list of all the default keybindings active in your Atom editor.
However, by default, Atom confirms an autocomplete suggestion with both the Tab and Enter keys. But I only want to use the Tab key.
In order to disable Enter as an autocomplete confirm key, we need to go to the Keybindings menu where you&#8217;ll see a link that says your keymap file. Click on that link to open the keymap.cson file.
There, you need to write:<pre class="crayon-plain-tag"># Disable Enter key for confirming an autocomplete suggestion
'atom-text-editor:not(mini).autocomplete-active':
 'enter': 'editor:newline'</pre>
Save the file and you&#8217;ll see the changes immediately. No need to restart Atom <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
<h2>Other Useful Packages</h2>
<a href="https://atom.io/packages/project-manager" target="_blank">Project manager</a>: a package for saving your projects.
<a href="https://atom.io/packages/atom-django" target="_blank">Atom Django</a>: Django support for Atom
<a href="https://atom.io/packages/minimap" target="_blank">Minimap</a>: Displays a small map of the current file on the right side of your document (like Sublime Text by default).
Do you use other Packages? Write a comment below about them! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2Finstall-and-configure-atom-editor-for-python&amp;linkname=Install%20and%20Configure%20the%20Atom%20Editor%20for%20Python" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2Finstall-and-configure-atom-editor-for-python&amp;linkname=Install%20and%20Configure%20the%20Atom%20Editor%20for%20Python" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2Finstall-and-configure-atom-editor-for-python&amp;linkname=Install%20and%20Configure%20the%20Atom%20Editor%20for%20Python" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2Finstall-and-configure-atom-editor-for-python&amp;linkname=Install%20and%20Configure%20the%20Atom%20Editor%20for%20Python" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2Finstall-and-configure-atom-editor-for-python&amp;linkname=Install%20and%20Configure%20the%20Atom%20Editor%20for%20Python" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/install-and-configure-atom-editor-for-python">Install and Configure the Atom Editor for Python</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

In this post we’ll talk about the Atom editor which is, as they say, A hackable text editor for the 21st Century.
It’s a really nice, open source and modern editor, with a broad community that provides different and new packages and functionalities. Have you tried it yet?
Here, you’ll learn how to install it and how to configure it to write Python code. Let’s start! 

First, download Atom from the official webpage.
Once installed, if you have a Mac or Windows, you’ll have two commands available: 
atom
 and 
apm
. The first one is for opening the Atom editor, and the second one for installing Atom packages. We’ll see an example of both in the following.
Edit a Python file and use Atom’s Autocomplete
Let’s start by creating a Python file with:
$ atom myfile.py

This will open the file in Atom, and you’ll see the containing folder with all its contents on the left sidebar.
In the new file, if you type 
de
, you’ll see that it suggests if you want to create a new function. This is because Atom has detected that the file extension is a Python extension.

If you type the 
Tab
 key, you’ll see a template for a new function:

Note that you have the 
fname
 highlighted. This is because you can now type the name of your function and it will replace 
fname
. Let’s name our function 
product
.
Next, if you hit the 
Tab
 key again, the arguments of the function, 
arg
, will be now selected. Just write 
x, y
, as we need two different arguments for our function.
Finally, hit the 
Tab
 key again to select the body of our function, 
pass
, and replace it for our code. The end function should be something like:
def product(x,y):
    return x * y

Also notice the blue circle next to the file name. This means that there are unsaved changes in your current file. You can save it just typing the usual cmd+c (or ctrl+c in windows).
Linter for Atom
Linter is an Atom package that provides a top level API so that there is a unification among all the linter atom plugins. This means that all the extra packages that you install, that highlight your code (for example to detect errors) will use a unified method.
To install it, just type:
$ apm install linter

Next, we’re going to install a Python Linter package, to help us detect errors in our Python code.
This package is called linter-flake8 and it’s an interface to flake8. To install it, you need to run:
$ pip install flake8
$ pip install flake8-docstrings
$ apm install linter-flake8

You must restart Atom to see the changes. For example, if we add the folling line of code in our file:
y = product(a, b)

without specifying what 
a or 
b are, we’ll see the following in our Atom screen:

If you open Atom and you find an error that says
The linter binary flake8 cannot be found

You will need to open the Atom init script (Atom –> Open your Init Script) and write the following:
process.env.PATH = ['/usr/local/bin/', process.env.PATH].join(':')

Restart Atom the apply these changes. It should work now 
Moreover, there are Linters for other languages like HTML, CSS or Javascript. You can find a list here.
Further customisation for Python to follow PEP8
Here I’ll show you how you can configure Atom to follow PEP8, the official Python styling guide.
First, open the Atom –> Preferences window.
1. Use spaces instead of tabs.
Scroll down the Settings panel until you see the Soft Tabs option. Make sure it’s checked. This setting will convert tabs into spaces automatically.

2. Set the tab length to 4 spaces
A little below the Soft Tab setting, you”ll see the Tab Length. Set it to 4 spaces.
3. Automatic PEP8 validation.
If you installed the linter-flake8 package discussed in the previous section, you already have automatic PEP8 validation 
Keybindings customisation
In the same Preferences panel, you can see the Keybindings menu on the left. There, you’ll find a list of all the default keybindings active in your Atom editor.
However, by default, Atom confirms an autocomplete suggestion with both the Tab and Enter keys. But I only want to use the Tab key.
In order to disable Enter as an autocomplete confirm key, we need to go to the Keybindings menu where you’ll see a link that says your keymap file. Click on that link to open the keymap.cson file.
There, you need to write:
# Disable Enter key for confirming an autocomplete suggestion
'atom-text-editor:not(mini).autocomplete-active':
  'enter': 'editor:newline'

Save the file and you’ll see the changes immediately. No need to restart Atom 
Other Useful Packages
Project manager: a package for saving your projects.
Atom Django: Django support for Atom
Minimap: Displays a small map of the current file on the right side of your document (like Sublime Text by default).
Do you use other Packages? Write a comment below about them! 

The post Install and Configure the Atom Editor for Python appeared first on Marina Mele's site.

In this post we’ll talk about the Atom editor which is, as they say, A hackable text editor for the 21st Century. It’s a […]
The post Install and Configure the Atom Editor for Python appeared first on Marina Mele's site.

Install and Configure the Atom Editor for Python

Imagine what would you do if you could automate all the repetitive and boring activities you perform using internet, like checking every day [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/selenium-tutorial-web-scraping-with-selenium-and-python">Selenium Tutorial: Web Scraping with Selenium and Python</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

Imagine what would you do if you could automate all the repetitive and boring activities you perform using internet, like checking every day the first results of Google for a given keyword, or download a bunch of files from different websites.
In this post you&#8217;ll learn to use Selenium with Python, a Web Scraping tool that simulates a user surfing the Internet. For example, you can use it to automatically look for Google queries and read the results, log in to your social accounts, simulate a user to test your web application, and anything you find in your daily live that it&#8217;s repetitive. The possibilities are infinite! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />

*All the code in this post has been tested with Python 2.7 and Python 3.4.
<h2>Install and use Selenium</h2>
Selenium is a python package that can be installed via pip. I recommend that you install it in a virtual environment (using virtualenv and virtualenvwrapper).
<div class="su-spoiler su-spoiler-style-default su-spoiler-icon-arrow su-spoiler-closed"><div class="su-spoiler-title">No virtualenv or virtualenvwrapper?</div><div class="su-spoiler-content su-clearfix" style="display:none">
Learn how to create one here, for <a href="2014/05/install-python-virtualenv-virtualenvwrapper-mavericks.html" target="_blank">Python 2.7</a> and for <a href="2014/07/install-python3-on-mac-os-x-and-use-virtualenv-and-virtualenvwrapper.html" target="_blank">Python 3</a>. It&#8217;s really useful, once you start using them you won&#8217;t stop! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
Remember that to create the environment in Python 2.7, just type:<pre class="crayon-plain-tag">$ mkvirtualenv selenium_env</pre>
and in Python 3:<pre class="crayon-plain-tag">$ mkvirtualenv --python=/usr/local/bin/python3 selenium_env</pre>
where you should use your own Python 3 path.
Note: if you don&#8217;t want to use a virtual environment, you can still install the packages directly on you computer.
</div></div>
To install selenium, you just need to type:<pre class="crayon-plain-tag">$ pip install selenium</pre>
In this post we are going to initialize a Firefox driver &#8212; you can install it by visiting their <a href="https://www.mozilla.org/ca/firefox/new/" target="_blank">website</a>. However, if you want to work with Chrome or IE, you can find more information <a href="https://code.google.com/p/selenium/wiki/PythonBindings" target="_blank">here</a>.
Once you have Selenium and Firefox installed, create a python file, selenium_script.py. We are going to initialize a browser using Selenium:<pre class="crayon-plain-tag">import time
from selenium import webdriver

driver = webdriver.Firefox()
time.sleep(5)
driver.quit()</pre>
This just initializes a Firefox instance, waits for 5 seconds, and closes it.
Well, that was not very useful&#8230;
How about if we go to Google and search for something?
<h2>Web Scraping Google with Selenium</h2>
Let&#8217;s make a script that loads the main Google search page and makes a query to look for &#8220;Selenium&#8221;:<pre class="crayon-plain-tag">import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException


def init_driver():
 driver = webdriver.Firefox()
 driver.wait = WebDriverWait(driver, 5)
 return driver


def lookup(driver, query):
 driver.get("http://www.google.com")
 try:
 box = driver.wait.until(EC.presence_of_element_located(
 (By.NAME, "q")))
 button = driver.wait.until(EC.element_to_be_clickable(
 (By.NAME, "btnK")))
 box.send_keys(query)
 button.click()
 except TimeoutException:
 print("Box or Button not found in google.com")


if __name__ == "__main__":
 driver = init_driver()
 lookup(driver, "Selenium")
 time.sleep(5)
 driver.quit()</pre>
In the previous code:
<div class="su-list su-list-style-">
<ul>
<li> the function <pre class="crayon-plain-tag">init_driver</pre>  initializes a driver instance.
<ul>
<li> creates the driver instance</li>
<li> adds the <pre class="crayon-plain-tag">WebDriverWait</pre> function as an attribute to the driver, so it can be accessed more easily. This function is used to make the driver wait a certain amount of time (here 5 seconds) for an event to occur.</li>
</ul>
</li>
<li> the function <pre class="crayon-plain-tag">lookup</pre>  takes two arguments: a driver instance and a query lookup (a string).
<ul>
<li> it loads the Google search page</li>
<li> it waits for the query box element to be located and for the button to be clickable. Note that we are using the <pre class="crayon-plain-tag">WebDriverWait</pre> function to wait for these elements to appear.</li>
<li> Both elements are located by name. Other options would be to locate them by <pre class="crayon-plain-tag">ID, XPATH, TAG_NAME, CLASS_NAME, CSS_SELECTOR</pre> , etc (see table below). You can find more information <a href="http://selenium-python.readthedocs.org/en/latest/locating-elements.html" target="_blank">here</a>.</li>
<li> Next, it sends the query into the box element and clicks the search button.</li>
<li> If either the box or button are not located during the time established in the wait function (here, 5 seconds), the <pre class="crayon-plain-tag">TimeoutException</pre>  is raised.</li>
</ul>
</li>
<li> the next statement is a conditional that is true only when the script is run directly. This prevents the next statements to run when this file is imported.
<ul>
<li> it initializes the driver and calls the lookup function to look for &#8220;Selenium&#8221;.</li>
<li> it waits for 5 seconds to see the results and quits the driver</li>
</ul>
</li>
</ul>
</div>
Finally, run your code with:<pre class="crayon-plain-tag">$ python selenium_script.py</pre>
Did it work? If you got an <pre class="crayon-plain-tag">ElementNotVisibleException</pre> , keep reading!
<h2>How to catch an ElementNotVisibleExcpetion</h2>
Google search has recently changed so that initially, Google shows this page:
<a href="http://www.marinamele.com/wp-content/uploads/2015/02/Google-Search.png"><img class="wp-image-707 aligncenter" src="http://www.marinamele.com/wp-content/uploads/2015/02/Google-Search.png" alt="Google-Search" width="335" height="167" srcset="https://www.marinamele.com/wp-content/uploads/2015/02/Google-Search.png 622w, https://www.marinamele.com/wp-content/uploads/2015/02/Google-Search-300x149.png 300w" sizes="(max-width: 335px) 100vw, 335px" /></a>
and when you start writing your query, the search button moves into the upper part of the screen.
<a href="http://www.marinamele.com/wp-content/uploads/2015/02/Query-Google-Search.png"><img class="wp-image-708 aligncenter" src="http://www.marinamele.com/wp-content/uploads/2015/02/Query-Google-Search.png" alt="Query-Google-Search" width="540" height="123" srcset="https://www.marinamele.com/wp-content/uploads/2015/02/Query-Google-Search.png 790w, https://www.marinamele.com/wp-content/uploads/2015/02/Query-Google-Search-300x68.png 300w" sizes="(max-width: 540px) 100vw, 540px" /></a>
Well, actually it doesn&#8217;t move. The old button becomes invisible and the new one visible (and thus the exception when you click the old one: it&#8217;s not visible to click!).
We can update the lookup function in our code so that it catches this exception:<pre class="crayon-plain-tag">from selenium.common.exceptions import ElementNotVisibleException

def lookup(driver, query):
 driver.get("http://www.google.com")
 try:
 box = driver.wait.until(EC.presence_of_element_located(
 (By.NAME, "q")))
 button = driver.wait.until(EC.element_to_be_clickable(
 (By.NAME, "btnK")))
 box.send_keys(query)
 try:
 button.click()
 except ElementNotVisibleException:
 button = driver.wait.until(EC.visibility_of_element_located(
 (By.NAME, "btnG")))
 button.click()
 except TimeoutException:
 print("Box or Button not found in google.com")</pre>
<div class="su-list su-list-style-">
<ul>
<li> the element that raised the exception, <pre class="crayon-plain-tag">button.click()</pre> is inside a try statement.</li>
<li> if the exception is raised, we look for the second button, using <pre class="crayon-plain-tag">visibility_of_element_located</pre> to make sure the element is visible, and then click this button.</li>
<li> if at any time, some element is not found within the 5 second period, the <pre class="crayon-plain-tag">TimeoutException</pre>  is raised and caught by the two end lines of code.</li>
<li> Note that the initial button name is &#8220;btnK&#8221; and the new one is &#8220;btnG&#8221;.</li>
</ul>
</div>
<h2>Method list in Selenium</h2>
To sum up, I&#8217;ve created a table with the main methods used here.
Note: it&#8217;s not a python file &#8212; don&#8217;t try to run/import it <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" /><pre class="crayon-plain-tag"># INITIALIZE DRIVER
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

driver = webdriver.Firefox()
driver.wait = WebDriverWait(driver, 5)


# WAIT FOR ELEMENTS
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC

element = driver.wait.until(
 EC.presence_of_element_located(
 EC.element_to_be_clickable(
 EC.visibility_of_element_located(
 (By.NAME, "name")
 (By.ID, "id")
 (By.LINK_TEXT, "link text")
 (By.PARTIAL_LINK_TEXT, "partial link text")
 (By.TAG_NAME, "tag name")
 (By.CLASS_NAME, "class name")
 (By.CSS_SELECTOR, "css selector")
 (By.XPATH, "xpath")
 )
)


# CATCH EXCEPTIONS
from selenium.common.exceptions import
 TimeoutException
 ElementNotVisibleException</pre>
That&#8217;s all! Hope it was useful! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
Don’t forget to share it with your friends!
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fselenium-tutorial-web-scraping-with-selenium-and-python&amp;linkname=Selenium%20Tutorial%3A%20Web%20Scraping%20with%20Selenium%20and%20Python" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fselenium-tutorial-web-scraping-with-selenium-and-python&amp;linkname=Selenium%20Tutorial%3A%20Web%20Scraping%20with%20Selenium%20and%20Python" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fselenium-tutorial-web-scraping-with-selenium-and-python&amp;linkname=Selenium%20Tutorial%3A%20Web%20Scraping%20with%20Selenium%20and%20Python" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fselenium-tutorial-web-scraping-with-selenium-and-python&amp;linkname=Selenium%20Tutorial%3A%20Web%20Scraping%20with%20Selenium%20and%20Python" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fselenium-tutorial-web-scraping-with-selenium-and-python&amp;linkname=Selenium%20Tutorial%3A%20Web%20Scraping%20with%20Selenium%20and%20Python" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/selenium-tutorial-web-scraping-with-selenium-and-python">Selenium Tutorial: Web Scraping with Selenium and Python</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

Imagine what would you do if you could automate all the repetitive and boring activities you perform using internet, like checking every day the first results of Google for a given keyword, or download a bunch of files from different websites.
In this post you’ll learn to use Selenium with Python, a Web Scraping tool that simulates a user surfing the Internet. For example, you can use it to automatically look for Google queries and read the results, log in to your social accounts, simulate a user to test your web application, and anything you find in your daily live that it’s repetitive. The possibilities are infinite! 

*All the code in this post has been tested with Python 2.7 and Python 3.4.
Install and use Selenium
Selenium is a python package that can be installed via pip. I recommend that you install it in a virtual environment (using virtualenv and virtualenvwrapper).
No virtualenv or virtualenvwrapper?

Learn how to create one here, for Python 2.7 and for Python 3. It’s really useful, once you start using them you won’t stop! 
Remember that to create the environment in Python 2.7, just type:
$ mkvirtualenv selenium_env

and in Python 3:
$ mkvirtualenv --python=/usr/local/bin/python3 selenium_env

where you should use your own Python 3 path.
Note: if you don’t want to use a virtual environment, you can still install the packages directly on you computer.

To install selenium, you just need to type:
$ pip install selenium

In this post we are going to initialize a Firefox driver — you can install it by visiting their website. However, if you want to work with Chrome or IE, you can find more information here.
Once you have Selenium and Firefox installed, create a python file, selenium_script.py. We are going to initialize a browser using Selenium:
import time
from selenium import webdriver

driver = webdriver.Firefox()
time.sleep(5)
driver.quit()

This just initializes a Firefox instance, waits for 5 seconds, and closes it.
Well, that was not very useful…
How about if we go to Google and search for something?
Web Scraping Google with Selenium
Let’s make a script that loads the main Google search page and makes a query to look for “Selenium”:
import time
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from selenium.common.exceptions import TimeoutException


def init_driver():
    driver = webdriver.Firefox()
    driver.wait = WebDriverWait(driver, 5)
    return driver


def lookup(driver, query):
    driver.get("http://www.google.com")
    try:
        box = driver.wait.until(EC.presence_of_element_located(
            (By.NAME, "q")))
        button = driver.wait.until(EC.element_to_be_clickable(
            (By.NAME, "btnK")))
        box.send_keys(query)
        button.click()
    except TimeoutException:
        print("Box or Button not found in google.com")


if __name__ == "__main__":
    driver = init_driver()
    lookup(driver, "Selenium")
    time.sleep(5)
    driver.quit()

In the previous code:
 the function 
init_driver
  initializes a driver instance.

 creates the driver instance
 adds the 
WebDriverWait
 function as an attribute to the driver, so it can be accessed more easily. This function is used to make the driver wait a certain amount of time (here 5 seconds) for an event to occur.
 the function 
lookup
  takes two arguments: a driver instance and a query lookup (a string).

 it loads the Google search page
 it waits for the query box element to be located and for the button to be clickable. Note that we are using the 
WebDriverWait
 function to wait for these elements to appear.
 Both elements are located by name. Other options would be to locate them by 
ID, XPATH, TAG_NAME, CLASS_NAME, CSS_SELECTOR
 , etc (see table below). You can find more information here.
 Next, it sends the query into the box element and clicks the search button.
 If either the box or button are not located during the time established in the wait function (here, 5 seconds), the 
TimeoutException
  is raised.
 the next statement is a conditional that is true only when the script is run directly. This prevents the next statements to run when this file is imported.

 it initializes the driver and calls the lookup function to look for “Selenium”.
 it waits for 5 seconds to see the results and quits the driver
Finally, run your code with:
$ python selenium_script.py

Did it work? If you got an 
ElementNotVisibleException
 , keep reading!
How to catch an ElementNotVisibleExcpetion
Google search has recently changed so that initially, Google shows this page:

and when you start writing your query, the search button moves into the upper part of the screen.

Well, actually it doesn’t move. The old button becomes invisible and the new one visible (and thus the exception when you click the old one: it’s not visible to click!).
We can update the lookup function in our code so that it catches this exception:
from selenium.common.exceptions import ElementNotVisibleException

def lookup(driver, query):
    driver.get("http://www.google.com")
    try:
        box = driver.wait.until(EC.presence_of_element_located(
            (By.NAME, "q")))
        button = driver.wait.until(EC.element_to_be_clickable(
            (By.NAME, "btnK")))
        box.send_keys(query)
        try:
            button.click()
        except ElementNotVisibleException:
            button = driver.wait.until(EC.visibility_of_element_located(
                (By.NAME, "btnG")))
            button.click()
    except TimeoutException:
        print("Box or Button not found in google.com")



 the element that raised the exception, 
button.click()
 is inside a try statement.
 if the exception is raised, we look for the second button, using 
visibility_of_element_located
 to make sure the element is visible, and then click this button.
 if at any time, some element is not found within the 5 second period, the 
TimeoutException
  is raised and caught by the two end lines of code.
 Note that the initial button name is “btnK” and the new one is “btnG”.
Method list in Selenium
To sum up, I’ve created a table with the main methods used here.
Note: it’s not a python file — don’t try to run/import it 
# INITIALIZE DRIVER
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait

driver = webdriver.Firefox()
driver.wait = WebDriverWait(driver, 5)


# WAIT FOR ELEMENTS
from selenium.webdriver.common.by import By
from selenium.webdriver.support import expected_conditions as EC

element = driver.wait.until(
    EC.presence_of_element_located(
    EC.element_to_be_clickable(
    EC.visibility_of_element_located(
        (By.NAME, "name")
        (By.ID, "id")
        (By.LINK_TEXT, "link text")
        (By.PARTIAL_LINK_TEXT, "partial link text")
        (By.TAG_NAME, "tag name")
        (By.CLASS_NAME, "class name")
        (By.CSS_SELECTOR, "css selector")
        (By.XPATH, "xpath")
    )
)


# CATCH EXCEPTIONS
from selenium.common.exceptions import
    TimeoutException
    ElementNotVisibleException

That’s all! Hope it was useful! 
Don’t forget to share it with your friends!

The post Selenium Tutorial: Web Scraping with Selenium and Python appeared first on Marina Mele's site.

Imagine what would you do if you could automate all the repetitive and boring activities you perform using internet, like checking every day […]
The post Selenium Tutorial: Web Scraping with Selenium and Python appeared first on Marina Mele's site.

Selenium Tutorial: Web Scraping with Selenium and Python

When running a complex Python program that takes quite a long time to execute, you might want to improve its execution time. But [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage">7 tips to Time Python scripts and control Memory &#038; CPU usage</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

When running a complex Python program that takes quite a long time to execute, you might want to improve its execution time. But how?
First of all, you need the tools to detect the bottlenecks of your code, i.e. which parts take longer to execute. This way, you can concentrate in speeding these parts first.
And also, you should also control the memory and CPU usage, as it can point you towards new portions of code that could be improved.
Therefore, in this post I&#8217;ll comment on 7 different Python tools that give you some insight about the execution time of your functions and the Memory and CPU usage.

<h2>1. Use a decorator to time your functions</h2>
The simpler way to time a function is to define a decorator that measures the elapsed time in running the function, and prints the result:<pre class="crayon-plain-tag">import time
from functools import wraps


def fn_timer(function):
 @wraps(function)
 def function_timer(*args, **kwargs):
 t0 = time.time()
 result = function(*args, **kwargs)
 t1 = time.time()
 print ("Total time running %s: %s seconds" %
 (function.func_name, str(t1-t0))
 )
 return result
 return function_timer</pre>
Then, you have to add this decorator before the function you want to measure, like<pre class="crayon-plain-tag">@fn_timer
def myfunction(...):
 ...</pre>
For example, let&#8217;s measure how long it takes to sort an array of 2000000 random numbers:<pre class="crayon-plain-tag">@fn_timer
def random_sort(n):
 return sorted([random.random() for i in range(n)])


if __name__ == "__main__":
 random_sort(2000000)</pre>
If you run your script, you should see something like<pre class="crayon-plain-tag">Total time running random_sort: 1.41124916077 seconds</pre>
<h2>2. Using the timeit module</h2>
Anther option is to use the <a href="https://docs.python.org/2/library/timeit.html" target="_blank">timeit</a> module, which gives you an average time measure.
To run it, execute the following command in your terminal:<pre class="crayon-plain-tag">$ python -m timeit -n 4 -r 5 -s "import timing_functions" "timing_functions.random_sort(2000000)"</pre>
where timing_functions is the name of your script.
At the end of the output, you should see something like:<pre class="crayon-plain-tag">4 loops, best of 5: 2.08 sec per loop</pre>
indicating that of 4 times running the test (-n 4), and averaging 5 repetitions on each test (-r 5), the best test result was of 2.08 seconds.
If you don&#8217;t specify the number of tests or repetitions, it defaults to 10 loops and 5 repetitions.
<h2>3. Using the time Unix command</h2>
However, both the decorator and the timeit module are based on Python. This is why the unix time utility may be useful, as it is an external Python measure.
To run the time utility type:<pre class="crayon-plain-tag">$ time -p python timing_functions.py</pre>
which gives the output:<pre class="crayon-plain-tag">Total time running random_sort: 1.3931210041 seconds
real 1.49
user 1.40
sys 0.08</pre>
The first line comes from the decorator we defined, and the other three:
<ul>
<li>Real indicates the total time spent executing the script.</li>
<li>User indicates the amount of time the CPU spent executing the script</li>
<li>Sys indicates the amount of time spent in kernel-level functions.</li>
</ul>
Note: as defined in <a href="http://en.wikipedia.org/wiki/Kernel_(operating_system)" target="_blank">wikipedia</a>, the kernel is a computer program that manages input/output requests from software, and translates them into data processing instructions for the central processing unit (CPU) and other electronic components of a computer.
Therefore, the difference between the real time and the sum of user+sys may indicate the time spent waiting for input/output or that the system is busy running other external tasks.
<h2>4. Using the cProfile module</h2>
If you want to know how much time is spent on each function and method, and how many times each of them is called, you can use the <a href="https://docs.python.org/2/library/profile.html" target="_blank">cProfile</a> module:<pre class="crayon-plain-tag">$ python -m cProfile -s cumulative timing_functions.py</pre>
Now you&#8217;ll see a detailed description of how many times each function in your code is called, and it will be sorted by the cumulative time spent on each one (thanks to the -s cumulative option).
<a href="http://www.marinamele.com/wp-content/uploads/2014/11/cprofile_python.png"><img class="aligncenter wp-image-655 size-full" src="http://www.marinamele.com/wp-content/uploads/2014/11/cprofile_python.png" alt="cprofile_python" width="871" height="825" srcset="https://www.marinamele.com/wp-content/uploads/2014/11/cprofile_python.png 871w, https://www.marinamele.com/wp-content/uploads/2014/11/cprofile_python-300x284.png 300w" sizes="(max-width: 871px) 100vw, 871px" /></a>
You&#8217;ll see that the total amount of time spent on running your script is higher than before. This is the penalty we pay for measuring the time each function takes to execute.
<h2>5. Using line_profiler module</h2>
The <a href="https://github.com/rkern/line_profiler" target="_blank">line_profiler</a> module gives you information about the CPU time spent on each line in your code.
This module has to be installed first, with<pre class="crayon-plain-tag">$ pip install line_profiler</pre>
Next, you need to specify which functions you want to evaluate using the @profile decorator (you don&#8217;t need to import it in your file):<pre class="crayon-plain-tag">@profile
def random_sort2(n):
 l = [random.random() for i in range(n)]
 l.sort()
 return l

if __name__ == "__main__":
 random_sort2(2000000)</pre>
Finally, you can obtain a line by line description of the random_sort2 function by typing:<pre class="crayon-plain-tag">$ kernprof -l -v timing_functions.py</pre>
where the -l flag indicates line-by-line and the -v flag indicates verbose output. With this method, we see that the array construction takes about 44% of the computation time, whereas the sort() method takes the remaining 56%.
<a href="http://www.marinamele.com/wp-content/uploads/2014/11/kernprof_line_profiler.png"><img class="aligncenter wp-image-654 size-full" src="http://www.marinamele.com/wp-content/uploads/2014/11/kernprof_line_profiler.png" alt="kernprof_line_profiler" width="838" height="253" srcset="https://www.marinamele.com/wp-content/uploads/2014/11/kernprof_line_profiler.png 838w, https://www.marinamele.com/wp-content/uploads/2014/11/kernprof_line_profiler-300x90.png 300w" sizes="(max-width: 838px) 100vw, 838px" /></a>
You will also see that due to the time measurements, the script might take longer to execute.
<h2>6. Use the memory_profiler module</h2>
The <a href="https://pypi.python.org/pypi/memory_profiler" target="_blank">memory_profiler</a> module is used to measure memory usage in your code, on a line-by-line basis. However, it can make your code to run much more slower.
Install it with<pre class="crayon-plain-tag">$ pip install memory_profiler</pre>
Also, it is recommended to install the <a href="https://github.com/giampaolo/psutil" target="_blank">psutil</a> package, so that the memory_profile runs faster:<pre class="crayon-plain-tag">$ pip install psutil</pre>
In a similar way as the line_profiler, use the @profile decorator to mark which functions to track. Next, type:<pre class="crayon-plain-tag">$ python -m memory_profiler timing_functions.py</pre>
yes, the previous script takes longer than the 1 or 2 seconds that took before. And if you didn&#8217;t install the psutil package, maybe you&#8217;re still waiting for the results!
<a href="http://www.marinamele.com/wp-content/uploads/2014/11/memory_profiler.png"><img class="aligncenter wp-image-653 size-full" src="http://www.marinamele.com/wp-content/uploads/2014/11/memory_profiler.png" alt="memory_profiler" width="715" height="150" srcset="https://www.marinamele.com/wp-content/uploads/2014/11/memory_profiler.png 715w, https://www.marinamele.com/wp-content/uploads/2014/11/memory_profiler-300x62.png 300w" sizes="(max-width: 715px) 100vw, 715px" /></a>
Looking at the output, note that the memory usage is expressed in terms of MiB, which stand for mebibyte (1MiB = 1.05MB).
<h2>7. Using the guppy package</h2>
Finally, with this package you&#8217;ll be able to track how many objects of each type (str, tuple, dict, etc) are created at each stage in your code.
Install it with<pre class="crayon-plain-tag">$ pip install guppy</pre>
Next, add it in your code as:<pre class="crayon-plain-tag">from guppy import hpy


def random_sort3(n):
 hp = hpy()
 print "Heap at the beginning of the function\n", hp.heap()
 l = [random.random() for i in range(n)]
 l.sort()
 print "Heap at the end of the function\n", hp.heap()
 return l


if __name__ == "__main__":
 random_sort3(2000000)</pre>
And run your code with:<pre class="crayon-plain-tag">$ python timing_functions.py</pre>
You&#8217;ll see something like the following output:
<a href="http://www.marinamele.com/wp-content/uploads/2014/11/Guppy_Python.png"><img class="aligncenter wp-image-652 size-full" src="http://www.marinamele.com/wp-content/uploads/2014/11/Guppy_Python.png" alt="Guppy_Python" width="688" height="533" srcset="https://www.marinamele.com/wp-content/uploads/2014/11/Guppy_Python.png 688w, https://www.marinamele.com/wp-content/uploads/2014/11/Guppy_Python-300x232.png 300w" sizes="(max-width: 688px) 100vw, 688px" /></a>
By placing the heap at different places in your code, you can study the object creation and deletion in the script flow.
If you want to learn more about speeding your Python code, I recommend you the book <a href="http://www.amazon.com/High-Performance-Python-Performant-Programming/dp/1449361595/ref=sr_1_1?ie=UTF8&amp;qid=1416157131&amp;sr=8-1&amp;keywords=high+performance+python&amp;pebp=1416157123265" target="_blank">High Performance Python: Practical Performant Programming for Humans</a>, september 2014.
Hope it was useful! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
Don&#8217;t forget to share it with your friends!
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2F7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage&amp;linkname=7%20tips%20to%20Time%20Python%20scripts%20and%20control%20Memory%20%26%20CPU%20usage" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2F7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage&amp;linkname=7%20tips%20to%20Time%20Python%20scripts%20and%20control%20Memory%20%26%20CPU%20usage" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2F7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage&amp;linkname=7%20tips%20to%20Time%20Python%20scripts%20and%20control%20Memory%20%26%20CPU%20usage" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2F7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage&amp;linkname=7%20tips%20to%20Time%20Python%20scripts%20and%20control%20Memory%20%26%20CPU%20usage" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2F7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage&amp;linkname=7%20tips%20to%20Time%20Python%20scripts%20and%20control%20Memory%20%26%20CPU%20usage" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/7-tips-to-time-python-scripts-and-control-memory-and-cpu-usage">7 tips to Time Python scripts and control Memory &#038; CPU usage</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

When running a complex Python program that takes quite a long time to execute, you might want to improve its execution time. But how?
First of all, you need the tools to detect the bottlenecks of your code, i.e. which parts take longer to execute. This way, you can concentrate in speeding these parts first.
And also, you should also control the memory and CPU usage, as it can point you towards new portions of code that could be improved.
Therefore, in this post I’ll comment on 7 different Python tools that give you some insight about the execution time of your functions and the Memory and CPU usage.

1. Use a decorator to time your functions
The simpler way to time a function is to define a decorator that measures the elapsed time in running the function, and prints the result:
import time
from functools import wraps


def fn_timer(function):
    @wraps(function)
    def function_timer(*args, **kwargs):
        t0 = time.time()
        result = function(*args, **kwargs)
        t1 = time.time()
        print ("Total time running %s: %s seconds" %
               (function.func_name, str(t1-t0))
               )
        return result
    return function_timer

Then, you have to add this decorator before the function you want to measure, like
@fn_timer
def myfunction(...):
    ...

For example, let’s measure how long it takes to sort an array of 2000000 random numbers:
@fn_timer
def random_sort(n):
    return sorted([random.random() for i in range(n)])


if __name__ == "__main__":
 random_sort(2000000)

If you run your script, you should see something like
Total time running random_sort: 1.41124916077 seconds

2. Using the timeit module
Anther option is to use the timeit module, which gives you an average time measure.
To run it, execute the following command in your terminal:
$ python -m timeit -n 4 -r 5 -s "import timing_functions" "timing_functions.random_sort(2000000)"

where timing_functions is the name of your script.
At the end of the output, you should see something like:
4 loops, best of 5: 2.08 sec per loop

indicating that of 4 times running the test (-n 4), and averaging 5 repetitions on each test (-r 5), the best test result was of 2.08 seconds.
If you don’t specify the number of tests or repetitions, it defaults to 10 loops and 5 repetitions.
3. Using the time Unix command
However, both the decorator and the timeit module are based on Python. This is why the unix time utility may be useful, as it is an external Python measure.
To run the time utility type:
$ time -p python timing_functions.py

which gives the output:
Total time running random_sort: 1.3931210041 seconds
real         1.49
user         1.40
sys          0.08

The first line comes from the decorator we defined, and the other three:
Real indicates the total time spent executing the script.
User indicates the amount of time the CPU spent executing the script
Sys indicates the amount of time spent in kernel-level functions.
Note: as defined in wikipedia, the kernel is a computer program that manages input/output requests from software, and translates them into data processing instructions for the central processing unit (CPU) and other electronic components of a computer.
Therefore, the difference between the real time and the sum of user+sys may indicate the time spent waiting for input/output or that the system is busy running other external tasks.
4. Using the cProfile module
If you want to know how much time is spent on each function and method, and how many times each of them is called, you can use the cProfile module:
$ python -m cProfile -s cumulative timing_functions.py

Now you’ll see a detailed description of how many times each function in your code is called, and it will be sorted by the cumulative time spent on each one (thanks to the -s cumulative option).

You’ll see that the total amount of time spent on running your script is higher than before. This is the penalty we pay for measuring the time each function takes to execute.
5. Using line_profiler module
The line_profiler module gives you information about the CPU time spent on each line in your code.
This module has to be installed first, with
$ pip install line_profiler

Next, you need to specify which functions you want to evaluate using the @profile decorator (you don’t need to import it in your file):
@profile
def random_sort2(n):
    l = [random.random() for i in range(n)]
    l.sort()
    return l

if __name__ == "__main__":
    random_sort2(2000000)

Finally, you can obtain a line by line description of the random_sort2 function by typing:
$ kernprof -l -v timing_functions.py

where the -l flag indicates line-by-line and the -v flag indicates verbose output. With this method, we see that the array construction takes about 44% of the computation time, whereas the sort() method takes the remaining 56%.

You will also see that due to the time measurements, the script might take longer to execute.
6. Use the memory_profiler module
The memory_profiler module is used to measure memory usage in your code, on a line-by-line basis. However, it can make your code to run much more slower.
Install it with
$ pip install memory_profiler

Also, it is recommended to install the psutil package, so that the memory_profile runs faster:
$ pip install psutil

In a similar way as the line_profiler, use the @profile decorator to mark which functions to track. Next, type:
$ python -m memory_profiler timing_functions.py

yes, the previous script takes longer than the 1 or 2 seconds that took before. And if you didn’t install the psutil package, maybe you’re still waiting for the results!

Looking at the output, note that the memory usage is expressed in terms of MiB, which stand for mebibyte (1MiB = 1.05MB).
7. Using the guppy package
Finally, with this package you’ll be able to track how many objects of each type (str, tuple, dict, etc) are created at each stage in your code.
Install it with
$ pip install guppy

Next, add it in your code as:
from guppy import hpy


def random_sort3(n):
    hp = hpy()
    print "Heap at the beginning of the function\n", hp.heap()
    l = [random.random() for i in range(n)]
    l.sort()
    print "Heap at the end of the function\n", hp.heap()
    return l


if __name__ == "__main__":
    random_sort3(2000000)

And run your code with:
$ python timing_functions.py

You’ll see something like the following output:

By placing the heap at different places in your code, you can study the object creation and deletion in the script flow.
If you want to learn more about speeding your Python code, I recommend you the book High Performance Python: Practical Performant Programming for Humans, september 2014.
Hope it was useful! 
Don’t forget to share it with your friends!

The post 7 tips to Time Python scripts and control Memory & CPU usage appeared first on Marina Mele's site.

When running a complex Python program that takes quite a long time to execute, you might want to improve its execution time. But […]
The post 7 tips to Time Python scripts and control Memory & CPU usage appeared first on Marina Mele's site.

7 tips to Time Python scripts and control Memory & CPU usage

Google Analytics is a powerful tool that gives you useful insight about the traffic that arrives in your website. But together with Django, you [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/use-the-google-analytics-api-with-django">Use the Google Analytics API with Django</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

Google Analytics is a powerful tool that gives you useful insight about the traffic that arrives in your website. But together with Django, you will be able to retrieve data of your Analytics account and display it to the user, on demand.
In this post you&#8217;ll learn how to put together Django, the oauth2 protocol and the Google Analytics API.

Let&#8217;s Start! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
First of all, you might want to check this post if you&#8217;re not familiar with the <a href="use-google-analytics-api-with-python">Google Analytics API with Python</a>.
Moreover, it assumes that you are familiar with Python and pip, and that you know Django and have a working application. If you navigate into the Python and Django sections of this website you&#8217;ll learn more about those <img src="https://s.w.org/images/core/emoji/72x72/1f609.png" alt="😉" class="wp-smiley" style="height: 1em; max-height: 1em;" />
<h2>Create a Google Application</h2>
I assume you have a working Django application, and that you want to extract data from your Google Analytics account using an existing Project. If you didn&#8217;t create a Project in the Google Developers Console, check <a href="use-google-analytics-api-with-python">this post</a> and create one. Then, come back <img src="https://s.w.org/images/core/emoji/72x72/1f609.png" alt="😉" class="wp-smiley" style="height: 1em; max-height: 1em;" />
But if you have a live Django project, then you need to create a Web application instead. You just need to select Web application as the Application type when you are creating a Client Id in the Credentials section:
<a href="http://www.marinamele.com/wp-content/uploads/2014/11/web_application.png"><img class="wp-image-626 aligncenter" src="http://www.marinamele.com/wp-content/uploads/2014/11/web_application.png" alt="Google Web Application" width="401" height="504" srcset="https://www.marinamele.com/wp-content/uploads/2014/11/web_application.png 477w, https://www.marinamele.com/wp-content/uploads/2014/11/web_application-238x300.png 238w" sizes="(max-width: 401px) 100vw, 401px" /></a>
&nbsp;
In Authorized Javascript origins insert your website domain, and in authorized redirect uris, insert your domain plus /oauth2/oauth2callback. This endpoint will be used by django to catch the oatuh2 response.
After that, you should have the Oauth credentials in a json format.
<div class="su-spoiler su-spoiler-style-default su-spoiler-icon-arrow su-spoiler-closed"><div class="su-spoiler-title">From where should I get the JSON Credential file?</div><div class="su-spoiler-content su-clearfix" style="display:none">
You can obtain it from the Google Developers Console. Go to your project and then select APIs &amp; Oauth credentials &#8211;&gt; Oauth and click on Download JSON.
</div></div>
<h2>Install oauth2 and Google Analytics</h2>
Next, we need to install the oaut2client python package. Activate your virtual environment (if you have one) and type:<pre class="crayon-plain-tag">$ pip install oauth2client</pre>
This will install oauth2client and the following packages: httplib2 (an http library), pyasn1 and pyasn1-modules (to use the ASN.1 protocol), and rsa to use the RSA cryptosystem).
<div class="su-spoiler su-spoiler-style-default su-spoiler-icon-arrow su-spoiler-closed"><div class="su-spoiler-title">No virtual environment?</div><div class="su-spoiler-content su-clearfix" style="display:none">
Learn how to create one here, for <a href="2014/05/install-python-virtualenv-virtualenvwrapper-mavericks.html">Python 2.7</a> and for <a href="2014/07/install-python3-on-mac-os-x-and-use-virtualenv-and-virtualenvwrapper.html">Python 3</a>. It&#8217;s really useful, once you start using them you won&#8217;t stop! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
</div></div>
Don&#8217;t forget to add these packages into the requirements file of your virtual environment.
And also, we will need the API Python Client library:<pre class="crayon-plain-tag">$ pip install python-gflags
$ pip install -U google-api-python-client</pre>
<h2>Create a Django App</h2>
Next, we will create a Django app to manage the Authorization process. Depending on where you want to create the app&#8217;s folder, you will run a slightly different command (this one will create the folder in the current directory):<pre class="crayon-plain-tag">$ python manage.py startapp oauth2_authentication</pre>
Take the client_secrets.json file and save it inside this app, and include this app into your settings.py file, in the INSTALLED_APPS.
Now that we have the app created, we are going to create two different models that will store the Flow and Credential objects.
Edit the models.py inside the oaut2_authentication app and write:<pre class="crayon-plain-tag">from django.db import models
from django.contrib.auth.models import User
from oauth2client.django_orm import FlowField, CredentialsField


class FlowModel(models.Model):
 id = models.ForeignKey(User, primary_key=True)
 flow = FlowField()


class CredentialsModel(models.Model):
 id = models.ForeignKey(User, primary_key=True)
 credential = CredentialsField()</pre>
Next, we&#8217;ll edit the urls of your app. First, open the main urls.py and add the following urlpattern:<pre class="crayon-plain-tag">url(r'^oauth2/', include('oauth2_authentication.urls', namespace="oauth2"))</pre>
And in the oauth2_authentication/urls.py write:<pre class="crayon-plain-tag">from django.conf.urls import patterns, url
from . import views

urlpatterns = patterns(
 '',
 url(r'^$', views.index, name='index'),
 url(r'oauth2callback', views.auth_return, name='return'),
)</pre>
This way, /oauth2 will start the authorization process, and /oauth2/oaut2callback will wait for the authorization response.
But we need to write our views.py first:<pre class="crayon-plain-tag">import os
import httplib2
from oauth2client import xsrfutil
from oauth2client.client import flow_from_clientsecrets
from oauth2client.django_orm import Storage

from apiclient.discovery import build

from django.contrib.auth.decorators import login_required
from django.http import HttpResponseBadRequest
from django.http import HttpResponseRedirect
from django.shortcuts import render
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.urlresolvers import reverse
from django.contrib.sites.models import get_current_site

from .models import CredentialsModel, FlowModel

CLIENT_SECRETS = os.path.join(
 os.path.dirname(__file__), 'client_secrets.json')


def get_accounts_ids(service):
 accounts = service.management().accounts().list().execute()
 ids = []
 if accounts.get('items'):
 for account in accounts['items']:
 ids.append(account['id'])
 return ids


@login_required
def index(request):
 # use the first REDIRECT_URI if you are developing your app
 # locally, and the second in production
 # REDIRECT_URI = 'http://localhost:8000/oauth2/oauth2callback'
 REDIRECT_URI = "https://%s%s" % (
 get_current_site(request).domain, reverse("oauth2:return"))
 FLOW = flow_from_clientsecrets(
 CLIENT_SECRETS,
 scope='https://www.googleapis.com/auth/analytics.readonly',
 redirect_uri=REDIRECT_URI
 )
 user = request.user
 storage = Storage(CredentialsModel, 'id', user, 'credential')
 credential = storage.get()
 if credential is None or credential.invalid is True:
 FLOW.params['state'] = xsrfutil.generate_token(
 settings.SECRET_KEY, user)
 authorize_url = FLOW.step1_get_authorize_url()
 f = FlowModel(id=user, flow=FLOW)
 f.save()
 return HttpResponseRedirect(authorize_url)
 else:
 http = httplib2.Http()
 http = credential.authorize(http)
 service = build('analytics', 'v3', http=http)
 ids = get_account_ids(service)
 return render(
 request, 'oauth2_authentication/main.html', {'ids':ids})


@login_required
def auth_return(request):
 user = request.user
 if not xsrfutil.validate_token(
 settings.SECRET_KEY, request.REQUEST['state'], user):
 return HttpResponseBadRequest()
 FLOW = FlowModel.objects.get(id=user).flow
 credential = FLOW.step2_exchange(request.REQUEST)
 storage = Storage(CredentialsModel, 'id', user, 'credential')
 storage.put(credential)
 return HttpResponseRedirect("/oauth2")</pre>
Note that you have to choose which REDIRECT_URI to use, depending on if you are developing your Django app locally or your app is live on a server.
Inside the FLOW object, we have used the readonly scope, but you could also choose:
https://www.googleapis.com/auth/analytics for writing permissions, and https://www.googleapis.com/auth/analytics.manage.users to view and manage permission of users in the Analytics accounts (<a href="https://developers.google.com/analytics/devguides/config/mgmt/v3/mgmtAuthorization">more info</a>).
And finally, write something in the oauth2_authentication/main.html template, like:<pre class="crayon-plain-tag">Your credentials are up to date! :-)

{% if ids %}
The List of Ids of your Google Analytics accounts are: {{ids}}
{% endif %}</pre>
Now you just need to start the server and visit /oauth2 to start the authentication process. If everything worked correctly, you should see the list of ids of your Google Analytics account.
Note that once you have the Google Analytics service object you can retrieve all the data you want from your accounts. To see more examples, you can check this post: <a href="use-google-analytics-api-with-python">Google Analytics API with Python</a>.
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-the-google-analytics-api-with-django&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Django" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-the-google-analytics-api-with-django&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Django" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-the-google-analytics-api-with-django&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Django" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-the-google-analytics-api-with-django&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Django" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-the-google-analytics-api-with-django&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Django" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/use-the-google-analytics-api-with-django">Use the Google Analytics API with Django</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

Google Analytics is a powerful tool that gives you useful insight about the traffic that arrives in your website. But together with Django, you will be able to retrieve data of your Analytics account and display it to the user, on demand.
In this post you’ll learn how to put together Django, the oauth2 protocol and the Google Analytics API.

Let’s Start! 
First of all, you might want to check this post if you’re not familiar with the Google Analytics API with Python.
Moreover, it assumes that you are familiar with Python and pip, and that you know Django and have a working application. If you navigate into the Python and Django sections of this website you’ll learn more about those 
Create a Google Application
I assume you have a working Django application, and that you want to extract data from your Google Analytics account using an existing Project. If you didn’t create a Project in the Google Developers Console, check this post and create one. Then, come back 
But if you have a live Django project, then you need to create a Web application instead. You just need to select Web application as the Application type when you are creating a Client Id in the Credentials section:

 
In Authorized Javascript origins insert your website domain, and in authorized redirect uris, insert your domain plus /oauth2/oauth2callback. This endpoint will be used by django to catch the oatuh2 response.
After that, you should have the Oauth credentials in a json format.
From where should I get the JSON Credential file?

You can obtain it from the Google Developers Console. Go to your project and then select APIs & Oauth credentials –> Oauth and click on Download JSON.

Install oauth2 and Google Analytics
Next, we need to install the oaut2client python package. Activate your virtual environment (if you have one) and type:
$ pip install oauth2client

This will install oauth2client and the following packages: httplib2 (an http library), pyasn1 and pyasn1-modules (to use the ASN.1 protocol), and rsa to use the RSA cryptosystem).
No virtual environment?

Learn how to create one here, for Python 2.7 and for Python 3. It’s really useful, once you start using them you won’t stop! 

Don’t forget to add these packages into the requirements file of your virtual environment.
And also, we will need the API Python Client library:
$ pip install python-gflags
$ pip install -U google-api-python-client

Create a Django App
Next, we will create a Django app to manage the Authorization process. Depending on where you want to create the app’s folder, you will run a slightly different command (this one will create the folder in the current directory):
$ python manage.py startapp oauth2_authentication

Take the client_secrets.json file and save it inside this app, and include this app into your settings.py file, in the INSTALLED_APPS.
Now that we have the app created, we are going to create two different models that will store the Flow and Credential objects.
Edit the models.py inside the oaut2_authentication app and write:
from django.db import models
from django.contrib.auth.models import User
from oauth2client.django_orm import FlowField, CredentialsField


class FlowModel(models.Model):
    id = models.ForeignKey(User, primary_key=True)
    flow = FlowField()


class CredentialsModel(models.Model):
    id = models.ForeignKey(User, primary_key=True)
    credential = CredentialsField()

Next, we’ll edit the urls of your app. First, open the main urls.py and add the following urlpattern:
url(r'^oauth2/', include('oauth2_authentication.urls', namespace="oauth2"))

And in the oauth2_authentication/urls.py write:
from django.conf.urls import patterns, url
from . import views

urlpatterns = patterns(
    '',
    url(r'^$', views.index, name='index'),
    url(r'oauth2callback', views.auth_return, name='return'),
)

This way, /oauth2 will start the authorization process, and /oauth2/oaut2callback will wait for the authorization response.
But we need to write our views.py first:
import os
import httplib2
from oauth2client import xsrfutil
from oauth2client.client import flow_from_clientsecrets
from oauth2client.django_orm import Storage

from apiclient.discovery import build

from django.contrib.auth.decorators import login_required
from django.http import HttpResponseBadRequest
from django.http import HttpResponseRedirect
from django.shortcuts import render
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.urlresolvers import reverse
from django.contrib.sites.models import get_current_site

from .models import CredentialsModel, FlowModel

CLIENT_SECRETS = os.path.join(
    os.path.dirname(__file__), 'client_secrets.json')


def get_accounts_ids(service):
    accounts = service.management().accounts().list().execute()
    ids = []
    if accounts.get('items'):
        for account in accounts['items']:
            ids.append(account['id'])
    return ids


@login_required
def index(request):
    # use the first REDIRECT_URI if you are developing your app
    # locally, and the second in production
    # REDIRECT_URI = 'http://localhost:8000/oauth2/oauth2callback'
    REDIRECT_URI = "https://%s%s" % (
        get_current_site(request).domain, reverse("oauth2:return"))
    FLOW = flow_from_clientsecrets(
        CLIENT_SECRETS,
        scope='https://www.googleapis.com/auth/analytics.readonly',
        redirect_uri=REDIRECT_URI
    )
    user = request.user
    storage = Storage(CredentialsModel, 'id', user, 'credential')
    credential = storage.get()
    if credential is None or credential.invalid is True:
        FLOW.params['state'] = xsrfutil.generate_token(
            settings.SECRET_KEY, user)
        authorize_url = FLOW.step1_get_authorize_url()
        f = FlowModel(id=user, flow=FLOW)
        f.save()
        return HttpResponseRedirect(authorize_url)
    else:
        http = httplib2.Http()
        http = credential.authorize(http)
        service = build('analytics', 'v3', http=http)
        ids = get_account_ids(service)
        return render(
            request, 'oauth2_authentication/main.html', {'ids':ids})


@login_required
def auth_return(request):
    user = request.user
    if not xsrfutil.validate_token(
            settings.SECRET_KEY, request.REQUEST['state'], user):
        return HttpResponseBadRequest()
    FLOW = FlowModel.objects.get(id=user).flow
    credential = FLOW.step2_exchange(request.REQUEST)
    storage = Storage(CredentialsModel, 'id', user, 'credential')
    storage.put(credential)
    return HttpResponseRedirect("/oauth2")

Note that you have to choose which REDIRECT_URI to use, depending on if you are developing your Django app locally or your app is live on a server.
Inside the FLOW object, we have used the readonly scope, but you could also choose:
https://www.googleapis.com/auth/analytics for writing permissions, and https://www.googleapis.com/auth/analytics.manage.users to view and manage permission of users in the Analytics accounts (more info).
And finally, write something in the oauth2_authentication/main.html template, like:
Your credentials are up to date! :-)

{% if ids %}
The List of Ids of your Google Analytics accounts are: {{ids}}
{% endif %}

Now you just need to start the server and visit /oauth2 to start the authentication process. If everything worked correctly, you should see the list of ids of your Google Analytics account.
Note that once you have the Google Analytics service object you can retrieve all the data you want from your accounts. To see more examples, you can check this post: Google Analytics API with Python.

The post Use the Google Analytics API with Django appeared first on Marina Mele's site.

Google Analytics is a powerful tool that gives you useful insight about the traffic that arrives in your website. But together with Django, you […]
The post Use the Google Analytics API with Django appeared first on Marina Mele's site.

Use the Google Analytics API with Django

Do you want to share a Python script to a friend that doesn&#8217;t have Python installed? In this post you&#8217;ll learn how 🙂 [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/from-a-python-script-to-a-portable-mac-application-with-py2app">From a Python script to a portable Mac application with py2app</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

Do you want to share a Python script to a friend that doesn&#8217;t have Python installed? In this post you&#8217;ll learn how <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
With the py2app package you can compile a Python script and create a portable Mac application. If you&#8217;re using windows, you can check <a href="http://www.py2exe.org/">py2exe</a>.

First of all, we need to install the <a href="https://pythonhosted.org/py2app/">py2app</a> python package. If you have a <a title="Install Python 3 on Mac OS X and use virtualenv and virtualenvwrapper" href="2014/07/install-python3-on-mac-os-x-and-use-virtualenv-and-virtualenvwrapper.html" target="_blank">virtual environment</a>, activate it now <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" /><pre class="crayon-plain-tag">$ pip install -U py2app</pre>
Next, we need to create a setup.py file for our project. In your working directory (the one that contains your Python script), type:<pre class="crayon-plain-tag">$ py2applet --make-setup MyApplication.py</pre>
This will create the file setup.py, which is responsible to tell setuptools how to build your application.
If you edit this file, you should see something like:<pre class="crayon-plain-tag">"""
This is a setup.py script generated by py2applet

Usage:
 python setup.py py2app
"""

from setuptools import setup

APP = ['MyApplication.py']
DATA_FILES = []
OPTIONS = {'argv_emulation': True}

setup(
 app=APP,
 data_files=DATA_FILES,
 options={'py2app': OPTIONS},
 setup_requires=['py2app'],
)</pre>
You should put the name of your starting python script (the one your run to start) in the APP variable.<pre class="crayon-plain-tag">APP = ['application_name.py']</pre>
Also, if your application uses some data files, like a json or a txt file, you should include it in DATA_FILES. For example:<pre class="crayon-plain-tag">DATA_FILES = ['myfile.json', 'myfile.txt']</pre>
Now, we will compile our project in Alias mode. This instructs py2app to build an application that uses the source data files in-place. Note that this means that the application will not be portable to other machines (we&#8217;ll do that next!).<pre class="crayon-plain-tag">$ python setup.py py2app -A</pre>
You will have two new folders inside your working directory: build and dist. The first one is used for building your app (you don&#8217;t have to touch it) and the second one contains your application bundle.
From the working directory, you can run your app using:<pre class="crayon-plain-tag">$ ./dist/application_name.app/Contents/MacOS/application_name</pre>
or you can find your application in Finder and open it from there (you&#8217;ll find it in dist/application_name).
Once your application is running, we are ready to create the stand alone version. First remove the build and dist folders with:<pre class="crayon-plain-tag">$ rm -rf build dist</pre>
and next, build your application:<pre class="crayon-plain-tag">$ python setup.py py2app</pre>
During the building process, I encounter some problems with the ModuleGraph package (remember that this package is installed at the same time as py2app).
If you get one of the following errors:<pre class="crayon-plain-tag">AttributeError: 'ModuleGraph' object has no attribute 'scan_code'
AttributeError: 'ModuleGraph' object has no attribute 'load_module'</pre>
Edit the file where this error ocured (for me, it was inside the virtual environment folder, named myenv), at:<pre class="crayon-plain-tag">myenv/lib/python2.7/site-packages/py2app/recipes/virtualenv.py</pre>
Look for the functions scan_code or load_module and add it an underscore before them, _scan_code and _load_module. Build again your application, it should work now <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
Next, try to run your app, and see if it works.
If you get errors with external packages, like certificates with httplib2 or requests, missing files in selenium webdriver, or import errors that normally work, you&#8217;ll have to fully include these packages in your application. Edit again the setup.py file and add the package that raised the error:<pre class="crayon-plain-tag">OPTIONS = {
 'argv_emulation': True,
 'packages': ['httplib2', 'requests', 'selenium']
 }</pre>
After saving the file, remove again the build and dist directories, build your application and try to run it. Maybe another package failed? Try to include it in the setup file and start over.
However, not all the errors you get will be solved like this, sorry&#8230;!
Once you&#8217;re application runs correctly, and you&#8217;re happy with the results, you can share it by copying the application bundle dist/application_name.
That&#8217;s all! Hope it was useful!
And please, don&#8217;t forget to share it with your friends, they might find it useful too <img src="https://s.w.org/images/core/emoji/72x72/1f609.png" alt="😉" class="wp-smiley" style="height: 1em; max-height: 1em;" />
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2Ffrom-a-python-script-to-a-portable-mac-application-with-py2app&amp;linkname=From%20a%20Python%20script%20to%20a%20portable%20Mac%20application%20with%20py2app" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2Ffrom-a-python-script-to-a-portable-mac-application-with-py2app&amp;linkname=From%20a%20Python%20script%20to%20a%20portable%20Mac%20application%20with%20py2app" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2Ffrom-a-python-script-to-a-portable-mac-application-with-py2app&amp;linkname=From%20a%20Python%20script%20to%20a%20portable%20Mac%20application%20with%20py2app" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2Ffrom-a-python-script-to-a-portable-mac-application-with-py2app&amp;linkname=From%20a%20Python%20script%20to%20a%20portable%20Mac%20application%20with%20py2app" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2Ffrom-a-python-script-to-a-portable-mac-application-with-py2app&amp;linkname=From%20a%20Python%20script%20to%20a%20portable%20Mac%20application%20with%20py2app" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/from-a-python-script-to-a-portable-mac-application-with-py2app">From a Python script to a portable Mac application with py2app</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

Do you want to share a Python script to a friend that doesn’t have Python installed? In this post you’ll learn how 
With the py2app package you can compile a Python script and create a portable Mac application. If you’re using windows, you can check py2exe.

First of all, we need to install the py2app python package. If you have a virtual environment, activate it now 
$ pip install -U py2app

Next, we need to create a setup.py file for our project. In your working directory (the one that contains your Python script), type:
$ py2applet --make-setup MyApplication.py

This will create the file setup.py, which is responsible to tell setuptools how to build your application.
If you edit this file, you should see something like:
"""
This is a setup.py script generated by py2applet

Usage:
    python setup.py py2app
"""

from setuptools import setup

APP = ['MyApplication.py']
DATA_FILES = []
OPTIONS = {'argv_emulation': True}

setup(
    app=APP,
    data_files=DATA_FILES,
    options={'py2app': OPTIONS},
    setup_requires=['py2app'],
)

You should put the name of your starting python script (the one your run to start) in the APP variable.
APP = ['application_name.py']

Also, if your application uses some data files, like a json or a txt file, you should include it in DATA_FILES. For example:
DATA_FILES = ['myfile.json', 'myfile.txt']

Now, we will compile our project in Alias mode. This instructs py2app to build an application that uses the source data files in-place. Note that this means that the application will not be portable to other machines (we’ll do that next!).
$ python setup.py py2app -A

You will have two new folders inside your working directory: build and dist. The first one is used for building your app (you don’t have to touch it) and the second one contains your application bundle.
From the working directory, you can run your app using:
$ ./dist/application_name.app/Contents/MacOS/application_name

or you can find your application in Finder and open it from there (you’ll find it in dist/application_name).
Once your application is running, we are ready to create the stand alone version. First remove the build and dist folders with:
$ rm -rf build dist

and next, build your application:
$ python setup.py py2app

During the building process, I encounter some problems with the ModuleGraph package (remember that this package is installed at the same time as py2app).
If you get one of the following errors:
AttributeError: 'ModuleGraph' object has no attribute 'scan_code'
AttributeError: 'ModuleGraph' object has no attribute 'load_module'

Edit the file where this error ocured (for me, it was inside the virtual environment folder, named myenv), at:
myenv/lib/python2.7/site-packages/py2app/recipes/virtualenv.py

Look for the functions scan_code or load_module and add it an underscore before them, _scan_code and _load_module. Build again your application, it should work now 
Next, try to run your app, and see if it works.
If you get errors with external packages, like certificates with httplib2 or requests, missing files in selenium webdriver, or import errors that normally work, you’ll have to fully include these packages in your application. Edit again the setup.py file and add the package that raised the error:
OPTIONS = {
    'argv_emulation': True,
    'packages': ['httplib2', 'requests', 'selenium']
    }

After saving the file, remove again the build and dist directories, build your application and try to run it. Maybe another package failed? Try to include it in the setup file and start over.
However, not all the errors you get will be solved like this, sorry…!
Once you’re application runs correctly, and you’re happy with the results, you can share it by copying the application bundle dist/application_name.
That’s all! Hope it was useful!
And please, don’t forget to share it with your friends, they might find it useful too 

The post From a Python script to a portable Mac application with py2app appeared first on Marina Mele's site.

Do you want to share a Python script to a friend that doesn’t have Python installed? In this post you’ll learn how 🙂 […]
The post From a Python script to a portable Mac application with py2app appeared first on Marina Mele's site.

From a Python script to a portable Mac application with py2app

When you remove a Django Model or a full app in Django, you have to be careful in how you do it, and [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/how-to-correctly-remove-a-model-or-app-in-django">How to correctly remove a Model or an App in Django</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

When you remove a Django Model or a full app in Django, you have to be careful in how you do it, and how the database will be affected.
Thus, in this short post I&#8217;ll explain what I do when deleting a model or an app.

<h2 style="text-align: left;">Remove the Models from models.py</h2>
Weather you&#8217;re removing a single model or a full app, you should first remove the desired models from the models.py file.
Moreover, you have to make sure that no other file imports these models or uses them (admin.py, views.py, etc).
Next, run South or migrate your database to properly delete these models from your database.
If you are using South, you should run something like
<pre class="crayon-plain-tag">$ python manage.py schemamigration --auto your-app
$ python manage.py migrate your-app</pre>
changing your-app by the name of the app to migrate (where your deleted models were).
<h2>Remove an App from your Django project</h2>
Next, if you are removing an entire app, you can now remove all the files in that app (models.py, views.py, etc). Again, make sure that the other apps don&#8217;t make an import from these files.
And finally, remove this app from your Installed Apps in the settings.py file.
<h2 style="text-align: left;">Remove the remnant ContentTypes</h2>
But after doing all this, you will still have remnants of your models in the ContentType table, like permissions related to the deleted models.
One way to see this is when creating a Group in the Auth app using the admin. When you have to choose the permissions of the group, the box will show permissions that refer to the deleted models.
To clean these tables, we will create the file clean_model_app_remove.py and write the following:
<pre class="crayon-plain-tag">from django.contrib.contenttypes.models import ContentType

# List of deleted apps
DEL_APPS = ["app-you-deleted", "second-app-deleted"]
# List of deleted models (that are not in the app deleted) In lowercase!
DEL_MODELS = ["model-you-deleted", "second-model-deleted"]

ct = ContentType.objects.all().order_by("app_label", "model")

for c in ct:
 if (c.app_label in DEL_APPS) or (c.model in DEL_MODELS):
 print "Deleting Content Type %s %s" % (c.app_label, c.model)
 c.delete()</pre>
where you should write in DEL_APPS the apps that you deleted, and in DEL_MODELS the models that you delete and that do not belong to any of the deleted apps. Moreover, note that the models have to be written in lowercase.
Finally, we just need to run our script with<pre class="crayon-plain-tag">$ python manage.py shell
&gt;&gt;&gt;execfile("clean_model_app_remove.py")</pre>
Great! Now we cleanly removed our apps/models! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fhow-to-correctly-remove-a-model-or-app-in-django&amp;linkname=How%20to%20correctly%20remove%20a%20Model%20or%20an%20App%20in%20Django" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fhow-to-correctly-remove-a-model-or-app-in-django&amp;linkname=How%20to%20correctly%20remove%20a%20Model%20or%20an%20App%20in%20Django" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fhow-to-correctly-remove-a-model-or-app-in-django&amp;linkname=How%20to%20correctly%20remove%20a%20Model%20or%20an%20App%20in%20Django" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fhow-to-correctly-remove-a-model-or-app-in-django&amp;linkname=How%20to%20correctly%20remove%20a%20Model%20or%20an%20App%20in%20Django" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fhow-to-correctly-remove-a-model-or-app-in-django&amp;linkname=How%20to%20correctly%20remove%20a%20Model%20or%20an%20App%20in%20Django" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/how-to-correctly-remove-a-model-or-app-in-django">How to correctly remove a Model or an App in Django</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

When you remove a Django Model or a full app in Django, you have to be careful in how you do it, and how the database will be affected.
Thus, in this short post I’ll explain what I do when deleting a model or an app.

Remove the Models from models.py
Weather you’re removing a single model or a full app, you should first remove the desired models from the models.py file.
Moreover, you have to make sure that no other file imports these models or uses them (admin.py, views.py, etc).
Next, run South or migrate your database to properly delete these models from your database.
If you are using South, you should run something like
$ python manage.py schemamigration --auto your-app
$ python manage.py migrate your-app
Remove an App from your Django project
Next, if you are removing an entire app, you can now remove all the files in that app (models.py, views.py, etc). Again, make sure that the other apps don’t make an import from these files.
And finally, remove this app from your Installed Apps in the settings.py file.
Remove the remnant ContentTypes
But after doing all this, you will still have remnants of your models in the ContentType table, like permissions related to the deleted models.
One way to see this is when creating a Group in the Auth app using the admin. When you have to choose the permissions of the group, the box will show permissions that refer to the deleted models.
To clean these tables, we will create the file clean_model_app_remove.py and write the following:
from django.contrib.contenttypes.models import ContentType

# List of deleted apps
DEL_APPS = ["app-you-deleted", "second-app-deleted"]
# List of deleted models (that are not in the app deleted) In lowercase!
DEL_MODELS = ["model-you-deleted", "second-model-deleted"]

ct = ContentType.objects.all().order_by("app_label", "model")

for c in ct:
    if (c.app_label in DEL_APPS) or (c.model in DEL_MODELS):
        print "Deleting Content Type %s %s" % (c.app_label, c.model)
        c.delete()
DEL_APPS the apps that you deleted, and in DEL_MODELS the models that you delete and that do not belong to any of the deleted apps. Moreover, note that the models have to be written in lowercase.
Finally, we just need to run our script with
$ python manage.py shell
>>>execfile("clean_model_app_remove.py")

Great! Now we cleanly removed our apps/models! 

The post How to correctly remove a Model or an App in Django appeared first on Marina Mele's site.

When you remove a Django Model or a full app in Django, you have to be careful in how you do it, and […]
The post How to correctly remove a Model or an App in Django appeared first on Marina Mele's site.

How to correctly remove a Model or an App in Django

In this post you will learn to create a Python script that allows users to enter its Google Analytics account and get information from [&#8230;]
The post <a rel="nofollow" href="https://www.marinamele.com/use-google-analytics-api-with-python">Use the Google Analytics API with Python</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

<img class="wp-image-523 alignleft" src="http://www.marinamele.com/wp-content/uploads/2014/10/python_google_analytics-300x294.jpg" alt="Python and Google Analytics" width="214" height="210" srcset="https://www.marinamele.com/wp-content/uploads/2014/10/python_google_analytics-300x294.jpg 300w, https://www.marinamele.com/wp-content/uploads/2014/10/python_google_analytics-1024x1004.jpg 1024w, https://www.marinamele.com/wp-content/uploads/2014/10/python_google_analytics-75x75.jpg 75w" sizes="(max-width: 214px) 100vw, 214px" />In this post you will learn to create a Python script that allows users to enter its Google Analytics account and get information from there.
In order to do that, we will create a Project in the Google Developers Console and authorize it to use the Analytics API.
Next, we will use the Oauth 2.0 protocol to allow users to connect to their Analytics account through our Project.
And finally, we will retrieve the number of sessions of our view, segmented by traffic source.
Let&#8217;s start!

<h2>Create a Project in Google Developers Console</h2>
Go to the <a href="https://console.developers.google.com" target="_blank">Google Developers Console</a> and login with your account.
Click on Create Project and write your Project name and choose (if you want) your project ID.
Next, on your new project menu, go to APIs &amp; auth &#8211;&gt; Credentials. Here, in the Oauth section, click on Create new Client ID.
In this case, as we are creating a script that will run on our computer, we will choose Installed application as the application type, and Other as the installed application type.
<a href="http://www.marinamele.com/wp-content/uploads/2014/10/client_id.png"><img class="aligncenter wp-image-472" src="http://www.marinamele.com/wp-content/uploads/2014/10/client_id-300x273.png" alt="Create a Project for Google Analytics API" width="455" height="414" srcset="https://www.marinamele.com/wp-content/uploads/2014/10/client_id-300x273.png 300w, https://www.marinamele.com/wp-content/uploads/2014/10/client_id.png 457w" sizes="(max-width: 455px) 100vw, 455px" /></a>
Finally, click on Create Client ID.
You will see, next to the OAuth section, the credentials for your project, which contain your Client ID, the Client Secret, and the redirect URIS. Click on Download JSON to download them, and save the file as client_secrets.json.
From here, go to APIs &amp; auth &#8211;&gt; Consent screen and personalize the message that your users will see when requesting access to their accounts.
Next, we need to activate the Goolge Analytics API in your Project. Go to APIs &amp; auth &#8211;&gt; APIs and look for the Analytics API. You just need to activate it by clicking at the OFF button on the right.
Ok! now that we have our Project created we can move on to our Python script!
<h2>The Google API Python client library</h2>
In order to use the Analytics API with Python, we will use the Google API Python Client library. You can install it in your working environment using pip (how? learn to <a href="2014/05/install-python-virtualenv-virtualenvwrapper-mavericks.html" target="_blank">install Python, virtualenv and virtualenvwrapper </a>to work with virtual environments).<pre class="crayon-plain-tag">$ pip install python-gflags
$ pip install -U google-api-python-client</pre>
We also install the python-gflags library, which we will use latter in the code.
Next create the file analytics_service_object.py in your working directory (where client_secrets.json is located). This file will create an authorized Analytics Service object, used to interact with the user&#8217;s analytics accounts.<pre class="crayon-plain-tag">import httplib2
from apiclient.discovery import build
from oauth2client.client import flow_from_clientsecrets
from oauth2client.file import Storage
from oauth2client import tools
import argparse

CLIENT_SECRETS = 'client_secrets.json'

# The Flow object to be used if we need to authenticate.
FLOW = flow_from_clientsecrets(
 CLIENT_SECRETS,
 scope='https://www.googleapis.com/auth/analytics.readonly',
 message='%s is missing' % CLIENT_SECRETS
 )

# A file to store the access token
TOKEN_FILE_NAME = 'credentials.dat'


def prepare_credentials():
 parser = argparse.ArgumentParser(parents=[tools.argparser])
 flags = parser.parse_args()
 # Retrieve existing credendials
 storage = Storage(TOKEN_FILE_NAME)
 credentials = storage.get()
 # If no credentials exist, we create new ones
 if credentials is None or credentials.invalid:
 credentials = tools.run_flow(FLOW, storage, flags)
 return credentials


def initialize_service():
 # Creates an http object and authorize it using
 # the function prepare_creadentials()
 http = httplib2.Http()
 credentials = prepare_credentials()
 http = credentials.authorize(http)
 # Build the Analytics Service Object with the authorized http object
 return build('analytics', 'v3', http=http)

if __name__ == '__main__':
 service = initialize_service()</pre>
In the previous script:
<ul>
<li>CLIENT_SECRETS loads your credentials from the client_secrets.json file.</li>
<li>TOKEN_FILE_NAME is the file where the user-specific credentials will be stored (this file also includes some project-specific credentials).</li>
<li>the prepare_credentials() function tries to load the credentials from the TOKEN_FILE_NAME and if they don&#8217;t exist it creates new ones using the run_flow function.</li>
<li>the initialize_service() function uses the credentials to build an authorized Analytics Service object, and returns this object.</li>
</ul>
Now, when you type<pre class="crayon-plain-tag">$ python analytics_service_object.py</pre>
you will see, in a browser window, the consent screen you customized before. This means that your Project is asking your permission to access your Analytics account through the API. After clicking yes, your new credentials will be stored in TOKEN_FILE_NAME so that you won&#8217;t have to enter them again (except when the access_token expires).
<h2>The Analytics Service object</h2>
Once we have an authorized Analytics service object, we can use it to retrieve all the data in the user&#8217;s analytics accounts.
For example, to get a list of all the existing accounts of the user, just type:<pre class="crayon-plain-tag">accounts = service.management().accounts().list().execute()</pre>
This will give you a dictionary containing the following keys:
<ul>
<li>username: the email address of the user</li>
<li>kind: analytics#accounts</li>
<li>items: a list of the user&#8217;s accounts.</li>
<li>totalResults</li>
<li>itemsPerPage</li>
<li>startIndex</li>
</ul>
As we will see, this is a common structure when getting data from analytics, even when we ask for properties or views instead of accounts (the returned object has the same keys).
Moreover, the items value is a list of accounts, each of which is in turn a dictionary with keys:
<ul>
<li>id: your account id</li>
<li>kind: analytics#account</li>
<li>childLink</li>
<li>created</li>
<li>permissions</li>
<li>selfLink</li>
<li>updated</li>
</ul>
Therefore, you can get a list of your users accounts with:<pre class="crayon-plain-tag">def get_accounts_ids(service):
 accounts = service.management().accounts().list().execute()
 ids = []
 if accounts.get('items'):
 for account in accounts['items']:
 ids.append(account['id'])
 return ids</pre>
You can also see the account ids in the <a href="https://www.google.com/analytics/web" target="_blank">Google Analytics web</a>. You have to go to the Admin tab, and open the top-left drop down menu. There, your different accounts will be displayed, with their id on the right.
But as you may know, each Account can have multiple Properties, each of which has a different tracking code. To obtain a list of the Properties inside the Account with an id of account_id, you can use:<pre class="crayon-plain-tag">webproperties = service.management().webproperties().list(
 accountId=account_id).execute()</pre>
where webproperties is a dictionary with the same keys as accounts, but in which
<ul>
<li>kind: analytics#webproperties</li>
<li>items: list of web properties for this account</li>
</ul>
Again, each web property is a dictionary that contains the keys:
<ul>
<li>id: the web property id</li>
<li>kind: analytics#webproperty</li>
</ul>
and many more (you can print the webproperties object to see its keys).
You&#8217;ll see that the web property id is the tracking code of this property, which you can also obtain in the Google Analytics Admin tab.
But there is another level! Inside each Property there can be multiple views! You can obtain a list of views (or profiles) of each web property with:<pre class="crayon-plain-tag">profiles = service.management().profiles().list(
 accountId=firstAccountId,
 webPropertyId=firstWebpropertyId).execute()</pre>
The profiles dictionary contains the same keys as accounts and webproperties, but with
<ul>
<li>kind: analytics#profiles</li>
<li>items: list of profiles for this account and web property</li>
</ul>
and each profile has:
<ul>
<li>id: the profile id</li>
<li>kind: analytics#profile</li>
<li>name: the profile name</li>
</ul>
<h2>Get the number of Sessions of a Google Analytics View</h2>
Now that we know how to get information about our accounts, properties and views, let&#8217;s obtain the number of sessions of a view during a period of time.
Create the file get_sessions.py and write:<pre class="crayon-plain-tag">from analytics_service_object import initialize_service


def get_sessions(service, profile_id, start_date, end_date):
 ids = "ga:" + profile_id
 metrics = "ga:sessions"
 data = service.data().ga().get(
 ids=ids, start_date=start_date, end_date=end_date, metrics=metrics
 ).execute()
 return data["totalsForAllResults"][metrics]


if __name__ == '__main__':
 service = initialize_service()
 profile_id = "your_profile_id"
 print get_sessions(service, profile_id, "2014-09-01", "2014-09-30")</pre>
Note: you have to add your view id in &#8220;your_profile_id&#8221;, and then, run this script with:<pre class="crayon-plain-tag">$ python get_sessions.py</pre>
Check all the functionalities of the <a href="https://developers.google.com/resources/api-libraries/documentation/analytics/v3/python/latest/analytics_v3.data.ga.html" target="_blank">service.data().ga().get()</a> method, and retrieve all the data you want form your view!
<h2>Get the number of Sessions for each traffic source</h2>
Obtaining the number of sessions for each traffic source (i.e. organic, referral, social, direct, email and other) is a little bit trickier. You have to work with filters in order to segment your data.
Here&#8217;s a little script that does this, thanks to Michael for the update <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" /><pre class="crayon-plain-tag">from analytics_service_object import initialize_service

def get_source_group(service, profile_id, start_date, end_date):
 ids = "ga:" + profile_id
 metrics = "ga:sessions"
 dimensions = "ga:channelGrouping"
 data = service.data().ga().get(
 ids=ids, start_date=start_date, end_date=end_date, metrics=metrics,
 dimensions=dimensions).execute()
 return dict(
 data["rows"] + [["total", data["totalsForAllResults"][metrics]]])


if __name__ == '__main__':
 service = initialize_service()
 profile_id = "your_profile_id"
 start_date = "2014-09-01"
 end_date = "2014-09-30"
 data = get_source_group(service, profile_id, start_date, end_date)
 for key, value in data.iteritems():
 print key, value</pre>
Again, add your view&#8217;s id in &#8220;your_profile_id&#8221;, and change the start_date and end_date to match the time interval you want.
After running this script, you&#8217;ll see the desired information in your terminal.
Another solution to get the number of sessions by traffic source, less optimized but instructive, is to use filter instead of dimensions:<pre class="crayon-plain-tag">from analytics_service_object import initialize_service


not_source_filters = {
 "social": "ga:hasSocialSourceReferral==No",
 "organic": "ga:medium!=organic",
 "direct": "ga:source!=(direct),ga:medium!=(none);ga:medium!=(not set)",
 "email": "ga:medium!=email",
 "referral": "ga:medium!=referral,ga:hasSocialSourceReferral!=No"
}

source_filters = {
 "social": "ga:hasSocialSourceReferral==Yes",
 "organic": "ga:medium==organic",
 "direct": "ga:source==(direct);ga:medium==(none),ga:medium==(not set)",
 "email": "ga:medium==email",
 "referral": "ga:medium==referral;ga:hasSocialSourceReferral==No",
 "other": "%s;%s;%s;%s;%s" % (
 not_source_filters["social"], not_source_filters["organic"],
 not_source_filters["direct"], not_source_filters["email"],
 not_source_filters["referral"])
}


def get_source_sessions(service, profile_id, start_date, end_date, source):
 ids = "ga:" + profile_id
 metrics = "ga:sessions"
 filters = source_filters[source]
 data = service.data().ga().get(
 ids=ids, start_date=start_date, end_date=end_date, metrics=metrics,
 filters=filters).execute()
 return data["totalsForAllResults"][metrics]


if __name__ == '__main__':
 service = initialize_service()
 profile_id = "your_profile_id"
 start_date = "2014-09-01"
 end_date = "2014-09-30"
 for source in ["social", "organic", "direct", "email", "referral", "other"]:
 print source, get_source_sessions(
 service, profile_id, start_date, end_date, source)</pre>
Again, add your view&#8217;s id in &#8220;your_profile_id&#8221;, and change the start_date and end_date to match the time interval you want.
After running this script, you&#8217;ll see the desired information in your terminal.
Some information you may find useful when working with filters:
<ul>
<li>, means OR</li>
<li>; means AND</li>
<li>== means exact match</li>
<li>!= means does not match</li>
<li>=@ means contains substring</li>
<li>!@ means does not contain substring</li>
<li>learn more in the <a href="https://developers.google.com/analytics/devguides/reporting/core/v3/reference" target="_blank">Google Reference Guide</a></li>
</ul>
That&#8217;s all for today! <img src="https://s.w.org/images/core/emoji/72x72/1f642.png" alt="🙂" class="wp-smiley" style="height: 1em; max-height: 1em;" />
Please, +1 if was useful and share it with your friends! Thaaanks!
<a class="a2a_button_google_plus" href="http://www.addtoany.com/add_to/google_plus?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-google-analytics-api-with-python&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Python" title="Google+" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/google_plus.png" width="16" height="16" alt="Google+"/></a><a class="a2a_button_twitter" href="http://www.addtoany.com/add_to/twitter?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-google-analytics-api-with-python&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Python" title="Twitter" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/twitter.png" width="16" height="16" alt="Twitter"/></a><a class="a2a_button_linkedin" href="http://www.addtoany.com/add_to/linkedin?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-google-analytics-api-with-python&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Python" title="LinkedIn" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/linkedin.png" width="16" height="16" alt="LinkedIn"/></a><a class="a2a_button_facebook" href="http://www.addtoany.com/add_to/facebook?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-google-analytics-api-with-python&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Python" title="Facebook" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/facebook.png" width="16" height="16" alt="Facebook"/></a><a class="a2a_button_reddit" href="http://www.addtoany.com/add_to/reddit?linkurl=https%3A%2F%2Fwww.marinamele.com%2Fuse-google-analytics-api-with-python&amp;linkname=Use%20the%20Google%20Analytics%20API%20with%20Python" title="Reddit" rel="nofollow" target="_blank"><img src="http://www.marinamele.com/wp-content/plugins/add-to-any/icons/reddit.png" width="16" height="16" alt="Reddit"/></a>The post <a rel="nofollow" href="https://www.marinamele.com/use-google-analytics-api-with-python">Use the Google Analytics API with Python</a> appeared first on <a rel="nofollow" href="https://www.marinamele.com">Marina Mele&#039;s site</a>.

In this post you will learn to create a Python script that allows users to enter its Google Analytics account and get information from there.
In order to do that, we will create a Project in the Google Developers Console and authorize it to use the Analytics API.
Next, we will use the Oauth 2.0 protocol to allow users to connect to their Analytics account through our Project.
And finally, we will retrieve the number of sessions of our view, segmented by traffic source.
Let’s start!

Create a Project in Google Developers Console
Go to the Google Developers Console and login with your account.
Click on Create Project and write your Project name and choose (if you want) your project ID.
Next, on your new project menu, go to APIs & auth –> Credentials. Here, in the Oauth section, click on Create new Client ID.
In this case, as we are creating a script that will run on our computer, we will choose Installed application as the application type, and Other as the installed application type.

Finally, click on Create Client ID.
You will see, next to the OAuth section, the credentials for your project, which contain your Client ID, the Client Secret, and the redirect URIS. Click on Download JSON to download them, and save the file as client_secrets.json.
From here, go to APIs & auth –> Consent screen and personalize the message that your users will see when requesting access to their accounts.
Next, we need to activate the Goolge Analytics API in your Project. Go to APIs & auth –> APIs and look for the Analytics API. You just need to activate it by clicking at the OFF button on the right.
Ok! now that we have our Project created we can move on to our Python script!
The Google API Python client library
In order to use the Analytics API with Python, we will use the Google API Python Client library. You can install it in your working environment using pip (how? learn to install Python, virtualenv and virtualenvwrapper to work with virtual environments).
$ pip install python-gflags
$ pip install -U google-api-python-client

We also install the python-gflags library, which we will use latter in the code.
Next create the file analytics_service_object.py in your working directory (where client_secrets.json is located). This file will create an authorized Analytics Service object, used to interact with the user’s analytics accounts.
import httplib2
from apiclient.discovery import build
from oauth2client.client import flow_from_clientsecrets
from oauth2client.file import Storage
from oauth2client import tools
import argparse

CLIENT_SECRETS = 'client_secrets.json'

# The Flow object to be used if we need to authenticate.
FLOW = flow_from_clientsecrets(
    CLIENT_SECRETS,
    scope='https://www.googleapis.com/auth/analytics.readonly',
    message='%s is missing' % CLIENT_SECRETS
    )

# A file to store the access token
TOKEN_FILE_NAME = 'credentials.dat'


def prepare_credentials():
    parser = argparse.ArgumentParser(parents=[tools.argparser])
    flags = parser.parse_args()
    # Retrieve existing credendials
    storage = Storage(TOKEN_FILE_NAME)
    credentials = storage.get()
    # If no credentials exist, we create new ones
    if credentials is None or credentials.invalid:
        credentials = tools.run_flow(FLOW, storage, flags)
    return credentials


def initialize_service():
    # Creates an http object and authorize it using
    # the function prepare_creadentials()
    http = httplib2.Http()
    credentials = prepare_credentials()
    http = credentials.authorize(http)
    # Build the Analytics Service Object with the authorized http object
    return build('analytics', 'v3', http=http)

if __name__ == '__main__':
    service = initialize_service()

In the previous script:
CLIENT_SECRETS loads your credentials from the client_secrets.json file.
TOKEN_FILE_NAME is the file where the user-specific credentials will be stored (this file also includes some project-specific credentials).
the prepare_credentials() function tries to load the credentials from the TOKEN_FILE_NAME and if they don’t exist it creates new ones using the run_flow function.
the initialize_service() function uses the credentials to build an authorized Analytics Service object, and returns this object.
Now, when you type
$ python analytics_service_object.py

you will see, in a browser window, the consent screen you customized before. This means that your Project is asking your permission to access your Analytics account through the API. After clicking yes, your new credentials will be stored in TOKEN_FILE_NAME so that you won’t have to enter them again (except when the access_token expires).
The Analytics Service object
Once we have an authorized Analytics service object, we can use it to retrieve all the data in the user’s analytics accounts.
For example, to get a list of all the existing accounts of the user, just type:
accounts = service.management().accounts().list().execute()

This will give you a dictionary containing the following keys:
username: the email address of the user
kind: analytics#accounts
items: a list of the user’s accounts.
totalResults
itemsPerPage
startIndex
As we will see, this is a common structure when getting data from analytics, even when we ask for properties or views instead of accounts (the returned object has the same keys).
Moreover, the items value is a list of accounts, each of which is in turn a dictionary with keys:
id: your account id
kind: analytics#account
childLink
created
permissions
selfLink
updated
Therefore, you can get a list of your users accounts with:
def get_accounts_ids(service):
    accounts = service.management().accounts().list().execute()
    ids = []
    if accounts.get('items'):
        for account in accounts['items']:
            ids.append(account['id'])
    return ids

You can also see the account ids in the Google Analytics web. You have to go to the Admin tab, and open the top-left drop down menu. There, your different accounts will be displayed, with their id on the right.
But as you may know, each Account can have multiple Properties, each of which has a different tracking code. To obtain a list of the Properties inside the Account with an id of account_id, you can use:
webproperties = service.management().webproperties().list(
    accountId=account_id).execute()

where webproperties is a dictionary with the same keys as accounts, but in which
kind: analytics#webproperties
items: list of web properties for this account
Again, each web property is a dictionary that contains the keys:
id: the web property id
kind: analytics#webproperty
and many more (you can print the webproperties object to see its keys).
You’ll see that the web property id is the tracking code of this property, which you can also obtain in the Google Analytics Admin tab.
But there is another level! Inside each Property there can be multiple views! You can obtain a list of views (or profiles) of each web property with:
profiles = service.management().profiles().list(
    accountId=firstAccountId,
    webPropertyId=firstWebpropertyId).execute()

The profiles dictionary contains the same keys as accounts and webproperties, but with
kind: analytics#profiles
items: list of profiles for this account and web property
and each profile has:
id: the profile id
kind: analytics#profile
name: the profile name
Get the number of Sessions of a Google Analytics View
Now that we know how to get information about our accounts, properties and views, let’s obtain the number of sessions of a view during a period of time.
Create the file get_sessions.py and write:
from analytics_service_object import initialize_service


def get_sessions(service, profile_id, start_date, end_date):
    ids = "ga:" + profile_id
    metrics = "ga:sessions"
    data = service.data().ga().get(
        ids=ids, start_date=start_date, end_date=end_date, metrics=metrics
        ).execute()
    return data["totalsForAllResults"][metrics]


if __name__ == '__main__':
    service = initialize_service()
    profile_id = "your_profile_id"
    print get_sessions(service, profile_id, "2014-09-01", "2014-09-30")

Note: you have to add your view id in “your_profile_id”, and then, run this script with:
$ python get_sessions.py

Check all the functionalities of the service.data().ga().get() method, and retrieve all the data you want form your view!
Get the number of Sessions for each traffic source
Obtaining the number of sessions for each traffic source (i.e. organic, referral, social, direct, email and other) is a little bit trickier. You have to work with filters in order to segment your data.
Here’s a little script that does this, thanks to Michael for the update 
from analytics_service_object import initialize_service

def get_source_group(service, profile_id, start_date, end_date):
    ids = "ga:" + profile_id
    metrics = "ga:sessions"
    dimensions = "ga:channelGrouping"
    data = service.data().ga().get(
        ids=ids, start_date=start_date, end_date=end_date, metrics=metrics,
        dimensions=dimensions).execute()
    return dict(
        data["rows"] + [["total", data["totalsForAllResults"][metrics]]])


if __name__ == '__main__':
    service = initialize_service()
    profile_id = "your_profile_id"
    start_date = "2014-09-01"
    end_date = "2014-09-30"
    data = get_source_group(service, profile_id, start_date, end_date)
    for key, value in data.iteritems():
        print key, value

Again, add your view’s id in “your_profile_id”, and change the start_date and end_date to match the time interval you want.
After running this script, you’ll see the desired information in your terminal.
Another solution to get the number of sessions by traffic source, less optimized but instructive, is to use filter instead of dimensions:
from analytics_service_object import initialize_service


not_source_filters = {
    "social": "ga:hasSocialSourceReferral==No",
    "organic": "ga:medium!=organic",
    "direct":  "ga:source!=(direct),ga:medium!=(none);ga:medium!=(not set)",
    "email": "ga:medium!=email",
    "referral": "ga:medium!=referral,ga:hasSocialSourceReferral!=No"
}

source_filters = {
    "social": "ga:hasSocialSourceReferral==Yes",
    "organic": "ga:medium==organic",
    "direct":  "ga:source==(direct);ga:medium==(none),ga:medium==(not set)",
    "email": "ga:medium==email",
    "referral": "ga:medium==referral;ga:hasSocialSourceReferral==No",
    "other": "%s;%s;%s;%s;%s" % (
        not_source_filters["social"], not_source_filters["organic"],
        not_source_filters["direct"], not_source_filters["email"],
        not_source_filters["referral"])
}


def get_source_sessions(service, profile_id, start_date, end_date, source):
    ids = "ga:" + profile_id
    metrics = "ga:sessions"
    filters = source_filters[source]
    data = service.data().ga().get(
        ids=ids, start_date=start_date, end_date=end_date, metrics=metrics,
        filters=filters).execute()
    return data["totalsForAllResults"][metrics]


if __name__ == '__main__':
    service = initialize_service()
    profile_id = "your_profile_id"
    start_date = "2014-09-01"
    end_date = "2014-09-30"
    for source in ["social", "organic", "direct", "email", "referral", "other"]:
        print source, get_source_sessions(
            service, profile_id, start_date, end_date, source)

Again, add your view’s id in “your_profile_id”, and change the start_date and end_date to match the time interval you want.
After running this script, you’ll see the desired information in your terminal.
Some information you may find useful when working with filters:
, means OR
; means AND
== means exact match
!= means does not match
=@ means contains substring
!@ means does not contain substring
learn more in the Google Reference Guide
That’s all for today! 
Please, +1 if was useful and share it with your friends! Thaaanks!

The post Use the Google Analytics API with Python appeared first on Marina Mele's site.

In this post you will learn to create a Python script that allows users to enter its Google Analytics account and get information from […]
The post Use the Google Analytics API with Python appeared first on Marina Mele's site.

Use the Google Analytics API with Python

What You Should Know About The Django User Model

How to Start a Production-Ready Django Project

Chart.js is a cool open source JavaScript library that helps you render HTML5 charts. It is responsive and counts with
8 different chart types.
In this tutorial we are going to explore a little bit of how to make Django talk with Chart.js and render some simple
charts based on data extracted from our models.
Installation
For this tutorial all you are going to do is add the Chart.js lib to your HTML page:
<script src="https://cdn.jsdelivr.net/npm/chart.js@2.9.3/dist/Chart.min.js"></script>


You can download it from Chart.js official website and use it locally, or you can use it from a CDN using the URL above.
Example Scenario
I’m going to use the same example I used for the tutorial How to Create Group By Queries With Django ORM which is a good complement to this tutorial because actually the tricky part of working with charts is to transform the data so it can fit in a bar chart / line chart / etc.
We are going to use the two models below, Country and City:
class Country(models.Model):
 name = models.CharField(max_length=30)

class City(models.Model):
 name = models.CharField(max_length=30)
 country = models.ForeignKey(Country, on_delete=models.CASCADE)
 population = models.PositiveIntegerField()


And the raw data stored in the database:
cities
 
 
id
 name
 country_id
 population
 
1Tokyo2836,923,000
2Shanghai1334,000,000
3Jakarta1930,000,000
4Seoul2125,514,000
5Guangzhou1325,000,000
6Beijing1324,900,000
7Karachi2224,300,000
8Shenzhen1323,300,000
9Delhi2521,753,486
10Mexico City2421,339,781
11Lagos921,000,000
12São Paulo120,935,204
13Mumbai2520,748,395
14New York City2020,092,883
15Osaka2819,342,000
16Wuhan1319,000,000
17Chengdu1318,100,000
18Dhaka417,151,925
19Chongqing1317,000,000
20Tianjin1315,400,000
21Kolkata2514,617,882
22Tehran1114,595,904
23Istanbul214,377,018
24London2614,031,830
25Hangzhou1313,400,000
26Los Angeles2013,262,220
27Buenos Aires813,074,000
28Xi'an1312,900,000
29Paris612,405,426
30Changzhou1312,400,000
31Shantou1312,000,000
32Rio de Janeiro111,973,505
33Manila1811,855,975
34Nanjing1311,700,000
35Rhine-Ruhr1611,470,000
36Jinan1311,000,000
37Bangalore2510,576,167
38Harbin1310,500,000
39Lima79,886,647
40Zhengzhou139,700,000
41Qingdao139,600,000
42Chicago209,554,598
43Nagoya289,107,000
44Chennai258,917,749
45Bangkok158,305,218
46Bogotá277,878,783
47Hyderabad257,749,334
48Shenyang137,700,000
49Wenzhou137,600,000
50Nanchang137,400,000
51Hong Kong137,298,600
52Taipei297,045,488
53Dallas–Fort Worth206,954,330
54Santiago146,683,852
55Luanda236,542,944
56Houston206,490,180
57Madrid176,378,297
58Ahmedabad256,352,254
59Toronto56,055,724
60Philadelphia206,051,170
61Washington, D.C.206,033,737
62Miami205,929,819
63Belo Horizonte15,767,414
64Atlanta205,614,323
65Singapore125,535,000
66Barcelona175,445,616
67Munich165,203,738
68Stuttgart165,200,000
69Ankara25,150,072
70Hamburg165,100,000
71Pune255,049,968
72Berlin165,005,216
73Guadalajara244,796,050
74Boston204,732,161
75Sydney105,000,500
76San Francisco204,594,060
77Surat254,585,367
78Phoenix204,489,109
79Monterrey244,477,614
80Inland Empire204,441,890
81Rome34,321,244
82Detroit204,296,611
83Milan34,267,946
84Melbourne104,650,000
countries
 
 
id
 name
 
1Brazil
2Turkey
3Italy
4Bangladesh
5Canada
6France
7Peru
8Argentina
9Nigeria
10Australia
11Iran
12Singapore
13China
14Chile
15Thailand
16Germany
17Spain
18Philippines
19Indonesia
20United States
21South Korea
22Pakistan
23Angola
24Mexico
25India
26United Kingdom
27Colombia
28Japan
29Taiwan
Example 1: Pie Chart
For the first example we are only going to retrieve the top 5 most populous cities and render it as a pie chart.
In this strategy we are going to return the chart data as part of the view context and inject the results in the
JavaScript code using the Django Template language.
views.py
from django.shortcuts import render
from mysite.core.models import City

def pie_chart(request):
 labels = []
 data = []

 queryset = City.objects.order_by('-population')[:5]
 for city in queryset:
 labels.append(city.name)
 data.append(city.population)

 return render(request, 'pie_chart.html', {
 'labels': labels,
 'data': data,
 })


Basically in the view above we are iterating through the City queryset and building a list of labels and a list of
data. Here in this case the data is the population count saved in the City model.
For the urls.py just a simple routing:
urls.py
from django.urls import path
from mysite.core import views

urlpatterns = [
 path('pie-chart/', views.pie_chart, name='pie-chart'),
]


Now the template. I got a basic snippet from the Chart.js Pie Chart Documentation.
pie_chart.html
{% extends 'base.html' %}

{% block content %}
 <div id="container" style="width: 75%;">
 <canvas id="pie-chart"></canvas>
 </div>

 <script src="https://cdn.jsdelivr.net/npm/chart.js@2.9.3/dist/Chart.min.js"></script>
 <script>

 var config = {
 type: 'pie',
 data: {
 datasets: [{
 data: {{ data|safe }},
 backgroundColor: [
 '#696969', '#808080', '#A9A9A9', '#C0C0C0', '#D3D3D3'
 ],
 label: 'Population'
 }],
 labels: {{ labels|safe }}
 },
 options: {
 responsive: true
 }
 };

 window.onload = function() {
 var ctx = document.getElementById('pie-chart').getContext('2d');
 window.myPie = new Chart(ctx, config);
 };

 </script>

{% endblock %}


In the example above the base.html template is not important but you can see it in the code example I shared in the
end of this post.
This strategy is not ideal but works fine. The bad thing is that we are using the Django Template Language to interfere
with the JavaScript logic. When we put {{ data|safe}} we are injecting a variable that came from
the server directly in the JavaScript code.
The code above looks like this:

Example 2: Bar Chart with Ajax
As the title says, we are now going to render a bar chart using an async call.
views.py
from django.shortcuts import render
from django.db.models import Sum
from django.http import JsonResponse
from mysite.core.models import City

def home(request):
 return render(request, 'home.html')

def population_chart(request):
 labels = []
 data = []

 queryset = City.objects.values('country__name').annotate(country_population=Sum('population')).order_by('-country_population')
 for entry in queryset:
 labels.append(entry['country__name'])
 data.append(entry['country_population'])
 
 return JsonResponse(data={
 'labels': labels,
 'data': data,
 })


So here we are using two views. The home view would be the main page where the chart would be loaded at. The other
view population_chart would be the one with the sole responsibility to aggregate the data the return a JSON response
with the labels and data.
If you are wondering about what this queryset is doing, it is grouping the cities by the country and aggregating the
total population of each country. The result is going to be a list of country + total population. To learn more about
this kind of query have a look on this post: How to Create Group By Queries With Django ORM
urls.py
from django.urls import path
from mysite.core import views

urlpatterns = [
 path('', views.home, name='home'),
 path('population-chart/', views.population_chart, name='population-chart'),
]


home.html
{% extends 'base.html' %}

{% block content %}

 <div id="container" style="width: 75%;">
 <canvas id="population-chart" data-url="{% url 'population-chart' %}"></canvas>
 </div>

 <script src="https://code.jquery.com/jquery-3.4.1.min.js"></script>
 <script src="https://cdn.jsdelivr.net/npm/chart.js@2.9.3/dist/Chart.min.js"></script>
 <script>

 $(function () {

 var $populationChart = $("#population-chart");
 $.ajax({
 url: $populationChart.data("url"),
 success: function (data) {

 var ctx = $populationChart[0].getContext("2d");

 new Chart(ctx, {
 type: 'bar',
 data: {
 labels: data.labels,
 datasets: [{
 label: 'Population',
 backgroundColor: 'blue',
 data: data.data
 }] 
 },
 options: {
 responsive: true,
 legend: {
 position: 'top',
 },
 title: {
 display: true,
 text: 'Population Bar Chart'
 }
 }
 });

 }
 });

 });

 </script>

{% endblock %}


Now we have a better separation of concerns. Looking at the chart container:
<canvas id="population-chart" data-url="{% url 'population-chart' %}"></canvas>


We added a reference to the URL that holds the chart rendering logic. Later on we are using it to execute the Ajax call.
var $populationChart = $("#population-chart");
$.ajax({
 url: $populationChart.data("url"),
 success: function (data) {
 // ...
 }
});


Inside the success callback we then finally execute the Chart.js related code using the JsonResponse data.

Conclusions
I hope this tutorial helped you to get started with working with charts using Chart.js. I published another tutorial
on the same subject a while ago but using the Highcharts library. The approach is pretty much the same: 
How to Integrate Highcharts.js with Django.
If you want to grab the code I used in this tutorial you can find it here: github.com/sibtc/django-chartjs-example.

How to Use Chart.js with Django

In this tutorial you are going to learn how to pass extra data to your serializer, before saving it to the database.

<ul>
 <li><a href="#introduction">Introduction</a></li>
 <li><a href="#example-using-apiview">Example Using APIView</a></li>
 <li><a href="#example-using-viewset">Example Using ViewSet</a></li>
</ul>

<h3 id="introduction">Introduction</h3>

When using regular Django forms, there is this common pattern where we save the form with <code class="highlighter-rouge">commit=False</code> and then pass
some extra data to the instance before saving it to the database, like this:

<figure class="highlight"><pre><code class="language-python" data-lang="python">form = InvoiceForm(request.POST)
if form.is_valid():
 invoice = form.save(commit=False)
 invoice.user = request.user
 invoice.save()</code></pre></figure>

This is very useful because we can save the required information using only one database query and it also make it 
possible to handle not nullable columns that was not defined in the form.

To simulate this pattern using a Django REST Framework serializer you can do something like this:

<figure class="highlight"><pre><code class="language-python" data-lang="python">serializer = InvoiceSerializer(data=request.data)
if serializer.is_valid():
 serializer.save(user=request.user)</code></pre></figure>

You can also pass several parameters at once:

<figure class="highlight"><pre><code class="language-python" data-lang="python">serializer = InvoiceSerializer(data=request.data)
if serializer.is_valid():
 serializer.save(user=request.user, date=timezone.now(), status='sent')</code></pre></figure>

<hr />

<h3 id="example-using-apiview">Example Using APIView</h3>

In this example I created an app named <code class="highlighter-rouge">core</code>.

models.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from django.contrib.auth.models import User
from django.db import models

class Invoice(models.Model):
 SENT = 1
 PAID = 2
 VOID = 3
 STATUS_CHOICES = (
 (SENT, 'sent'),
 (PAID, 'paid'),
 (VOID, 'void'),
 )

 user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='invoices')
 number = models.CharField(max_length=30)
 date = models.DateTimeField(auto_now_add=True)
 status = models.PositiveSmallIntegerField(choices=STATUS_CHOICES)
 amount = models.DecimalField(max_digits=10, decimal_places=2)</code></pre></figure>

serializers.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from rest_framework import serializers
from core.models import Invoice

class InvoiceSerializer(serializers.ModelSerializer):
 class Meta:
 model = Invoice
 fields = ('number', 'amount')</code></pre></figure>

views.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from core.models import Invoice
from core.serializers import InvoiceSerializer

class InvoiceAPIView(APIView):
 def post(self, request):
 serializer = InvoiceSerializer(data=request.data)
 serializer.is_valid(raise_exception=True)
 serializer.save(user=request.user, status=Invoice.SENT)
 return Response(status=status.HTTP_201_CREATED)</code></pre></figure>

<hr />

<h3 id="example-using-viewset">Example Using ViewSet</h3>

Very similar example, using the same models.py and serializers.py as in the previous example.

views.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from rest_framework.viewsets import ModelViewSet
from core.models import Invoice
from core.serializers import InvoiceSerializer

class InvoiceViewSet(ModelViewSet):
 queryset = Invoice.objects.all()
 serializer_class = InvoiceSerializer

 def perform_create(self, serializer):
 serializer.save(user=self.request.user, status=Invoice.SENT)</code></pre></figure>

In this tutorial you are going to learn how to pass extra data to your serializer, before saving it to the database.
Introduction
Example Using APIView
Example Using ViewSet
Introduction
When using regular Django forms, there is this common pattern where we save the form with commit=False and then pass
some extra data to the instance before saving it to the database, like this:
form = InvoiceForm(request.POST)
if form.is_valid():
    invoice = form.save(commit=False)
    invoice.user = request.user
    invoice.save()


This is very useful because we can save the required information using only one database query and it also make it 
possible to handle not nullable columns that was not defined in the form.
To simulate this pattern using a Django REST Framework serializer you can do something like this:
serializer = InvoiceSerializer(data=request.data)
if serializer.is_valid():
    serializer.save(user=request.user)


You can also pass several parameters at once:
serializer = InvoiceSerializer(data=request.data)
if serializer.is_valid():
    serializer.save(user=request.user, date=timezone.now(), status='sent')




Example Using APIView
In this example I created an app named core.
models.py
from django.contrib.auth.models import User
from django.db import models

class Invoice(models.Model):
    SENT = 1
    PAID = 2
    VOID = 3
    STATUS_CHOICES = (
        (SENT, 'sent'),
        (PAID, 'paid'),
        (VOID, 'void'),
    )

    user = models.ForeignKey(User, on_delete=models.CASCADE, related_name='invoices')
    number = models.CharField(max_length=30)
    date = models.DateTimeField(auto_now_add=True)
    status = models.PositiveSmallIntegerField(choices=STATUS_CHOICES)
    amount = models.DecimalField(max_digits=10, decimal_places=2)


serializers.py
from rest_framework import serializers
from core.models import Invoice

class InvoiceSerializer(serializers.ModelSerializer):
    class Meta:
        model = Invoice
        fields = ('number', 'amount')


views.py
from rest_framework import status
from rest_framework.response import Response
from rest_framework.views import APIView
from core.models import Invoice
from core.serializers import InvoiceSerializer

class InvoiceAPIView(APIView):
    def post(self, request):
        serializer = InvoiceSerializer(data=request.data)
        serializer.is_valid(raise_exception=True)
        serializer.save(user=request.user, status=Invoice.SENT)
        return Response(status=status.HTTP_201_CREATED)




Example Using ViewSet
Very similar example, using the same models.py and serializers.py as in the previous example.
views.py
from rest_framework.viewsets import ModelViewSet
from core.models import Invoice
from core.serializers import InvoiceSerializer

class InvoiceViewSet(ModelViewSet):
    queryset = Invoice.objects.all()
    serializer_class = InvoiceSerializer

    def perform_create(self, serializer):
        serializer.save(user=self.request.user, status=Invoice.SENT)

How to Save Extra Data to a Django REST Framework Serializer

In this tutorial we are going to explore three date/datetime pickers options that you can easily use in a Django 
project. We are going to explore how to do it manually first, then how to set up a custom widget and finally how to
use a third-party Django app with support to datetime pickers.
Introduction
Tempus Dominus Bootstrap 4
 
Direct Usage
Custom Widget
XDSoft DateTimePicker
 
Direct Usage
Custom Widget
Fengyuan Chen’s Datepicker
 
Direct Usage
Custom Widget
Conclusions
Introduction
The implementation of a date picker is mostly done on the front-end.
The key part of the implementation is to assure Django will receive the date input value in the correct format, and 
also that Django will be able to reproduce the format when rendering a form with initial data.
We can also use custom widgets to provide a deeper integration between the front-end and back-end and also to promote
better reuse throughout a project.
In the next sections we are going to explore following date pickers:
Tempus Dominus Bootstrap 4
Docs 
Source 

XDSoft DateTimePicker
Docs 
Source 

Fengyuan Chen’s Datepicker
Docs 
Source 

Tempus Dominus Bootstrap 4
Docs 
Source 
This is a great JavaScript library and it integrate well with Bootstrap 4. The downside is that it requires moment.js
and sort of need Font-Awesome for the icons.
It only make sense to use this library with you are already using Bootstrap 4 + jQuery, otherwise the list of CSS and JS
may look a little bit overwhelming.
To install it you can use their CDN or download the 
latest release from their GitHub Releases page.
If you downloaded the code from the releases page, grab the processed code from the build/ folder.
Below, a static HTML example of the datepicker:
<!doctype html>
<html lang="en">
 <head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>Static Example</title>

 
 <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.2.1/css/bootstrap.min.css" integrity="sha384-GJzZqFGwb1QTTN6wy59ffF1BuGJpLSa9DkKMp0DgiMDm4iYMj70gZWKYbI706tWS" crossorigin="anonymous">
 <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>
 <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.6/umd/popper.min.js" integrity="sha384-wHAiFfRlMFy6i5SRaxvfOCifBUQy1xHdJ/yoi7FRNXMRBu5WHdZYu1hA6ZOblgut" crossorigin="anonymous"></script>
 <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.2.1/js/bootstrap.min.js" integrity="sha384-B0UglyR+jN6CkvvICOB2joaf5I4l3gm9GU6Hc1og6Ls7i6U/mkkaduKaBhlAXv9k" crossorigin="anonymous"></script>

 
 <link href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" integrity="sha384-wvfXpqpZZVQGK6TAh5PVlGOfQNHSoD2xbE+QkPxCAFlNEevoEH3Sl0sibVcOQVnN" crossorigin="anonymous">

 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.23.0/moment.min.js" integrity="sha256-VBLiveTKyUZMEzJd6z2mhfxIqz3ZATCuVMawPZGzIfA=" crossorigin="anonymous"></script>

 
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/tempusdominus-bootstrap-4/5.1.2/css/tempusdominus-bootstrap-4.min.css" integrity="sha256-XPTBwC3SBoWHSmKasAk01c08M6sIA5gF5+sRxqak2Qs=" crossorigin="anonymous" />
 <script src="https://cdnjs.cloudflare.com/ajax/libs/tempusdominus-bootstrap-4/5.1.2/js/tempusdominus-bootstrap-4.min.js" integrity="sha256-z0oKYg6xiLq3yJGsp/LsY9XykbweQlHl42jHv2XTBz4=" crossorigin="anonymous"></script>

 </head>
 <body>

 <div class="input-group date" id="datetimepicker1" data-target-input="nearest">
 <input type="text" class="form-control datetimepicker-input" data-target="#datetimepicker1"/>
 <div class="input-group-append" data-target="#datetimepicker1" data-toggle="datetimepicker">
 <div class="input-group-text"></div>
 </div>
 </div>

 <script>
 $(function () {
 $("#datetimepicker1").datetimepicker();
 });
 </script>

 </body>
</html>



 

 
Direct Usage
The challenge now is to have this input snippet integrated with a Django form.
forms.py
from django import forms

class DateForm(forms.Form):
 date = forms.DateTimeField(
 input_formats=['%d/%m/%Y %H:%M'],
 widget=forms.DateTimeInput(attrs={
 'class': 'form-control datetimepicker-input',
 'data-target': '#datetimepicker1'
 })
 )


template
<div class="input-group date" id="datetimepicker1" data-target-input="nearest">
 {{ form.date }}
 <div class="input-group-append" data-target="#datetimepicker1" data-toggle="datetimepicker">
 <div class="input-group-text"></div>
 </div>
</div>

<script>
 $(function () {
 $("#datetimepicker1").datetimepicker({
 format: 'DD/MM/YYYY HH:mm',
 });
 });
</script>


The script tag can be placed anywhere because the snippet $(function () { ... }); will run the datetimepicker 
initialization when the page is ready. The only requirement is that this script tag is placed after the jQuery script
tag.
Custom Widget
You can create the widget in any app you want, here I’m going to consider we have a Django app named core.
core/widgets.py
from django.forms import DateTimeInput

class BootstrapDateTimePickerInput(DateTimeInput):
 template_name = 'widgets/bootstrap_datetimepicker.html'

 def get_context(self, name, value, attrs):
 datetimepicker_id = 'datetimepicker_{name}'.format(name=name)
 if attrs is None:
 attrs = dict()
 attrs['data-target'] = '#{id}'.format(id=datetimepicker_id)
 attrs['class'] = 'form-control datetimepicker-input'
 context = super().get_context(name, value, attrs)
 context['widget']['datetimepicker_id'] = datetimepicker_id
 return context


In the implementation above we generate a unique ID datetimepicker_id and also include it in the widget context.
Then the front-end implementation is done inside the widget HTML snippet.
widgets/bootstrap_datetimepicker.html
<div class="input-group date" id="{{ widget.datetimepicker_id }}" data-target-input="nearest">
 {% include "django/forms/widgets/input.html" %}
 <div class="input-group-append" data-target="#{{ widget.datetimepicker_id }}" data-toggle="datetimepicker">
 <div class="input-group-text"></div>
 </div>
</div>

<script>
 $(function () {
 $("#{{ widget.datetimepicker_id }}").datetimepicker({
 format: 'DD/MM/YYYY HH:mm',
 });
 });
</script>


Note how we make use of the built-in django/forms/widgets/input.html template.
Now the usage:
core/forms.py
from .widgets import BootstrapDateTimePickerInput

class DateForm(forms.Form):
 date = forms.DateTimeField(
 input_formats=['%d/%m/%Y %H:%M'], 
 widget=BootstrapDateTimePickerInput()
 )


Now simply render the field:
template
{{ form.date }}


The good thing about having the widget is that your form could have several date fields using the widget and you
could simply render the whole form like:
<form method="post">
 {% csrf_token %}
 {{ form.as_p }}
 <input type="submit" value="Submit">
</form>




XDSoft DateTimePicker
Docs 
Source 
The XDSoft DateTimePicker is a very versatile date picker and doesn’t rely on moment.js or Bootstrap, although it looks
good in a Bootstrap website.
It is easy to use and it is very straightforward.
You can download the source from GitHub releases page.
Below, a static example so you can see the minimum requirements and how all the pieces come together:
<!doctype html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>Static Example</title>

 
 <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>

 
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/jquery-datetimepicker/2.5.20/jquery.datetimepicker.min.css" integrity="sha256-DOS9W6NR+NFe1fUhEE0PGKY/fubbUCnOfTje2JMDw3Y=" crossorigin="anonymous" />
 <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery-datetimepicker/2.5.20/jquery.datetimepicker.full.min.js" integrity="sha256-FEqEelWI3WouFOo2VWP/uJfs1y8KJ++FLh2Lbqc8SJk=" crossorigin="anonymous"></script>
</head>
<body>

 <input id="datetimepicker" type="text">

 <script>
 $(function () {
 $("#datetimepicker").datetimepicker();
 });
 </script>

</body>
</html>



 

 
Direct Usage
A basic integration with Django would look like this:
forms.py
from django import forms

class DateForm(forms.Form):
 date = forms.DateTimeField(input_formats=['%d/%m/%Y %H:%M'])


Simple form, default widget, nothing special.
Now using it on the template:
template
{{ form.date }}

<script>
 $(function () {
 $("#id_date").datetimepicker({
 format: 'd/m/Y H:i',
 });
 });
</script>


The id_date is the default ID Django generates for the form fields (id_ + name).
Custom Widget
core/widgets.py
from django.forms import DateTimeInput

class XDSoftDateTimePickerInput(DateTimeInput):
 template_name = 'widgets/xdsoft_datetimepicker.html'


widgets/xdsoft_datetimepicker.html
{% include "django/forms/widgets/input.html" %}

<script>
 $(function () {
 $("input[name='{{ widget.name }}']").datetimepicker({
 format: 'd/m/Y H:i',
 });
 });
</script>


To have a more generic implementation, this time we are selecting the field to initialize the component using its name
instead of its id, should the user change the id prefix.
Now the usage:
core/forms.py
from django import forms
from .widgets import XDSoftDateTimePickerInput

class DateForm(forms.Form):
 date = forms.DateTimeField(
 input_formats=['%d/%m/%Y %H:%M'], 
 widget=XDSoftDateTimePickerInput()
 )


template
{{ form.date }}




Fengyuan Chen’s Datepicker
Docs 
Source 
This is a very beautiful and minimalist date picker. Unfortunately there is no time support. But if you only need dates
this is a great choice.
To install this datepicker you can either use their CDN or download the 
sources from their GitHub releases page. Please note that they
do not provide a compiled/processed JavaScript files. But you can download those to your local machine using the CDN.
<!doctype html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <title>Static Example</title>
 <style>body {font-family: Arial, sans-serif;}</style>
 
 
 <script src="https://code.jquery.com/jquery-3.3.1.slim.min.js" integrity="sha384-q8i/X+965DzO0rT7abK41JStQIAqVgRVzpbzo5smXKp4YfRvH+8abtTE1Pi6jizo" crossorigin="anonymous"></script>

 
 <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/datepicker/0.6.5/datepicker.min.css" integrity="sha256-b88RdwbRJEzRx95nCuuva+hO5ExvXXnpX+78h8DjyOE=" crossorigin="anonymous" />
 <script src="https://cdnjs.cloudflare.com/ajax/libs/datepicker/0.6.5/datepicker.min.js" integrity="sha256-/7FLTdzP6CfC1VBAj/rsp3Rinuuu9leMRGd354hvk0k=" crossorigin="anonymous"></script>
</head>
<body>

 <input id="datepicker">

 <script>
 $(function () {
 $("#datepicker").datepicker();
 });
 </script>

</body>
</html>



 

 
Direct Usage
A basic integration with Django (note that we are now using DateField instead of DateTimeField):
forms.py
from django import forms

class DateForm(forms.Form):
 date = forms.DateTimeField(input_formats=['%d/%m/%Y %H:%M'])


template
{{ form.date }}

<script>
 $(function () {
 $("#id_date").datepicker({
 format:'dd/mm/yyyy',
 });
 });
</script>


Custom Widget
core/widgets.py
from django.forms import DateInput

class FengyuanChenDatePickerInput(DateInput):
 template_name = 'widgets/fengyuanchen_datepicker.html'


widgets/fengyuanchen_datepicker.html
{% include "django/forms/widgets/input.html" %}

<script>
 $(function () {
 $("input[name='{{ widget.name }}']").datepicker({
 format:'dd/mm/yyyy',
 });
 });
</script>


Usage:
core/forms.py
from django import forms
from .widgets import FengyuanChenDatePickerInput

class DateForm(forms.Form):
 date = forms.DateTimeField(
 input_formats=['%d/%m/%Y %H:%M'], 
 widget=FengyuanChenDatePickerInput()
 )


template
{{ form.date }}




Conclusions
The implementation is very similar no matter what date/datetime picker you are using. Hopefully this tutorial provided
some insights on how to integrate this kind of frontend library to a Django project.
As always, the best source of information about each of those libraries are their official documentation.
I also created an example project to show the usage and implementation of the widgets for each of the libraries 
presented in this tutorial. Grab the source code at github.com/sibtc/django-datetimepicker-example.

How to Use Date Picker with Django

The Django forms API have two field types to work with multiple options: <code class="highlighter-rouge">ChoiceField</code> and <code class="highlighter-rouge">ModelChoiceField</code>.

Both use select input as the default widget and they work in a similar way, except that <code class="highlighter-rouge">ModelChoiceField</code> is designed 
to handle QuerySets and work with foreign key relationships.

A basic implementation using a <code class="highlighter-rouge">ChoiceField</code> would be:

<div class="row" id="ChoiceField">
 <div class="eight columns">


<figure class="highlight"><pre><code class="language-python" data-lang="python">class ExpenseForm(forms.Form):
 CHOICES = (
 (11, 'Credit Card'),
 (12, 'Student Loans'),
 (13, 'Taxes'),
 (21, 'Books'),
 (22, 'Games'),
 (31, 'Groceries'),
 (32, 'Restaurants'),
 )
 amount = forms.DecimalField()
 date = forms.DateField()
 category = forms.ChoiceField(choices=CHOICES)</code></pre></figure>


 </div>
 <div class="four columns">
 <img src="https://simpleisbetterthancomplex.com/media/2019/01/form.jpg" alt="Django ChoiceField" style="max-width:100%;" />
 </div>
</div>

<hr />

<h4 id="grouped-choice-field">Grouped Choice Field</h4>

You can also organize the choices in groups to generate the <code class="highlighter-rouge">&lt;optgroup&gt;</code> tags like this:

<div class="row">
 <div class="eight columns">


<figure class="highlight"><pre><code class="language-python" data-lang="python">class ExpenseForm(forms.Form):
 CHOICES = (
 ('Debt', (
 (11, 'Credit Card'),
 (12, 'Student Loans'),
 (13, 'Taxes'),
 )),
 ('Entertainment', (
 (21, 'Books'),
 (22, 'Games'),
 )),
 ('Everyday', (
 (31, 'Groceries'),
 (32, 'Restaurants'),
 )),
 )
 amount = forms.DecimalField()
 date = forms.DateField()
 category = forms.ChoiceField(choices=CHOICES)</code></pre></figure>


 </div>
 <div class="four columns">
 <img src="https://simpleisbetterthancomplex.com/media/2019/01/form2.jpg" alt="Django Grouped ChoiceField" style="max-width:100%;" />
 </div>
</div>

<hr />

<h4 id="grouped-model-choice-field">Grouped Model Choice Field</h4>

When you are using a <code class="highlighter-rouge">ModelChoiceField</code> unfortunately there is no built-in solution.

Recently I found a nice solution on <a href="https://code.djangoproject.com/ticket/27331">Django’s ticket tracker</a>, where 
someone proposed adding an <code class="highlighter-rouge">opt_group</code> argument to the <code class="highlighter-rouge">ModelChoiceField</code>.

While the discussion is still ongoing, <a href="https://code.djangoproject.com/ticket/27331#comment:7">Simon Charette</a> proposed
a really good solution.

Let’s see how we can integrate it in our project.

First consider the following models:

models.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from django.db import models

class Category(models.Model):
 name = models.CharField(max_length=30)
 parent = models.ForeignKey('Category', on_delete=models.CASCADE, null=True)

 def __str__(self):
 return self.name

class Expense(models.Model):
 amount = models.DecimalField(max_digits=10, decimal_places=2)
 date = models.DateField()
 category = models.ForeignKey(Category, on_delete=models.CASCADE)

 def __str__(self):
 return self.amount</code></pre></figure>

So now our category instead of being a regular choices field it is now a model and the <code class="highlighter-rouge">Expense</code> model have a 
relationship with it using a foreign key.

If we create a <code class="highlighter-rouge">ModelForm</code> using this model, the result will be very similar to <a href="#ChoiceField">our first example</a>.

To simulate a grouped categories you will need the code below. First create a new module named fields.py:

fields.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from functools import partial
from itertools import groupby
from operator import attrgetter

from django.forms.models import ModelChoiceIterator, ModelChoiceField


class GroupedModelChoiceIterator(ModelChoiceIterator):
 def __init__(self, field, groupby):
 self.groupby = groupby
 super().__init__(field)

 def __iter__(self):
 if self.field.empty_label is not None:
 yield ("", self.field.empty_label)
 queryset = self.queryset
 # Can't use iterator() when queryset uses prefetch_related()
 if not queryset._prefetch_related_lookups:
 queryset = queryset.iterator()
 for group, objs in groupby(queryset, self.groupby):
 yield (group, [self.choice(obj) for obj in objs])


class GroupedModelChoiceField(ModelChoiceField):
 def __init__(self, *args, choices_groupby, **kwargs):
 if isinstance(choices_groupby, str):
 choices_groupby = attrgetter(choices_groupby)
 elif not callable(choices_groupby):
 raise TypeError('choices_groupby must either be a str or a callable accepting a single argument')
 self.iterator = partial(GroupedModelChoiceIterator, groupby=choices_groupby)
 super().__init__(*args, **kwargs)</code></pre></figure>

And here is how you use it in your forms:

forms.py

<div class="row">
 <div class="eight columns">


<figure class="highlight"><pre><code class="language-python" data-lang="python">from django import forms
from .fields import GroupedModelChoiceField
from .models import Category, Expense

class ExpenseForm(forms.ModelForm):
 category = GroupedModelChoiceField(
 queryset=Category.objects.exclude(parent=None), 
 choices_groupby='parent'
 )

 class Meta:
 model = Expense
 fields = ('amount', 'date', 'category')</code></pre></figure>


 </div>
 <div class="four columns">
 <img src="https://simpleisbetterthancomplex.com/media/2019/01/form3.jpg" alt="Django Grouped ModelChoiceField" style="max-width:100%;" />
 </div>
</div>

Because in the example above I used a self-referencing relationship I had to add the <code class="highlighter-rouge">exclude(parent=None)</code> to hide
the “group categories” from showing up in the select input as a valid option.

<hr />

<h4 id="further-reading">Further Reading</h4>

You can download the code used in this tutorial from GitHub: <a href="https://github.com/sibtc/django-grouped-choice-field-example">github.com/sibtc/django-grouped-choice-field-example</a>

Credits to the solution <a href="https://code.djangoproject.com/ticket/27331#comment:7">Simon Charette on Django Ticket Track</a>.

The Django forms API have two field types to work with multiple options: ChoiceField and ModelChoiceField.
Both use select input as the default widget and they work in a similar way, except that ModelChoiceField is designed 
to handle QuerySets and work with foreign key relationships.
A basic implementation using a ChoiceField would be:
class ExpenseForm(forms.Form):
 CHOICES = (
 (11, 'Credit Card'),
 (12, 'Student Loans'),
 (13, 'Taxes'),
 (21, 'Books'),
 (22, 'Games'),
 (31, 'Groceries'),
 (32, 'Restaurants'),
 )
 amount = forms.DecimalField()
 date = forms.DateField()
 category = forms.ChoiceField(choices=CHOICES)



 
Grouped Choice Field
You can also organize the choices in groups to generate the <optgroup> tags like this:
class ExpenseForm(forms.Form):
 CHOICES = (
 ('Debt', (
 (11, 'Credit Card'),
 (12, 'Student Loans'),
 (13, 'Taxes'),
 )),
 ('Entertainment', (
 (21, 'Books'),
 (22, 'Games'),
 )),
 ('Everyday', (
 (31, 'Groceries'),
 (32, 'Restaurants'),
 )),
 )
 amount = forms.DecimalField()
 date = forms.DateField()
 category = forms.ChoiceField(choices=CHOICES)



 
Grouped Model Choice Field
When you are using a ModelChoiceField unfortunately there is no built-in solution.
Recently I found a nice solution on Django’s ticket tracker, where 
someone proposed adding an opt_group argument to the ModelChoiceField.
While the discussion is still ongoing, Simon Charette proposed
a really good solution.
Let’s see how we can integrate it in our project.
First consider the following models:
models.py
from django.db import models

class Category(models.Model):
 name = models.CharField(max_length=30)
 parent = models.ForeignKey('Category', on_delete=models.CASCADE, null=True)

 def __str__(self):
 return self.name

class Expense(models.Model):
 amount = models.DecimalField(max_digits=10, decimal_places=2)
 date = models.DateField()
 category = models.ForeignKey(Category, on_delete=models.CASCADE)

 def __str__(self):
 return self.amount


So now our category instead of being a regular choices field it is now a model and the Expense model have a 
relationship with it using a foreign key.
If we create a ModelForm using this model, the result will be very similar to our first example.
To simulate a grouped categories you will need the code below. First create a new module named fields.py:
fields.py
from functools import partial
from itertools import groupby
from operator import attrgetter

from django.forms.models import ModelChoiceIterator, ModelChoiceField


class GroupedModelChoiceIterator(ModelChoiceIterator):
 def __init__(self, field, groupby):
 self.groupby = groupby
 super().__init__(field)

 def __iter__(self):
 if self.field.empty_label is not None:
 yield ("", self.field.empty_label)
 queryset = self.queryset
 # Can't use iterator() when queryset uses prefetch_related()
 if not queryset._prefetch_related_lookups:
 queryset = queryset.iterator()
 for group, objs in groupby(queryset, self.groupby):
 yield (group, [self.choice(obj) for obj in objs])


class GroupedModelChoiceField(ModelChoiceField):
 def __init__(self, *args, choices_groupby, **kwargs):
 if isinstance(choices_groupby, str):
 choices_groupby = attrgetter(choices_groupby)
 elif not callable(choices_groupby):
 raise TypeError('choices_groupby must either be a str or a callable accepting a single argument')
 self.iterator = partial(GroupedModelChoiceIterator, groupby=choices_groupby)
 super().__init__(*args, **kwargs)


And here is how you use it in your forms:
forms.py
from django import forms
from .fields import GroupedModelChoiceField
from .models import Category, Expense

class ExpenseForm(forms.ModelForm):
 category = GroupedModelChoiceField(
 queryset=Category.objects.exclude(parent=None), 
 choices_groupby='parent'
 )

 class Meta:
 model = Expense
 fields = ('amount', 'date', 'category')



 
Because in the example above I used a self-referencing relationship I had to add the exclude(parent=None) to hide
the “group categories” from showing up in the select input as a valid option.
Further Reading
You can download the code used in this tutorial from GitHub: github.com/sibtc/django-grouped-choice-field-example
Credits to the solution Simon Charette on Django Ticket Track.

How to Implement Grouped Model Choice Field

JWT stand for JSON Web Token and it is an authentication strategy used by client/server applications where the
client is a Web application using JavaScript and some frontend framework like Angular, React or VueJS.

In this tutorial we are going to explore the specifics of JWT authentication. If you want to learn more about
Token-based authentication using Django REST Framework (DRF), or if you want to know how to start a new DRF project
you can read this tutorial: <a href="/tutorial/2018/11/22/how-to-implement-token-authentication-using-django-rest-framework.html">How to Implement Token Authentication using Django REST Framework</a>.
The concepts are the same, we are just going to switch the authentication backend.

<ul>
 <li><a href="#how-jwt-works">How JWT Works?</a></li>
 <li><a href="#installation--setup">Installation &amp; Setup</a></li>
 <li><a href="#example-code">Example Code</a></li>
 <li><a href="#usage">Usage</a>
 <ul>
 <li><a href="#obtain-token">Obtain Token</a></li>
 <li><a href="#refresh-token">Refresh Token</a></li>
 </ul>
 </li>
 <li><a href="#whats-the-point-of-the-refresh-token">What’s The Point of The Refresh Token?</a></li>
 <li><a href="#further-reading">Further Reading</a></li>
</ul>

<hr />

<h4 id="how-jwt-works">How JWT Works?</h4>

The JWT is just an authorization token that should be included in all requests:

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">curl http://127.0.0.1:8000/hello/ -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQzODI4NDMxLCJqdGkiOiI3ZjU5OTdiNzE1MGQ0NjU3OWRjMmI0OTE2NzA5N2U3YiIsInVzZXJfaWQiOjF9.Ju70kdcaHKn1Qaz8H42zrOYk0Jx9kIckTn9Xx7vhikY'</code></pre></figure>

The JWT is acquired by exchanging an username + password for an access token and an refresh token.

The access token is usually short-lived (expires in 5 min or so, can be customized though).

The refresh token lives a little bit longer (expires in 24 hours, also customizable). It is comparable to an
authentication session. After it expires, you need a full login with username + password again.

Why is that?

It’s a security feature and also it’s because the JWT holds a little bit more information. If you look closely the
example I gave above, you will see the token is composed by three parts:

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">xxxxx.yyyyy.zzzzz</code></pre></figure>

Those are three distinctive parts that compose a JWT:

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">header.payload.signature</code></pre></figure>

So we have here:

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">header = eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9
payload = eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQzODI4NDMxLCJqdGkiOiI3ZjU5OTdiNzE1MGQ0NjU3OWRjMmI0OTE2NzA5N2U3YiIsInVzZXJfaWQiOjF9
signature = Ju70kdcaHKn1Qaz8H42zrOYk0Jx9kIckTn9Xx7vhikY</code></pre></figure>

This information is encoded using Base64. If we decode, we will see something like this:

header

<figure class="highlight"><pre><code class="language-json" data-lang="json">{
 "typ": "JWT",
 "alg": "HS256"
}</code></pre></figure>

payload

<figure class="highlight"><pre><code class="language-json" data-lang="json">{
 "token_type": "access",
 "exp": 1543828431,
 "jti": "7f5997b7150d46579dc2b49167097e7b",
 "user_id": 1
}</code></pre></figure>

signature

The signature is issued by the JWT backend, using the header base64 + payload base64 + <code class="highlighter-rouge">SECRET_KEY</code>. Upon each request
this signature is verified. If any information in the header or in the payload was changed by the client it will
invalidate the signature. The only way of checking and validating the signature is by using your application’s
<code class="highlighter-rouge">SECRET_KEY</code>. Among other things, that’s why you should always keep your <code class="highlighter-rouge">SECRET_KEY</code> secret!

<hr />

<h4 id="installation--setup">Installation &amp; Setup</h4>

For this tutorial we are going to use the <a href="https://github.com/davesque/django-rest-framework-simplejwt"><code class="highlighter-rouge">djangorestframework_simplejwt</code></a>
library, recommended by the DRF developers.

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">pip install djangorestframework_simplejwt</code></pre></figure>

settings.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">REST_FRAMEWORK = {
 'DEFAULT_AUTHENTICATION_CLASSES': [
 'rest_framework_simplejwt.authentication.JWTAuthentication',
 ],
}</code></pre></figure>

urls.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from django.urls import path
from rest_framework_simplejwt import views as jwt_views

urlpatterns = [
 # Your URLs...
 path('api/token/', jwt_views.TokenObtainPairView.as_view(), name='token_obtain_pair'),
 path('api/token/refresh/', jwt_views.TokenRefreshView.as_view(), name='token_refresh'),
]</code></pre></figure>

<hr />

<h4 id="example-code">Example Code</h4>

For this tutorial I will use the following route and API view:

views.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated


class HelloView(APIView):
 permission_classes = (IsAuthenticated,)

 def get(self, request):
 content = {'message': 'Hello, World!'}
 return Response(content)</code></pre></figure>

urls.py

<figure class="highlight"><pre><code class="language-python" data-lang="python">from django.urls import path
from myapi.core import views

urlpatterns = [
 path('hello/', views.HelloView.as_view(), name='hello'),
]</code></pre></figure>

<hr />

<h4 id="usage">Usage</h4>

I will be using <a href="https://httpie.org">HTTPie</a> to consume the API endpoints via the terminal. But you can also use
<a href="https://curl.haxx.se/">cURL</a> (readily available in many OS) to try things out locally.

Or alternatively, use the DRF web interface by accessing the endpoint URLs like this:

<img src="https://simpleisbetterthancomplex.com/media/2018/12/drf-web.png" alt="DRF JWT Obtain Token" />

<h5 id="obtain-token">Obtain Token</h5>

First step is to authenticate and obtain the token. The endpoint is <code class="highlighter-rouge">/api/token/</code> and it only accepts POST requests.

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">http post http://127.0.0.1:8000/api/token/ username=vitor password=123</code></pre></figure>

<img src="https://simpleisbetterthancomplex.com/media/2018/12/jwt-obtain-token.png" alt="HTTPie JWT Obtain Token" />

So basically your response body is the two tokens:

<figure class="highlight"><pre><code class="language-json" data-lang="json">{
 "access": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQ1MjI0MjU5LCJqdGkiOiIyYmQ1NjI3MmIzYjI0YjNmOGI1MjJlNThjMzdjMTdlMSIsInVzZXJfaWQiOjF9.D92tTuVi_YcNkJtiLGHtcn6tBcxLCBxz9FKD3qzhUg8",
 "refresh": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTU0NTMxMDM1OSwianRpIjoiMjk2ZDc1ZDA3Nzc2NDE0ZjkxYjhiOTY4MzI4NGRmOTUiLCJ1c2VyX2lkIjoxfQ.rA-mnGRg71NEW_ga0sJoaMODS5ABjE5HnxJDb0F8xAo"
}</code></pre></figure>

After that you are going to store both the access token and the refresh token on the client side, usually in
the <a href="https://developer.mozilla.org/en-US/docs/Web/API/Window/localStorage">localStorage</a>.

In order to access the protected views on the backend (i.e., the API endpoints that require authentication), you should
include the access token in the header of all requests, like this:

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">http http://127.0.0.1:8000/hello/ "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQ1MjI0MjAwLCJqdGkiOiJlMGQxZDY2MjE5ODc0ZTY3OWY0NjM0ZWU2NTQ2YTIwMCIsInVzZXJfaWQiOjF9.9eHat3CvRQYnb5EdcgYFzUyMobXzxlAVh_IAgqyvzCE"</code></pre></figure>

<img src="https://simpleisbetterthancomplex.com/media/2018/12/jwt-bearer.png" alt="HTTPie JWT Hello, World!" />

You can use this access token for the next five minutes.

After five min, the token will expire, and if you try to access the view again, you are going to get the following
error:

<figure class="highlight"><pre><code class="language-bash" data-lang="bash">http http://127.0.0.1:8000/hello/ "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQ1MjI0MjAwLCJqdGkiOiJlMGQxZDY2MjE5ODc0ZTY3OWY0NjM0ZWU2NTQ2YTIwMCIsInVzZXJfaWQiOjF9.9eHat3CvRQYnb5EdcgYFzUyMobXzxlAVh_IAgqyvzCE"</code></pre></figure>

<img src="https://simpleisbetterthancomplex.com/media/2018/12/jwt-expired.png" alt="HTTPie JWT Expired" />

<h5 id="refresh-token">Refresh Token</h5>

To get a new access token, you should use the refresh token endpoint <code class="highlighter-rouge">/api/token/refresh/</code> posting the
refresh token:

<figure class="highlight"><pre><code class="language-python" data-lang="python">http post http://127.0.0.1:8000/api/token/refresh/ refresh=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTU0NTMwODIyMiwianRpIjoiNzAyOGFlNjc0ZTdjNDZlMDlmMzUwYjg3MjU1NGUxODQiLCJ1c2VyX2lkIjoxfQ.Md8AO3dDrQBvWYWeZsd_A1J39z6b6HEwWIUZ7ilOiPE</code></pre></figure>

<img src="https://simpleisbetterthancomplex.com/media/2018/12/jwt-refresh-token.png" alt="HTTPie JWT Refresh Token" />

The return is a new access token that you should use in the subsequent requests.

The refresh token is valid for the next 24 hours. When it finally expires too, the user will need to perform a
full authentication again using their username and password to get a new set of access token + refresh token.

<hr />

<h4 id="whats-the-point-of-the-refresh-token">What’s The Point of The Refresh Token?</h4>

At first glance the refresh token may look pointless, but in fact it is necessary to make sure the user still have
the correct permissions. If your access token have a long expire time, it may take longer to update the information
associated with the token. That’s because the authentication check is done by cryptographic means, instead of querying
the database and verifying the data. So some information is sort of cached.

There is also a security aspect, in a sense that the refresh token only travel in the POST data. And the
access token is sent via HTTP header, which may be logged along the way. So this also give a short window, should
your access token be compromised.

<hr />

<h4 id="further-reading">Further Reading</h4>

This should cover the basics on the backend implementation. It’s worth checking the
<a href="https://github.com/davesque/django-rest-framework-simplejwt">djangorestframework_simplejwt settings</a> for further
customization and to get a better idea of what the library offers.

The implementation on the frontend depends on what framework/library you are using. Some libraries and articles
covering popular frontend frameworks like angular/react/vue.js:

<ul>
 <li><a href="https://github.com/auth0/angular-jwt">Angular JWT library</a></li>
 <li><a href="https://github.com/auth0/angular2-jwt">Angular 2 JWT library</a></li>
 <li><a href="https://auth0.com/blog/secure-your-react-and-redux-app-with-jwt-authentication/">Secure Your React and Redux App with JWT Authentication</a></li>
 <li><a href="https://www.pydanny.com/drf-jwt-axios-vue.html">Authenticating via JWT using Django, Axios, and Vue</a></li>
</ul>

The code used in this tutorial is available at <a href="https://github.com/sibtc/drf-jwt-example">github.com/sibtc/drf-jwt-example</a>.

JWT stand for JSON Web Token and it is an authentication strategy used by client/server applications where the
client is a Web application using JavaScript and some frontend framework like Angular, React or VueJS.
In this tutorial we are going to explore the specifics of JWT authentication. If you want to learn more about
Token-based authentication using Django REST Framework (DRF), or if you want to know how to start a new DRF project
you can read this tutorial: How to Implement Token Authentication using Django REST Framework.
The concepts are the same, we are just going to switch the authentication backend.
How JWT Works?
Installation & Setup
Example Code
Usage
    
Obtain Token
Refresh Token
What’s The Point of The Refresh Token?
Further Reading
How JWT Works?
The JWT is just an authorization token that should be included in all requests:
curl http://127.0.0.1:8000/hello/ -H 'Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQzODI4NDMxLCJqdGkiOiI3ZjU5OTdiNzE1MGQ0NjU3OWRjMmI0OTE2NzA5N2U3YiIsInVzZXJfaWQiOjF9.Ju70kdcaHKn1Qaz8H42zrOYk0Jx9kIckTn9Xx7vhikY'


The JWT is acquired by exchanging an username + password for an access token and an refresh token.
The access token is usually short-lived (expires in 5 min or so, can be customized though).
The refresh token lives a little bit longer (expires in 24 hours, also customizable). It is comparable to an
authentication session. After it expires, you need a full login with username + password again.
Why is that?
It’s a security feature and also it’s because the JWT holds a little bit more information. If you look closely the
example I gave above, you will see the token is composed by three parts:
xxxxx.yyyyy.zzzzz


Those are three distinctive parts that compose a JWT:
header.payload.signature


So we have here:
header = eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9
payload = eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQzODI4NDMxLCJqdGkiOiI3ZjU5OTdiNzE1MGQ0NjU3OWRjMmI0OTE2NzA5N2U3YiIsInVzZXJfaWQiOjF9
signature = Ju70kdcaHKn1Qaz8H42zrOYk0Jx9kIckTn9Xx7vhikY


This information is encoded using Base64. If we decode, we will see something like this:
header
{
  "typ": "JWT",
  "alg": "HS256"
}


payload
{
  "token_type": "access",
  "exp": 1543828431,
  "jti": "7f5997b7150d46579dc2b49167097e7b",
  "user_id": 1
}


signature
The signature is issued by the JWT backend, using the header base64 + payload base64 + SECRET_KEY. Upon each request
this signature is verified. If any information in the header or in the payload was changed by the client it will
invalidate the signature. The only way of checking and validating the signature is by using your application’s
SECRET_KEY. Among other things, that’s why you should always keep your SECRET_KEY secret!
Installation & Setup
For this tutorial we are going to use the djangorestframework_simplejwt
library, recommended by the DRF developers.
pip install djangorestframework_simplejwt


settings.py
REST_FRAMEWORK = {
    'DEFAULT_AUTHENTICATION_CLASSES': [
        'rest_framework_simplejwt.authentication.JWTAuthentication',
    ],
}


urls.py
from django.urls import path
from rest_framework_simplejwt import views as jwt_views

urlpatterns = [
    # Your URLs...
    path('api/token/', jwt_views.TokenObtainPairView.as_view(), name='token_obtain_pair'),
    path('api/token/refresh/', jwt_views.TokenRefreshView.as_view(), name='token_refresh'),
]




Example Code
For this tutorial I will use the following route and API view:
views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated


class HelloView(APIView):
    permission_classes = (IsAuthenticated,)

    def get(self, request):
        content = {'message': 'Hello, World!'}
        return Response(content)


urls.py
from django.urls import path
from myapi.core import views

urlpatterns = [
    path('hello/', views.HelloView.as_view(), name='hello'),
]




Usage
I will be using HTTPie to consume the API endpoints via the terminal. But you can also use
cURL (readily available in many OS) to try things out locally.
Or alternatively, use the DRF web interface by accessing the endpoint URLs like this:

Obtain Token
First step is to authenticate and obtain the token. The endpoint is /api/token/ and it only accepts POST requests.
http post http://127.0.0.1:8000/api/token/ username=vitor password=123



So basically your response body is the two tokens:
{
    "access": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQ1MjI0MjU5LCJqdGkiOiIyYmQ1NjI3MmIzYjI0YjNmOGI1MjJlNThjMzdjMTdlMSIsInVzZXJfaWQiOjF9.D92tTuVi_YcNkJtiLGHtcn6tBcxLCBxz9FKD3qzhUg8",
    "refresh": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTU0NTMxMDM1OSwianRpIjoiMjk2ZDc1ZDA3Nzc2NDE0ZjkxYjhiOTY4MzI4NGRmOTUiLCJ1c2VyX2lkIjoxfQ.rA-mnGRg71NEW_ga0sJoaMODS5ABjE5HnxJDb0F8xAo"
}


After that you are going to store both the access token and the refresh token on the client side, usually in
the localStorage.
In order to access the protected views on the backend (i.e., the API endpoints that require authentication), you should
include the access token in the header of all requests, like this:
http http://127.0.0.1:8000/hello/ "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQ1MjI0MjAwLCJqdGkiOiJlMGQxZDY2MjE5ODc0ZTY3OWY0NjM0ZWU2NTQ2YTIwMCIsInVzZXJfaWQiOjF9.9eHat3CvRQYnb5EdcgYFzUyMobXzxlAVh_IAgqyvzCE"



You can use this access token for the next five minutes.
After five min, the token will expire, and if you try to access the view again, you are going to get the following
error:
http http://127.0.0.1:8000/hello/ "Authorization: Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoiYWNjZXNzIiwiZXhwIjoxNTQ1MjI0MjAwLCJqdGkiOiJlMGQxZDY2MjE5ODc0ZTY3OWY0NjM0ZWU2NTQ2YTIwMCIsInVzZXJfaWQiOjF9.9eHat3CvRQYnb5EdcgYFzUyMobXzxlAVh_IAgqyvzCE"



Refresh Token
To get a new access token, you should use the refresh token endpoint /api/token/refresh/ posting the
refresh token:
http post http://127.0.0.1:8000/api/token/refresh/ refresh=eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJ0b2tlbl90eXBlIjoicmVmcmVzaCIsImV4cCI6MTU0NTMwODIyMiwianRpIjoiNzAyOGFlNjc0ZTdjNDZlMDlmMzUwYjg3MjU1NGUxODQiLCJ1c2VyX2lkIjoxfQ.Md8AO3dDrQBvWYWeZsd_A1J39z6b6HEwWIUZ7ilOiPE



The return is a new access token that you should use in the subsequent requests.
The refresh token is valid for the next 24 hours. When it finally expires too, the user will need to perform a
full authentication again using their username and password to get a new set of access token + refresh token.
What’s The Point of The Refresh Token?
At first glance the refresh token may look pointless, but in fact it is necessary to make sure the user still have
the correct permissions. If your access token have a long expire time, it may take longer to update the information
associated with the token. That’s because the authentication check is done by cryptographic means, instead of querying
the database and verifying the data. So some information is sort of cached.
There is also a security aspect, in a sense that the refresh token only travel in the POST data. And the
access token is sent via HTTP header, which may be logged along the way. So this also give a short window, should
your access token be compromised.
Further Reading
This should cover the basics on the backend implementation. It’s worth checking the
djangorestframework_simplejwt settings for further
customization and to get a better idea of what the library offers.
The implementation on the frontend depends on what framework/library you are using. Some libraries and articles
covering popular frontend frameworks like angular/react/vue.js:
Angular JWT library
Angular 2 JWT library
Secure Your React and Redux App with JWT Authentication
Authenticating via JWT using Django, Axios, and Vue
The code used in this tutorial is available at github.com/sibtc/drf-jwt-example.

How to Use JWT Authentication with Django REST Framework

[Django 2.1.3 / Python 3.6.5 / Bootstrap 4.1.3]
In this tutorial we are going to explore some of the Django Crispy Forms features to handle advanced/custom forms
rendering. This blog post started as a discussion in our community forum,
so I decided to compile the insights and solutions in a blog post to benefit a wider audience.
Table of Contents
Introduction
Installation
Basic Form Rendering
Basic Crispy Form Rendering
Custom Fields Placement with Crispy Forms
Crispy Forms Layout Helpers
Custom Crispy Field
Conclusions
Introduction
Throughout this tutorial we are going to implement the following Bootstrap 4 form using Django APIs:

This was taken from Bootstrap 4 official documentation
as an example of how to use form rows.
NOTE!
The examples below refer to a base.html template. Consider the code below:
base.html
<!doctype html>
<html lang="en">
<head>
 <meta charset="utf-8">
 <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
 <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.1.3/css/bootstrap.min.css" integrity="sha384-MCw98/SFnGE8fJT3GXwEOngsV7Zt27NXFoaoApmYm81iuXoPkFOJwJ8ERdknLPMO" crossorigin="anonymous">
</head>
<body>
 <div class="container">
 {% block content %}
 {% endblock %}
 </div>
</body>
</html>




Installation
Install it using pip:
pip install django-crispy-forms


Add it to your INSTALLED_APPS and select which styles to use:
settings.py
INSTALLED_APPS = [
 ...

 'crispy_forms',
]

CRISPY_TEMPLATE_PACK = 'bootstrap4'


For detailed instructions about how to install django-crispy-forms, please refer to this tutorial:
How to Use Bootstrap 4 Forms With Django
Basic Form Rendering
The Python code required to represent the form above is the following:
from django import forms

STATES = (
 ('', 'Choose...'),
 ('MG', 'Minas Gerais'),
 ('SP', 'Sao Paulo'),
 ('RJ', 'Rio de Janeiro')
)

class AddressForm(forms.Form):
 email = forms.CharField(widget=forms.TextInput(attrs={'placeholder': 'Email'}))
 password = forms.CharField(widget=forms.PasswordInput())
 address_1 = forms.CharField(
 label='Address',
 widget=forms.TextInput(attrs={'placeholder': '1234 Main St'})
 )
 address_2 = forms.CharField(
 widget=forms.TextInput(attrs={'placeholder': 'Apartment, studio, or floor'})
 )
 city = forms.CharField()
 state = forms.ChoiceField(choices=STATES)
 zip_code = forms.CharField(label='Zip')
 check_me_out = forms.BooleanField(required=False)


In this case I’m using a regular Form, but it could also be a ModelForm based on a Django model with similar
fields. The state field and the STATES choices could be either a foreign key or anything else. Here I’m just using
a simple static example with three Brazilian states.
Template:
{% extends 'base.html' %}

{% block content %}
 <form method="post">
 {% csrf_token %}
 <table>{{ form.as_table }}</table>
 <button type="submit">Sign in</button>
 </form>
{% endblock %}


Rendered HTML:

Rendered HTML with validation state:

Basic Crispy Form Rendering
Same form code as in the example before.
Template:
{% extends 'base.html' %}

{% load crispy_forms_tags %}

{% block content %}
 <form method="post">
 {% csrf_token %}
 {{ form|crispy }}
 <button type="submit" class="btn btn-primary">Sign in</button>
 </form>
{% endblock %}


Rendered HTML:

Rendered HTML with validation state:

Custom Fields Placement with Crispy Forms
Same form code as in the first example.
Template:
{% extends 'base.html' %}

{% load crispy_forms_tags %}

{% block content %}
 <form method="post">
 {% csrf_token %}
 <div class="form-row">
 <div class="form-group col-md-6 mb-0">
 {{ form.email|as_crispy_field }}
 </div>
 <div class="form-group col-md-6 mb-0">
 {{ form.password|as_crispy_field }}
 </div>
 </div>
 {{ form.address_1|as_crispy_field }}
 {{ form.address_2|as_crispy_field }}
 <div class="form-row">
 <div class="form-group col-md-6 mb-0">
 {{ form.city|as_crispy_field }}
 </div>
 <div class="form-group col-md-4 mb-0">
 {{ form.state|as_crispy_field }}
 </div>
 <div class="form-group col-md-2 mb-0">
 {{ form.zip_code|as_crispy_field }}
 </div>
 </div>
 {{ form.check_me_out|as_crispy_field }}
 <button type="submit" class="btn btn-primary">Sign in</button>
 </form>
{% endblock %}


Rendered HTML:

Rendered HTML with validation state:

Crispy Forms Layout Helpers
We could use the crispy forms layout helpers to achieve the same result as above. The implementation is done inside
the form __init__ method:
forms.py
from django import forms
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Layout, Submit, Row, Column

STATES = (
 ('', 'Choose...'),
 ('MG', 'Minas Gerais'),
 ('SP', 'Sao Paulo'),
 ('RJ', 'Rio de Janeiro')
)

class AddressForm(forms.Form):
 email = forms.CharField(widget=forms.TextInput(attrs={'placeholder': 'Email'}))
 password = forms.CharField(widget=forms.PasswordInput())
 address_1 = forms.CharField(
 label='Address',
 widget=forms.TextInput(attrs={'placeholder': '1234 Main St'})
 )
 address_2 = forms.CharField(
 widget=forms.TextInput(attrs={'placeholder': 'Apartment, studio, or floor'})
 )
 city = forms.CharField()
 state = forms.ChoiceField(choices=STATES)
 zip_code = forms.CharField(label='Zip')
 check_me_out = forms.BooleanField(required=False)

 def __init__(self, *args, **kwargs):
 super().__init__(*args, **kwargs)
 self.helper = FormHelper()
 self.helper.layout = Layout(
 Row(
 Column('email', css_class='form-group col-md-6 mb-0'),
 Column('password', css_class='form-group col-md-6 mb-0'),
 css_class='form-row'
 ),
 'address_1',
 'address_2',
 Row(
 Column('city', css_class='form-group col-md-6 mb-0'),
 Column('state', css_class='form-group col-md-4 mb-0'),
 Column('zip_code', css_class='form-group col-md-2 mb-0'),
 css_class='form-row'
 ),
 'check_me_out',
 Submit('submit', 'Sign in')
 )


The template implementation is very minimal:
{% extends 'base.html' %}

{% load crispy_forms_tags %}

{% block content %}
 {% crispy form %}
{% endblock %}


The end result is the same.
Rendered HTML:

Rendered HTML with validation state:

Custom Crispy Field
You may also customize the field template and easily reuse throughout your application. Let’s say we want to use the
custom Bootstrap 4 checkbox:

From the official documentation, the necessary HTML to output the input above:
<div class="custom-control custom-checkbox">
 <input type="checkbox" class="custom-control-input" id="customCheck1">
 <label class="custom-control-label" for="customCheck1">Check this custom checkbox</label>
</div>


Using the crispy forms API, we can create a new template for this custom field in our “templates” folder:
custom_checkbox.html
{% load crispy_forms_field %}

<div class="form-group">
 <div class="custom-control custom-checkbox">
 {% crispy_field field 'class' 'custom-control-input' %}
 <label class="custom-control-label" for="{{ field.id_for_label }}">{{ field.label }}</label>
 </div>
</div>


Now we can create a new crispy field, either in our forms.py module or in a new Python module named fields.py
or something.
forms.py
from crispy_forms.layout import Field

class CustomCheckbox(Field):
 template = 'custom_checkbox.html'


We can use it now in our form definition:
forms.py
class CustomFieldForm(AddressForm):
 def __init__(self, *args, **kwargs):
 super().__init__(*args, **kwargs)
 self.helper = FormHelper()
 self.helper.layout = Layout(
 Row(
 Column('email', css_class='form-group col-md-6 mb-0'),
 Column('password', css_class='form-group col-md-6 mb-0'),
 css_class='form-row'
 ),
 'address_1',
 'address_2',
 Row(
 Column('city', css_class='form-group col-md-6 mb-0'),
 Column('state', css_class='form-group col-md-4 mb-0'),
 Column('zip_code', css_class='form-group col-md-2 mb-0'),
 css_class='form-row'
 ),
 CustomCheckbox('check_me_out'), # <-- Here
 Submit('submit', 'Sign in')
 )


(PS: the AddressForm was defined here and is the same as in the previous example.)
The end result:

Conclusions
There is much more Django Crispy Forms can do. Hopefully this tutorial gave you some extra insights on how to use the
form helpers and layout classes. As always, the official documentation is the best source of information:
Django Crispy Forms layouts docs
Also, the code used in this tutorial is available on GitHub at github.com/sibtc/advanced-crispy-forms-examples.

Advanced Form Rendering with Django Crispy Forms

In this tutorial you are going to learn how to implement Token-based authentication using Django REST Framework (DRF).
The token authentication works by exchanging username and password for a token that will be used in all subsequent
requests so to identify the user on the server side.
The specifics of how the authentication is handled on the client side vary a lot depending on the
technology/language/framework you are working with. The client could be a mobile application using iOS or Android.
It could be a desktop application using Python or C++. It could be a Web application using PHP or Ruby.
But once you understand the overall process, it’s easier to find the necessary resources and documentation for your
specific use case.
Token authentication is suitable for client-server applications, where the token is safely stored. You should never
expose your token, as it would be (sort of) equivalent of a handing out your username and password.
Table of Contents
Setting Up The REST API Project (If you already know how to start a DRF project you can skip this)
Implementing the Token Authentication
User Requesting a Token
Conclusions
Setting Up The REST API Project
So let’s start from the very beginning. Install Django and DRF:
pip install django
pip install djangorestframework


Create a new Django project:
django-admin.py startproject myapi .


Navigate to the myapi folder:
cd myapi


Start a new app. I will call my app core:
django-admin.py startapp core


Here is what your project structure should look like:
myapi/
 |-- core/
 | |-- migrations/
 | |-- __init__.py
 | |-- admin.py
 | |-- apps.py
 | |-- models.py
 | |-- tests.py
 | +-- views.py
 |-- __init__.py
 |-- settings.py
 |-- urls.py
 +-- wsgi.py
manage.py


Add the core app (you created) and the rest_framework app (you installed) to the INSTALLED_APPS, inside the
settings.py module:
myapi/settings.py
INSTALLED_APPS = [
 # Django Apps
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',

 # Third-Party Apps
 'rest_framework',

 # Local Apps (Your project's apps)
 'myapi.core',
]


Return to the project root (the folder where the manage.py script is), and migrate the database:
python manage.py migrate


Let’s create our first API view just to test things out:
myapi/core/views.py
from rest_framework.views import APIView
from rest_framework.response import Response

class HelloView(APIView):
 def get(self, request):
 content = {'message': 'Hello, World!'}
 return Response(content)


Now register a path in the urls.py module:
myapi/urls.py
from django.urls import path
from myapi.core import views

urlpatterns = [
 path('hello/', views.HelloView.as_view(), name='hello'),
]


So now we have an API with just one endpoint /hello/ that we can perform GET requests. We can use the browser to
consume this endpoint, just by accessing the URL http://127.0.0.1:8000/hello/:

We can also ask to receive the response as plain JSON data by passing the format parameter in the querystring like
http://127.0.0.1:8000/hello/?format=json:

Both methods are fine to try out a DRF API, but sometimes a command line tool is more handy as we can play more easily
with the requests headers. You can use cURL, which is widely available on all major
Linux/macOS distributions:
curl http://127.0.0.1:8000/hello/



But usually I prefer to use HTTPie, which is a pretty awesome Python command line tool:
http http://127.0.0.1:8000/hello/



Now let’s protect this API endpoint so we can implement the token authentication:
myapi/core/views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import IsAuthenticated # <-- Here


class HelloView(APIView):
 permission_classes = (IsAuthenticated,) # <-- And here

 def get(self, request):
 content = {'message': 'Hello, World!'}
 return Response(content)


Try again to access the API endpoint:
http http://127.0.0.1:8000/hello/



And now we get an HTTP 403 Forbidden error. Now let’s implement the token authentication so we can access this
endpoint.
Implementing the Token Authentication
We need to add two pieces of information in our settings.py module. First include rest_framework.authtoken to
your INSTALLED_APPS and include the TokenAuthentication to REST_FRAMEWORK:
myapi/settings.py
INSTALLED_APPS = [
 # Django Apps
 'django.contrib.admin',
 'django.contrib.auth',
 'django.contrib.contenttypes',
 'django.contrib.sessions',
 'django.contrib.messages',
 'django.contrib.staticfiles',

 # Third-Party Apps
 'rest_framework',
 'rest_framework.authtoken', # <-- Here

 # Local Apps (Your project's apps)
 'myapi.core',
]

REST_FRAMEWORK = {
 'DEFAULT_AUTHENTICATION_CLASSES': [
 'rest_framework.authentication.TokenAuthentication', # <-- And here
 ],
}


Migrate the database to create the table that will store the authentication tokens:
python manage.py migrate



Now we need a user account. Let’s just create one using the manage.py command line utility:
python manage.py createsuperuser --username vitor --email vitor@example.com


The easiest way to generate a token, just for testing purpose, is using the command line utility again:
python manage.py drf_create_token vitor



This piece of information, the random string 9054f7aa9305e012b3c2300408c3dfdf390fcddf is what we are going to use
next to authenticate.
But now that we have the TokenAuthentication in place, let’s try to make another request to our /hello/ endpoint:
http http://127.0.0.1:8000/hello/



Notice how our API is now providing some extra information to the client on the required authentication method.
So finally, let’s use our token!
http http://127.0.0.1:8000/hello/ 'Authorization: Token 9054f7aa9305e012b3c2300408c3dfdf390fcddf'



And that’s pretty much it. For now on, on all subsequent request you should include the header Authorization: Token 9054f7aa9305e012b3c2300408c3dfdf390fcddf.
The formatting looks weird and usually it is a point of confusion on how to set this header. It will depend on the
client and how to set the HTTP request header.
For example, if we were using cURL, the command would be something like this:
curl http://127.0.0.1:8000/hello/ -H 'Authorization: Token 9054f7aa9305e012b3c2300408c3dfdf390fcddf'


Or if it was a Python requests call:
import requests

url = 'http://127.0.0.1:8000/hello/'
headers = {'Authorization': 'Token 9054f7aa9305e012b3c2300408c3dfdf390fcddf'}
r = requests.get(url, headers=headers)


Or if we were using Angular, you could implement an HttpInterceptor and set a header:
import { Injectable } from '@angular/core';
import { HttpRequest, HttpHandler, HttpEvent, HttpInterceptor } from '@angular/common/http';
import { Observable } from 'rxjs';

@Injectable()
export class AuthInterceptor implements HttpInterceptor {
 intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
 const user = JSON.parse(localStorage.getItem('user'));
 if (user && user.token) {
 request = request.clone({
 setHeaders: {
 Authorization: `Token ${user.accessToken}`
 }
 });
 }
 return next.handle(request);
 }
}




User Requesting a Token
The DRF provide an endpoint for the users to request an authentication token using their username and password.
Include the following route to the urls.py module:
myapi/urls.py
from django.urls import path
from rest_framework.authtoken.views import obtain_auth_token # <-- Here
from myapi.core import views

urlpatterns = [
 path('hello/', views.HelloView.as_view(), name='hello'),
 path('api-token-auth/', obtain_auth_token, name='api_token_auth'), # <-- And here
]


So now we have a brand new API endpoint, which is /api-token-auth/. Let’s first inspect it:
http http://127.0.0.1:8000/api-token-auth/



It doesn’t handle GET requests. Basically it’s just a view to receive a POST request with username and password.
Let’s try again:
http post http://127.0.0.1:8000/api-token-auth/ username=vitor password=123



The response body is the token associated with this particular user. After this point you store this token and apply
it to the future requests.
Then, again, the way you are going to make the POST request to the API depends on the language/framework you are using.
If this was an Angular client, you could store the token in the localStorage, if this was a Desktop CLI application
you could store in a text file in the user’s home directory in a dot file.
Conclusions
Hopefully this tutorial provided some insights on how the token authentication works. I will try to follow up this
tutorial providing some concrete examples of Angular applications, command line applications and Web clients as well.
It is important to note that the default Token implementation has some limitations such as only one token per user, no
built-in way to set an expiry date to the token.
You can grab the code used in this tutorial at github.com/sibtc/drf-token-auth-example.

How to Implement Token Authentication using Django REST Framework

<div class="info">
 Updated at Nov 8, 2018:
 New video added to the series: How to integrate Django forms with Bootstrap 4.
</div>

In this tutorial series, we are going to explore Django’s authentication system by implementing sign up, login, logout,
password change, password reset and protected views from non-authenticated users. This tutorial is organized in 8
videos, one for each topic, ranging from 4 min to 15 min each.

<ul>
 <li><a href="#setup">Setup</a></li>
 <li><a href="#sign-up">Sign Up</a></li>
 <li><a href="#login">Login</a></li>
 <li><a href="#logout">Logout</a></li>
 <li><a href="#password-change">Password Change</a></li>
 <li><a href="#password-reset">Password Reset</a></li>
 <li><a href="#protecting-views">Protecting Views</a></li>
 <li><a href="#bootstrap-4-forms">Bootstrap 4 Forms (Extra)</a></li>
 <li><a href="#conclusions">Conclusions</a></li>
</ul>

<hr />

<h4 id="setup">Setup</h4>

Starting a Django project from scratch, creating a virtual environment and an initial Django app. After that, we are
going to setup the templates and create an initial view to start working on the authentication.

If you are already familiar with Django, you can skip this video and jump to the <a href="#sign-up">Sign Up</a> tutorial below.

<iframe width="560" height="315" src="https://www.youtube.com/embed/60GTvKCuam8" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="sign-up">Sign Up</h4>

First thing we are going to do is implement a sign up view using the built-in <code class="highlighter-rouge">UserCreationForm</code>. In this video you
are also going to get some insights on basic Django form processing.

<iframe width="560" height="315" src="https://www.youtube.com/embed/9-ALutreCkE" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="login">Login</h4>

In this video tutorial we are going to first include the built-in Django auth URLs to our project and proceed to
implement the login view.

<iframe width="560" height="315" src="https://www.youtube.com/embed/R8yjsg0TlCI" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="logout">Logout</h4>

In this tutorial we are going to include Django logout and also start playing with conditional templates, displaying
different content depending if the user is authenticated or not.

<iframe width="560" height="315" src="https://www.youtube.com/embed/UtasCG2Eb7o" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="password-change">Password Change</h4>

Next The password change is a view where an authenticated user can change their password.

<iframe width="560" height="315" src="https://www.youtube.com/embed/mJkwKsSnWXo" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="password-reset">Password Reset</h4>

This tutorial is perhaps the most complicated one, because it involves several views and also sending emails. In this
video tutorial you are going to learn how to use the default implementation of the password reset process and how to
change the email messages.

<iframe width="560" height="315" src="https://www.youtube.com/embed/JBhpo0o1Ajg" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="protecting-views">Protecting Views</h4>

After implementing the whole authentication system, this video gives you an overview on how to protect some views from
non authenticated users by using the <code class="highlighter-rouge">@login_required</code> decorator and also using class-based views mixins.

<iframe width="560" height="315" src="https://www.youtube.com/embed/o0nvMYxBpRo" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="bootstrap-4-forms">Bootstrap 4 Forms</h4>

Extra video showing how to integrate Django with Bootstrap 4 and how to use Django Crispy Forms to render Bootstrap
forms properly. This video also include some general advices and tips about using Bootstrap 4.

<iframe width="560" height="315" src="https://www.youtube.com/embed/Sy8dVjJqLHI" frameborder="0" allow="accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture" allowfullscreen=""></iframe>

<hr />

<h4 id="conclusions">Conclusions</h4>

If you want to learn more about Django authentication and some extra stuff related to it, like how to use Bootstrap
to make your auth forms look good, or how to write unit tests for your auth-related views, you can read the forth part
of my beginners guide to Django: <a href="/series/2017/09/25/a-complete-beginners-guide-to-django-part-4.html">A Complete Beginner’s Guide to Django - Part 4 - Authentication</a>.

Of course the official documentation is the best source of information: <a href="https://docs.djangoproject.com/en/2.1/topics/auth/default/">Using the Django authentication system</a>

The code used in this tutorial: <a href="https://github.com/sibtc/django-auth-tutorial-example">github.com/sibtc/django-auth-tutorial-example</a>

This was my first time recording this kind of content, so your feedback is highly appreciated. Please let me know what
you think!

And don’t forget to <a href="https://www.youtube.com/channel/UCS3lgmo8xYcOGTn_fv2mLgw?sub_confirmation=1">subscribe to my YouTube channel!</a>
I will post exclusive Django tutorials there. So stay tuned! :-)

Updated at Nov 8, 2018:
  New video added to the series: How to integrate Django forms with Bootstrap 4.


In this tutorial series, we are going to explore Django’s authentication system by implementing sign up, login, logout,
password change, password reset and protected views from non-authenticated users. This tutorial is organized in 8
videos, one for each topic, ranging from 4 min to 15 min each.
Setup
Sign Up
Login
Logout
Password Change
Password Reset
Protecting Views
Bootstrap 4 Forms (Extra)
Conclusions
Setup
Starting a Django project from scratch, creating a virtual environment and an initial Django app. After that, we are
going to setup the templates and create an initial view to start working on the authentication.
If you are already familiar with Django, you can skip this video and jump to the Sign Up tutorial below.




Sign Up
First thing we are going to do is implement a sign up view using the built-in UserCreationForm. In this video you
are also going to get some insights on basic Django form processing.




Login
In this video tutorial we are going to first include the built-in Django auth URLs to our project and proceed to
implement the login view.




Logout
In this tutorial we are going to include Django logout and also start playing with conditional templates, displaying
different content depending if the user is authenticated or not.




Password Change
Next The password change is a view where an authenticated user can change their password.




Password Reset
This tutorial is perhaps the most complicated one, because it involves several views and also sending emails. In this
video tutorial you are going to learn how to use the default implementation of the password reset process and how to
change the email messages.




Protecting Views
After implementing the whole authentication system, this video gives you an overview on how to protect some views from
non authenticated users by using the @login_required decorator and also using class-based views mixins.




Bootstrap 4 Forms
Extra video showing how to integrate Django with Bootstrap 4 and how to use Django Crispy Forms to render Bootstrap
forms properly. This video also include some general advices and tips about using Bootstrap 4.




Conclusions
If you want to learn more about Django authentication and some extra stuff related to it, like how to use Bootstrap
to make your auth forms look good, or how to write unit tests for your auth-related views, you can read the forth part
of my beginners guide to Django: A Complete Beginner’s Guide to Django - Part 4 - Authentication.
Of course the official documentation is the best source of information: Using the Django authentication system
The code used in this tutorial: github.com/sibtc/django-auth-tutorial-example
This was my first time recording this kind of content, so your feedback is highly appreciated. Please let me know what
you think!
And don’t forget to subscribe to my YouTube channel!
I will post exclusive Django tutorials there. So stay tuned! :-)

Django Authentication Video Tutorial

Hey, there!
This is Kenn, Your Daily Advocate from CodeWithKenn!
Welcome to the Blog! Make yourself at home! 
In this article, we won't talk much. For a couple of days, I've been thinking about a way of making my content easier and shorter so that Developers won't have to spend so much time scrolling; I want this Blog a Place of Resources and Discovery, not a Boring Blog.
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644857915236/HNJherNb5.jpeg" alt="save-your-time-2a7fb4.jpg" />
<h1 id="heading-what-are-python-lists">What are Python Lists?</h1>
Today, we're gonna get one of the first resources, Python Lists Easy Cheatsheet.
Python Lists are used to store an ordered collection of items, which might be of different types but usually they aren't.
<h1 id="heading-cheatsheet-content">Cheatsheet Content</h1>
<h2 id="heading-step-1">Step 1</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644858459662/CGjzyuSpc.png" alt="carbon (1).png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code># Create an empty list using square brackets.
numbers = []
print(numbers) # Output: []

# Create an empty list using list().
numbers = list()
print(numbers) # Output: []

# Create a list of numbers.
numbers = [1, 2, 3]
print(numbers) # Output: [1, 2, 3]

# Create a list of numbers in a range.
numbers = list(range(1, 4))
print(numbers) # Output: [1, 2, 3]

# Create a list of tuples.
tuples_list = [(1, 2), (2, 4), (3, 6)]
print(tuples_list) # Output: [(1, 2), (2, 4), (3, 6)]
</code></pre><h2 id="heading-step-2">Step 2</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644858667007/4gPld_KaY.png" alt="carbon (2).png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code># Create a list of lists.
list_of_lists = [[1, 2], [2, 4], [3, 6]]
print(list_of_lists) # Output: [[1, 2], [2, 4], [3, 6]]

# Create a list with items of different data types.
random_list = [1, "hey", [1, 2]]
print(random_list) # Output: [1, "hey", [1, 2]]

# Get length of list by using len() method.
numbers = [5, 8, 8]
print(len(numbers)) # Output: 3

# Access elements of a list by indexing.
str_list = ["hey", "there!", "how", "are", "you?"]
print(str_list[0]) # Output: "hey"
print(str_list[len(str_list) - 1]) # Output: "you?"
print(str_list[-1]) # Output: "you?"
</code></pre><h2 id="heading-step-3">Step 3</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644858847484/c0ND1W-Sd.png" alt="carbon (3).png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code># Slicing a list.
str_list = ["hey", "there!", "how", "are", "you?"]
print(str_list[2:]) # Output: ["how", "are", "you?"]
print(str_list[:2]) # Output: ["hey", "there!"]
print(str_list[-3:]) # Output: ["how", "are", "you?"]
print(str_list[:-3]) # Output: ["hey", "there!"]
print(str_list[1:4]) # Output: ["there!", "how", "are"]
# Get a copy of list by slicing.
print(str_list[:]) # Output: ["hey", "there!", "how", "are", "you?"]
</code></pre><h2 id="heading-step-4">Step 4</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644859067103/nPyMnPAEf.png" alt="carbon (4).png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code>
# Append to a list.
numbers = [1, 2]
print(numbers) # Output: [1, 2]
numbers.append(3)
print(numbers) # Output: [1, 2, 3]

# Concatenate lists.
numbers = [1, 2]
strings = ["Hey", "there"]
print(numbers + strings) # Output: [1, 2, "Hey", "there"]
</code></pre><h2 id="heading-step-5">Step 5</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644859171328/c4_s-MMOg.png" alt="carbon (5).png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code># Mutate a list, that is, change its contents.
numbers = [1, 2, 3]
numbers[0] = 100
print(numbers) # Output: [100, 2, 3]
numbers[0:2] = [300, 400]
print(numbers) # Output: [300, 400, 3]
numbers[1:3] = []
print(numbers) # Output: [300]
numbers[:] = []
print(numbers) # Output: []

# Insert item to a list.
greeting = ["how", "you?"]
greeting.insert(1, "are")
print(greeting) # Output: ["how", "are", "you?"]
</code></pre><h2 id="heading-step-6">Step 6</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644859543800/asWaM8DPR.png" alt="carbon-lists-2.png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code># Our list of lists.
matrix_1 = [[1,1,1], [2,2,2], [3,3,3]]
matrix_2 = [[4,4,4], [5,5,5], [6,6,6]]

# Matrix addition with for loop.
# Assuming that the matrices are of the same dimensions
matrix_sum = []
for row in range(len(matrix_1)):
 matrix_sum.append([])
 for column in range(len(matrix[0])):
 matrix_sum[row].append(matrix_1[row][column] + matrix_2[row][column])
</code></pre><h2 id="heading-step-7">Step 7</h2>
<h3 id="heading-snippet-image">Snippet - Image</h3>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644859582127/JjYy8T4TYT.png" alt="carbon-lists-2-1.png" />
<h3 id="heading-snippet-code">Snippet - Code</h3>
<pre><code>
# Our list of lists.
matrix_1 = [[1,1,1], [2,2,2], [3,3,3]]
matrix_2 = [[4,4,4], [5,5,5], [6,6,6]]


# Rewrite using list comprehension only for inner lists.
matrix_sum = []
for row in range(len(matrix_1)):
 matrix_sum.append([matrix_1[row][column] + matrix_2[row][column] for column in range(len(matrix[0]))])

# Rewrite using nested list comprehension.
matrix_sum = [[matrix_1[row][column] + matrix_2[row][column] for column in range(len(matrix[0]))]
 for row in range(len(matrix_1))]

print(matrix_sum) # Output: [[5, 5, 5], [7, 7, 7], [9, 9, 9]]
</code></pre><h2 id="heading-credit-cheat-sheet">Credit - Cheat Sheet</h2>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1644859646012/41yYXVXuE.png" alt="carbon.png" />
 All the Credit goes to <a target="_blank" href="https://gist.github.com/ShyamaSankar">@ShyamaSankar</a>
<h1 id="heading-before-leaving">🌎 Before Leaving</h1>
<ul>
<li> <a target="_blank" href="https://codewithkenn.hashnode.dev/discover-amazing-python-resources-for-free">Discover Amazing Python Resources FOR FREE!</a>
</li>
<li> <a target="_blank" href="https://codewithkenn.hashnode.dev/you-need-to-learn-python-in-2022-business-perspective">YOU NEED to Learn Python in 2022! (Business Perspective)</a>
</li>
</ul>
<ul>
<li><a target="_blank" href="https://twitter.com/CodeWithKenn">Twitter</a> </li>
<li><a target="_blank" href="https://github.com/KennStack01">Github</a> </li>
<li><a target="_blank" href="https://www.linkedin.com/in/kennkibadi/">LinkedIn</a> </li>
<li><a target="_blank" href="https://www.instagram.com/codewithkenn_/">Instagram</a> </li>
<li><a target="_blank" href="https://www.facebook.com/Code-With-Kenn-104376625415201">Facebook</a></li>
<li><a target="_blank" href="https://www.bio.link/IamKenn">See My Bio Link</a></li>
</ul>
Want to start blogging? 🔥<a target="_blank" href="https://hashnode.com/@CodeWithKenn/joinme">Join NOW!</a>

Hey, there!
This is Kenn, Your Daily Advocate from CodeWithKenn!
Welcome to the Blog! Make yourself at home! 
In this article, we won't talk much. For a couple of days, I've been thinking about a way of making my content easier and shorter so that Developers won't have to spend so much time scrolling; I want this Blog a Place of Resources and Discovery, not a Boring Blog.

What are Python Lists?
Today, we're gonna get one of the first resources, Python Lists Easy Cheatsheet.
Python Lists are used to store an ordered collection of items, which might be of different types but usually they aren't.
Cheatsheet Content
Step 1
Snippet - Image

Snippet - Code
# Create an empty list using square brackets.
numbers = []
print(numbers) # Output: []

# Create an empty list using list().
numbers = list()
print(numbers) # Output: []

# Create a list of numbers.
numbers = [1, 2, 3]
print(numbers) # Output: [1, 2, 3]

# Create a list of numbers in a range.
numbers = list(range(1, 4))
print(numbers) # Output: [1, 2, 3]

# Create a list of tuples.
tuples_list = [(1, 2), (2, 4), (3, 6)]
print(tuples_list) # Output: [(1, 2), (2, 4), (3, 6)]

Step 2
Snippet - Image

Snippet - Code
# Create a list of lists.
list_of_lists = [[1, 2], [2, 4], [3, 6]]
print(list_of_lists) # Output: [[1, 2], [2, 4], [3, 6]]

# Create a list with items of different data types.
random_list = [1, "hey", [1, 2]]
print(random_list) # Output: [1, "hey", [1, 2]]

# Get length of list by using len() method.
numbers = [5, 8, 8]
print(len(numbers)) # Output: 3

# Access elements of a list by indexing.
str_list = ["hey", "there!", "how", "are", "you?"]
print(str_list[0]) # Output: "hey"
print(str_list[len(str_list) - 1]) # Output: "you?"
print(str_list[-1]) # Output: "you?"

Step 3
Snippet - Image

Snippet - Code
# Slicing a list.
str_list = ["hey", "there!", "how", "are", "you?"]
print(str_list[2:]) # Output: ["how", "are", "you?"]
print(str_list[:2]) # Output: ["hey", "there!"]
print(str_list[-3:]) # Output: ["how", "are", "you?"]
print(str_list[:-3]) # Output: ["hey", "there!"]
print(str_list[1:4]) # Output: ["there!", "how", "are"]
# Get a copy of list by slicing.
print(str_list[:]) # Output: ["hey", "there!", "how", "are", "you?"]

Step 4
Snippet - Image

Snippet - Code

# Append to a list.
numbers = [1, 2]
print(numbers) # Output: [1, 2]
numbers.append(3)
print(numbers) # Output: [1, 2, 3]

# Concatenate lists.
numbers = [1, 2]
strings = ["Hey", "there"]
print(numbers + strings) # Output: [1, 2, "Hey", "there"]

Step 5
Snippet - Image

Snippet - Code
# Mutate a list, that is, change its contents.
numbers = [1, 2, 3]
numbers[0] = 100
print(numbers) # Output: [100, 2, 3]
numbers[0:2] = [300, 400]
print(numbers) # Output: [300, 400, 3]
numbers[1:3] = []
print(numbers) # Output: [300]
numbers[:] = []
print(numbers) # Output: []

# Insert item to a list.
greeting = ["how", "you?"]
greeting.insert(1, "are")
print(greeting) # Output: ["how", "are", "you?"]

Step 6
Snippet - Image

Snippet - Code
# Our list of lists.
matrix_1 = [[1,1,1], [2,2,2], [3,3,3]]
matrix_2 = [[4,4,4], [5,5,5], [6,6,6]]

# Matrix addition with for loop.
# Assuming that the matrices are of the same dimensions
matrix_sum = []
for row in range(len(matrix_1)):
  matrix_sum.append([])
  for column in range(len(matrix[0])):
      matrix_sum[row].append(matrix_1[row][column] + matrix_2[row][column])

Step 7
Snippet - Image

Snippet - Code

# Our list of lists.
matrix_1 = [[1,1,1], [2,2,2], [3,3,3]]
matrix_2 = [[4,4,4], [5,5,5], [6,6,6]]


# Rewrite using list comprehension only for inner lists.
matrix_sum = []
for row in range(len(matrix_1)):
  matrix_sum.append([matrix_1[row][column] + matrix_2[row][column] for column in range(len(matrix[0]))])

# Rewrite using nested list comprehension.
matrix_sum = [[matrix_1[row][column] + matrix_2[row][column] for column in range(len(matrix[0]))]
              for row in range(len(matrix_1))]

print(matrix_sum) # Output: [[5, 5, 5], [7, 7, 7], [9, 9, 9]]

Credit - Cheat Sheet

 All the Credit goes to @ShyamaSankar
🌎 Before Leaving
 Discover Amazing Python Resources FOR FREE!
 YOU NEED to Learn Python in 2022! (Business Perspective)
Twitter 
Github 
LinkedIn 
Instagram 
Facebook
See My Bio Link
Want to start blogging?  🔥Join NOW!

Python Lists Cheat Sheet - Developer Resources

What if I told you You can learn Python in ONLY three weeks? 
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1642666266619/IWrUSxbAn.jpeg" alt="a4a7c2e1507c539f41229ca8200d3a44.jpg" />
Will you trust me? haha 😅
Hey, there! 
This is Kenn, Your Daily Advocate, and Friend from CodeWithKenn!
In this Article, You gonna get one of the easiest Python Learning Roadmap and Resources for Free. Make sure to follow up for more articles coming. That's it! Let's get down to Business!
Don't worry, You won't get bored with CodeWithKenn! Easy, Free, Short, but Use articles for Your Journey. Let's Gooooooo!
<h1 id="heading-brief-description-of-python">Brief Description of Python</h1>
If you just come from my article on <a target="_blank" href="https://codewithkenn.hashnode.dev/you-need-to-learn-python-in-2022-business-perspective">Learning Python in 2022! (Business Perspective)</a>, You've already known much on the subject.
In a nutshell, Python is one of the easiest programming languages to get started with. For this reason, the community keeps growing every month, with a market value of over $10 Billion.
So, why not get the Resources you really need for the Journey???
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1642666622218/c1IFjXUpB.jpeg" alt="4752b206e5dc2c3713d57f536d527d06.jpg" />
<h1 id="heading-get-what-you-really-need">Get what You really need</h1>
As they are plenty of them, here are the two main resources you can use as references to go and check according to what you need:
<h2 id="heading-refresh-the-memory-with-the-fundamentals">Refresh the memory with the Fundamentals</h2>
Without the fundamentals, there is no way to bring innovation, meaning there is a necessity of getting a foundation. Here are the main resources:
<h4 id="heading-videos-resources">Videos Resources</h4>
 <a target="_blank" href="https://www.youtube.com/watch?v=rfscVS0vtbw">FreeCodeCamp Beginners Course</a> 
 <a target="_blank" href="https://www.youtube.com/playlist?list=PL-osiE80TeTskrapNbzXhwoFUiLCjGgY7">Corey Schafer Beginners Python Videos Series</a> 
 <a target="_blank" href="https://www.youtube.com/watch?v=8ext9G7xspg">Start Building Projects</a> 
<h4 id="heading-community-resources">Community Resources</h4>
 <a target="_blank" href="https://forum.freecodecamp.org/c/python/424">FreeCodeCamp Python Community</a> 
 <a target="_blank" href="https://www.reddit.com/r/Python/">Python Sub-reddit to ask for help</a> 
<h4 id="heading-docs-resources">Docs Resources</h4>
 <a target="_blank" href="https://docs.python.org/3/tutorial/index.html">Python Official Docs</a> 
 <a target="_blank" href="https://devdocs.io/python~3.10-tutorial/">DevDocs Python</a> 
<h2 id="heading-python-for-web-development">Python for Web Development</h2>
Here you have all You need for your Backend Journey. Don't overthink, use this and start building stuff:
<h3 id="heading-interested-in-flask-app-development">Interested in Flask App Development?</h3>
<h4 id="heading-videos-resources">Videos Resources</h4>
 <a target="_blank" href="https://www.youtube.com/playlist?list=PL-osiE80TeTs4UjLw5MM6OjgkjFeUxCYH">Corey Schafer Beginners Flask Videos Series</a> 
 <a target="_blank" href="https://www.youtube.com/watch?v=yKHJsLUENl0">Build a CRUD APP with Python Engineer</a> 
<h4 id="heading-community-resources">Community Resources</h4>
Coding, but Stuck with some bugs? Here is the Solution, Go and ask the Community:
 <a target="_blank" href="https://www.reddit.com/r/flask/">Flask Subreddit Community</a>
 <a target="_blank" href="https://www.reddit.com/r/Python/">Python Subreddit Community</a>
<h4 id="heading-docs-resources">Docs Resources</h4>
 <a target="_blank" href="https://github.com/humiaozuzu/awesome-flask">Awesome Flask Links</a> 
 <a target="_blank" href="https://github.com/realpython/discover-flask">Flask for your Project</a> 
 <a target="_blank" href="https://flask.palletsprojects.com/en/latest/">Flask Latest Docs</a> 
<h3 id="heading-django-app-development">Django App Development</h3>
<h4 id="heading-videos-resources">Videos Resources</h4>
 <a target="_blank" href="https://www.youtube.com/playlist?list=PL-osiE80TeTtoQCKZ03TU5fNfx2UY6U4p">Corey Schafer Beginners Django Videos Series</a> 
 <a target="_blank" href="https://www.youtube.com/watch?v=F5mRW0jo-U4&amp;t=64s">FreeCodeCamp Djajngo for Beginners</a> 
<h4 id="heading-community-resources">Community Resources</h4>
Coding, but Stuck with some bugs? Here is the Solution, Go and ask the Community:
 <a target="_blank" href="https://www.reddit.com/r/django/">Django Subreddit Community</a>
 <a target="_blank" href="https://www.djangoproject.com/community/blogs/">Django Community</a>
<h4 id="heading-docs-resources">Docs Resources</h4>
 <a target="_blank" href="https://docs.djangoproject.com/en/4.0/intro/">Django Official Docs</a> 
 <a target="_blank" href="https://django.readthedocs.io/en/stable/contents.html">Django ReadTheDocs.io</a> 
🔥 This article is being updated, I'm adding Fast API Resources and AI/ML Resources on the Blog! Stay tuned! 
Stay tuned! More articles are coming out! Feel free to comment and share the articles to support me 🤙
<h1 id="heading-lets-connect">🌎 Let's connect</h1>
<ul>
<li><a target="_blank" href="https://twitter.com/CodeWithKenn">Twitter</a> </li>
<li><a target="_blank" href="https://github.com/KennStack01">Github</a> </li>
<li><a target="_blank" href="https://www.linkedin.com/in/kennkibadi/">LinkedIn</a> </li>
<li><a target="_blank" href="https://www.instagram.com/codewithkenn_/">Instagram</a> </li>
<li><a target="_blank" href="https://www.facebook.com/Code-With-Kenn-104376625415201">Facebook</a></li>
</ul>
Want to start blogging? 🔥<a target="_blank" href="https://hashnode.com/@CodeWithKenn/joinme">Join NOW!</a>

What if I told you You can learn Python in ONLY three weeks? 

Will you trust me? haha 😅
Hey, there! 
This is Kenn, Your Daily Advocate, and Friend from CodeWithKenn!
In this Article, You gonna get one of the easiest Python Learning Roadmap and Resources for Free. Make sure to follow up for more articles coming. That's it! Let's get down to Business!
Don't worry, You won't get bored with CodeWithKenn! Easy, Free, Short, but Use articles for Your Journey. Let's Gooooooo!
Brief Description of Python
If you just come from my article on Learning Python in 2022! (Business Perspective), You've already known much on the subject.
In a nutshell, Python is one of the easiest programming languages to get started with. For this reason, the community keeps growing every month, with a market value of over $10 Billion.
So, why not get the Resources you really need for the Journey???

Get what You really need
As they are plenty of them, here are the two main resources you can use as references to go and check according to what you need:
Refresh the memory with the Fundamentals
Without the fundamentals, there is no way to bring innovation, meaning there is a necessity of getting a foundation. Here are the main resources:
Videos Resources
 FreeCodeCamp Beginners Course 
 Corey Schafer Beginners Python Videos Series 
 Start Building Projects 
Community Resources
 FreeCodeCamp Python Community 
 Python Sub-reddit to ask for help 
Docs Resources
 Python Official Docs 
 DevDocs Python 
Python for Web Development
Here you have all You need for your Backend Journey. Don't overthink, use this and start building stuff:
Interested in Flask App Development?
Videos Resources
 Corey Schafer Beginners Flask Videos Series 
 Build a CRUD APP with Python Engineer 
Community Resources
Coding, but Stuck with some bugs? Here is the Solution, Go and ask the Community:
 Flask Subreddit Community
 Python Subreddit Community
Docs Resources
 Awesome Flask Links 
 Flask for your Project 
 Flask Latest Docs 
Django App Development
Videos Resources
 Corey Schafer Beginners Django Videos Series 
 FreeCodeCamp Djajngo for Beginners 
Community Resources
Coding, but Stuck with some bugs? Here is the Solution, Go and ask the Community:
 Django Subreddit Community
 Django Community
Docs Resources
 Django Official Docs 
 Django ReadTheDocs.io 
🔥 This article is being updated, I'm adding Fast API Resources and AI/ML Resources on the Blog! Stay tuned! 
Stay tuned! More articles are coming out! Feel free to comment and share the articles to support me 🤙
🌎 Let's connect
Twitter 
Github 
LinkedIn 
Instagram 
Facebook
Want to start blogging?  🔥Join NOW!

Discover Amazing Python Resources FOR FREE!

Python is one of the easiest programming languages to get started with. For this reason, the community keeps growing every month.
Because of its simplicity (of the Syntax), Python has become the most popular language.
Besides, Python helps Engineers build great products in many industries and professional domains.
The Programmer's life gets easier when it comes to having a look at Python.
<h1 id="heading-what-about-the-python-business-market-size">What about the Python Business Market size?</h1>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1642662070916/ha3UIJDHx.jpeg" alt="market-size-market-share.jpg" />
Python is an open-source language, which means that anyone can use it. However, if you look to an industry such as data analytics, in which Python can be used, the market value is over $10 billion.
Shared by <a target="_blank" href="https://www.futurelearn.com/info/insights/python-insights">futurelearn.com</a> 
<h1 id="heading-here-are-the-top-10-most-common-uses-of-python-by-industry">Here are the top 10 most common uses of Python by industry</h1>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1642662192938/xYTgi2Ycs.png" alt="pandemic-hero.png" />
 Insurance: Creating business insights with machine learning.
 Retail Banking: Flexible data transformation and manipulation.
 Aerospace: Meeting software system deadlines.
 Finance: Data mining to identify cross-sell opportunities.
 Business Services: API access to financial information
 Hardware: Automating network administration
 Healthcare: Predicting disease prognosis
 Consulting Services: Bespoke web development
 InfoTech: IT modernization
 Software: Adding extensibility to legacy applications
Shared by <a target="_blank" href="https://appdevelopermagazine.com/ten-industries-using-python-programming/">appdevelopermagazine.com</a> 
<h1 id="heading-here-are-5-world-class-software-companies-that-use-python">Here are 5 World-Class Software Companies That Use Python</h1>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1642662333807/Y73E563_X.jpeg" alt="COTW-TechAcquisitions-Shareable-2.jpg" />
(Photo by Visual Capitalist)
Google, Meta (Facebook), Instagram, Netflix, Instagram.
There are plenty of companies searching for Python Developers around the globe.
<h1 id="heading-hence-i-created-this-blog-to-help-you-out">Hence, I created this Blog to help you out!</h1>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1642662424540/nnlZkUO_y.jpeg" alt="Design-Blog-Page-Python.jpg" />
Hence, Learning Python helps you create Opportunities from jobs to Building Products people use.
I just got into Full-stack development using Python Software Development, React + Python as Tech Stack.
<h2 id="heading-make-sure-to-follow-codewithkenn-for-more-articles-about">Make sure to follow CodeWithKenn for more articles about:</h2>
 Learning Python in simple terms
 Building Side Projects and SaaS using React + Python
 Getting useful Resources and tips for your coding Journey
Stay tuned! More articles are coming out! Feel free to comment and share the articles to support me 🤙
<h1 id="heading-lets-connect">🌎 Let's connect</h1>
<ul>
<li><a target="_blank" href="https://twitter.com/CodeWithKenn">Twitter</a> </li>
<li><a target="_blank" href="https://github.com/KennStack01">Github</a> </li>
<li><a target="_blank" href="https://www.linkedin.com/in/kennkibadi/">LinkedIn</a> </li>
<li><a target="_blank" href="https://www.instagram.com/codewithkenn_/">Instagram</a> </li>
<li><a target="_blank" href="https://www.facebook.com/Code-With-Kenn-104376625415201">Facebook</a></li>
</ul>
Want to start blogging? 🔥<a target="_blank" href="https://hashnode.com/@CodeWithKenn/joinme">Join NOW!</a>

Python is one of the easiest programming languages to get started with. For this reason, the community keeps growing every month.
Because of its simplicity (of the Syntax), Python has become the most popular language.
Besides, Python helps Engineers build great products in many industries and professional domains.
The Programmer's life gets easier when it comes to having a look at Python.
What about the Python Business Market size?

Python is an open-source language, which means that anyone can use it. However, if you look to an industry such as data analytics, in which Python can be used, the market value is over $10 billion.
Shared by futurelearn.com 
Here are the top 10 most common uses of Python by industry

 Insurance: Creating business insights with machine learning.
 Retail Banking: Flexible data transformation and manipulation.
 Aerospace: Meeting software system deadlines.
 Finance: Data mining to identify cross-sell opportunities.
 Business Services: API access to financial information
 Hardware: Automating network administration
 Healthcare: Predicting disease prognosis
 Consulting Services: Bespoke web development
 InfoTech: IT modernization
 Software: Adding extensibility to legacy applications
Shared by appdevelopermagazine.com 
Here are 5 World-Class Software Companies That Use Python

(Photo by Visual Capitalist)
Google, Meta (Facebook), Instagram, Netflix, Instagram.
There are plenty of companies searching for Python Developers around the globe.
Hence, I created this Blog to help you out!

Hence, Learning Python helps you create Opportunities from jobs to Building Products people use.
I just got into Full-stack development using Python Software Development, React + Python as Tech Stack.
Make sure to follow CodeWithKenn for more articles about:
 Learning Python in simple terms
 Building Side Projects and SaaS using React + Python
 Getting useful Resources and tips for your coding Journey
Stay tuned! More articles are coming out! Feel free to comment and share the articles to support me 🤙
🌎 Let's connect
Twitter 
Github 
LinkedIn 
Instagram 
Facebook
Want to start blogging?  🔥Join NOW!

YOU NEED to Learn Python in 2022! (Business Perspective)

Python is one of the most popular coding languages available and is great as a starting point in your learning journey. It can be used for a range of things, such as web and internet development, software development application, network programming, and 3D graphics... (<a target="_blank" href="https://hethelinnovation.com/">hethelinnovation.com</a>)
While learning, we end up getting stuck in small bugs that can take more time to solve, whereas we could have solved it quickly if we could only remember the basics. 
So, this is a series of Basics Python tips to remember whenever we work with numbers and strings. You can also use this article as a reference somehow while coding...
Enjoy!
<h1 id="heading-python-numbers">Python Numbers</h1>
There are three numeric types we use in Python: 
<ul>
<li>int: or integer, is a whole number without decimals.</li>
</ul>
<pre><code>x = 1245
y = -789

print(type(x))
print(type(y))
</code></pre><ul>
<li>float: or Floating, a number with one or more decimals.</li>
</ul>
<pre><code>x = 12.45
y = 42E5

print(type(x))
print(type(y))
</code></pre><ul>
<li>complex: as studied in high school, is a number written with a "j" as the imaginary part.</li>
</ul>
<pre><code>x = 3 + 2j
y = -15j

print(type(x))
print(type(y))
</code></pre><h2 id="heading-numbers-types-conversion">Numbers Types Conversion</h2>
To convert numbers from one type (from the three) to another, we used methods.
In Python, a method is a function that is available for a given object because of the object's type.
So, You can convert from one type to another with the int(), float(), and complex() methods:
<pre><code>
x = 4 # int number
y = 0.8 # float number
z = 4j # complex number

# from int to float:
a = float(x)

# from float to int:
b = int(y)

# from int to complex:
c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))
</code></pre><h2 id="heading-lets-build-a-simple-calculator">Let's Build a Simple Calculator</h2>
<pre><code># Python Simple calculator

# Addition Function
def add(x, y):
 return x + y

# Substraction Function
def subtract(x, y):
 return x - y

# Multiplication Function
def multiply(x, y):
 return x * y

# Division Function
def divide(x, y):
 return x / y


def calculate(first_number, second_number, operator):
 if operator == "+":
 answer = add(first_number, second_number)
 return answer

 elif operator == "-":
 answer = subtract(first_number, second_number)
 return answer

 elif operator == "/":
 answer = divide(first_number, second_number)
 return answer
 elif operator == "*" or operator == "x":
 answer = subtract(first_number, second_number)
 return answer
 else:
 return "Invalid"


num1 = int(input("Enter the first number: "))
num2 = int(input("Enter the second number: "))
operator = input("Enter the Operator: ")

print(f"{num1} {operator} {num2} = {calculate(num1, num2, operator)}")
</code></pre><h1 id="heading-python-strings">Python Strings</h1>
Strings in python are surrounded by: 
<ul>
<li>Single quotation marks 
<pre><code>'bonjour'
</code></pre></li>
<li>Double quotation marks
<pre><code>"bonjour"
</code></pre></li>
</ul>
<h2 id="heading-use-a-variable-to-save-the-string">Use a Variable to save the String</h2>
The assignment sign is made of = (equal sign).
<pre><code>name = "Kennedy"
role = "Software Engineer"
print(name)
print(role)
</code></pre><h2 id="heading-we-can-also-use-multiline-strings">We can also use Multiline Strings</h2>
<pre><code>poem = """Your face is the grave of your nose
your face is the grave of your ears
your face is the grave of your face
once again your face overflows uncontrollably."""

print(poem)
</code></pre><h2 id="heading-accessing-a-character-of-the-string">Accessing a Character of the String</h2>
We can think of strings like an array made of characters. For example, the word "Elon Musk" is made of "E", "l", "o", "n", " ", "M", "u", "s" and "k" (Notice the space is also counted as a character).
The first character is counted at index 0 (not 1). 
<pre><code>greeting = "Hello, World!"
print(greeting[1]) #prints "e"
</code></pre><h2 id="heading-working-with-strings">Working with Strings</h2>
<h3 id="heading-checking-the-string-length">Checking the String Length</h3>
use the <code>len()</code> function
<pre><code>name = "Kennedy"
length_of_name = len(name)

print(length_of_name)
</code></pre><h3 id="heading-checking-an-existing-string-or-character-in-a-string">Checking an existing string or character in a string</h3>
Use the <code>in</code> keyword.
<pre><code>sentence = "Kennedy is a python programmer"
if "python" in a sentence:
 print("Yes, 'python' is present.")
</code></pre><h3 id="heading-most-common-string-methods">Most Common String Methods</h3>
<ul>
<li><code>capitalize()</code> method converts the first character of a string to an uppercase letter and lowercases all other characters.</li>
</ul>
<pre><code>name = "python"
print(name.capitalize())
</code></pre><ul>
<li><code>casefold()</code> method Converts string into lower case.</li>
</ul>
<pre><code>name = "PYTHON"
print(name.casefold())
</code></pre><ul>
<li><code>upper()</code> method converts all the characters into Uppercase.</li>
</ul>
<pre><code>name = "python"
print(name.upper())
</code></pre><ul>
<li><code>lower()</code> method converts all the characters into Lowercase.</li>
</ul>
<pre><code>name = "PYTHON"
print(name.lower())
</code></pre><ul>
<li><code>len()</code> method used to count the total number of characters in a string.</li>
</ul>
<pre><code>name = "python"
print( len(name) )
</code></pre><ul>
<li><code>find()</code> searches the string for a specified value and returns the position of where it was found.</li>
</ul>
<pre><code>sentence = "python is great"
print( sentence.find('great') )
</code></pre><ul>
<li><code>replace()</code> is used to replace a string with another.</li>
</ul>
<pre><code>sentence = "python is great"
new_sentence = sentence.replace('great', 'awesome') 
print(new_sentence)
</code></pre><ul>
<li><code>str()</code> is used for string conversion</li>
</ul>
<pre><code>ten = str(10)
print(ten) #converts 10 to '10'
</code></pre><ul>
<li>You can find more in the <a target="_blank" href="https://docs.python.org/2.5/lib/string-methods.html">Python.org Official Docs</a> </li>
</ul>
<h3 id="heading-lets-work-on-a-small-project">Let's work on a Small Project</h3>
<h4 id="heading-arrange-string-characters-such-that-lowercase-letters-should-come-first">- Arrange string characters such that lowercase letters should come first</h4>
Initial Code
<pre><code>noun = PrOgRamMinG

# Expected Output : rgaminPORMG
</code></pre>Solution
<pre><code>noun = "PrOgRamMinG"

# Let's create a Function to handle it

def arrange_string(my_string):
 print('Original String:', my_string)
 lower = []
 upper = []

 #Let's iterate and convert
 for char in my_string:
 if char.islower():
 # add lowercase characters to lower list
 lower.append(char)
 else:
 # add uppercase characters to lower list
 upper.append(char)

 # Join both list
 sorted_str = ''.join(lower + upper)
 print('Result:', sorted_str)

# Now, let's call execute the function we just created! 
arrange_string(noun)

# Output: 
# Original String: PrOgRamMinG
# Result: rgaminPORMG
</code></pre>Resources for more Details:
<ul>
<li><a target="_blank" href="https://www.w3schools.com/python/">www.w3schools.com</a> </li>
<li><a target="_blank" href="https://www.programiz.com/python-programming">www.programiz.com</a> </li>
<li><a target="_blank" href="https://pynative.com/python-string-exercise/#h-exercise-4-arrange-string-characters-such-that-lowercase-letters-should-come-first">www.pynative.com/</a> </li>
</ul>
👉 <a target="_blank" href="https://codewithkenn.hashnode.dev/">DISCOVER MORE useful ARTICLES</a> 
Thanks for reading this article, many others are coming very soon, Feel free to subscribe 🤙.
<h1 id="heading-lets-connect">🌎 Let's connect</h1>
<ul>
<li><a target="_blank" href="https://twitter.com/CodeWithKenn">Twitter</a> </li>
<li><a target="_blank" href="https://github.com/KennStack01">Github</a> </li>
<li><a target="_blank" href="https://www.linkedin.com/in/kennkibadi/">LinkedIn</a> </li>
<li><a target="_blank" href="https://www.instagram.com/codewithkenn_/">Instagram</a> </li>
</ul>
Want to start blogging? 🔥<a target="_blank" href="https://hashnode.com/@CodeWithKenn/joinme">Join NOW!</a>

Python is one of the most popular coding languages available and is great as a starting point in your learning journey. It can be used for a range of things, such as web and internet development, software development application, network programming, and 3D graphics... (hethelinnovation.com)
While learning, we end up getting stuck in small bugs that can take more time to solve, whereas we could have solved it quickly if we could only remember the basics. 
So, this is a series of Basics Python tips to remember whenever we work with numbers and strings. You can also use this article as a reference somehow while coding...
Enjoy!
Python Numbers
There are three numeric types we use in Python: 
int: or integer, is a whole number without decimals.
x = 1245
y = -789

print(type(x))
print(type(y))


float: or Floating, a number with one or more decimals.
x = 12.45
y = 42E5

print(type(x))
print(type(y))


complex: as studied in high school, is a number written with a "j" as the imaginary part.
x = 3 + 2j
y = -15j

print(type(x))
print(type(y))

Numbers Types Conversion
To convert numbers from one type (from the three) to another, we used methods.
In Python, a method is a function that is available for a given object because of the object's type.
So, You can convert from one type to another with the int(), float(), and complex() methods:

x = 4    # int number
y = 0.8  # float number
z = 4j   # complex number

# from int to float:
a = float(x)

# from float to int:
b = int(y)

# from int to complex:
c = complex(x)

print(a)
print(b)
print(c)

print(type(a))
print(type(b))
print(type(c))

Let's Build a Simple Calculator
# Python Simple calculator

# Addition Function
def add(x, y):
    return x + y

# Substraction Function
def subtract(x, y):
    return x - y

# Multiplication Function
def multiply(x, y):
    return x * y

# Division Function
def divide(x, y):
    return x / y


def calculate(first_number, second_number, operator):
    if operator == "+":
        answer = add(first_number, second_number)
        return answer

    elif operator == "-":
        answer = subtract(first_number, second_number)
        return answer

    elif operator == "/":
        answer = divide(first_number, second_number)
        return answer
    elif operator == "*" or operator == "x":
        answer = subtract(first_number, second_number)
        return answer
    else:
        return "Invalid"


num1 = int(input("Enter the first number: "))
num2 = int(input("Enter the second number: "))
operator = input("Enter the Operator: ")

print(f"{num1} {operator} {num2} = {calculate(num1, num2, operator)}")

Python Strings
Strings in python are surrounded by: 
Single quotation marks 
'bonjour'



Double quotation marks
"bonjour"



Use a Variable to save the String
The assignment sign is made of = (equal sign).
name = "Kennedy"
role = "Software Engineer"
print(name)
print(role)

We can also use Multiline Strings
poem = """Your face is the grave of your nose
your face is the grave of your ears
your face is the grave of your face
once again your face overflows uncontrollably."""

print(poem)

Accessing a Character of the String
We can think of strings like an array made of characters. For example, the word "Elon Musk" is made of "E", "l", "o", "n", " ", "M", "u", "s" and "k" (Notice the space is also counted as a character).
The first character is counted at index 0 (not 1). 
greeting = "Hello, World!"
print(greeting[1]) #prints "e"

Working with Strings
Checking the String Length
use the len() function
name = "Kennedy"
length_of_name = len(name)

print(length_of_name)

Checking an existing string or character in a string
Use the in keyword.
sentence = "Kennedy is a python programmer"
if "python" in a sentence:
  print("Yes, 'python' is present.")

Most Common String Methods
capitalize() method converts the first character of a string to an uppercase letter and lowercases all other characters.
name = "python"
print(name.capitalize())


casefold() method Converts string into lower case.
name = "PYTHON"
print(name.casefold())


upper() method converts all the characters into Uppercase.
name = "python"
print(name.upper())


lower() method converts all the characters into Lowercase.
name = "PYTHON"
print(name.lower())


len() method used to count the total number of characters in a string.
name = "python"
print( len(name) )


find() searches the string for a specified value and returns the position of where it was found.
sentence = "python is great"
print( sentence.find('great') )


replace() is used to replace a string with another.
sentence = "python is great"
new_sentence = sentence.replace('great', 'awesome') 
print(new_sentence)


str() is used for string conversion
ten = str(10)
print(ten) #converts 10 to '10'


You can find more in the Python.org Official Docs 
Let's work on a Small Project
- Arrange string characters such that lowercase letters should come first
Initial Code
noun = PrOgRamMinG

# Expected Output : rgaminPORMG

Solution
noun = "PrOgRamMinG"

# Let's create a Function to handle it

def arrange_string(my_string):
    print('Original String:', my_string)
    lower = []
    upper = []

    #Let's iterate and convert
    for char in my_string:
        if char.islower():
            # add lowercase characters to lower list
            lower.append(char)
        else:
            # add uppercase characters to lower list
            upper.append(char)

    # Join both list
    sorted_str = ''.join(lower + upper)
    print('Result:', sorted_str)

# Now, let's call execute the function we just created! 
arrange_string(noun)

# Output: 
# Original String: PrOgRamMinG
# Result: rgaminPORMG

Resources for more Details:
www.w3schools.com 
www.programiz.com 
www.pynative.com/ 
👉 DISCOVER MORE useful ARTICLES 
Thanks for reading this article, many others are coming very soon, Feel free to subscribe 🤙.
🌎 Let's connect
Twitter 
Github 
LinkedIn 
Instagram 
Want to start blogging?  🔥Join NOW!

Working with Numbers & Strings in Python

We live in a world full of resources and data. Being a Python Developer can't escape the trend. That being said, in this article you're going to get all the resources you need to get started for the Journey.
After learning Python basics, you'll find yourself being overwhelmed with a lot of information, and this can be very hard to go on. It becomes easier to get trapped in the Tutorial Hell 🔥.
<h1 id="heading-brief-description-of-flask">Brief Description of Flask</h1>
Flask is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries. 
In other words, The Flask Framework is a Python platform that provides a foundation for developing software applications using Python Programming language. 
If your goal is to use Python for Web Development apps, Flask is what you need (sort of) for the Journey. Flask helps you set the Backend of your Web App. It's equivalent to Django (Another Python Backend Framework), NodeJS, Ruby on Rails, and so on.
What is Special about Flask is its simplicity, there are not many things to get overwhelmed, You only get what you need, simply. 🤙
That being said, using your favorite front-end technology (React, Vue, Angular, Svelte, or whatever you prefer), before jumping to read on the resources, you really have to determine what you need, exactly. Because, as we just said at the beginning, there are tons of resources and information you don't need, but still it makes you overwhelmed... 
<h1 id="heading-check-these-resources">Check these Resources</h1>
As they are plenty of them, here are the two main resources you can use as references to go and check according to what you need:
<h3 id="heading-refresh-the-memory-with-the-fundamentals">Refresh the memory with the Fundamentals</h3>
Without the fundamentals, there is no way to bring innovation, meaning there is a necessity of getting a foundation. Here are the main resources:
 <a target="_blank" href="https://blog.miguelgrinberg.com/post/the-flask-mega-tutorial-part-i-hello-world">The Flask Mega-Tutorial</a>
 <a target="_blank" href="https://medium.com/javarevisited/5-best-python-flask-courses-for-beginners-2f262f8e23da">Five Best Python Flask Courses You need</a> 
<h3 id="heading-get-the-resources-you-need-to-build-real-world-projects">Get the Resources you need to Build Real-world Projects</h3>
Knowing the Fundamentals isn't sufficient for real-world projects, you need to know topics like plugins (to avoid reinventing the wheel). Get the resources here:
 <a target="_blank" href="https://github.com/humiaozuzu/awesome-flask">Awesome Flask Links</a> 
 <a target="_blank" href="https://github.com/realpython/discover-flask">Flask for your Project</a> 
<h3 id="heading-get-the-benefit-of-the-flask-community">Get the Benefit of the Flask Community</h3>
Coding, but Stuck with some bugs? Here is the Solution, Go and ask the Community:
 <a target="_blank" href="https://www.reddit.com/r/flask/">Flask Subreddit Community</a>
 <a target="_blank" href="https://www.reddit.com/r/Python/">Python Subreddit Community</a>
Thanks for reading this article, many others are coming very soon, Feel free to subscribe 🤙.
<h1 id="heading-lets-connect">🌎 Let's connect</h1>
<ul>
<li><a target="_blank" href="https://twitter.com/CodeWithKenn">Twitter</a> </li>
<li><a target="_blank" href="https://github.com/KennStack01">Github</a> </li>
<li><a target="_blank" href="https://www.linkedin.com/in/kennkibadi/">LinkedIn</a> </li>
<li><a target="_blank" href="https://www.instagram.com/codewithkenn_/">Instagram</a> </li>
</ul>
Want to start blogging? 🔥<a target="_blank" href="https://hashnode.com/@CodeWithKenn/joinme">Join NOW!</a>

We live in a world full of resources and data. Being a Python Developer can't escape the trend. That being said, in this article you're going to get all the resources you need to get started for the Journey.
After learning Python basics, you'll find yourself being overwhelmed with a lot of information, and this can be very hard to go on. It becomes easier to get trapped in the Tutorial Hell 🔥.
Brief Description of Flask
Flask is a micro web framework written in Python. It is classified as a microframework because it does not require particular tools or libraries. 
In other words, The Flask Framework is a Python platform that provides a foundation for developing software applications using Python Programming language. 
If your goal is to use Python for Web Development apps, Flask is what you need (sort of) for the Journey. Flask helps you set the Backend of your Web App. It's equivalent to Django (Another Python Backend Framework), NodeJS, Ruby on Rails, and so on.
What is Special about Flask is its simplicity, there are not many things to get overwhelmed, You only get what you need, simply. 🤙
That being said, using your favorite front-end technology (React, Vue, Angular, Svelte, or whatever you prefer), before jumping to read on the resources, you really have to determine what you need, exactly. Because, as we just said at the beginning, there are tons of resources and information you don't need, but still it makes you overwhelmed... 
Check these Resources
As they are plenty of them, here are the two main resources you can use as references to go and check according to what you need:
Refresh the memory with the Fundamentals
Without the fundamentals, there is no way to bring innovation, meaning there is a necessity of getting a foundation. Here are the main resources:
  The Flask Mega-Tutorial
  Five Best Python Flask Courses You need 
Get the Resources you need to Build Real-world Projects
Knowing the Fundamentals isn't sufficient for real-world projects, you need to know topics like plugins (to avoid reinventing the wheel). Get the resources here:
 Awesome Flask Links 
 Flask for your Project 
Get the Benefit of the Flask Community
Coding, but Stuck with some bugs? Here is the Solution, Go and ask the Community:
 Flask Subreddit Community
 Python Subreddit Community
Thanks for reading this article, many others are coming very soon, Feel free to subscribe 🤙.
🌎 Let's connect
Twitter 
Github 
LinkedIn 
Instagram 
Want to start blogging?  🔥Join NOW!

Amazing Flask Resources FOR FREE!

Breaking up django-ninja views

Nullable DRF FloatFields and Javascript

A Tip About DRF Permissions

Custom Exceptions in Django REST Framework

How to Add Django Models to the Wagtail Admin

Using Different Read and Write Serializers in Django REST Framework

Keeping Django Models Ordered

Using Private Packages in Python

Optimized Python

Tips for Using Django&#x27;s ManyToManyField

Sentinel values in Python

Celery and Django and Docker: Oh My!

pytest support for django-test-plus

Django Birthday: Recap

Django Birthday Party

Improved Django Tests

Django Performance: 4 Simple Things

Wagtail 1.0 (beta) best Django CMS?

Loading Django FileField and ImageFields from the file system

Recommended Django Project Layout

Python Dev Tip: DRY your shell with PYTHONSTARTUP

Django Debugging Bookmarklet Trick

Django 1.3 is out - time to upgrade!

Two new Django classes: deployment and the ecosystem

Investing in Yourself - A review of Django 1.1 Testing and Debugging by Karen M. Tracey

Early registration for our Advanced Django class ends soon

Django Training in 2010

Django 1.0 Template Development Review

Django Training

Django Software Foundation

Fret Free -- Introduction to Django and the Django Software Foundation

A Brief Intro to Docker for Djangonauts

Python 3 run command over SSH

Python: atexit

Python 12-factor apps with envparse

Extend Django Templates Smartly

<div class="medium-feed-item"><a href="https://python.plainenglish.io/functions-in-python-ad0d4968ac74?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*Ioql-UUznN_bHdHX" width="3424"></a>Python for Beginners Series&#x200A;&#x2014;&#x200A;Part 14<a href="https://python.plainenglish.io/functions-in-python-ad0d4968ac74?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Python for Beginners Series — Part 14
Continue reading on Python in Plain English »

Functions in Python

<div class="medium-feed-item"><a href="https://python.plainenglish.io/exception-handling-in-python-7ffba7d73328?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*ESAkKoPdiFvXo9HE" width="5184"></a>Python is a versatile programming language known for its simplicity, readability, and flexibility. Its ease of use and powerful libraries&#x2026;<a href="https://python.plainenglish.io/exception-handling-in-python-7ffba7d73328?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Python is a versatile programming language known for its simplicity, readability, and flexibility. Its ease of use and powerful libraries…
Continue reading on Python in Plain English »

Exception Handling in Python

<h4>Phil Nash, a C++ developer, says Python is the best starter language or a fantastic second language for frontend and web developers.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/800/0*sMEB_7LvN-TNTTJt.gif" /></figure>Python is a good place to start for new programmers looking for a first language or anybody who wants to add another language to their portfolio.According to Phil Nash, a developer supporter for SonarSource and one of the original creators of the C++ test framework, Catch2.“It’s a boring choice, but for exciting reasons,” Nash said to <a href="https://thenewstack.io/">The New Stack</a>.“It’s quite basic to start with, but it scales with you plain simple to being a genuinely industrial-strength, very popular language.There isn’t any language that comes close to covering all of those bases.”<h3>For a First Language, should you learn Python or JavaScript?</h3>But what’s the problem with using JavaScript as a first language?JavaScript is an excellent choice, but it was never meant to be a beginner-friendly language, according to Nash.This inspired a moral story about BASIC, a popular programming language from the 1980s that was meant for Basic All-purpose Symbolic Instruction Code. That was wonderful in that it was basic.The problem was that it wasn’t a very good language, so it wasn’t used for potential uses until Microsoft released Visual Basic in the 1990s, he said.Python is special in that it is simple to use, but as developers gain experience, they can dive into more complex uses and eventually build real-world applications, he adds.According to Nash, JavaScript is also fairly simple, but by chance instead of design.“[JavaScript] was created as part of something else and unexpectedly became the most popular language in the world just because it came bundled with the web,” he explained.“As a result, it’s a wonderful language to learn. It’s just not as user-friendly for beginners.”Python, on the other hand, covers all bases — it is both beginner and useful, according to Nash.“It reads more like pseudocode that you might put on paper when sketching out an ideal, that translates into real working code in a production code base,” he remarked. “It doesn’t get much more user-friendly than that, yet it’s also widely used in industry.”He regularly changes between Python and JavaScript, and the biggest challenge he faces is choosing whether or not to use a semicolon at the end of lines.“One of the problems with JavaScript is that many things are optional. Thus semicolons are optional, save for a few cases,” he observed.“One of Python’s guiding principles is that there should be just one correct method to do things.It’s not always true, but in speaking, they try to construct things in such a way that there is an obvious way, the Pythonic way, to do things.Everything seems to be fairly consistent. JavaScript is almost the total opposite of that.”<h3>Should You Learn Python as a Second Language?</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/0*0EyTJ5oo7kqD8-ou" /></figure>“But it’s useless,” you could reply. When it comes to the web and you’re a frontend/web developer, JavaScript wins every time.Consider this: Python is now making its way to the front, because of the launch of Anaconda’s open-source PyScript last year.“You can also use it as a fantastic web technology on the backend,” he said.“And it’s starting to show some potential of being a frontend language as well, although it’s very early days.It’s too early to say if it will take off, but if you already know Python, you can now call yourself (or believe yourself) a front-end developer, at least if you played with it.So it’s possible, which is impossible to say for many other languages.”But suppose it’s too late for you since you’ve already learned JavaScript or the other language.Python is also a good alternative language, according to Nash.“Python is a great scripting language,” he added. “It’s also a full feature for it since it grows to the challenge.”Python is also known as a dynamic language, which means that when you create a variable, you don’t have to specify what sort of variable it is (number, string, boolean).The language suggests it depending on how you use it, similarly to how JavaScript does. It is not true for strongly typed languages like Java or C++.He stated that dynamic languages are often easier for beginners.“Since Python is a dynamic language, you may create mistakes in the code that are only caught at runtime, whereas a strongly typed language detects it at compile time,” he stated.“Many people, myself included, prefer statically typed languages, notably for larger, more complex code bases.Python now has an optional type annotation, that provides many benefits, but only if you use an extra static analysis tool.”He said that Sonar has a static analysis tool that would detect mismatches in types of use, even in Python.Python can serve as an appealing frontend to more complex code bases like C++.“You can wrap it in a Python interface, and then it’s very easy to write Python code against that.So that’s what most <a href="https://thenewstack.io/7-must-have-python-tools-for-ml-devs-and-data-scientists/">ML libraries</a> do, for example, they’re written mostly in C++, the underlying heavy lifting, and then the nice, relatively easy Python frontend,” he said. “It’s great as a second language.Most developers, if they’re going to learn another language, should have Python in their toolkit.”Python is best known for its use in machine learning, but it’s also a popular language in finance, in part because of NumPy and quant computing, which applies mathematical and statistical methods to financial and risk management problems.“Quant developers, traditionally have worked pretty much exclusively in C++, and maybe with MATLAB for sketching things out, and then they’ll convert their code into C++ for performance,” he said.“But with Python and NumPy, they find they get everything in one package.Their code looks like what they would have written in MATLAB, but it performs like C ++ under the hood.”<h3>What Python Developers Should Know</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/400/0*XRjarpQdNGsdw2-d.png" /></figure>There are two major Python frameworks for web development on the backend: Django and Flask. Nash builds websites with Flask.“Django is more of a standard web framework, where you have to do things the Django way.“And now you’re almost a Django developer,” he said. “Flask takes inspiration from Django but is far less demanding.And you can put in exactly the level you want, add more dependencies, and do things your way, which is my choice when I’m programming.”He also mentioned that there are millions of courses and resources available for learning these frameworks or anything else using Python.Python is also pre-installed on pcs using a Unix-based os, such as MacOS or Linux.It is simple to install on Windows PCs. It can then be used via the command line by typing Python.Then it opens an interactive shell, where developers can quickly start writing code.It can also be accessed using IDEs such as PyCharm, a Python IDE, or a VS Code plugin.It is not, for example, a high-performance language like C++ or Java, though Python can work on those projects as well.“When performance isn’t an issue, it’s usually the best option,” he says.“Alternatively, you can use it alongside a fast language; you can easily connect with C++ and have the best of both worlds.”More content at <a href="https://plainenglish.io/">PlainEnglish.io</a>.Sign up for our <a href="http://newsletter.plainenglish.io/">free weekly newsletter</a>. Follow us on <a href="https://twitter.com/inPlainEngHQ">Twitter</a>, <a href="https://www.linkedin.com/company/inplainenglish/">LinkedIn</a>, <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw">YouTube</a>, and <a href="https://discord.gg/GtDtUAvyhW">Discord</a>.Interested in scaling your software startup? Check out <a href="https://circuit.ooo?utm=publication-post-cta">Circuit</a>.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=58b056397dba" width="1" height="1" alt=""><hr><a href="https://python.plainenglish.io/veteran-c-developer-says-python-is-the-profitable-starting-language-58b056397dba">Veteran C++ Developer Says Python Is The Profitable Starting Language</a> was originally published in <a href="https://python.plainenglish.io">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Phil Nash, a C++ developer, says Python is the best starter language or a fantastic second language for frontend and web developers.

Python is a good place to start for new programmers looking for a first language or anybody who wants to add another language to their portfolio.
According to Phil Nash, a developer supporter for SonarSource and one of the original creators of the C++ test framework, Catch2.
“It’s a boring choice, but for exciting reasons,” Nash said to The New Stack.
“It’s quite basic to start with, but it scales with you plain simple to being a genuinely industrial-strength, very popular language.
There isn’t any language that comes close to covering all of those bases.”
For a First Language, should you learn Python or JavaScript?
But what’s the problem with using JavaScript as a first language?
JavaScript is an excellent choice, but it was never meant to be a beginner-friendly language, according to Nash.
This inspired a moral story about BASIC, a popular programming language from the 1980s that was meant for Basic All-purpose Symbolic Instruction Code. That was wonderful in that it was basic.
The problem was that it wasn’t a very good language, so it wasn’t used for potential uses until Microsoft released Visual Basic in the 1990s, he said.
Python is special in that it is simple to use, but as developers gain experience, they can dive into more complex uses and eventually build real-world applications, he adds.
According to Nash, JavaScript is also fairly simple, but by chance instead of design.
“[JavaScript] was created as part of something else and unexpectedly became the most popular language in the world just because it came bundled with the web,” he explained.
“As a result, it’s a wonderful language to learn. It’s just not as user-friendly for beginners.”
Python, on the other hand, covers all bases — it is both beginner and useful, according to Nash.
“It reads more like pseudocode that you might put on paper when sketching out an ideal, that translates into real working code in a production code base,” he remarked. “It doesn’t get much more user-friendly than that, yet it’s also widely used in industry.”
He regularly changes between Python and JavaScript, and the biggest challenge he faces is choosing whether or not to use a semicolon at the end of lines.
“One of the problems with JavaScript is that many things are optional. Thus semicolons are optional, save for a few cases,” he observed.
“One of Python’s guiding principles is that there should be just one correct method to do things.
It’s not always true, but in speaking, they try to construct things in such a way that there is an obvious way, the Pythonic way, to do things.
Everything seems to be fairly consistent. JavaScript is almost the total opposite of that.”
Should You Learn Python as a Second Language?

“But it’s useless,” you could reply. When it comes to the web and you’re a frontend/web developer, JavaScript wins every time.
Consider this: Python is now making its way to the front, because of the launch of Anaconda’s open-source PyScript last year.
“You can also use it as a fantastic web technology on the backend,” he said.
“And it’s starting to show some potential of being a frontend language as well, although it’s very early days.
It’s too early to say if it will take off, but if you already know Python, you can now call yourself (or believe yourself) a front-end developer, at least if you played with it.
So it’s possible, which is impossible to say for many other languages.”
But suppose it’s too late for you since you’ve already learned JavaScript or the other language.
Python is also a good alternative language, according to Nash.
“Python is a great scripting language,” he added. “It’s also a full feature for it since it grows to the challenge.”
Python is also known as a dynamic language, which means that when you create a variable, you don’t have to specify what sort of variable it is (number, string, boolean).
The language suggests it depending on how you use it, similarly to how JavaScript does. It is not true for strongly typed languages like Java or C++.
He stated that dynamic languages are often easier for beginners.
“Since Python is a dynamic language, you may create mistakes in the code that are only caught at runtime, whereas a strongly typed language detects it at compile time,” he stated.
“Many people, myself included, prefer statically typed languages, notably for larger, more complex code bases.
Python now has an optional type annotation, that provides many benefits, but only if you use an extra static analysis tool.”
He said that Sonar has a static analysis tool that would detect mismatches in types of use, even in Python.
Python can serve as an appealing frontend to more complex code bases like C++.
“You can wrap it in a Python interface, and then it’s very easy to write Python code against that.
So that’s what most ML libraries do, for example, they’re written mostly in C++, the underlying heavy lifting, and then the nice, relatively easy Python frontend,” he said. “It’s great as a second language.
Most developers, if they’re going to learn another language, should have Python in their toolkit.”
Python is best known for its use in machine learning, but it’s also a popular language in finance, in part because of NumPy and quant computing, which applies mathematical and statistical methods to financial and risk management problems.
“Quant developers, traditionally have worked pretty much exclusively in C++, and maybe with MATLAB for sketching things out, and then they’ll convert their code into C++ for performance,” he said.
“But with Python and NumPy, they find they get everything in one package.
Their code looks like what they would have written in MATLAB, but it performs like C ++ under the hood.”
What Python Developers Should Know

There are two major Python frameworks for web development on the backend: Django and Flask. Nash builds websites with Flask.
“Django is more of a standard web framework, where you have to do things the Django way.
“And now you’re almost a Django developer,” he said. “Flask takes inspiration from Django but is far less demanding.
And you can put in exactly the level you want, add more dependencies, and do things your way, which is my choice when I’m programming.”
He also mentioned that there are millions of courses and resources available for learning these frameworks or anything else using Python.
Python is also pre-installed on pcs using a Unix-based os, such as MacOS or Linux.
It is simple to install on Windows PCs. It can then be used via the command line by typing Python.
Then it opens an interactive shell, where developers can quickly start writing code.
It can also be accessed using IDEs such as PyCharm, a Python IDE, or a VS Code plugin.
It is not, for example, a high-performance language like C++ or Java, though Python can work on those projects as well.
“When performance isn’t an issue, it’s usually the best option,” he says.
“Alternatively, you can use it alongside a fast language; you can easily connect with C++ and have the best of both worlds.”
More content at PlainEnglish.io.
Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.
Interested in scaling your software startup? Check out Circuit.

Veteran C++ Developer Says Python Is The Profitable Starting Language was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Veteran C++ Developer Says Python Is The Profitable Starting Language

<div class="medium-feed-item"><a href="https://python.plainenglish.io/python-classes-5f8293275ee5?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*JX9mnaaSRj9C7AKF" width="3543"></a>Python for Beginners Series&#x200A;&#x2014;&#x200A;Part 15<a href="https://python.plainenglish.io/python-classes-5f8293275ee5?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Python for Beginners Series — Part 15
Continue reading on Python in Plain English »

Python Classes

<div class="medium-feed-item"><a href="https://python.plainenglish.io/exploring-lucrative-opportunities-beyond-freelance-platforms-7badbdd22ad7?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*1a1MmI4rs5qtk_sF" width="6016"></a>Python for Profit<a href="https://python.plainenglish.io/exploring-lucrative-opportunities-beyond-freelance-platforms-7badbdd22ad7?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Python for Profit
Continue reading on Python in Plain English »

Exploring Lucrative Opportunities Beyond Freelance Platforms

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*u_o1Dephmea46DpM.jpg" /></figure>Chatbots have become increasingly popular over the past few years, with more and more businesses and individuals turning to conversational AI technology to improve their customer service, automate routine tasks, and enhance user engagement. One of the most powerful chatbot development tools available today is ChatGPT, a cutting-edge natural language processing (NLP) technology built on the GPT-3.5 architecture and powered by Python.In this article, we’ll take a closer look at ChatGPT and explore how it is revolutionizing the conversational AI landscape with Python.<h3>What is ChatGPT?</h3>ChatGPT is an advanced conversational AI technology that is designed to understand and interpret human language in a way that is more accurate and contextually relevant than ever before. It is built on the GPT-3.5 architecture, which is a variant of the GPT-3 architecture that was trained on an even larger dataset of text.At its core, ChatGPT is a language model that is capable of generating human-like responses to natural language input. This means that it can understand the meaning behind a user’s message and generate a response that is appropriate and relevant to the context of the conversation.One of the key advantages of ChatGPT over other chatbot development tools is its ability to learn and adapt to new contexts and domains. This is achieved through a process known as “fine-tuning,” in which the language model is trained on a specific set of data or use case.<h3>How is ChatGPT Powered by Python?</h3>Python is one of the most popular programming languages for AI and machine learning development, thanks to its ease of use, flexibility, and extensive set of libraries and frameworks.ChatGPT is no exception — it is powered by Python and leverages a variety of Python libraries and tools to perform its NLP tasks. One of the most important libraries for ChatGPT development is OpenAI’s Python API, which provides a simple and intuitive interface for accessing the ChatGPT model.Here is an example of how to use the OpenAI Python API to generate a response to user input:<pre>import openai openai.api_key = &quot;INSERT YOUR API KEY HERE&quot; def generate_response(prompt): response = openai.Completion.create( engine=&quot;text-davinci-002&quot;, prompt=prompt, max_tokens=1024, n=1, stop=None, temperature=0.5, ) return response.choices[0].text.strip() while True: user_input = input(&quot;User: &quot;) if user_input.lower() == &quot;exit&quot;: break response = generate_response(user_input) print(&quot;ChatGPT: &quot; + response)</pre>In this example, we first set our OpenAI API key, then define a function called generate_response that takes a prompt as input and returns a response generated by the Text-Davinci-002 engine. We then use a while loop to continuously prompt the user for input and generate responses until the user types &quot;exit&quot; to end the program.<h3>Why is ChatGPT a Game-Changer in Conversational AI?</h3>ChatGPT is a game-changer in the world of conversational AI for a number of reasons. Firstly, it is capable of generating responses that are much more human-like and natural-sounding than other chatbot development tools. This makes for a more engaging and authentic user experience, which is essential for building customer trust and loyalty.Secondly, ChatGPT is highly adaptable and can be fine-tuned to work with a wide range of use cases and domains. This means that it can be customized to suit the needs of different businesses and organizations, from customer service chatbots to virtual assistants and language learning tools.Finally, ChatGT’s integration with Python makes it highly accessible and easy to use for developers of all levels. Python is known for its simplicity and readability, and the vast ecosystem of libraries and tools available for it make it an ideal choice for building AI and machine learning applications.In addition, the OpenAI Python API provides a streamlined way to access the ChatGPT model and generate responses, even for those without a deep understanding of NLP or machine learning. This means that developers can focus on building the user interface and logic of their chatbot application, rather than getting bogged down in the technical details of how the AI works.<h3>How is ChatGPT Being Used Today?</h3>ChatGPT is being used in a variety of industries and domains to power conversational AI applications of all types. Some examples of its current use cases include:<ul><li>Customer service chatbots: ChatGPT can be trained on large datasets of customer support interactions to provide personalized, helpful responses to user queries and complaints.</li><li>Virtual assistants: ChatGPT can be used to power virtual assistants that can help users with a wide range of tasks, from scheduling appointments to providing recommendations based on user preferences.</li><li>Language learning tools: ChatGPT can be used to build language learning tools that provide interactive and engaging language practice exercises, such as conversation simulations and writing prompts.</li><li>Social media bots: ChatGPT can be used to build social media bots that can engage with users and generate content based on user input and preferences.</li></ul><h3>Conclusion</h3>ChatGPT is a powerful and revolutionary technology that is changing the face of conversational AI. Its advanced NLP capabilities, coupled with its adaptability and ease of use through Python, make it an ideal choice for developers looking to build engaging and effective chatbot applications. With its potential for a wide range of use cases and industries, ChatGPT is sure to continue making waves in the world of AI and machine learning for years to come.More content at <a href="https://plainenglish.io/">PlainEnglish.io</a>.Sign up for our <a href="http://newsletter.plainenglish.io/">free weekly newsletter</a>. Follow us on <a href="https://twitter.com/inPlainEngHQ">Twitter</a>, <a href="https://www.linkedin.com/company/inplainenglish/">LinkedIn</a>, <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw">YouTube</a>, and <a href="https://discord.gg/GtDtUAvyhW">Discord</a>.Interested in scaling your software startup? Check out <a href="https://circuit.ooo?utm=publication-post-cta">Circuit</a>.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b0c387b76b02" width="1" height="1" alt=""><hr><a href="https://python.plainenglish.io/chatgpt-revolutionizing-the-conversational-ai-landscape-with-python-b0c387b76b02">ChatGPT: Revolutionizing the Conversational AI Landscape with Python</a> was originally published in <a href="https://python.plainenglish.io">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Chatbots have become increasingly popular over the past few years, with more and more businesses and individuals turning to conversational AI technology to improve their customer service, automate routine tasks, and enhance user engagement. One of the most powerful chatbot development tools available today is ChatGPT, a cutting-edge natural language processing (NLP) technology built on the GPT-3.5 architecture and powered by Python.
In this article, we’ll take a closer look at ChatGPT and explore how it is revolutionizing the conversational AI landscape with Python.
What is ChatGPT?
ChatGPT is an advanced conversational AI technology that is designed to understand and interpret human language in a way that is more accurate and contextually relevant than ever before. It is built on the GPT-3.5 architecture, which is a variant of the GPT-3 architecture that was trained on an even larger dataset of text.
At its core, ChatGPT is a language model that is capable of generating human-like responses to natural language input. This means that it can understand the meaning behind a user’s message and generate a response that is appropriate and relevant to the context of the conversation.
One of the key advantages of ChatGPT over other chatbot development tools is its ability to learn and adapt to new contexts and domains. This is achieved through a process known as “fine-tuning,” in which the language model is trained on a specific set of data or use case.
How is ChatGPT Powered by Python?
Python is one of the most popular programming languages for AI and machine learning development, thanks to its ease of use, flexibility, and extensive set of libraries and frameworks.
ChatGPT is no exception — it is powered by Python and leverages a variety of Python libraries and tools to perform its NLP tasks. One of the most important libraries for ChatGPT development is OpenAI’s Python API, which provides a simple and intuitive interface for accessing the ChatGPT model.
Here is an example of how to use the OpenAI Python API to generate a response to user input:
import openai
openai.api_key = "INSERT YOUR API KEY HERE"
def generate_response(prompt):
    response = openai.Completion.create(
        engine="text-davinci-002",
        prompt=prompt,
        max_tokens=1024,
        n=1,
        stop=None,
        temperature=0.5,
    )
    return response.choices[0].text.strip()
while True:
    user_input = input("User: ")
    if user_input.lower() == "exit":
        break
    response = generate_response(user_input)
    print("ChatGPT: " + response)
In this example, we first set our OpenAI API key, then define a function called generate_response that takes a prompt as input and returns a response generated by the Text-Davinci-002 engine. We then use a while loop to continuously prompt the user for input and generate responses until the user types "exit" to end the program.
Why is ChatGPT a Game-Changer in Conversational AI?
ChatGPT is a game-changer in the world of conversational AI for a number of reasons. Firstly, it is capable of generating responses that are much more human-like and natural-sounding than other chatbot development tools. This makes for a more engaging and authentic user experience, which is essential for building customer trust and loyalty.
Secondly, ChatGPT is highly adaptable and can be fine-tuned to work with a wide range of use cases and domains. This means that it can be customized to suit the needs of different businesses and organizations, from customer service chatbots to virtual assistants and language learning tools.
Finally, ChatGT’s integration with Python makes it highly accessible and easy to use for developers of all levels. Python is known for its simplicity and readability, and the vast ecosystem of libraries and tools available for it make it an ideal choice for building AI and machine learning applications.
In addition, the OpenAI Python API provides a streamlined way to access the ChatGPT model and generate responses, even for those without a deep understanding of NLP or machine learning. This means that developers can focus on building the user interface and logic of their chatbot application, rather than getting bogged down in the technical details of how the AI works.
How is ChatGPT Being Used Today?
ChatGPT is being used in a variety of industries and domains to power conversational AI applications of all types. Some examples of its current use cases include:

Customer service chatbots: ChatGPT can be trained on large datasets of customer support interactions to provide personalized, helpful responses to user queries and complaints.
Virtual assistants: ChatGPT can be used to power virtual assistants that can help users with a wide range of tasks, from scheduling appointments to providing recommendations based on user preferences.
Language learning tools: ChatGPT can be used to build language learning tools that provide interactive and engaging language practice exercises, such as conversation simulations and writing prompts.
Social media bots: ChatGPT can be used to build social media bots that can engage with users and generate content based on user input and preferences.

Conclusion
ChatGPT is a powerful and revolutionary technology that is changing the face of conversational AI. Its advanced NLP capabilities, coupled with its adaptability and ease of use through Python, make it an ideal choice for developers looking to build engaging and effective chatbot applications. With its potential for a wide range of use cases and industries, ChatGPT is sure to continue making waves in the world of AI and machine learning for years to come.
More content at PlainEnglish.io.
Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.
Interested in scaling your software startup? Check out Circuit.

ChatGPT: Revolutionizing the Conversational AI Landscape with Python was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

ChatGPT: Revolutionizing the Conversational AI Landscape with Python

<h4>Python Shorts — Part 3</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UYcp2CWlau25j8KdOo_cCg.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@cdr6934?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Chris Ried</a> on <a href="https://unsplash.com/s/photos/python-programming?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure>In the <a href="https://medium.com/@hrmnmichaels/iterators-in-python-bd7332ddbc00">previous post</a> we looked at iterators. Here, we will showcase generators — which fulfil a similar purpose, but are more convenient to use. Generators are functions returning an iterator, thus we can iterate over them.For demonstration, let us re-use the example from the previous post, namely generating the first n square numbers. This is done with the following code:<pre>def square(n): i = 0 while (i &lt; n): yield i**2 i += 1</pre>A value is generated and returned every time when reaching the yield statement. The generator can then be used like any other iterator, e.g.:<pre>for x in square(5): print(x) print(sum(square(5)))</pre><h3>Generator Functions</h3>To make things even more convenient, there are generator functions. They are the generator equivalent of list comprehension, and defined by an expression in round brackets, such as: g = (x**2 for x in range(5))If we inspect g, we see that is a generator object — and we can use it in any function that consumes an Iterable (and naturally also use the generator expression directly):<pre>print(sum(g)) print((x**2 for x in range(5)))</pre>Thanks for reading!This post is part of a series show-casing important Python concepts quickly. You can find the other parts here:<ul><li>Part 1: <a href="https://medium.com/@hrmnmichaels/lambda-functions-in-python-a124cebc2e99">Lambda Functions in Python</a></li><li>Part 2: <a href="https://medium.com/@hrmnmichaels/iterators-in-python-bd7332ddbc00">Iterators in Python</a></li><li>Part 4: <a href="https://medium.com/@hrmnmichaels/advanced-iteration-in-python-with-enumerate-and-zip-676b31ceac44">Advanced Iteration in Python with enumerate() and zip()</a></li><li>Part 5: <a href="https://medium.com/@hrmnmichaels/managing-resources-in-python-with-context-managers-with-statement-f07afc1afb4f">Managing Resources in Python with Context Managers (with statement)</a></li><li>Part 6: <a href="https://medium.com/@hrmnmichaels/generating-temporary-files-and-directories-in-python-dfc11f017a97">Generating Temporary Files and Directories in Python</a></li><li>Part 7: <a href="https://medium.com/@hrmnmichaels/logging-in-python-3df84ce78cef">Logging in Python</a></li><li>Part 8: <a href="https://medium.com/gitconnected/partial-functions-in-python-66998eef1384">Partial Functions in Python</a></li><li>Part 9: <a href="https://medium.com/gitconnected/f-strings-in-python-80e30c64fb95">f-Strings in Python</a></li></ul>More content at <a href="https://plainenglish.io/">PlainEnglish.io</a>.Sign up for our <a href="http://newsletter.plainenglish.io/">free weekly newsletter</a>. Follow us on <a href="https://twitter.com/inPlainEngHQ">Twitter</a>, <a href="https://www.linkedin.com/company/inplainenglish/">LinkedIn</a>, <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw">YouTube</a>, and <a href="https://discord.gg/GtDtUAvyhW">Discord</a>.Interested in scaling your software startup? Check out <a href="https://circuit.ooo?utm=publication-post-cta">Circuit</a>.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a8d2e700945e" width="1" height="1" alt=""><hr><a href="https://python.plainenglish.io/generators-and-generator-expressions-in-python-a8d2e700945e">Generators and Generator Expressions in Python</a> was originally published in <a href="https://python.plainenglish.io">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Python Shorts — Part 3
Photo by Chris Ried on Unsplash
In the previous post we looked at iterators. Here, we will showcase generators — which fulfil a similar purpose, but are more convenient to use. Generators are functions returning an iterator, thus we can iterate over them.
For demonstration, let us re-use the example from the previous post, namely generating the first n square numbers. This is done with the following code:
def square(n):
 i = 0
 while (i < n):
 yield i**2
 i += 1
A value is generated and returned every time when reaching the yield statement. The generator can then be used like any other iterator, e.g.:
for x in square(5):
 print(x)
print(sum(square(5)))
Generator Functions
To make things even more convenient, there are generator functions. They are the generator equivalent of list comprehension, and defined by an expression in round brackets, such as: g = (x**2 for x in range(5))
If we inspect g, we see that is a generator object — and we can use it in any function that consumes an Iterable (and naturally also use the generator expression directly):
print(sum(g))
print((x**2 for x in range(5)))
Thanks for reading!
This post is part of a series show-casing important Python concepts quickly. You can find the other parts here:

Part 1: Lambda Functions in Python
Part 2: Iterators in Python
Part 4: Advanced Iteration in Python with enumerate() and zip()
Part 5: Managing Resources in Python with Context Managers (with statement)
Part 6: Generating Temporary Files and Directories in Python
Part 7: Logging in Python
Part 8: Partial Functions in Python
Part 9: f-Strings in Python

More content at PlainEnglish.io.
Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.
Interested in scaling your software startup? Check out Circuit.

Generators and Generator Expressions in Python was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Generators and Generator Expressions in Python

<div class="medium-feed-item">ChatGPT created an error-free code to scrape news from the respective website.<a href="https://python.plainenglish.io/chatgpt-generated-code-to-scrape-news-from-the-website-a2ae26705e02?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

ChatGPT created an error-free code to scrape news from the respective website.
Continue reading on Python in Plain English »

ChatGPT generated code to scrape news from the website

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*xin0ZnZubqgM-DreXV6eXA.jpeg" /><figcaption>Photo by <a href="https://unsplash.com/@chuttersnap?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">CHUTTERSNAP</a> on <a href="https://unsplash.com/photos/JChRnikx0tM?utm_source=unsplash&amp;utm_medium=referral&amp;utm_content=creditCopyText">Unsplash</a></figcaption></figure>Variables in Python are like containers for storing the data values.Example:<pre>Age=21</pre>Where age is the variable name and 21 is information associated with the variable name, in this variable 21 is a number.<h4>Valid variable name in python</h4>Variable name contains only letters, numbers, and, underscore but can only start with a letter or an underscore but not with a number.Examples:Start with a letter:<pre>age=21 print(age) #output 21</pre>Start with an underscore:<pre>_age=21 print(_age) #output 21</pre>Contain numbers and underscore:<pre>age_1=21 print(age_1) #output 21</pre>Space is not allowed instead use an underscore to separate words:<pre>my_age=21 print(my_age) #output 21</pre>Avoid using Python functions and keywords as the names of variables:If we use the print function as a variable name:<pre>print=21 print(print)</pre>Output:<pre>&#39;int&#39; object is not callable</pre>More content at <a href="https://plainenglish.io/">PlainEnglish.io</a>.Sign up for our <a href="http://newsletter.plainenglish.io/">free weekly newsletter</a>. Follow us on <a href="https://twitter.com/inPlainEngHQ">Twitter</a>, <a href="https://www.linkedin.com/company/inplainenglish/">LinkedIn</a>, <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw">YouTube</a>, and <a href="https://discord.gg/GtDtUAvyhW">Discord</a>.Interested in scaling your software startup? Check out <a href="https://circuit.ooo?utm=publication-post-cta">Circuit</a>.<img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2e826cddef1c" width="1" height="1" alt=""><hr><a href="https://python.plainenglish.io/valid-variable-name-in-python-2e826cddef1c">Valid Variable Name in Python</a> was originally published in <a href="https://python.plainenglish.io">Python in Plain English</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.

Photo by CHUTTERSNAP on Unsplash
Variables in Python are like containers for storing the data values.
Example:
Age=21
Where age is the variable name and 21 is information associated with the variable name, in this variable 21 is a number.
Valid variable name in python
Variable name contains only letters, numbers, and, underscore but can only start with a letter or an underscore but not with a number.
Examples:
Start with a letter:
age=21
print(age)
#output
21
Start with an underscore:
_age=21
print(_age)
#output
21
Contain numbers and underscore:
age_1=21
print(age_1)
#output
21
Space is not allowed instead use an underscore to separate words:
my_age=21
print(my_age)
#output
21
Avoid using Python functions and keywords as the names of variables:
If we use the print function as a variable name:
print=21
print(print)
Output:
'int' object is not callable
More content at PlainEnglish.io.
Sign up for our free weekly newsletter. Follow us on Twitter, LinkedIn, YouTube, and Discord.
Interested in scaling your software startup? Check out Circuit.

Valid Variable Name in Python was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Valid Variable Name in Python

I am a long fan and user of Cloudflare and with Cloudflare R2 i am more in love with cloudflare.
Cloudflare R2 is one of the amazing and interesting service that Cloudflare has released. It's called,
<blockquote>
Rapid and Reliable Object Storage, minus the egress fees and gives you the freedom to create the multi-cloud architectures you desire with an S3-compatible distributed object storage.
</blockquote>
Which means, it's a object storage and the amazing part is egress charges is free.
You can try and play around R2 for free with its free Monthly Quota and trust me the free limit will be enough to build an app, up and running easily.
<h1 id="heading-grab-secret-keys-and-bucket-info-from-cloudflare">Grab secret keys and bucket info from Cloudflare</h1>
<ol>
<li>Creating a Bucket
 On Cloudflare Dashboard go to R2 and create a bucket
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1657710796774/uwbjxupsQ.png" alt="cloudflare-r2-create-bucket.png" />
<blockquote>
Note: As of now, Buckets can only be private.
</blockquote>
</li>
<li>Create API tokens to communicate with R2
 Go to <code>Manage R2 API Tokens</code> from R2 Dashboard and create a API token which consist of <code>access_key</code> and <code>secret_key</code>
</li>
<li>Make sure you copy these to safe location
<ul>
<li>Account ID : You can get it from the URL section, or from the bucket url or from the right most div on the R2 dashboard</li>
<li>Bucket name: You just created</li>
<li>Access key: You just obtained while creating API tokens</li>
<li>Secret Key: You just obtained while creating API tokens</li>
</ul>
</li>
</ol>
<h1 id="heading-implementing-on-django">Implementing on Django</h1>
Since, R2 is compatible with S3 apis* we can easily use third party packages that are using S3 api for object storage.
Let's install the required libraries
<pre><code>pip install django-storages
pip install boto3
</code></pre>on Django <code>settings.py</code> add the following,
<pre><code>
DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
AWS_STORAGE_BUCKET_NAME = '&lt;YOUR_BUCKET_NAME&gt;'
AWS_S3_ENDPOINT_URL = 'https://&lt;YOUR_ACCOUNT_ID&gt;.r2.cloudflarestorage.com'
AWS_S3_ACCESS_KEY_ID = '&lt;YOUR_ACCESS_KEY&gt;'
AWS_S3_SECRET_ACCESS_KEY = '&lt;YOUR_SECRET_KEY&gt;'
AWS_S3_SIGNATURE_VERSION = 's3v4'
</code></pre><blockquote>
Make sure: signature version is <code>s3v4</code> since Cloudflare R2 doesn't support SigV2 and we need to explicitly set it to SigV4
</blockquote>
That's it, you can use Django freely with R2 now.
<h4 id="heading-general-tipshelps">General Tips/Helps</h4>
<ol>
<li>Since, R2 currently supports Private bucket only, every object should be pre signed. Using <code>django-storages</code> with the above configurations does that to us automatically. In simple word it means <code>generating a presigned url for object</code></li>
<li>Since, a bucket cannot be made public as of now, i wouldn't suggest storing static files from Django on R2</li>
<li>Since Cloudflare R2 api is compatible with S3 api, we are able to use <code>boto3</code> and S3 API to communicate with R2</li>
<li>Public Buckets are currently in roadmap but not implemented. (I am really waiting and excited for this)</li>
<li>Learn more about R2 from Cloudflare docs at <a target="_blank" href="https://developers.cloudflare.com/r2/">https://developers.cloudflare.com/r2/</a></li>
</ol>
<h5 id="heading-tested-on">Tested on</h5>
<ul>
<li>Django==4.0.6</li>
<li>django-storages==1.12.3</li>
<li>boto3==1.24.28</li>
</ul>
Last Updated: July 13, 2022

I am a long fan and user of Cloudflare and with Cloudflare R2 i am more in love with cloudflare.
Cloudflare R2 is one of the amazing and interesting service that Cloudflare has released. It's called,
Rapid and Reliable Object Storage, minus the egress fees and gives you the freedom to create the multi-cloud architectures you desire with an S3-compatible distributed object storage.
Which means, it's a object storage and the amazing part is egress charges is free.
You can try and play around R2 for free with its free Monthly Quota and trust me the free limit will be enough to build an app, up and running easily.
Grab secret keys and bucket info from Cloudflare
Creating a Bucket
 On Cloudflare Dashboard go to R2 and create a bucket

Note: As of now, Buckets can only be private.
Create API tokens to communicate with R2
 Go to Manage R2 API Tokens from R2 Dashboard and create a API token which consist of access_key and secret_key
Make sure you copy these to safe location
Account ID : You can get it from the URL section, or from the bucket url or from the right most div on the R2 dashboard
Bucket name: You just created
Access key: You just obtained while creating API tokens
Secret Key: You just obtained while creating API tokens
Implementing on Django
Since, R2 is compatible with S3 apis* we can easily use third party packages that are using S3 api for object storage.
Let's install the required libraries
pip install django-storages
pip install boto3

on Django settings.py add the following,

DEFAULT_FILE_STORAGE = 'storages.backends.s3boto3.S3Boto3Storage'
AWS_STORAGE_BUCKET_NAME = '<YOUR_BUCKET_NAME>'
AWS_S3_ENDPOINT_URL = 'https://<YOUR_ACCOUNT_ID>.r2.cloudflarestorage.com'
AWS_S3_ACCESS_KEY_ID = '<YOUR_ACCESS_KEY>'
AWS_S3_SECRET_ACCESS_KEY = '<YOUR_SECRET_KEY>'
AWS_S3_SIGNATURE_VERSION = 's3v4'


Make sure: signature version is s3v4 since Cloudflare R2 doesn't support SigV2 and we need to explicitly set it to SigV4
That's it, you can use Django freely with R2 now.
General Tips/Helps
Since, R2 currently supports Private bucket only, every object should be pre signed. Using django-storages with the above configurations does that to us automatically. In simple word it means generating a presigned url for object
Since, a bucket cannot be made public as of now, i wouldn't suggest storing static files from Django on R2
Since Cloudflare R2 api is compatible with S3 api, we are able to use boto3 and S3 API to communicate with R2
Public Buckets are currently in roadmap but not implemented. (I am really waiting and excited for this)
Learn more about R2 from Cloudflare docs at https://developers.cloudflare.com/r2/
Tested on
Django==4.0.6
django-storages==1.12.3
boto3==1.24.28
Last Updated: July 13, 2022

Using Cloudflare R2 with Django for storage

Django under the hood provides an app called Admin a.k.a Django Admin, which provides Admin UI interface/web page for your Django Project. This admin interface can automatically generate CRUD views/ (form/tables) for your models with very minimal setup i.e (Registering your models to admin)
This Admin app is usually said to be one of the most powerful parts of Django
Let's deep to use Django Admin on our projects
<h3 id="heading-using-django-admin-registering-models">Using Django Admin/ Registering Models</h3>
<ol>
<li>Creating a test Model named Information
<pre><code class="lang-py"> # inside your models.py file
 from django.db import models

 class Information(models.Model):
 name = models.CharField(max_length=100)
 date_of_birth = models.DateField()
 salary = models.IntegerField()
</code></pre>
<blockquote>
Don't forget to create migrations and then migrate 
</blockquote>
</li>
<li>Registering your models to Django Admin
<ul>
<li>Open up <code>admin.py</code> file that exists in your app (when you create django app through <code>manage.py startapp [app]</code> command, you will automatically get this file along other files like <code>models.py</code> that we have been using)</li>
<li>To let Django Admin work for our models, we simply register our model class on this <code>admin.py</code> file, by using <code>admin.site.register()</code>
<pre><code class="lang-py">from django.contrib import admin

from .models import Information # import your model

admin.site.register(Information) # actual registration
</code></pre>
</li>
</ul>
</li>
<li>Create Superuser to login to Django Admin
<ul>
<li>Because Django also contains a built in Auth/User app which we can use to manage users and authentication, we can easily use this to create our superuser/login mechanism and everything works like a magic</li>
<li>You can always create a new <code>User</code> app and authentication process, but we will leave that for another tutorial</li>
<li>On your shell, run <code>python manage.py createsuperuser</code> command</li>
<li>This command will ask bunch of questions to fill up the <code>User table</code> with attributes <code>is_staff</code> and <code>is_superuser</code> set to True. This, attributes are the table columns</li>
<li>Django admin/UI login requires <code>is_staff</code> or <code>is_superuser</code> set to True for authorization</li>
<li>Which means, anyone, any user on our project can initiate login to the admin site but won't get access since other users <code>is_staff</code> and <code>is_superuser</code> are set to False
<pre><code>-&gt; python manage.py createsuperuser
Username (leave blank to use 'djangotherightway'): admin
Email address: admin@example.com
Password: 
Password (again): 
Superuser created successfully.
</code></pre></li>
</ul>
</li>
<li>login to Django Admin Site
<ul>
<li>So, we completed our core process for working out with Django Admin, we now need a URL through which we can access our Admin Site</li>
<li>Register Admin urls to our <code>urls.py</code>
<pre><code>from django.contrib import admin
from django.urls import path

urlpatterns = [
 path('admin/', admin.site.urls),
]
</code></pre></li>
<li>Now, we can access our admin site through /admin/ url</li>
<li>I suggest to change this from <code>/admin/</code> to something unguessable, so as to prevent users from bruteforcing this page or accessing this page. In production environment, i usually disable this url path<blockquote>
By default, when creating a project using <code>django-admin startproject [project]</code> command, Django will automatically do this for us
</blockquote>
</li>
<li>Run your Django server using <code>python manage.py runserver</code> and navigate to <code>/admin/</code>
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1648874387503/_bLy9801s.png" alt="djangotherightway-django-admin-login-page.png" />
</li>
<li>Now, login using the credentials we just created on Step-3, and you will be able to see the model we registered on Step-2
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1648874520555/aCXEBFZdH.png" alt="djangotherightway-django-admin-home-page.png" />
</li>
<li>You can now, perform CRUD operations to your models, like add a new object/row, view all objects/rows, update and delete
<blockquote>
You may see that <code>Groups</code> and <code>Users</code> models are already registered on Django admin through we didn't do it manually. This is because this <code>Auth</code> app has already registered those models on its <code>admin.py</code> file. You can see the code on github <a target="_blank" href="https://github.com/django/django/blob/main/django/contrib/auth/admin.py">here</a>
</blockquote>
</li>
</ul>
</li>
</ol>
<h3 id="heading-customizing-django-admin-site">Customizing Django Admin Site</h3>
Django admin site is super customizable, but we will see some basics so that you can get some idea about its customizations.
Customizing Admin view for models can be done through <code>admin.ModelAdmin</code> class. We basically create a class using/subclassing <code>admin.ModelAdmin</code> and then tell Django admin to use this custom ModelAdmin while registering a model
<ul>
<li><h4 id="heading-customize-table-display-field">Customize Table display field</h4>
<ul>
<li>When you see the table page for your models like from the above example, you will see something like this (assuming you have created two records/objects)
<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1648879239263/Z5KIPUxTN.png?w=1000&amp;h=800" alt="a.png" /></li>
<li>This table view doesn't look nice, so lets add some columns/fields on this table view using <code>list_display</code> attributes on <code>admin.ModelAdmin</code>
<pre><code class="lang-py"> # on your admin.py 
 from django.contrib import admin
 from .models import Information

 class InformationAdmin(admin.ModelAdmin):
 list_display = ('name', 'date_of_birth', 'salary')

 admin.site.register(Information, InformationAdmin)
</code></pre>
</li>
<li>Now, save the changes and run your server, you will see the table now has name, date_of_birth and salary fields </li>
<li><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1648879374910/t0eobZTuu.png?w=1000&amp;h=800" alt="django-admin1.png" /></li>
</ul>
</li>
</ul>
<ul>
<li><h4 id="heading-add-custom-fields-to-table-list-display">Add custom fields to table List Display</h4>
<ul>
<li>Let's create up <code>age</code> field obtained from <code>date_of_birth</code> and display it on the list display table fields 
<pre><code class="lang-py"> from django.contrib import admin
 from .models import Information

 class InformationAdmin(admin.ModelAdmin):
 list_display = ('name', 'date_of_birth', 'salary', 'age')

 @admin.display()
 def age(self, obj):
 # this is rough implementation of finding
 # out age from date of birth, so as to keep
 # this example as easy as possible
 from datetime import datetime
 current_year = datetime.today().year
 born_year = obj.date_of_birth.year
 return current_year - born_year
</code></pre>
</li>
<li><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1648880272837/bFckMk2pV.png" alt="Screen Shot 2022-04-02 at 12.02.42.png" /></li>
</ul>
</li>
</ul>
<ul>
<li><h4 id="heading-adding-filters">Adding filters</h4>
<ul>
<li>We can use list_filters attribute to set filter fields
<pre><code class="lang-py"> from django.contrib import admin
 from .models import Information

 class InformationAdmin(admin.ModelAdmin):
 list_filters=['date_of_birth']

 admin.site.register(Information,InformationAdmin)
</code></pre>
</li>
<li><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1648880969794/y1MbLDGsS.png" alt="django-admin-filters.png" /></li>
</ul>
</li>
</ul>
<blockquote>
These were all basics things that we can do with Django Admin interface, but there are much more advance customizations available to use.
</blockquote>
If i should write more on advanced Customization, let me know in comments.

Django under the hood provides an app called Admin a.k.a Django Admin, which provides Admin UI interface/web page for your Django Project. This admin interface can automatically generate CRUD views/ (form/tables) for your models with very minimal setup i.e (Registering your models to admin)
This Admin app is usually said to be one of the most powerful parts of Django
Let's deep to use Django Admin on our projects
Using Django Admin/ Registering Models
Creating a test Model named Information
 # inside your models.py file
 from django.db import models

 class Information(models.Model):
     name = models.CharField(max_length=100)
     date_of_birth = models.DateField()
     salary = models.IntegerField()

Don't forget to create migrations and then migrate 
Registering your models to Django Admin
Open up admin.py file that exists in your app (when you create django app through manage.py startapp [app] command, you will automatically get this file along other files like models.py that we have been using)
To let Django Admin work for our models, we simply register our model class on this admin.py file, by using admin.site.register()
from django.contrib import admin

from .models import Information  # import your model

admin.site.register(Information) # actual registration

Create Superuser to login to Django Admin
Because Django also contains a built in Auth/User app which we can use to manage users and authentication, we can easily use this to create our superuser/login mechanism and everything works like a magic
You can always create a new User app and authentication process, but we will leave that for another tutorial
On your shell, run python manage.py createsuperuser command
This command will ask bunch of questions to fill up the User table with attributes is_staff and is_superuser set to True. This, attributes are the table columns
Django admin/UI login requires is_staff or is_superuser set to True for authorization
Which means, anyone, any user on our project can initiate login to the admin site but won't get access since other users is_staff and is_superuser are set to False
-> python manage.py createsuperuser
Username (leave blank to use 'djangotherightway'): admin
Email address: admin@example.com
Password: 
Password (again): 
Superuser created successfully.





login to Django Admin Site
So, we completed our core process for working out with Django Admin, we now need a URL through which we can access our Admin Site
Register Admin urls to our urls.py
from django.contrib import admin
from django.urls import path

urlpatterns = [
  path('admin/', admin.site.urls),
]


Now, we can access our admin site through /admin/ url
I suggest to change this from /admin/ to something unguessable, so as to prevent users from bruteforcing this page or accessing this page. In production environment, i usually disable this url path
By default, when creating a project using django-admin startproject [project] command, Django will automatically do this for us
Run your Django server using python manage.py runserver and navigate to /admin/

Now, login using the credentials we just created on Step-3, and you will be able to see the model we registered on Step-2

You can now, perform CRUD operations to your models, like add a new object/row, view all objects/rows, update and delete
You may see that Groups and Users models are already registered on Django admin through we didn't do it manually. This is because this Auth app has already registered those models on its admin.py file. You can see the code on github here
Customizing Django Admin Site
Django admin site is super customizable, but we will see some basics so that you can get some idea about its customizations.
Customizing Admin view for models can be done through admin.ModelAdmin class. We basically create a class using/subclassing admin.ModelAdmin  and then tell Django admin to use this custom ModelAdmin while registering a model
Customize Table display field
When you see the table page for your models like from the above example, you will see something like this (assuming you have created two records/objects)

This table view doesn't look nice, so lets add some columns/fields on this table view using list_display attributes on admin.ModelAdmin
  # on your admin.py 
  from django.contrib import admin
  from .models import Information

  class InformationAdmin(admin.ModelAdmin):
      list_display = ('name', 'date_of_birth', 'salary')

  admin.site.register(Information, InformationAdmin)

Now, save the changes and run your server, you will see the table now has name, date_of_birth and salary fields 

Add custom fields to table List Display
Let's create up age field obtained from date_of_birth and display it on the list display table fields 
  from django.contrib import admin
  from .models import Information

  class InformationAdmin(admin.ModelAdmin):
      list_display = ('name', 'date_of_birth', 'salary', 'age')

      @admin.display()
      def age(self, obj):
          # this is rough implementation of finding
          # out age from date of birth, so as to keep
          # this example as easy as possible
          from datetime import datetime
          current_year = datetime.today().year
          born_year = obj.date_of_birth.year
          return current_year - born_year


Adding filters
We can use list_filters attribute to set filter fields
  from django.contrib import admin
  from .models import Information

  class InformationAdmin(admin.ModelAdmin):
      list_filters=['date_of_birth']

  admin.site.register(Information,InformationAdmin)


These were all basics things that we can do with Django Admin interface, but there are much more advance customizations available to use.
If i should write more on advanced Customization, let me know in comments.

Django Admin (Registering Models, Customizing Admin Site)

<h3 id="heading-model-field-validation">Model Field Validation</h3>
To validate a model field on application level we can create up a <code>validator</code> which is a callable that take the value to be validated and raises error (<code>ValidationError</code> to be precise) if the value doesn't meet the criteria or it is invalid
The <code>ValidationError</code> it raises can be imported as <code>from django.core.exceptions import ValidationError</code>
<h4 id="heading-1-individual-field-validation">1. Individual Field validation</h4>
We can add callable validators to our model field through <code>validators</code> arguments
Let's take a simple example of a model having a field <code>email</code> which requires <code>@djangotherightway.com</code> emails to be valid
<pre><code class="lang-py">from django.core.exceptions import ValidationError
from django.db import models

def django_the_right_way_email_validator(email):
 if not email.endswith('@djangotherightway.com'):
 raise ValidationError('Email must end with @djangotherightway.com')

class Info(models.Model):
 email = models.EmailField(
 validators=[django_the_right_way_email_validator]
 )
</code></pre>
<blockquote>
You can add as many validator function/callables to a field
</blockquote>
<h4 id="heading-2-validating-multiple-fields-together">2. Validating multiple fields together</h4>
Sometime we come up for a need to validate two or more field together or are dependent on each other, in such scenario we can use <code>clean()</code> method provided by <code>models.Model</code>
Let's add up simple requirements on our previous model example. Let's add up <code>phone_number</code> and <code>age</code> to our model, and imagine a situation where <code>phone_number</code> is required if <code>age&gt;20</code>
<pre><code class="lang-py">from django.core.exceptions import ValidationError
from django.db import models

def django_the_right_way_email(email):
 if not email.endswith('@djangotherightway.com'):
 raise ValidationError('Email must end with @djangotherightway.com')

class Info(models.Model):
 email = models.EmailField(
 validators=[django_the_right_way_email]
 )
 # make phone nullable, since phone_number is
 # required only if age&gt;20
 phone_number = models.CharField(
 max_length=10, null=True, blank=True
 )
 age = models.IntegerField()

 def clean(self):
 if self.age &gt; 20:
 if not self.phone_number:
 raise ValidationError(
 'Phone number is required if age is greater than 20'
 )
</code></pre>
<h4 id="heading-running-validators">Running Validators</h4>
These validators we created will not run automatically when you create/update object/row. To make this validators run, we need to call <code>full_clean()</code> method which under the hood runs all the validator
<blockquote>
Note: Validators run automatically when using <code>ModelForm</code>
</blockquote>
<pre><code class="lang-py"># this code can be on your view func or ...
# ...for this example you can use django shell 
# Open Django shell using: python manage.py shell
obj = Info()
obj.email = "example@djangotherightway.com"
obj.age = 21
obj.phone_number = '1234567890'
try:
 obj.full_clean()
except ValidationError as e:
 print(e)
else:
 obj.save()
</code></pre>
<blockquote>
Have a look into <a target="_blank" href="https://github.com/django/django/blob/main/django/db/models/base.py#L1397">full_clean() Django code:Github</a> where it runs all individual field validators like <code>django_the_right_way_email</code> in our case and even runs <code>clean()</code> method we implemented for validations
You can call <code>full_clean()</code> from your models <code>save()</code> method, so that you don't have to manually call <code>full_clean()</code> everytime while validating objects, but this might bring up another issue of <code>full_clean()</code> being called two times in case using <code>ModelForm</code>.
</blockquote>
<h3 id="heading-built-in-validators">Built-in validators</h3>
Django already has a collection of validators used for general purpose that we can use openly as a function/callable validator to our <code>Model field</code> or <code>Forms</code> or you own data validation
These built-in validators can be imported from <code>django.core.validators</code> module
Some list of commonly used built-in validators are <code>validate_email</code>, <code>validate_slug</code>, <code>validate_ipv4_address</code>, <code>validate_ipv6_address</code>, <code>int_list_validator</code>, <code>validate_image_file_extension</code> e.t.c
A simple example to demonstrate use of built-in validators
<pre><code class="lang-py">from django.db import models
from django.core.validators import validate_email

class Info(models.Model):
 # we didn't make email=models.EmailField() 
 # because models.EmailField() would already contain
 # validate_email validator that checks for 
 # valid email addresses
 email = models.CharField(validators=[validate_email])
</code></pre>
<h3 id="heading-django-models-meta-class">Django models Meta class</h3>
Model Meta class in Django is a way to provide some more information regarding <code>table_name</code> <code>whether model is abstract</code> <code>singular or plural names</code> <code>app_label</code> <code>ordering</code> and many more....
<blockquote>
Python metaclass is different than that of Django model meta class. Metaclass in Python are class factory where as meta class in Django is completely different which is used to provide additional information about a model to Django. Don't get confused on they sharing the same name during our <code>pronouncing</code> <code>speaking</code> <code>listening</code> but they are way different on writings.
</blockquote>
<h4 id="heading-basic-example-of-creating-meta-options-class-in-django">Basic example of creating <code>Meta</code> options class in Django</h4>
Django automatically create a <code>database table</code> for every models in the format of <code>{app_name}_{model_name}</code>, so lets customize this behaviour and provide it with a custom <code>table name</code>
<pre><code class="lang-py">from django.db import models

class Address(models.Model):
 name = models.CharField(max_length=100)

 class Meta:
 db_table = 'address'
</code></pre>
Now, when we create <code>migrations file</code> and run our migrations through <code>migrate</code> command, django will create a table named <code>address</code> instead of its default <code>{app_name}_address</code>
<h4 id="heading-available-models-meta-options">Available Models Meta Options</h4>
<ol>
<li>abstract<ul>
<li>if <code>abstract=True</code> this model will be a abstract model class</li>
</ul>
</li>
<li>db_table<ul>
<li>if <code>db_table</code> is set to a value, Django will take this value to create <code>database table</code> like we saw in previous example</li>
</ul>
</li>
<li>managed<ul>
<li>if <code>managed=True</code> (default behaviour) Django will create and manage database table for this model</li>
<li>if <code>managed=False</code> table is not created. This might be useful to integrate already existing table into Django</li>
</ul>
</li>
<li>ordering<ul>
<li>default ordering when retrieving list of objects/rows</li>
</ul>
</li>
<li>verbose_name<ul>
<li>Human readable name for the singular object</li>
</ul>
</li>
<li>verbose_name_plural<ul>
<li>Human readable plural name for the object</li>
</ul>
</li>
</ol>
<h3 id="heading-abstract-model-base-class-abstracttrue">Abstract Model Base class (abstract=True)</h3>
Abstract model base class is also a model class which is used to place common <code>model fields</code> used in other models into a single model so that it can be used/inherited into other <code>model</code>. 
<ul>
<li>This type of model will not be used to create and <code>Database Table</code> by the <code>migrations framework</code></li>
<li>Since, this type of model doesn't create database table, we cannot perform any queries on this model</li>
<li>This type of models are inherited on other models to obtain features/fields from abstract model to normal model</li>
<li>So, this abstract base class is useful when you want to group common logics/fields of models into a single model but do not want to create it's corresponding database table</li>
</ul>
<h5 id="heading-lets-take-example-of-simple-information-abstract-base-class">Let's take example of simple <code>Information</code> abstract base class</h5>
<pre><code class="lang-py">from django.db import models

class InfoBase(models.Model):
 name = models.CharField(max_length=100)
 email = models.EmailField()

 class Meta:
 abstract = True
</code></pre>
<h5 id="heading-lets-use-this-abstract-class-to-form-other-normal-model-class">Let's use this abstract class to form other normal model class</h5>
<pre><code class="lang-py">class User(InfoBase):
 address = models.CharField(max_length=100)
</code></pre>
So, the <code>User</code> model will now have fields <code>name</code> <code>email</code> <code>address</code>, where <code>name</code> and <code>email</code> is inherited from the <code>InfoBase</code> abstract model class
<ol>
<li>Override fields in child model 
 Some time, we may need to override some fields from the base class so that it gets changed in our child class. let's take an example we need to change <code>max_length</code> of name in <code>User</code>, we can do it by
<pre><code class="lang-py">class User(InfoBase):
 name = models.CharField(max_length=50) # changed
 address = models.CharField(max_length=100)
</code></pre>
</li>
<li>Remove/delete fields in child model
 Some time, there may occur a case when we need to delete/remove some fields in our child class, we can do it by simply overriding the fields with <code>None</code> value
<pre><code class="lang-py">class User(InfoBase):
 name = models.CharField(max_length=50)
 email = None
 address = models.CharField(max_length=100)
</code></pre>
 So, considering this example, <code>User</code> model will only have <code>name</code> and <code>address</code> fields
</li>
</ol>

Model Field Validation
To validate a model field on application level we can create up a validator which is a callable that take the value to be validated and raises error (ValidationError to be precise) if the value doesn't meet the criteria or it is invalid
The ValidationError it raises can be imported as from django.core.exceptions import ValidationError
1. Individual Field validation
We can add callable validators to our model field through validators arguments
Let's take a simple example of a model having a field email which requires @djangotherightway.com emails to be valid
from django.core.exceptions import ValidationError
from django.db import models

def django_the_right_way_email_validator(email):
    if not email.endswith('@djangotherightway.com'):
        raise ValidationError('Email must end with @djangotherightway.com')

class Info(models.Model):
    email = models.EmailField(
        validators=[django_the_right_way_email_validator]
    )

You can add as many validator function/callables to a field
2. Validating multiple fields together
Sometime we come up for a need to validate two or more field together or are dependent on each other, in such scenario we can use clean() method provided by models.Model
Let's add up simple requirements on our previous model example. Let's add up phone_number and age to our model, and imagine a situation where phone_number is required if age>20
from django.core.exceptions import ValidationError
from django.db import models

def django_the_right_way_email(email):
    if not email.endswith('@djangotherightway.com'):
        raise ValidationError('Email must end with @djangotherightway.com')

class Info(models.Model):
    email = models.EmailField(
        validators=[django_the_right_way_email]
    )
    # make phone nullable, since phone_number is
    # required only if age>20
    phone_number = models.CharField(
        max_length=10, null=True, blank=True
    )
    age = models.IntegerField()

    def clean(self):
        if self.age > 20:
            if not self.phone_number:
                raise ValidationError(
                    'Phone number is required if age is greater than 20'
                )

Running Validators
These validators we created will not run automatically when you create/update object/row. To make this validators run, we need to call full_clean() method which under the hood runs all the validator
Note: Validators run automatically when using ModelForm
# this code can be on your view func or ...
# ...for this example you can use django shell 
#  Open Django shell using: python manage.py shell
obj = Info()
obj.email = "example@djangotherightway.com"
obj.age = 21
obj.phone_number = '1234567890'
try:
    obj.full_clean()
except ValidationError as e:
    print(e)
else:
    obj.save()

Have a look into full_clean() Django code:Github where it runs all individual field validators like django_the_right_way_email in our case and even runs clean() method we implemented for validations
You can call full_clean() from your models save() method, so that you don't have to manually call full_clean() everytime while validating objects, but this might bring up another issue of full_clean() being called two times in case using ModelForm.
Built-in validators
Django already has a collection of validators used for general purpose that we can use openly as a function/callable validator to our Model field or Forms or you own data validation
These built-in validators can be imported from django.core.validators module
Some list of commonly used built-in validators are validate_email, validate_slug, validate_ipv4_address, validate_ipv6_address, int_list_validator, validate_image_file_extension e.t.c
A simple example to demonstrate use of built-in validators
from django.db import models
from django.core.validators import validate_email

class Info(models.Model):
    # we didn't make email=models.EmailField() 
    #  because models.EmailField() would already contain
    #  validate_email validator that checks for 
    #  valid email addresses
    email = models.CharField(validators=[validate_email])

Django models Meta class
Model Meta class in Django is a way to provide some more information regarding table_name whether model is abstract singular or plural names app_label ordering and many more....
Python metaclass is different than that of Django model meta class. Metaclass in Python are class factory where as meta class in Django is completely different which is used to provide additional information about a model to Django. Don't get confused on they sharing the same name during our pronouncing speaking listening but they are way different on writings.
Basic example of creating Meta options class in Django
Django automatically create a database table for every models in the format of {app_name}_{model_name}, so lets customize this behaviour and provide it with a custom table name
from django.db import models

class Address(models.Model):
    name = models.CharField(max_length=100)

    class Meta:
        db_table = 'address'

Now, when we create migrations file and run our migrations through migrate command, django will create a table named address instead of its default {app_name}_address
Available Models Meta Options
abstract
if abstract=True this model will be a abstract model class
db_table
if db_table is set to a value, Django will take this value to create database table like we saw in previous example
managed
if managed=True (default behaviour) Django will create and manage database table for this model
if managed=False table is not created. This might be useful to integrate already existing table into Django
ordering
default ordering when retrieving list of objects/rows
verbose_name
Human readable name for the singular object
verbose_name_plural
Human readable plural name for the object
Abstract Model Base class (abstract=True)
Abstract model base class is also a model class which is used to place common model fields used in other models into a single model so that it can be used/inherited into other model. 
This type of model will not be used to create and Database Table by the migrations framework
Since, this type of model doesn't create database table, we cannot perform any queries on this model
This type of models are inherited on other models to obtain features/fields from abstract model to normal model
So, this abstract base class is useful when you want to group common logics/fields of models into a single model but do not want to create it's corresponding database table
Let's take example of simple Information abstract base class
from django.db import models

class InfoBase(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()

    class Meta:
        abstract = True

Let's use this abstract class to form other normal model class
class User(InfoBase):
    address = models.CharField(max_length=100)

So, the User model will now have fields name email address, where name and email is inherited from the InfoBase abstract model class
Override fields in child model 
 Some time, we may need to override some fields from the base class so that it gets changed in our child class. let's take an example we need to change max_length of name in User, we can do it by
class User(InfoBase):
     name = models.CharField(max_length=50) # changed
     address = models.CharField(max_length=100)

Remove/delete fields in child model
  Some time, there may occur a case when we need to delete/remove some fields in our child class, we can do it by simply overriding the fields with None value
class User(InfoBase):
     name = models.CharField(max_length=50)
     email = None
     address = models.CharField(max_length=100)

 So, considering this example, User model will only have name and address fields

Hello, Python

Python Jobs 💼