<div class="medium-feed-item"><a href="https://python.plainenglish.io/step-by-step-download-stock-data-market-for-free-in-2024-with-python-5acdabc5ccc1?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/1*KQ7Coa4O7AoOTfiRFducAA.jpeg" width="7831"></a>Let&#x2019;s learn step-by-step download the stock data market for free with Python in 2024 for your Portofolio<a href="https://python.plainenglish.io/step-by-step-download-stock-data-market-for-free-in-2024-with-python-5acdabc5ccc1?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Let’s learn step-by-step download the stock data market for free with Python in 2024 for your Portofolio
Continue reading on Python in Plain English »

Step-by-Step Download Stock Data Market For Free in 2024 with Python

<div class="medium-feed-item"><a href="https://python.plainenglish.io/pythonic-way-to-merge-dictionaries-92ba86278543?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*X2BQ5BQmYG_DI7Vb" width="4160"></a>Merge Dictionaries Like a Pro with the Union Operator (|)<a href="https://python.plainenglish.io/pythonic-way-to-merge-dictionaries-92ba86278543?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Merge Dictionaries Like a Pro with the Union Operator (|)
Continue reading on Python in Plain English »

Pythonic Way To Merge Dictionaries

<div class="medium-feed-item"><a href="https://python.plainenglish.io/key-python-libraries-for-automation-every-beginner-should-know-43cb850c0f1b?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*okMW-JSkgwR7shks" width="7680"></a>Simplify your tasks with these Python libraries that feel like magic<a href="https://python.plainenglish.io/key-python-libraries-for-automation-every-beginner-should-know-43cb850c0f1b?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Simplify your tasks with these Python libraries that feel like magic
Continue reading on Python in Plain English »

Key Python Libraries for Automation Every Beginner Should Know

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*A9e_0wEvPoTVuzed-qPdDg.jpeg" /></figure>Python is easy to start with, but mastering its full potential is a different story. Even experienced developers sometimes overlook its many features and best practices. In this article, I’ll share 12 practical tips to help you write cleaner, more efficient, and more professional Python code.<h4>1. Use enumerate Instead of a Manual Counter</h4>When iterating through a list and needing an index, avoid manually maintaining a counter. Use enumerate for cleaner and more Pythonic code.Before:<pre>i = 0 for item in my_list: print(i, item) i += 1</pre>After:<pre>for i, item in enumerate(my_list): print(i, item)</pre><h4>2. Compare with None the Right Way</h4>When checking for None, always use is instead of ==. It’s more readable and follows PEP 8 recommendations.<pre>if value is None: print(&quot;Value is None&quot;)</pre><h4>3. Avoid Mutable Default Arguments</h4>Using mutable objects (like lists) as default arguments can lead to unexpected bugs.Problematic:<pre>def append_to_list(value, my_list=[]): my_list.append(value) return my_list</pre>Better:<pre>def append_to_list(value, my_list=None): if my_list is None: my_list = [] my_list.append(value) return my_list</pre><h4>4. Use f-strings for Formatting</h4>F-strings make your code more readable and concise compared to older string formatting methods.<pre>name = &quot;Alice&quot; print(f&quot;Hello, {name}!&quot;)</pre><h4>5. Explore the collections Library</h4>The collections module offers powerful alternatives for common tasks. For example, Counter makes counting elements in a list straightforward.<pre>from collections import Counter data = [&#39;apple&#39;, &#39;banana&#39;, &#39;apple&#39;] counter = Counter(data) print(counter) # Output: Counter({&#39;apple&#39;: 2, &#39;banana&#39;: 1})pyt</pre><h4>6. Favor Generators Over Lists</h4>If you don’t need to use all elements of a list at once, use generators to save memory.<pre>squared_numbers = (x**2 for x in range(10)) for num in squared_numbers: print(num)</pre><h4>7. Optimize Membership Checks</h4>For large datasets, checking membership in a list can be slow. Convert the list to a set for faster lookups.Inefficient:<pre>if value in my_list: # O(n) print(&quot;Found!&quot;)</pre>Efficient:<pre>my_set = set(my_list) if value in my_set: # O(1) print(&quot;Found!&quot;)</pre><h4>8. **Master *args and kwargs</h4>These features simplify handling dynamic numbers of arguments in functions.<pre>def print_all(*args, **kwargs): print(&quot;Positional:&quot;, args) print(&quot;Keyword:&quot;, kwargs) print_all(1, 2, 3, name=&quot;Alice&quot;, age=30)</pre><h4>9. Use Decorators for Repeated Logic</h4>If the same logic repeats across functions, decorators can help reduce redundancy.<pre>def log_execution(func): def wrapper(*args, **kwargs): print(f&quot;Executing {func.__name__}&quot;) return func(*args, **kwargs) return wrapper @log_execution def say_hello(): print(&quot;Hello!&quot;) say_hello()</pre><h4>10. Write Tests with pytest</h4>pytest makes testing your code simple and enjoyable. It’s a favorite among Python developers.Example:<pre>def add(a, b): return a + b def test_add(): assert add(2, 3) == 5</pre><h4>11. Leverage Context Managers</h4>The with statement isn’t just for files—it can manage other resources like database connections or threading locks.<pre>with open(&quot;file.txt&quot;, &quot;r&quot;) as file: content = file.read()</pre><h4>12. **Control Imports with **all</h4>If you’re creating a package, use __all__ to explicitly control what gets imported with from module import *.<pre>__all__ = [&#39;function1&#39;, &#39;ClassA&#39;]</pre><h3>Conclusion</h3>Python’s true power reveals itself when you use the language the right way. By following these tips, you can write code that’s cleaner, more efficient, and easier to maintain. Which of these tips are you already using, and which ones surprised you? Share your thoughts in the comments below!<h3>In Plain English 🚀</h3>Thank you for being a part of the <a href="https://plainenglish.io/">In Plain English</a> community! Before you go:<ul><li>Be sure to clap and follow the writer ️👏️️</li><li>Follow us: <a href="https://x.com/inPlainEngHQ">X</a> | <a href="https://www.linkedin.com/company/inplainenglish/">LinkedIn</a> | <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw">YouTube</a> | <a href="https://discord.gg/in-plain-english-709094664682340443">Discord</a> | <a href="https://newsletter.plainenglish.io/">Newsletter</a> | <a href="https://open.spotify.com/show/7qxylRWKhvZwMz2WuEoua0">Podcast</a></li><li><a href="https://differ.blog/">Create a free AI-powered blog on Differ.</a></li><li>More content at <a href="https://plainenglish.io/">PlainEnglish.io</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=fe3214c22a14" width="1" height="1" alt=""><hr><a href="https://python.plainenglish.io/12-python-tips-every-developer-should-know-and-use-fe3214c22a14">12 Python Tips Every Developer Should Know and Use</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 is easy to start with, but mastering its full potential is a different story. Even experienced developers sometimes overlook its many features and best practices. In this article, I’ll share 12 practical tips to help you write cleaner, more efficient, and more professional Python code.
1. Use enumerate Instead of a Manual Counter
When iterating through a list and needing an index, avoid manually maintaining a counter. Use enumerate for cleaner and more Pythonic code.
Before:
i = 0
for item in my_list:
    print(i, item)
    i += 1
After:
for i, item in enumerate(my_list):
    print(i, item)
2. Compare with None the Right Way
When checking for None, always use is instead of ==. It’s more readable and follows PEP 8 recommendations.
if value is None:
    print("Value is None")
3. Avoid Mutable Default Arguments
Using mutable objects (like lists) as default arguments can lead to unexpected bugs.
Problematic:
def append_to_list(value, my_list=[]):
    my_list.append(value)
    return my_list
Better:
def append_to_list(value, my_list=None):
    if my_list is None:
        my_list = []
    my_list.append(value)
    return my_list
4. Use f-strings for Formatting
F-strings make your code more readable and concise compared to older string formatting methods.
name = "Alice"
print(f"Hello, {name}!")
5. Explore the collections Library
The collections module offers powerful alternatives for common tasks. For example, Counter makes counting elements in a list straightforward.
from collections import Counter
data = ['apple', 'banana', 'apple']
counter = Counter(data)
print(counter)
# Output: Counter({'apple': 2, 'banana': 1})pyt
6. Favor Generators Over Lists
If you don’t need to use all elements of a list at once, use generators to save memory.
squared_numbers = (x**2 for x in range(10))
for num in squared_numbers:
    print(num)
7. Optimize Membership Checks
For large datasets, checking membership in a list can be slow. Convert the list to a set for faster lookups.
Inefficient:
if value in my_list:  # O(n)
    print("Found!")
Efficient:
my_set = set(my_list)
if value in my_set:  # O(1)
    print("Found!")
8. **Master *args and kwargs
These features simplify handling dynamic numbers of arguments in functions.
def print_all(*args, **kwargs):
    print("Positional:", args)
    print("Keyword:", kwargs)
print_all(1, 2, 3, name="Alice", age=30)
9. Use Decorators for Repeated Logic
If the same logic repeats across functions, decorators can help reduce redundancy.
def log_execution(func):
    def wrapper(*args, **kwargs):
        print(f"Executing {func.__name__}")
        return func(*args, **kwargs)
    return wrapper
@log_execution
def say_hello():
    print("Hello!")
say_hello()
10. Write Tests with pytest
pytest makes testing your code simple and enjoyable. It’s a favorite among Python developers.
Example:
def add(a, b):
    return a + b
def test_add():
    assert add(2, 3) == 5
11. Leverage Context Managers
The with statement isn’t just for files—it can manage other resources like database connections or threading locks.
with open("file.txt", "r") as file:
    content = file.read()
12. **Control Imports with **all
If you’re creating a package, use __all__ to explicitly control what gets imported with from module import *.
__all__ = ['function1', 'ClassA']
Conclusion
Python’s true power reveals itself when you use the language the right way. By following these tips, you can write code that’s cleaner, more efficient, and easier to maintain. Which of these tips are you already using, and which ones surprised you? Share your thoughts in the comments below!
In Plain English 🚀
Thank you for being a part of the In Plain English community! Before you go:

Be sure to clap and follow the writer ️👏️️
Follow us: X | LinkedIn | YouTube | Discord | Newsletter | Podcast
Create a free AI-powered blog on Differ.
More content at PlainEnglish.io

12 Python Tips Every Developer Should Know and Use was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

12 Python Tips Every Developer Should Know and Use

<div class="medium-feed-item"><a href="https://python.plainenglish.io/mastering-risk-and-reward-in-cryptocurrency-backtesting-a-complete-python-guide-with-real-world-efba5ccc08a0?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/1*VdDZTsQYUJpPpQScHwzVMQ.jpeg" width="5913"></a>Cryptocurrency trading has the potential to be very profitable, however, the risks are also very high.<a href="https://python.plainenglish.io/mastering-risk-and-reward-in-cryptocurrency-backtesting-a-complete-python-guide-with-real-world-efba5ccc08a0?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Cryptocurrency trading has the potential to be very profitable, however, the risks are also very high.
Continue reading on Python in Plain English »

Mastering Risk and Reward in Cryptocurrency Backtesting: A Complete Python Guide with…

Essential tips for data analysts to improve Python skills, from effective learning methods to practical resources.<figure><img alt="" src="https://cdn-images-1.medium.com/max/750/1*IuXt34djeXpJMO2CQrdhag.jpeg" /></figure>Python has become the go-to programming language for data analysts due to its simplicity, versatility, and extensive libraries for data manipulation, visualization, and machine learning. But mastering Python requires more than just writing code — it’s about understanding how to leverage its powerful tools efficiently.If you’re a data analyst looking to upskill, here are 10 tips to help you master Python and elevate your data game.<h3>1. Start with the Basics of Python</h3>Before diving into advanced libraries like Pandas or NumPy, ensure you have a solid foundation in Python basics. Focus on understanding variables, data types, loops, functions, and file handling.<h3>What to Practice:</h3><ul><li>Writing and running Python scripts.</li><li>Using loops (for, while) to iterate over data.</li><li>Writing reusable functions using def.</li></ul><h3>Example: Basic Python Script</h3><pre># Calculate average sales sales = [1200, 900, 1500, 1100] average_sales = sum(sales) / len(sales) print(f&quot;Average Sales: {average_sales}&quot;)</pre><blockquote>Pro Tip: Use interactive platforms like <a href="https://jupyter.org/">Jupyter Notebook</a> to test and practice Python basics in an intuitive environment.</blockquote><h3>2. Get Comfortable with Pandas for Data Manipulation</h3>Pandas is the backbone of Python-based data analysis. It allows you to manipulate, clean, and organize data efficiently using DataFrames and Series.<h3>What to Focus On:</h3><ul><li>Reading and writing data from CSVs, Excel, or SQL databases.</li><li>Filtering, grouping, and sorting data in DataFrames.</li><li>Handling missing values and duplicates.</li></ul><h3>Example: Data Manipulation with Pandas</h3><pre>import pandas as pd # Load data df = pd.read_csv(&quot;sales_data.csv&quot;) # Filter rows where sales &gt; 1000 filtered_data = df[df[&#39;sales&#39;] &gt; 1000] # Group by region and calculate total sales grouped_data = df.groupby(&#39;region&#39;)[&#39;sales&#39;].sum() print(grouped_data)</pre><blockquote>Pro Tip: Explore Pandas’ built-in methods like df.describe() and df.info() to quickly understand your dataset.</blockquote><h3>3. Learn NumPy for Numerical Operations</h3>NumPy is essential for handling numerical data in Python. Its array-based operations are faster and more memory-efficient than Python lists.<h3>What to Practice:</h3><ul><li>Creating and manipulating NumPy arrays.</li><li>Performing mathematical operations on arrays.</li><li>Using NumPy for statistical calculations.</li></ul><h3>Example: NumPy Array Operations</h3><pre>import numpy as np # Create a NumPy array sales = np.array([1200, 900, 1500, 1100]) # Calculate total and average sales total_sales = np.sum(sales) average_sales = np.mean(sales) print(f&quot;Total: {total_sales}, Average: {average_sales}&quot;)</pre><blockquote>Pro Tip: Use NumPy’s random module to generate sample data for practice.</blockquote><h3>4. Master Data Visualization with Matplotlib and Seaborn</h3>Data visualization is crucial for communicating insights, and Python’s Matplotlib and Seaborn libraries offer powerful tools to create impactful charts and graphs.<h3>What to Focus On:</h3><ul><li>Creating line, bar, scatter, and pie charts with Matplotlib.</li><li>Customizing visualizations with titles, labels, and legends.</li><li>Using Seaborn for advanced visualizations like heatmaps and pair plots.</li></ul><h3>Example: Sales Visualization</h3><pre>import matplotlib.pyplot as plt import seaborn as sns # Plot sales trend plt.plot(df[&#39;month&#39;], df[&#39;sales&#39;], marker=&#39;o&#39;) plt.title(&quot;Monthly Sales Trend&quot;) plt.xlabel(&quot;Month&quot;) plt.ylabel(&quot;Sales&quot;) plt.show() # Create a heatmap for correlation sns.heatmap(df.corr(), annot=True) plt.show()</pre><blockquote>Pro Tip: Save your plots as images with plt.savefig() for use in reports or presentations.</blockquote><h3>5. Practice Data Cleaning Techniques</h3>Real-world data is messy, and cleaning it is a critical skill. Use Python to handle missing values, incorrect formats, duplicates, and outliers.<h3>Key Techniques:</h3><ul><li>Handling null values with fillna() or dropna().</li><li>Removing duplicates using drop_duplicates().</li><li>Standardizing data formats (e.g., converting strings to dates).</li></ul><h3>Example: Cleaning Data with Pandas</h3><pre># Fill missing values in sales with the median df[&#39;sales&#39;].fillna(df[&#39;sales&#39;].median(), inplace=True) # Drop duplicate rows df.drop_duplicates(inplace=True) # Convert date column to datetime df[&#39;date&#39;] = pd.to_datetime(df[&#39;date&#39;])</pre><blockquote>Pro Tip: Automate repetitive cleaning tasks by creating reusable cleaning functions.</blockquote><h3>6. Automate Repetitive Tasks</h3>Automation is one of Python’s greatest strengths. From data cleaning to generating reports, Python can save you hours by automating repetitive workflows.<h3>Example: Automating a Daily Sales Report</h3><pre># Generate a summary report def generate_report(data): total_sales = data[&#39;sales&#39;].sum() print(f&quot;Total Sales: {total_sales}&quot;) # Automate for new files for file in [&quot;sales_data_jan.csv&quot;, &quot;sales_data_feb.csv&quot;]: df = pd.read_csv(file) generate_report(df)</pre><blockquote>Pro Tip: Use Python scripts to schedule regular tasks with tools like cron jobs or Task Scheduler.</blockquote><h3>7. Use SQL with Python for Database Queries</h3>Combine Python with SQL for seamless interaction with relational databases. Libraries like <a href="https://www.youtube.com/watch?v=byHcYRpMgI4">SQLite3 </a>or <a href="https://www.youtube.com/watch?v=aAy-B6KPld8">SQLAlchemy</a> allow you to query, analyze, and manipulate data directly from a database.<h3>Example: Querying Data with SQL in Python</h3><pre>import sqlite3 # Connect to database conn = sqlite3.connect(&quot;sales.db&quot;) # Query data query = &quot;SELECT region, SUM(sales) FROM sales GROUP BY region;&quot; df = pd.read_sql_query(query, conn) print(df)</pre><blockquote>Pro Tip: Use Python to automate repetitive SQL queries and transform results into Pandas DataFrames for analysis.</blockquote><h3>8. Learn Python for Exploratory Data Analysis (EDA)</h3>Exploratory Data Analysis (EDA) is the process of summarizing and understanding data. Python makes EDA efficient with its ability to handle large datasets and produce quick insights.<h3>What to Practice:</h3><ul><li>Calculating summary statistics with Pandas (mean, median, std).</li><li>Identifying trends and outliers using visualization tools.</li><li>Using groupby to explore aggregated metrics.</li></ul><h3>Example: Quick EDA</h3><pre># Summarize data print(df.describe()) # Group data by region print(df.groupby(&#39;region&#39;)[&#39;sales&#39;].mean()) # Visualize outliers with boxplots sns.boxplot(x=&#39;region&#39;, y=&#39;sales&#39;, data=df) plt.show()</pre><blockquote>Pro Tip: Combine EDA techniques in a Jupyter Notebook to document your findings as you explore.</blockquote><h3>9. Explore Advanced Python Libraries</h3>Once you’re comfortable with the basics, dive into advanced Python libraries like Scikit-learn for machine learning, Statsmodels for statistical analysis, and Dash for interactive dashboards.<h3>Example: Predictive Analysis with Scikit-learn</h3><pre>from sklearn.linear_model import LinearRegression # Train a linear regression model X = df[[&#39;marketing_spend&#39;, &#39;sales_team_size&#39;]] y = df[&#39;sales&#39;] model = LinearRegression().fit(X, y) # Predict sales predictions = model.predict(X) print(predictions)</pre><blockquote>Pro Tip: Use these libraries to expand your skillset into predictive analytics and beyond.</blockquote><h3>10. Work on Real-World Projects</h3>The best way to master Python is by applying it to real-world problems. Practice with publicly available datasets from platforms like <a href="https://www.kaggle.com/">Kaggle</a> or <a href="https://datasetsearch.research.google.com/">Google Dataset Search</a>.<h3>Ideas for Practice Projects:</h3><ul><li>Build a sales dashboard showing monthly and regional performance.</li><li>Analyze customer behavior and churn using transactional data.</li><li>Create a forecasting model for revenue or demand.</li></ul><blockquote>Pro Tip: Document your projects in Jupyter Notebooks and include them in your portfolio to showcase your skills.</blockquote><h3>Conclusion</h3>Mastering Python as a data analyst is a journey, but with these tips, you can build a strong foundation and quickly scale your skills. Start with the basics, dive into essential libraries like Pandas and NumPy, and practice on real-world projects to gain confidence.Python isn’t just a tool — it’s the key to unlocking faster, more effective data analysis. Start applying these tips today, and you’ll soon see the difference in your workflows and insights.<h3>In Plain English 🚀</h3>Thank you for being a part of the <a href="https://plainenglish.io/">In Plain English</a> community! Before you go:<ul><li>Be sure to clap and follow the writer ️👏️️</li><li>Follow us: <a href="https://x.com/inPlainEngHQ">X</a> | <a href="https://www.linkedin.com/company/inplainenglish/">LinkedIn</a> | <a href="https://www.youtube.com/channel/UCtipWUghju290NWcn8jhyAw">YouTube</a> | <a href="https://discord.gg/in-plain-english-709094664682340443">Discord</a> | <a href="https://newsletter.plainenglish.io/">Newsletter</a> | <a href="https://open.spotify.com/show/7qxylRWKhvZwMz2WuEoua0">Podcast</a></li><li><a href="https://differ.blog/">Create a free AI-powered blog on Differ.</a></li><li>More content at <a href="https://plainenglish.io/">PlainEnglish.io</a></li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=43a7b2de0c54" width="1" height="1" alt=""><hr><a href="https://python.plainenglish.io/top-10-tips-for-data-analysts-to-master-python-43a7b2de0c54">Top 10 Tips for Data Analysts to Master 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.

Essential tips for data analysts to improve Python skills, from effective learning methods to practical resources.

Python has become the go-to programming language for data analysts due to its simplicity, versatility, and extensive libraries for data manipulation, visualization, and machine learning. But mastering Python requires more than just writing code — it’s about understanding how to leverage its powerful tools efficiently.
If you’re a data analyst looking to upskill, here are 10 tips to help you master Python and elevate your data game.
1. Start with the Basics of Python
Before diving into advanced libraries like Pandas or NumPy, ensure you have a solid foundation in Python basics. Focus on understanding variables, data types, loops, functions, and file handling.
What to Practice:

Writing and running Python scripts.
Using loops (for, while) to iterate over data.
Writing reusable functions using def.

Example: Basic Python Script
# Calculate average sales
sales = [1200, 900, 1500, 1100]
average_sales = sum(sales) / len(sales)
print(f"Average Sales: {average_sales}")
Pro Tip: Use interactive platforms like Jupyter Notebook to test and practice Python basics in an intuitive environment.
2. Get Comfortable with Pandas for Data Manipulation
Pandas is the backbone of Python-based data analysis. It allows you to manipulate, clean, and organize data efficiently using DataFrames and Series.
What to Focus On:

Reading and writing data from CSVs, Excel, or SQL databases.
Filtering, grouping, and sorting data in DataFrames.
Handling missing values and duplicates.

Example: Data Manipulation with Pandas
import pandas as pd
# Load data
df = pd.read_csv("sales_data.csv")
# Filter rows where sales > 1000
filtered_data = df[df['sales'] > 1000]
# Group by region and calculate total sales
grouped_data = df.groupby('region')['sales'].sum()
print(grouped_data)
Pro Tip: Explore Pandas’ built-in methods like df.describe() and df.info() to quickly understand your dataset.
3. Learn NumPy for Numerical Operations
NumPy is essential for handling numerical data in Python. Its array-based operations are faster and more memory-efficient than Python lists.
What to Practice:

Creating and manipulating NumPy arrays.
Performing mathematical operations on arrays.
Using NumPy for statistical calculations.

Example: NumPy Array Operations
import numpy as np
# Create a NumPy array
sales = np.array([1200, 900, 1500, 1100])
# Calculate total and average sales
total_sales = np.sum(sales)
average_sales = np.mean(sales)
print(f"Total: {total_sales}, Average: {average_sales}")
Pro Tip: Use NumPy’s random module to generate sample data for practice.
4. Master Data Visualization with Matplotlib and Seaborn
Data visualization is crucial for communicating insights, and Python’s Matplotlib and Seaborn libraries offer powerful tools to create impactful charts and graphs.
What to Focus On:

Creating line, bar, scatter, and pie charts with Matplotlib.
Customizing visualizations with titles, labels, and legends.
Using Seaborn for advanced visualizations like heatmaps and pair plots.

Example: Sales Visualization
import matplotlib.pyplot as plt
import seaborn as sns
# Plot sales trend
plt.plot(df['month'], df['sales'], marker='o')
plt.title("Monthly Sales Trend")
plt.xlabel("Month")
plt.ylabel("Sales")
plt.show()
# Create a heatmap for correlation
sns.heatmap(df.corr(), annot=True)
plt.show()
Pro Tip: Save your plots as images with plt.savefig() for use in reports or presentations.
5. Practice Data Cleaning Techniques
Real-world data is messy, and cleaning it is a critical skill. Use Python to handle missing values, incorrect formats, duplicates, and outliers.
Key Techniques:

Handling null values with fillna() or dropna().
Removing duplicates using drop_duplicates().
Standardizing data formats (e.g., converting strings to dates).

Example: Cleaning Data with Pandas
# Fill missing values in sales with the median
df['sales'].fillna(df['sales'].median(), inplace=True)
# Drop duplicate rows
df.drop_duplicates(inplace=True)
# Convert date column to datetime
df['date'] = pd.to_datetime(df['date'])
Pro Tip: Automate repetitive cleaning tasks by creating reusable cleaning functions.
6. Automate Repetitive Tasks
Automation is one of Python’s greatest strengths. From data cleaning to generating reports, Python can save you hours by automating repetitive workflows.
Example: Automating a Daily Sales Report
# Generate a summary report
def generate_report(data):
    total_sales = data['sales'].sum()
    print(f"Total Sales: {total_sales}")
# Automate for new files
for file in ["sales_data_jan.csv", "sales_data_feb.csv"]:
    df = pd.read_csv(file)
    generate_report(df)
Pro Tip: Use Python scripts to schedule regular tasks with tools like cron jobs or Task Scheduler.
7. Use SQL with Python for Database Queries
Combine Python with SQL for seamless interaction with relational databases. Libraries like SQLite3 or SQLAlchemy allow you to query, analyze, and manipulate data directly from a database.
Example: Querying Data with SQL in Python
import sqlite3
# Connect to database
conn = sqlite3.connect("sales.db")
# Query data
query = "SELECT region, SUM(sales) FROM sales GROUP BY region;"
df = pd.read_sql_query(query, conn)
print(df)
Pro Tip: Use Python to automate repetitive SQL queries and transform results into Pandas DataFrames for analysis.
8. Learn Python for Exploratory Data Analysis (EDA)
Exploratory Data Analysis (EDA) is the process of summarizing and understanding data. Python makes EDA efficient with its ability to handle large datasets and produce quick insights.
What to Practice:

Calculating summary statistics with Pandas (mean, median, std).
Identifying trends and outliers using visualization tools.
Using groupby to explore aggregated metrics.

Example: Quick EDA
# Summarize data
print(df.describe())
# Group data by region
print(df.groupby('region')['sales'].mean())
# Visualize outliers with boxplots
sns.boxplot(x='region', y='sales', data=df)
plt.show()
Pro Tip: Combine EDA techniques in a Jupyter Notebook to document your findings as you explore.
9. Explore Advanced Python Libraries
Once you’re comfortable with the basics, dive into advanced Python libraries like Scikit-learn for machine learning, Statsmodels for statistical analysis, and Dash for interactive dashboards.
Example: Predictive Analysis with Scikit-learn
from sklearn.linear_model import LinearRegression
# Train a linear regression model
X = df[['marketing_spend', 'sales_team_size']]
y = df['sales']
model = LinearRegression().fit(X, y)
# Predict sales
predictions = model.predict(X)
print(predictions)
Pro Tip: Use these libraries to expand your skillset into predictive analytics and beyond.
10. Work on Real-World Projects
The best way to master Python is by applying it to real-world problems. Practice with publicly available datasets from platforms like Kaggle or Google Dataset Search.
Ideas for Practice Projects:

Build a sales dashboard showing monthly and regional performance.
Analyze customer behavior and churn using transactional data.
Create a forecasting model for revenue or demand.

Pro Tip: Document your projects in Jupyter Notebooks and include them in your portfolio to showcase your skills.
Conclusion
Mastering Python as a data analyst is a journey, but with these tips, you can build a strong foundation and quickly scale your skills. Start with the basics, dive into essential libraries like Pandas and NumPy, and practice on real-world projects to gain confidence.
Python isn’t just a tool — it’s the key to unlocking faster, more effective data analysis. Start applying these tips today, and you’ll soon see the difference in your workflows and insights.
In Plain English 🚀
Thank you for being a part of the In Plain English community! Before you go:

Be sure to clap and follow the writer ️👏️️
Follow us: X | LinkedIn | YouTube | Discord | Newsletter | Podcast
Create a free AI-powered blog on Differ.
More content at PlainEnglish.io

Top 10 Tips for Data Analysts to Master Python was originally published in Python in Plain English on Medium, where people are continuing the conversation by highlighting and responding to this story.

Top 10 Tips for Data Analysts to Master Python

<div class="medium-feed-item"><a href="https://python.plainenglish.io/how-to-understand-machine-learning-basics-in-python-in-30-days-1cd4dd96ecc0?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*Ss0heCv7RRtpzTWa" width="3456"></a>Machine learning (ML) has become an integral part of modern technology, powering innovations from recommendation systems to autonomous&#x2026;<a href="https://python.plainenglish.io/how-to-understand-machine-learning-basics-in-python-in-30-days-1cd4dd96ecc0?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Machine learning (ML) has become an integral part of modern technology, powering innovations from recommendation systems to autonomous…
Continue reading on Python in Plain English »

How to Understand Machine Learning Basics in Python in 30 Days

<div class="medium-feed-item"><a href="https://python.plainenglish.io/understanding-vs-is-in-python-a-comprehensive-guide-5a4a9f88330f?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/2600/0*rjlkEqFRWt6qyyW0" width="3961"></a>A Complete Guide to Python&#x2019;s == vs is<a href="https://python.plainenglish.io/understanding-vs-is-in-python-a-comprehensive-guide-5a4a9f88330f?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

A Complete Guide to Python’s == vs is
Continue reading on Python in Plain English »

Understanding “== vs is” in Python: A Comprehensive Guide

<div class="medium-feed-item"><a href="https://python.plainenglish.io/how-to-compress-images-losslessly-using-python-2f1ffb61191e?source=rss----78073def27b8---4"><img src="https://cdn-images-1.medium.com/max/1280/1*cJvsYX2pH8PcXB9f1r7OUg.png" width="1280"></a>Compressing images is an essential step in optimizing applications for performance. Whether you&#x2019;re managing a website, building a mobile&#x2026;<a href="https://python.plainenglish.io/how-to-compress-images-losslessly-using-python-2f1ffb61191e?source=rss----78073def27b8---4">Continue reading on Python in Plain English »</a></div>

Compressing images is an essential step in optimizing applications for performance. Whether you’re managing a website, building a mobile…
Continue reading on Python in Plain English »

How to Compress Images Losslessly Using Python

It's weekend and after a very busy week i am back in my home desk and navigating through my checklist. Though i had not put any priority on my checklist, my eye went to A Simple Django version for beginners. Frankly i forgot what was my real idea ove...

<![CDATA[It's weekend and after a very busy week i am back in my home desk and navigating through my checklist. Though i had not put any priority on my checklist, my eye went to <code>A Simple Django version for beginners</code>. Frankly i forgot what was my real idea over it, but i know few of them<ol><li>Running Django inside a single file</li><li>Simple file and folder structure</li></ol><h1 id="heading-running-django-inside-a-single-file">Running Django Inside a Single File</h1>I came up with my own solution from my stackoverflow answers. See Screenshot below.<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1716061430465/99e8f4c8-8602-4e7f-8a9c-f789680d39d9.png" alt class="image--center mx-auto" />Reference: <a target="_blank" href="https://stackoverflow.com/a/59356081/7587197">https://stackoverflow.com/a/59356081/7587197</a>So looks like Django in a single file is possible. Here, your views and URLs are inside this same file, but we face problem when dealing with models inside this file since Django works on <code>App concept</code> and has its own guidelines on implementing apps like creating <code>apps.py</code> <code>models.py</code> <code>migrations package</code> and so onso now let's try to make it more readable and usable.<h1 id="heading-simple-file-and-folder-structure">Simple file and folder structure</h1>So, continuing from the single file solution, lets create couple of files to make the code readable. (I am assuming the root folder is <code>mdj</code>) so this means every files will stay inside it.<ol><li><code>urls.py</code><pre><code class="lang-python"> urlpatterns = []</code></pre></li><li><code>views.py</code> (empty file for now)</li><li><code>manage.py</code> (The main entry file)<pre><code class="lang-python"> import sys SETTINGS = dict( SECRET_KEY='djangoISsoCOOL', DEBUG=True, ROOT_URLCONF='urls', # so that it can denote urls.py INSTALLED_APPS=[], ) if __name__ == "__main__": import django from django.conf import settings from django.core.management import execute_from_command_line settings.configure(**SETTINGS) django.setup() execute_from_command_line(sys.argv)</code></pre> lets run this with command <code>python manage.py runserver</code> and it works. Now, lets create a simple page to check if view and urls works.</li></ol><pre><code class="lang-python"># views.pyfrom django.http import HttpResponsedef index(request): return HttpResponse("Hello, world.")</code></pre><pre><code class="lang-python"># urls.pyfrom django.urls import pathimport views # import the view# Todo for you : try with other import style as wellurlpatterns = [ path('', views.index),]</code></pre>Now, run the server again using <code>python manage.py runserver</code> and it works.<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1716065180214/5b7afc54-a6b8-4da1-b8b1-c6b309952cfa.png" alt class="image--center mx-auto" />Now, let's make the model and database to work, but we will need to configure app for this, so create few files to configure<ol><li><code>apps.py</code><pre><code class="lang-python"> from django.apps import AppConfig # just a random name, MDJ=mini django class MDJConfig(AppConfig): name = 'mdj' # name of the root folder</code></pre></li><li><code>models.py</code></li><li><code>migrations package</code> (<code>migrations</code> folder and an empty <code>__init__.py</code> file)</li></ol>and register this apps config location on settings(<code>manage.py file</code>), <code>INSTALLED_APPS</code> as<pre><code class="lang-python"># manage.pySETTINGS = dict( ... INSTALLED_APPS=[ 'apps.MDJConfig', ], ...)</code></pre>Now, lets run the server using, and it did not work this time and we see the error as <code>ModuleNotFoundError: No module named 'mdj'</code> this means, the module, which we assumed to be the root of our project, is not being recognized. So, lets add out <code>root folder path</code> into <code>systems path</code> so that it can be recognized.Add these following in the <code>manage.py</code> file<pre><code class="lang-python">import sysfrom pathlib import Path# BASE_DIR = parent of manage.py fileBASE_DIR = Path(__file__).resolve().parent # this line will do the magicsys.path.append(str(BASE_DIR.parent))</code></pre>And now, run the server, and it works.now let's create our very first sample model<pre><code class="lang-python"># models.pyfrom django.db import modelsclass Sample(models.Model): name = models.CharField(max_length=100)</code></pre>Create migrations using command: <code>python manage.py makemigrations</code> and it works, the migration is created and placed under <code>migrations folder</code>Now, before applying migrations, configure database (<code>sqlite3 for demo</code>)<pre><code class="lang-python"># manage.pySETTINGS = dict( ... DATABASES={ 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': BASE_DIR / 'db.sqlite3', } } ...)</code></pre>and apply migrations using command <code>python manage.py migrate</code> and everything works, the database is created and the migrations are reflected in the database.Open up Django shell using command <code>python manage.py shell</code> to play with the model.<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1716067810228/d7ebccd6-25a3-4061-96b2-0ceaf46d46f9.png" alt class="image--center mx-auto" />So, the final structure of the project will look like this,<ul><li>manage.py (core entry point contains settings as well)</li><li>urls.py (all urls for the project)</li><li>views.py (all view functions and classes for the project)</li><li>apps.py (app level configurations)</li><li>models.py (the model file which contains db related works)</li><li>migrations/__init__.py (<code>migrations</code> folder and the empty <code>__init__.py</code> file to store migrations when <code>python manage.py makemigrations</code> command is used)</li></ul>The final <code>manage.py</code> looks like this<pre><code class="lang-python">import sysfrom pathlib import PathBASE_DIR = Path(__file__).resolve().parentsys.path.append(str(BASE_DIR.parent))SETTINGS = dict( BASE_DIR=BASE_DIR, SECRET_KEY='djangoISsoCOOL', DEBUG=True, ROOT_URLCONF='urls', # so that it can denote urls.py INSTALLED_APPS=[ 'apps.MDJConfig', ], DATABASES={ 'default': { 'ENGINE': 'django.db.backends.sqlite3', 'NAME': BASE_DIR / 'db.sqlite3', } })if __name__ == "__main__": import django from django.conf import settings from django.core.management import execute_from_command_line settings.configure(**SETTINGS) django.setup() execute_from_command_line(sys.argv)</code></pre><h1 id="heading-what-next">What next ?</h1><ol><li>Change <code>models</code> to <code>database</code> which can be done by changing <code>MODELS_MODULE_NAME</code> on <code>django/apps/config.py:10</code> Doing this, the app will now know it needs to load models from <code>database.py</code> file instead of <code>models.py</code></li><li>Changing <code>migrations</code> to <code>databasehistory.</code> To make this work series of changes needs to be done on <code>django.core.management.commands.makemigrations.py</code> file and <code>django.db.migrations.writer.MigrationWriter</code>. I still need to verify doing this myself, since i see lots of things are changed on Django core itself.</li><li>default app name should not be appended when creating table name for models. To make this work, changes are required on <code>django.db.models.options.Options.contribute_to_class</code> to not add <code>app_label</code> if <code>db_table</code> for model is not given</li><li>When (3) is fixed, root folder name can be changed to any without any problems. currently, root folder name is <code>mdj</code> which is hardcoded on some of the files</li><li>When performing all this fixes, create fix and patch it in runtime through <code>manage.py</code> file</li></ol>Find complete code at: <a target="_blank" href="https://github.com/shrawanx/mdj">https://github.com/shrawanx/mdj</a><h3 id="heading-at-the-end-i-feel-this-current-implementation-has-lots-and-lots-of-works-to-do-before-i-can-say-what-the-title-of-this-article-says-but-it-was-fun-trying-and-experimenting-happy-weekend">At the end, i feel this current implementation has lots and lots of works to do before i can say what the title of this article says, but it was fun trying and experimenting. Happy weekend</h3>]]>

A Simple Django version for beginners. Frankly i forgot what was my real idea over it, but i know few of them

Running Django inside a single file

Simple file and folder structure

Running Django Inside a Single File
I came up with my own solution from my stackoverflow answers. See Screenshot below.

Reference: https://stackoverflow.com/a/59356081/7587197
So looks like Django in a single file is possible. Here, your views and URLs are inside this same file, but we face problem when dealing with models inside this file since Django works on App concept and has its own guidelines on implementing apps like creating apps.py models.py migrations package and so on
so now let's try to make it more readable and usable.
Simple file and folder structure
So, continuing from the single file solution, lets create couple of files to make the code readable. (I am assuming the root folder is mdj) so this means every files will stay inside it.

urls.py
 urlpatterns = []

views.py (empty file for now)

manage.py (The main entry file)
 import sys SETTINGS = dict(     SECRET_KEY='djangoISsoCOOL',     DEBUG=True,     ROOT_URLCONF='urls',  # so that it can denote urls.py     INSTALLED_APPS=[], ) if __name__ == "__main__":     import django     from django.conf import settings     from django.core.management import execute_from_command_line     settings.configure(**SETTINGS)     django.setup()     execute_from_command_line(sys.argv)
 lets run this with command python manage.py runserver and it works. Now, lets create a simple page to check if view and urls works.

# views.pyfrom django.http import HttpResponsedef index(request):    return HttpResponse("Hello, world.")
# urls.pyfrom django.urls import pathimport views # import the view# Todo for you : try with other import style as wellurlpatterns = [    path('', views.index),]
Now, run the server again using python manage.py runserver and it works.

Now, let's make the model and database to work, but we will need to configure app for this, so create few files to configure

apps.py
 from django.apps import AppConfig # just a random name, MDJ=mini django class MDJConfig(AppConfig):     name = 'mdj' # name of the root folder

models.py

migrations package (migrations folder and an empty __init__.py file)

and register this apps config location on settings(manage.py file), INSTALLED_APPS as
# manage.pySETTINGS = dict(    ...    INSTALLED_APPS=[         'apps.MDJConfig',    ],    ...)
Now, lets run the server using, and it did not work this time and we see the error as ModuleNotFoundError: No module named 'mdj'
this means, the module, which we assumed to be the root of our project, is not being recognized. So, lets add out root folder path into systems path so that it can be recognized.
Add these following in the manage.py file
import sysfrom pathlib import Path# BASE_DIR = parent of manage.py fileBASE_DIR = Path(__file__).resolve().parent # this line will do the magicsys.path.append(str(BASE_DIR.parent))
And now, run the server, and it works.
now let's create our very first sample model
# models.pyfrom django.db import modelsclass Sample(models.Model):    name = models.CharField(max_length=100)
Create migrations using command: python manage.py makemigrations and it works, the migration is created and placed under migrations folder
Now, before applying migrations, configure database (sqlite3 for demo)
# manage.pySETTINGS = dict(    ...    DATABASES={        'default': {            'ENGINE': 'django.db.backends.sqlite3',            'NAME': BASE_DIR / 'db.sqlite3',        }    }    ...)
and apply migrations using command python manage.py migrate and everything works, the database is created and the migrations are reflected in the database.
Open up Django shell using command python manage.py shell to play with the model.

So, the final structure of the project will look like this,

manage.py (core entry point contains settings as well)

urls.py (all urls for the project)

views.py (all view functions and classes for the project)

apps.py (app level configurations)

models.py (the model file which contains db related works)

migrations/__init__.py (migrations folder and the empty __init__.py file to store migrations when python manage.py makemigrations command is used)

The final manage.py looks like this
import sysfrom pathlib import PathBASE_DIR = Path(__file__).resolve().parentsys.path.append(str(BASE_DIR.parent))SETTINGS = dict(    BASE_DIR=BASE_DIR,    SECRET_KEY='djangoISsoCOOL',    DEBUG=True,    ROOT_URLCONF='urls',  # so that it can denote urls.py    INSTALLED_APPS=[        'apps.MDJConfig',    ],    DATABASES={        'default': {            'ENGINE': 'django.db.backends.sqlite3',            'NAME': BASE_DIR / 'db.sqlite3',        }    })if __name__ == "__main__":    import django    from django.conf import settings    from django.core.management import execute_from_command_line    settings.configure(**SETTINGS)    django.setup()    execute_from_command_line(sys.argv)
What next ?

Change models to database which can be done by changing MODELS_MODULE_NAME on django/apps/config.py:10 Doing this, the app will now know it needs to load models from database.py file instead of models.py

Changing migrations to databasehistory. To make this work series of changes needs to be done on django.core.management.commands.makemigrations.py file and django.db.migrations.writer.MigrationWriter. I still need to verify doing this myself, since i see lots of things are changed on Django core itself.

default app name should not be appended when creating table name for models. To make this work, changes are required on django.db.models.options.Options.contribute_to_class to not add app_label if db_table for model is not given

When (3) is fixed, root folder name can be changed to any without any problems. currently, root folder name is mdj which is hardcoded on some of the files

When performing all this fixes, create fix and patch it in runtime through manage.py file

Find complete code at: https://github.com/shrawanx/mdj
At the end, i feel this current implementation has lots and lots of works to do before i can say what the title of this article says, but it was fun trying and experimenting. Happy weekend
]]>

Django in one file? Or should i call it a mini Django?

In Django, media files can be defined as those files which are uploaded by the users. For examples:

Profile Picture uploads
File Uploads and many more ...

Configurations
On our Django settings settings.py we add MEDIA_URL and MEDIA_ROOT settings
ME...

<![CDATA[In Django, media files can be defined as those files which are uploaded by the users. For examples:<ol><li>Profile Picture uploads</li><li>File Uploads and many more ...</li></ol><h4 id="heading-configurations">Configurations</h4>On our Django settings <code>settings.py</code> we add <code>MEDIA_URL</code> and <code>MEDIA_ROOT</code> settings<pre><code>MEDIA_URL='/media/'MEDIA_ROOT = BASE_DIR /'media'</code></pre>or <pre><code>MEDIA_ROOT = '/var/www/media/'</code></pre><blockquote>Note: <code>MEDIA_ROOT</code> is the folder where your file gets saved.</blockquote><h4 id="heading-creating-a-url-configurations-so-serve-uploaded-files">Creating a URL configurations so serve uploaded files</h4>In static files serving, Django would provide us with a way to serve static files automatically, But to serve the media files we will need to create a URL configurations to serve all media files from <code>MEDIA_ROOT</code><pre><code class="lang-py">from django.conf import settingsfrom django.conf.urls.static import staticurlpatterns = [ # rest of project url patterns]if settings.DEBUG: urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)</code></pre><blockquote>Note: we serve media files like this on local development environment only, on production servers we use a different approach. We serve these assets directly through the webserver.Just to try if everything is working, you can create a sample file(<code>image.jpg</code>) inside the <code>MEDIA_ROOT</code> directory, and check if Django is serving it at <code>/media/image.jpg</code></blockquote><h4 id="heading-simple-file-upload-in-django">Simple File Upload in Django</h4><ul><li>When files are submitted from HTML form to server, the file data can be accessed from <code>request.FILES</code> on Django views. <code>request.FILES</code> is a dict like object</li><li>Each key in <code>request.FILES</code> is the name from <code>&lt;input type="file" name=""&gt;</code></li><li>It's mandatory for the HTML forms to have the attribute <code>enctype="multipart/form-data"</code></li><li>Form must be submitted using <code>POST</code> method</li><li>Django has proper model fields <code>ImageField</code> and <code>FileField</code> for handling file uploads</li><li>These uploaded files are stored on filesystem <code>(MEDIA_ROOT)</code> and only the reference of file is stored in <code>ImageField</code> or <code>FileField</code> in Database. So basically these fields are abstraction created by Django to help us deal with file uploads but deep down they are just the <code>CharField</code> on database side</li></ul>Example: A basic file uploads, and handling the file uploads manually on the Django sideon HTML side,<pre><code>&lt;!-- image-uploads.html --&gt;&lt;form method="post" enctype="multipart/form-data"&gt; {% csrf_token %} &lt;input type="file" name="image"&gt; &lt;input type="submit" value="submit"&gt;&lt;/form&gt;</code></pre>on Django view side,<pre><code class="lang-py">from django.core.files.storage import FileSystemStoragefrom django.http import HttpResponsefrom django.shortcuts import renderdef image_upload(request): if request.method == 'POST' and request.FILES['image']: image = request.FILES['image'] fs = FileSystemStorage() # save the image on MEDIA_ROOT folder file_name = fs.save(image.name, image) # get file url with respect to `MEDIA_URL` file_url = fs.url(file_name) return HttpResponse(file_url) else: # render the form return render(request, "image-uploads.html")</code></pre>That't it, now we can process file uploads in Django, save it to the <code>MEDIA_ROOT</code> location automatically using <code>FileSystemStorage()</code> <blockquote>When using Django model and fields with <code>ImageFiled</code> or <code>FileField</code> we don't need to perform the file processing/saving manually like we did just now. Simply we would assign the file to the field, and call the model.save() method like we generally do. I will talk about it in detail in some other tutorial.</blockquote>]]>

Profile Picture uploads
File Uploads and many more ...

Configurations
On our Django settings settings.py we add MEDIA_URL and MEDIA_ROOT settings
MEDIA_URL='/media/'MEDIA_ROOT = BASE_DIR /'media'
or 
MEDIA_ROOT = '/var/www/media/'

Note: MEDIA_ROOT is the folder where your file gets saved.

Creating a URL configurations so serve uploaded files
In static files serving, Django would provide us with a way to serve static files automatically, But to serve the media files we will need to create a URL configurations to serve all media files from MEDIA_ROOT
from django.conf import settingsfrom django.conf.urls.static import staticurlpatterns = [ # rest of project url patterns]if settings.DEBUG: urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)

Note: we serve media files like this on local development environment only, on production servers we use a different approach. We serve these assets directly through the webserver.
Just to try if everything is working, you can create a sample file(image.jpg) inside the MEDIA_ROOT directory, and check if Django is serving it at /media/image.jpg

Simple File Upload in Django

When files are submitted from HTML form to server, the file data can be accessed from request.FILES on Django views. request.FILES is a dict like object
Each key in request.FILES is the name from <input type="file" name="">
It's mandatory for the HTML forms to have the attribute enctype="multipart/form-data"
Form must be submitted using POST method
Django has proper model fields ImageField and FileField for handling file uploads
These uploaded files are stored on filesystem (MEDIA_ROOT) and only the reference of file is stored in ImageField or FileField in Database. So basically these fields are abstraction created by Django to help us deal with file uploads but deep down they are just the CharField on database side

Example: A basic file uploads, and handling the file uploads manually on the Django side
on HTML side,
<form method="post" enctype="multipart/form-data"> {% csrf_token %} <input type="file" name="image"> <input type="submit" value="submit"></form>
on Django view side,
from django.core.files.storage import FileSystemStoragefrom django.http import HttpResponsefrom django.shortcuts import renderdef image_upload(request): if request.method == 'POST' and request.FILES['image']: image = request.FILES['image'] fs = FileSystemStorage() # save the image on MEDIA_ROOT folder file_name = fs.save(image.name, image) # get file url with respect to `MEDIA_URL` file_url = fs.url(file_name) return HttpResponse(file_url) else: # render the form return render(request, "image-uploads.html")
That't it, now we can process file uploads in Django, save it to the MEDIA_ROOT location automatically using FileSystemStorage() 

When using Django model and fields with ImageFiled or FileField we don't need to perform the file processing/saving manually like we did just now. Simply we would assign the file to the field, and call the model.save() method like we generally do. I will talk about it in detail in some other tutorial.
]]>

Django Media Files

When we develop a web application we also need a way to use and serve static contents like (JS,CSS, and images ...)
In Django, any assets which are required for project development can be called static files. Some examples are:

JS files

CSS files

...

<![CDATA[When we develop a web application we also need a way to use and serve static contents like (JS,CSS, and images ...)In Django, any assets which are required for project development can be called static files. Some examples are:<ol><li>JS files</li><li>CSS files</li><li>Logo and banners which i need to show on webpage</li></ol><blockquote>These <code>static</code> files are put in place by developers rather than the user, User uploaded files like (profile picture, CV) are called <code>media</code> files in Django which we will talk in next tutorial</blockquote><h4 id="heading-configure-static-files-settings">Configure static files settings</h4><ul><li>Make sure <code>django.contrib.staticfiles</code> is included on <code>INSTALLED_APPS</code></li><li>In your <code>settings.py</code> file, add <code>STATIC_URL</code> (e.g.: STATIC_URL = '/static/')</li><li>Store your static files in folder called <code>static</code> inside your django app</li></ul>Apart from storing static files inside django app's <code>static</code> folder, we can also provide Django with list of other directories as well. To do that, we need to configure <code>STATICFILES_DIRS</code> on our <code>settings.py</code> file<pre><code class="lang-plaintext"># settings.pySTATICFILES_DIRS = [ BASE_DIR/"static", "/data/django-project/static-images/", "/var/www/static-django/"]</code></pre><h3 id="heading-linking-static-files-on-html-templates">Linking static files on HTML Templates</h3>Let's assume, <code>logo.jpg</code> exists in our app <code>static</code> folder (any app)Now, your HTML templates would look like,<pre><code>{% load static %}&lt;img src="{% static 'logo.jpg' %}"&gt;</code></pre><blockquote>If you run this template through Django (creating views and URLs) and inspect the HTML source of your page, you will see <code>&lt;img src="{% static 'logo.jpg' %}"</code> replaced by <code>&lt;img src="/static/logo.jpg"&gt;</code>. the <code>/static/</code> part that got appended in the URL is from the <code>STATIC_URL</code> settings we kept on our Django settings <code>(settings.py)</code></blockquote><h3 id="heading-serving-static-files">Serving static files</h3>We just linked our static file on the Templates, but we also need a way to serve those static files, e.g: when browsers requests to <code>/static/logo.jpg</code> then our Django server must send the logo.jpg as response.<ul><li>If we use <code>django.contrib.staticfiles</code> as explained above, <code>python manage.py runserver</code> command will automatically serve static files when <code>DEBUG</code> is set to True <code>[ DEBUG=True on settings.py ]</code></li></ul>So this means, we do not need to create a new URL or view to serve these static files, because Django does this for us<blockquote>This way is not suitable for production, and on production environment we don't user <code>runserver</code> instead we use some <code>wsgi</code> or <code>asgi</code> servers with some webservers like <code>nginx</code>. We we see more about it on Django deployments series.</blockquote><h4 id="heading-static-files-deployment-for-production-deployment-only">Static files Deployment (for production deployment only)</h4>On production environment, since as discussed earlier we don't use Django built in static file serving mechanism, so we need a way to gather and collect all static files from all the static folders into one single folder, so that we can deploy this folder or serve content from this folder.<code>django.contrib.staticfiles</code> provides a command for gathering static files from different applications of the project in a single directory so you can serve them easily. Steps:<ol><li>Set <code>STATIC_ROOT</code> on settings.py <code>(e.g: STATIC_ROOT='/home/static/')</code></li><li>Run <code>collectstatic</code> command <code>(python manage.py collectstatic)</code></li></ol>]]>

In Django, any assets which are required for project development can be called static files. Some examples are:

JS files

CSS files

Logo and banners which i need to show on webpage


These static files are put in place by developers rather than the user, User uploaded files like (profile picture, CV) are called media files in Django which we will talk in next tutorial

Configure static files settings

Make sure django.contrib.staticfiles is included on INSTALLED_APPS

In your settings.py file, add STATIC_URL (e.g.: STATIC_URL = '/static/')

Store your static files in folder called static inside your django app

Apart from storing static files inside django app's static folder, we can also provide Django with list of other directories as well. To do that, we need to configure STATICFILES_DIRS on our settings.py file
# settings.pySTATICFILES_DIRS = [ BASE_DIR/"static", "/data/django-project/static-images/", "/var/www/static-django/"]
Linking static files on HTML Templates
Let's assume, logo.jpg exists in our app static folder (any app)Now, your HTML templates would look like,
{% load static %}<img src="{% static 'logo.jpg' %}">

If you run this template through Django (creating views and URLs) and inspect the HTML source of your page, you will see <img src="{% static 'logo.jpg' %}" replaced by <img src="/static/logo.jpg">. the /static/ part that got appended in the URL is from the STATIC_URL settings we kept on our Django settings (settings.py)

Serving static files
We just linked our static file on the Templates, but we also need a way to serve those static files, e.g: when browsers requests to /static/logo.jpg then our Django server must send the logo.jpg as response.

If we use django.contrib.staticfiles as explained above, python manage.py runserver command will automatically serve static files when DEBUG is set to True [ DEBUG=True on settings.py ]

So this means, we do not need to create a new URL or view to serve these static files, because Django does this for us

This way is not suitable for production, and on production environment we don't user runserver instead we use some wsgi or asgi servers with some webservers like nginx. We we see more about it on Django deployments series.

Static files Deployment (for production deployment only)
On production environment, since as discussed earlier we don't use Django built in static file serving mechanism, so we need a way to gather and collect all static files from all the static folders into one single folder, so that we can deploy this folder or serve content from this folder.
django.contrib.staticfiles provides a command for gathering static files from different applications of the project in a single directory so you can serve them easily. Steps:

Set STATIC_ROOT on settings.py (e.g: STATIC_ROOT='/home/static/')

Run collectstatic command (python manage.py collectstatic)

]]>

Django Static Files

As the name suggests, Django views can also be written in Class based style. The major advantage of using Class based views in Django is

Code reusability and Clean Code

But, when creating a complex Class with lots of inheritance or mixins can make ...

<![CDATA[As the name suggests, Django views can also be written in Class based style. The major advantage of using Class based views in Django is<ul><li>Code reusability and Clean Code</li></ul>But, when creating a complex Class with lots of inheritance or mixins can make the situation hard to debug. To create a Class() based view we subclass <code>django.views.View</code><pre><code class="lang-PY">from django.views import Viewclass DashboardView(View): def get(self, request): # GET method pass def post(self, request): # POST method pass</code></pre>Converting examples from our function() based views to Class() based views<pre><code class="lang-py">from django.views import Viewfrom django.http impoty HttpResponseclass DashboardView(View): def get(self, request): # process view here return HttpResponse("Welcome to Dashboard")</code></pre><pre><code class="lang-py">#urls.pyurlpatterns = [ path('dashboard/', DashboardView),]# this will not work</code></pre>Since URL configurations expects callable function rather than class, we will use <code>.as_view()</code> class method of our View because <code>as_view()</code> returns a function to be used with URLs. This function does series of work for us,<ol><li>calls <code>setup()</code> method to initialize the attributes</li><li>calls <code>dispatch()</code> method which determines if request if <code>GET</code> or <code>POST</code> and send this request to corresponding request method </li></ol>So on our <code>urls.py</code> we do the following,<pre><code class="lang-py"># urls.py# import your view urlpatterns = [ path('dashboard/', DashboardView.as_view()),]</code></pre><h4 id="heading-capturing-url-values-in-class-based-views">Capturing URL values in Class() based views</h4>If you need to capture values from URL here at Class() based view, its similar to the function() based view, just add the new parameters(arguments) in your respective method. <pre><code>#urls.pyurlpatterns = [ path('profile/&lt;str:username&gt;/', ProfileView.as_view()),]</code></pre><pre><code class="lang-py">from django.views import Viewfrom django.http impoty HttpResponseclass ProfileView(View): def get(self, request, username): # process view here # get user info from DB using username return HttpResponse("My Profile")</code></pre><blockquote>Note: To make the development fast and easy, Django provides us with generic class based views as well majorly for performing C-R-U-D operations, which we will talk about in another tutorial <a target="_blank" href="https://docs.djangoproject.com/en/4.1/topics/class-based-views/generic-display/">See Django Docs for Generic class based views</a></blockquote>]]>

Code reusability and Clean Code

But, when creating a complex Class with lots of inheritance or mixins can make the situation hard to debug. 
To create a Class() based view we subclass django.views.View
from django.views import Viewclass DashboardView(View): def get(self, request): # GET method pass def post(self, request): # POST method pass
Converting examples from our function() based views to Class() based views
from django.views import Viewfrom django.http impoty HttpResponseclass DashboardView(View): def get(self, request): # process view here return HttpResponse("Welcome to Dashboard")
#urls.pyurlpatterns = [ path('dashboard/', DashboardView),]# this will not work
Since URL configurations expects callable function rather than class, we will use .as_view() class method of our View because as_view() returns a function to be used with URLs. This function does series of work for us,

calls setup() method to initialize the attributes
calls dispatch() method which determines if request if GET or POST and send this request to corresponding request method 

So on our urls.py we do the following,
# urls.py# import your view urlpatterns = [ path('dashboard/', DashboardView.as_view()),]
Capturing URL values in Class() based views
If you need to capture values from URL here at Class() based view, its similar to the function() based view, just add the new parameters(arguments) in your respective method. 
#urls.pyurlpatterns = [ path('profile/<str:username>/', ProfileView.as_view()),]
from django.views import Viewfrom django.http impoty HttpResponseclass ProfileView(View): def get(self, request, username): # process view here # get user info from DB using username return HttpResponse("My Profile")

Note: To make the development fast and easy, Django provides us with generic class based views as well majorly for performing C-R-U-D operations, which we will talk about in another tutorial See Django Docs for Generic class based views
]]>

Django Views - Class() based

When we talk about views in Django, views are the core part of Django which serves as the main place to process the incoming request.
Basically, we write out the view function in the views.py file, but we can write this function on a different file a...

<![CDATA[When we talk about views in Django, views are the core part of Django which serves as the main place to process the incoming request.Basically, we write out the view function in the <code>views.py</code> file, but we can write this function on a different file as well. We just need to map this function with our URL configuration.Creating a function based view is quite easy, we just need to create a normal python function with first parameter <code>request</code> as mandatory, because this parameter is the <code>Request Object</code> which we may need on our views. Request Objects contains various useful information about the requests like <code>request method</code> ,<code>request data</code> and so on.Also, this function based view must return an <code>HttpResponse</code> or its valid subclasses which is very important since a HTTP Response contains various information which Django configures automatically. Basic Example;<pre><code class="lang-py">from django.http import HttpResponsedef dashboard_view(request): # write your view processing logics here return HttpResponse("Welcome to Dashboard")</code></pre><blockquote>To return a template we use <code>render()</code> function instead of <code>HttpResponse()</code>, but if you look into the code of this shortcut <code>render()</code> function it uses <code>HttpResponse()</code> at the end. <a target="_blank" href="https://github.com/django/django/blob/main/django/shortcuts.py#L17-L25">Django Github : django.shortcuts.render()</a></blockquote><h3 id="heading-allow-only-specific-request-method-on-views">Allow only specific request method on views</h3>When we work with views, we sometime need a way to allow only specific request method like <code>GET</code> or <code>POST</code> according to our need. The basic way to perform this can be by doing if/else check on the view itself <pre><code class="lang-py">from django.http import HttpResponsedef dashboard_view(request): if request.method == 'GET' return HttpResponse("Welcome to Dashboard") else: # send status= 405 which means method not allowed return HttpResponse(status=405)</code></pre>But we can perform this with help of view decorator <code>require_http_methods</code><pre><code class="lang-py">from django.http import HttpResponsefrom django.views.decorators.http import require_http_methods@require_http_methods(["GET"])def dashboard_view(request): # only GET allowed return HttpResponse("Welcome to Dashboard")</code></pre><h4 id="heading-adding-extra-parameter-on-view-to-capture-url-values">Adding extra parameter on view to capture URL values</h4>If you are capturing values from URL then your view function should have parameter to accept this values<pre><code class="lang-py"># urls.pyurlpatterns = [ path('/profile/&lt;str:username&gt;/', user_profile_detail_view) # we used &lt;str&gt; path converter and assigned the value to username]</code></pre><pre><code class="lang-py"># views.pydef user_profile_detail_view(request, username): # do something with the username pass</code></pre>Have a detail read about URL design and URL values capturing at: <a target="_blank" href="https://djangotherightway.com/url-designing-and-url-kwargs-in-django">URL designing and URL kwargs in Django</a>]]>

Basically, we write out the view function in the views.py file, but we can write this function on a different file as well. We just need to map this function with our URL configuration.
Creating a function based view is quite easy, we just need to create a normal python function with first parameter request as mandatory, because this parameter is the Request Object which we may need on our views. Request Objects contains various useful information about the requests like request method ,request data and so on.
Also, this function based view must return an HttpResponse or its valid subclasses which is very important since a HTTP Response contains various information which Django configures automatically. 
Basic Example;
from django.http import HttpResponsedef dashboard_view(request): # write your view processing logics here return HttpResponse("Welcome to Dashboard")

To return a template we use render() function instead of HttpResponse(), but if you look into the code of this shortcut render() function it uses HttpResponse() at the end. Django Github : django.shortcuts.render()

Allow only specific request method on views
When we work with views, we sometime need a way to allow only specific request method like GET or POST according to our need. The basic way to perform this can be by doing if/else check on the view itself 
from django.http import HttpResponsedef dashboard_view(request): if request.method == 'GET' return HttpResponse("Welcome to Dashboard") else: # send status= 405 which means method not allowed return HttpResponse(status=405)
But we can perform this with help of view decorator require_http_methods
from django.http import HttpResponsefrom django.views.decorators.http import require_http_methods@require_http_methods(["GET"])def dashboard_view(request): # only GET allowed return HttpResponse("Welcome to Dashboard")
Adding extra parameter on view to capture URL values
If you are capturing values from URL then your view function should have parameter to accept this values
# urls.pyurlpatterns = [ path('/profile/<str:username>/', user_profile_detail_view) # we used <str> path converter and assigned the value to username]
# views.pydef user_profile_detail_view(request, username): # do something with the username pass
Have a detail read about URL design and URL values capturing at: URL designing and URL kwargs in Django
]]>

Django Views - function() based

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 egre...

<![CDATA[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-storagespip 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]]>

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-storagespip 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 set...

<![CDATA[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 DjangoLet'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 adminfrom .models import Information # import your modeladmin.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 createsuperuserUsername (leave blank to use 'djangotherightway'): adminEmail address: admin@example.comPassword: 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 adminfrom django.urls import pathurlpatterns = [ 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.]]>

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 adminfrom .models import Information  # import your modeladmin.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 createsuperuserUsername (leave blank to use 'djangotherightway'): adminEmail address: admin@example.comPassword: 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 adminfrom django.urls import pathurlpatterns = [  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)

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 i...

<![CDATA[<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 invalidThe <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> argumentsLet'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 ValidationErrorfrom django.db import modelsdef 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 ValidationErrorfrom django.db import modelsdef 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 shellobj = Info()obj.email = "example@djangotherightway.com"obj.age = 21obj.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 validationsYou 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 validationThese built-in validators can be imported from <code>django.core.validators</code> moduleSome 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.cA simple example to demonstrate use of built-in validators<pre><code class="lang-py">from django.db import modelsfrom django.core.validators import validate_emailclass 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 modelsclass 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 modelsclass 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>]]>

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 ValidationErrorfrom django.db import modelsdef 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 ValidationErrorfrom django.db import modelsdef 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 shellobj = Info()obj.email = "example@djangotherightway.com"obj.age = 21obj.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 modelsfrom django.core.validators import validate_emailclass 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 modelsclass 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 modelsclass 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

]]>

Django Models Part 4 (Model validation, Model Meta, Abstract Model class)

Model Manager

A Manager is the interface through which we perform ORMs in Django models
By Default, Django automatically adds a Manager with a name of objects. This is the reason we are able to use objects and query to our Models eg: Model.objects.a...

<![CDATA[<h3 id="heading-model-manager">Model Manager</h3><ul><li>A <code>Manager</code> is the interface through which we perform ORMs in Django models</li><li>By Default, Django automatically adds a <code>Manager</code> with a name of <code>objects</code>. This is the reason we are able to use <code>objects</code> and query to our Models <code>eg: Model.objects.all()</code></li><li>We can always create a new Manager and add to our model. We can customize ORM methods or add some more functionality in our Manager for data query</li><li>Atleast one Manager should exist in every models</li></ul>Example to change rename default <code>objects</code> in our model<pre><code class="lang-py">from django.db import modelsclass Info(models.Model): name = models.CharField(max_length=100) data = models.Manager()# Info.objects.all() will not work but Info.data.all() will work</code></pre><h3 id="heading-queryset">QuerySet</h3><ul><li>QuerySet can be defined as a collection of Objects (model objects)</li><li>Until and unless you do something to evaluate a QuerySet <code>(loop, slice with increments,...)</code>, it doesn't hit your database. So, we call it by saying QuerSet is Lazy</li></ul><h4 id="heading-lets-take-an-example-of-basic-model-which-we-will-be-using-in-this-tutorial">Let's take an example of basic model which we will be using in this tutorial</h4><ul><li>All, methods, customizations will be done on basis of this model below</li></ul><pre><code class="lang-py">from django.db import modelsclass User(models.Model): name = models.CharField(max_length=100) age = models.IntegerField()</code></pre><h4 id="heading-queryset-methods">QuerySet Methods</h4><ol><li>filter()<ul><li>Returns a new QuerySet, list of objects that matches the given lookup criteria</li><li>To return list of <code>users</code> whose <code>age</code>=10, we can do <code>User.objects.filter(age=10)</code>;<pre><code class="lang-py">qs = User.objects.filter(age=10)for u in qs:print(u.name, u.age)</code></pre></li><li>Multiple arguments are joined by <code>AND</code> clause when crafting an SQL query</li><li>So, <code>User.objects.filter(age=10, name="John")</code> will return list of <code>users</code> whose <code>age</code> is <code>10</code> <code>AND</code> whose <code>name</code> is <code>John</code></li><li>If you need to join arguments with <code>OR</code> you can use <code>Q</code> objects. e.g. This example will return list of users whose name is <code>John</code> <code>OR</code> <code>Harry</code> <pre><code class="lang-py">from django.db.models import Qqs = User.objects.filter(Q(name='John') | Q(name='Harry'))</code></pre></li></ul></li><li>exclude()<ul><li>Returns a new Queryset, list of objects that do not match the given lookup criteria</li><li>Same like <code>filter()</code> multiple arguments/parameters are joined by <code>AND</code> clause</li><li><code>User.objects.exclude(age=20)</code> will return list of users whose <code>age</code> is not <code>20</code></li></ul></li><li>order_by()<ul><li>Used to perform some ordering for the return QuerySet list</li><li>If you have set default ordering for your models, you don't even have to use this method to order your <code>QuerySet</code>, because the results returned by <code>QuerySet</code> are ordered automatically by the ordering tuple given by the <code>ordering</code> option in models <code>Meta</code><pre><code class="lang-py">class User(models.Model): name = models.CharField(max_length=100) age = models.IntegerField() class Meta: ordering = ['-age'] # - negative sign for descending order and # no sign for asc order</code></pre></li><li><code>User.objects.filter(age=10)</code> on this model will return the list of users whose <code>age</code> is <code>10</code> in descending order of <code>age</code></li><li><code>User.objects.filter(age=10).order_by('age')</code> on this model will return the list of users whose <code>age</code> is <code>10</code> in ascending order of <code>age</code></li><li><code>User.objects.order_by('-name')</code> will return list of users in descending order</li></ul></li></ol><ol><li>none()<ul><li>Calling <code>none()</code> will create a <code>QuerySet</code> that will never return any objects</li><li>This doesn't return any data, so this can be used in place where we need a valid <code>QuerySet</code> but no data</li><li>calling <code>none()</code> will not hit database</li><li>e.g <code>User.objects.none()</code></li></ul></li><li>all()<ul><li>This method is the simplest way to retrieve all objects from the model</li><li><code>User.objects.all()</code> will return list of every users/objects</li></ul></li></ol><h4 id="heading-database-orm-methods-which-do-not-return-a-queryset">Database ORM methods which do not return a QuerySet</h4><ol><li>get()<ul><li><code>User.objects.get(id=1)</code> will return the row/object whose <code>id</code> is <code>1</code></li></ul></li><li>create()<ul><li><code>User.objects.create(name="Peter",age=25)</code> will create a new object/record in database and return that object</li></ul></li><li>first()<ul><li><code>User.objects.filter(id=10).first()</code> will return the first row/object whose <code>id</code> is <code>10</code></li></ul></li><li>last()<ul><li><code>User.objects.filter(id=10).last()</code> will return the last row/object whose <code>id</code> is <code>10</code></li></ul></li><li>delete()<ul><li><code>User.objects.filter(id=10).delete()</code> will delete objects/rows whose <code>id</code> is <code>10</code>. This works like a bulk delete</li><li>You can also perform <code>delete()</code> on model single objects like the objects obtained from <code>get()</code> <code>first()</code> <code>last()</code> methods. This works like a single object delete</li></ul></li><li>count()<ul><li><code>User.objects.filter(id=10).count()</code> will return total number of users/objects whose <code>id</code> is <code>10</code></li></ul></li></ol><h3 id="heading-field-lookups">Field Lookups</h3><ul><li>Field lookups are used to specify meaning to the SQL <code>WHERE</code> clause</li><li>These lookups are crafted and attached with the fields when performing an ORM queries</li><li>It looks like<ul><li><code>field_[LookupType]=value</code> [note the double underscores]</li></ul></li></ul><h4 id="heading-lookups-types">Lookups Types</h4><ol><li>exact (also a default lookup)<ul><li>An exact Match</li><li><code>User.objects.filter(name__exact="Peter")</code> would generate <code>SQL: select .... where name="Peter"</code> and returns the objects/rows whose name is <code>Peter</code><blockquote>If we do not provide a lookup like in the above <code>QuerySet</code> method examples, Django automatically uses <code>exact</code> lookup. This is the reason our ORMs were working even when we didn't pass any lookups</blockquote></li><li>Thus, <code>User.objects.filter(name__exact="Peter")</code> and <code>User.objects.filter(name="Peter")</code> QuerySet is practically the same</li></ul></li><li>iexact<ul><li>Case insensitive match</li><li><code>User.objects.filter(name__iexact="peter")</code> would return QuerySet of the list of users whose name is <code>peter(case insensitive)</code> i.e: <code>peter</code>, <code>Peter</code>, <code>PeTeR</code>, <code>peteR</code> e.t.c</li></ul></li><li>contains<ul><li>Case sensitive containment</li><li><code>User.objects.filter(name__contains="a")</code> would generate <code>SQL: select ..... where name like '%a%'</code> and would return QuerySet of list of users whose <code>name</code> contains/includes <code>a</code></li></ul></li><li>icontains<ul><li>Similar to <code>contains</code> but case-insensitive</li></ul></li><li>gt<ul><li>greater than </li><li><code>User.objects.filter(age_gt=10)</code> would return QuerySet of list of users whose age is greater than 10 i.e 11,12,13,.......</li></ul></li><li>gte<ul><li>greater than or equal to</li><li><ul><li><code>User.objects.filter(age_gte=10)</code> would return QuerySet of list of users whose age is greater than or equals to 10 i.e 10,11,12,13,.......</li></ul></li></ul></li><li>lt<ul><li>less than </li><li><code>User.objects.filter(age_lt=10)</code> would return QuerySet of list of users whose age is less than 10 i.e 9,8,7,......</li></ul></li><li>lte<ul><li>less than or equal to</li><li><ul><li><code>User.objects.filter(age_lte=10)</code> would return QuerySet of list of users whose age is less than or equals to 10 i.e 10,9,8,7,.....</li></ul></li></ul></li></ol><blockquote>There are other plenty of inbuilts lookups. To name some of them; <code>in</code> <code>startswith</code> <code>istartswith</code> <code>range</code> </blockquote>]]>

A Manager is the interface through which we perform ORMs in Django models
By Default, Django automatically adds a Manager with a name of objects. This is the reason we are able to use objects and query to our Models eg: Model.objects.all()
We can always create a new Manager and add to our model. We can customize ORM methods or add some more functionality in our Manager for data query
Atleast one Manager should exist in every models

Example to change rename default objects in our model
from django.db import modelsclass Info(models.Model):    name = models.CharField(max_length=100)    data = models.Manager()# Info.objects.all() will not work but Info.data.all() will work
QuerySet

QuerySet can be defined as a collection of Objects (model objects)
Until and unless you do something to evaluate a QuerySet (loop, slice with increments,...), it doesn't hit your database. So, we call it by saying QuerSet is Lazy

Let's take an example of basic model which we will be using in this tutorial

All, methods, customizations will be done on basis of this model below

from django.db import modelsclass User(models.Model):    name = models.CharField(max_length=100)    age = models.IntegerField()
QuerySet Methods

filter()

Returns a new QuerySet, list of objects that matches the given lookup criteria
To return list of users whose age=10, we can do User.objects.filter(age=10);
qs = User.objects.filter(age=10)for u in qs:print(u.name, u.age)

Multiple arguments are joined by AND clause when crafting an SQL query
So, User.objects.filter(age=10, name="John") will return list of users whose age is 10 AND whose name is John
If you need to join arguments with OR you can use Q objects. e.g. This example will return list of users whose name is John OR Harry 
from django.db.models import Qqs = User.objects.filter(Q(name='John') | Q(name='Harry'))


exclude()

Returns a new Queryset, list of objects that do not match the given lookup criteria
Same like filter() multiple arguments/parameters are joined by AND clause
User.objects.exclude(age=20) will return list of users whose age is not 20


order_by()

Used to perform some ordering for the return QuerySet list

If you have set default ordering for your models, you don't even have to use this method to order your QuerySet, because the results returned by QuerySet are ordered automatically by the ordering tuple given by the ordering option in models Meta
class User(models.Model):  name = models.CharField(max_length=100)  age = models.IntegerField()  class Meta:      ordering = ['-age'] # - negative sign for descending order and                      # no sign for asc order

User.objects.filter(age=10) on this model will return the list of users whose age is 10 in descending order of age
User.objects.filter(age=10).order_by('age') on this model will return the list of users whose age is 10 in ascending order of age
User.objects.order_by('-name') will return list of users in descending order



none()

Calling none() will create a QuerySet that will never return any objects
This doesn't return any data, so this can be used in place where we need a valid QuerySet but no data
calling none() will not hit database
e.g User.objects.none()


all()

This method is the simplest way to retrieve all objects from the model
User.objects.all() will return list of every users/objects


Database ORM methods which do not return a QuerySet

get()
User.objects.get(id=1) will return the row/object whose id is 1

create()
User.objects.create(name="Peter",age=25) will create a new object/record in database and return that object

first()
User.objects.filter(id=10).first() will return the first row/object whose id is 10

last()
User.objects.filter(id=10).last() will return the last row/object whose id is 10

delete()
User.objects.filter(id=10).delete() will delete objects/rows whose id is 10. This works like a bulk delete
You can also perform delete() on model single objects like the objects obtained from get() first() last() methods. This works like a single object delete

count()
User.objects.filter(id=10).count() will return total number of users/objects whose id is 10


Field Lookups

Field lookups are used to specify meaning to the SQL WHERE clause
These lookups are crafted and attached with the fields when performing an ORM queries
It looks like
field_[LookupType]=value [note the double underscores]


Lookups Types

exact (also a default lookup)

An exact Match
User.objects.filter(name__exact="Peter") would generate SQL: select .... where name="Peter" and returns the objects/rows whose name is Peter
If we do not provide a lookup like in the above QuerySet method examples, Django automatically uses exact lookup. This is the reason our ORMs were working even when we didn't pass any lookups

Thus, User.objects.filter(name__exact="Peter") and User.objects.filter(name="Peter") QuerySet is practically the same


iexact

Case insensitive match
User.objects.filter(name__iexact="peter") would return QuerySet of the list of users whose name is peter(case insensitive) i.e: peter, Peter, PeTeR, peteR e.t.c


contains

Case sensitive containment
User.objects.filter(name__contains="a") would generate SQL: select ..... where name like '%a%' and would return QuerySet of list of users whose name contains/includes a


icontains

Similar to contains but case-insensitive


gt

greater than 
User.objects.filter(age_gt=10) would return QuerySet of list of users whose age is greater than 10 i.e 11,12,13,.......


gte

greater than or equal to

User.objects.filter(age_gte=10) would return QuerySet of list of users whose age is greater than or equals to 10 i.e 10,11,12,13,.......



lt

less than 
User.objects.filter(age_lt=10) would return QuerySet of list of users whose age is less than 10 i.e 9,8,7,......


lte

less than or equal to

User.objects.filter(age_lte=10) would return QuerySet of list of users whose age is less than or equals to 10 i.e 10,9,8,7,.....



There are other plenty of inbuilts lookups. To name some of them; in startswith istartswith range 
]]>

Django Models Part 3 (Model Manager,  QuerySet,  Lookups)

Table relationships in Relational Database design
1.  One to One relationship (1-1)

A relation is said to be 1-1 if a row in Table A can have only one matching row in Table B
Let's take an example of simple 1-1 relationship between user and user_det...

<![CDATA[<h2 id="heading-table-relationships-in-relational-database-design">Table relationships in Relational Database design</h2><h3 id="heading-1-one-to-one-relationship-1-1">1. One to One relationship (1-1)</h3><ul><li>A relation is said to be 1-1 if a row in <code>Table A</code> can have only one matching row in <code>Table B</code></li><li>Let's take an example of simple 1-1 relationship between <code>user</code> and <code>user_detail</code> table<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1647813459928/F5uFc0FKT.png" alt="one-to-one.djangotherightway.com.png" /></li><li>Here, in this figure we can see that, a row from <code>user table (Table A)</code> can only reference <code>a row (1 row)</code> for <code>user_detail (Table B)</code> through <code>user_detail_id</code> column on <code>user table (Table A)</code></li><li>Practically speaking, all data stored on <code>user_detail table (table B)</code> could have been stored on <code>user table (Table A)</code> and we could have just ignored the relationship, but this relationship is quite useful when you have lot's of column in your table and you want to separate those columns in different table according to their business nature</li><li>I basically work with this relationship to make my data model/table more readable</li></ul><h4 id="heading-lets-implement-1-1-relation-on-django-onetoonefield">Let's implement (1-1) relation on Django (<code>OneToOneField</code>)</h4><pre><code class="lang-py"># models.pyfrom django.db import modelsclass UserDetail(models.Model): address = models.CharField(max_length=100) phone_number = models.CharField(max_length=20) date_of_birth = models.DateField() github_username = models.CharField(max_length=50)class User(models.Model): first_name = models.CharField(max_length=50) middle_name = models.CharField(max_length=50, null=True, blank=True) last_name = models.CharField(max_length=50) email = models.EmailField() # note: do not save password in plain text password = models.CharField(max_length=50) user_detail = models.OneToOneField(UserDetail, on_delete=models.CASCADE)</code></pre>so using <code>models.OneToOneField</code> we can easily create up 1-1 relation between different models in Django. <blockquote>You could have switched the relationship as well, i.e 1-1 relation from UserDetail to User</blockquote>Basic ORM to create data/rows for this relation<pre><code class="lang-py"># import your model # i.e from app.models import UserDetail, Userdetail = UserDetail.objects.create( address="Lake Street", phone_number='123456', date_of_birth='2000-01-01', github_username='django')user = User.objects.create( first_name='Django', last_name='Django', email="django@example.com", password="django", user_detail=detail # reference to the user_detail instance created above)</code></pre><h3 id="heading-2-one-to-many-relationship-1-m">2. One to Many Relationship (1-M)</h3><ul><li>One of the most common forms of relationships</li><li>A relationship is said to be 1-M if a row in <code>Table A</code> can have matching row in <code>Table B</code> but a row in <code>Table B</code> can only have one matching row in <code>Table A</code></li><li>Let's take an example of simple 1-M relationship between <code>address</code> and <code>user</code> table</li></ul><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1647815733365/BAE9roUwa.png" alt="one-to-many.djangotherightway.com.png" /><ul><li>Here, in the figure we can see that a row in <code>address (Table A)</code> can be referenced by many rows from <code>user (Table B)</code>. i.e a user can have only one address but a address can be of multiple users</li><li>This can be simplified as <code>1 Address = Multiple Users</code> but <code>1 User = 1 Address</code></li><li>Experiment: Lets take an imaginary requirement of <code>1 User= Multiple Address</code> and <code>1 Address = 1 User</code>, in such a case, we can reverse this relation and call it <code>Multiple Address = 1 User</code> and call this relation a <code>Reverse One to Many Relation</code> as shown in the figure below</li></ul><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1647816549866/WUDv6UNN2.png" alt="reverse.1-m.djangotherightway.com.png" /><blockquote>Now, there lies a big confusion on the 1-M and Reverse 1-M, because both looks same. Infact, both of them looks same, but the only difference occurs when you look the relationship from table point of view. i.e In the reverse 1-M figure, we named it Reverse relation because we looked the relation from <code>address</code> point of view, but if you had looked the relation from <code>user</code> point of view, then it would have been a normal 1-M relationHow you prepare your 1-M relation matters when you try to perform db query for the data</blockquote><h4 id="heading-lets-implement-1-m-relation-on-django-foreignkey">Let's implement (1-M) relation on Django (<code>ForeignKey</code>)</h4><pre><code class="lang-py">from django.db import modelsclass Address(models.Model): name = models.CharField(max_length=100) latitude = models.CharField(max_length=100) longitude = models.CharField(max_length=100)class User(models.Model): email = models.EmailField() name = models.CharField(max_length=50) password = models.CharField(max_length=50) address = models.ForeignKey(Address, on_delete=models.CASCADE)</code></pre>Basic ORM to create rows for this relation<pre><code class="lang-py">address = Address.objects.create( name="Lake Street", latitude='1.1', longitude='2.2',)# or to get already created object# address = Address.objects.get(name='Lake Street')user = User.objects.create( name='Django', email="django@example.com", password="django", address=address # reference to the address instance from above)</code></pre><h3 id="heading-3-many-to-many-relationship-m-m">3. Many to Many Relationship (M-M)</h3><ul><li>A row in <code>Table A</code> can have many matching rows in <code>Table B</code> and vice versa</li><li>A many-to-many relation can be defined as a one-to-many relation linked by an intermediate table</li><li>Under the hood this relation is created using two <code>1-M</code> relation. i.e <code>1-M</code> and <code>M-1</code></li><li>Let's take an example of simple M-M relationship between <code>user</code> and <code>address</code> table</li></ul><img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1647817884669/r21scyytt.png" alt="many-to-many.djangotherightway.com.png" /><ul><li>As you can see in the figure, the relation between <code>user</code> and <code>address</code> is maintained by an intermediate table <code>Table C</code>, this way we can achieve a relation where a <code>user</code> can have multiple <code>address</code> and a <code>address</code> can have multiple <code>user</code></li></ul><h4 id="heading-lets-implement-m-m-relation-on-django-manytomanyfield">Let's implement (M-M) relation on Django (<code>ManyToManyField</code>)</h4><pre><code class="lang-py">from django.db import modelsclass Address(models.Model): name = models.CharField(max_length=100) latitude = models.CharField(max_length=100) longitude = models.CharField(max_length=100)class User(models.Model): email = models.EmailField() name = models.CharField(max_length=50) password = models.CharField(max_length=50) address = models.ManyToManyField(Address)</code></pre><blockquote>This looks so simple, isn't it? But i can feel a big confusion. We discussed that a M-M relation would need an intermediate table but on the Django end we just created two models without an intermediate one, This is due to the awesome implementation of Django where, Django automatically creates an intermediate table when we define our field with <code>models.ManyToManyField</code>, but don't worry you can always tell <code>models.ManyToManyField</code> to point to some custom intermediate table or you can even implement <code>M-M</code> with just <code>1-M</code> and <code>M-1</code> relation without even using <code>models.ManyToManyField</code></blockquote>Basic ORM to create rows for this relation<pre><code class="lang-py">address = Address.objects.create( name="Lake Street", latitude='1.1', longitude='2.2',)# or to get already created object# address = Address.objects.get(name='Lake Street')# first create user objectuser = User.objects.create( name='Django', email="django@example.com", password="django",)# add address to user/user to addressuser.address.add(address)# to remove address from user/user from addressuser.address.remove(address)</code></pre><h4 id="heading-implementing-m-m-without-modelsmanytomanyfield">Implementing M-M without <code>models.ManyToManyField</code></h4>By using just <code>1-M</code> relation and an intermediate table let's try to create M-M relations<pre><code class="lang-py">from django.db import modelsclass Address(models.Model): name = models.CharField(max_length=100) latitude = models.CharField(max_length=100) longitude = models.CharField(max_length=100)class User(models.Model): email = models.EmailField() name = models.CharField(max_length=50) password = models.CharField(max_length=50)# intermediate tableclass UserAddress(models.Model): user = models.ForeignKey(User, on_delete=models.CASCADE) address = models.ForeignKey(Address, on_delete=models.CASCADE)</code></pre>Basic ORM for this custom way<pre><code class="lang-py">address = Address.objects.create( name="Lake Street", latitude='1.1', longitude='2.2',)user = User.objects.create( name='Django', email="django@example.com", password="django",)user_address = UserAddress.objects.create( user=user, address=address,)</code></pre><h3 id="heading-relation-field-arguments">Relation field Arguments</h3><ol><li>on_deleteAs you can see we used <code>on_delete</code> argument on our <code>OneToOneField</code> and <code>ForeignKey</code> field, but what does it do?<ul><li>When an object/row referenced by ForeignKey/OneToOneField is deleted, Django will emulate the behaviour of SQL constraint specified by the on_delete argument</li><li>e.g.1 You have a <code>ForeignKey</code> and want to delete the row when the object referenced by foreign key gets deleted</li></ul><pre><code class="lang-py"> from django.db import models class Info(models.Model): name=models.CharField(max_length=20) user= models.ForeignKey(User, on_delete=models.CASCASE)</code></pre> Here, The <code>Info</code> objects/rows gets deleted when the referenced user gets deleted on the <code>User</code> table<h4 id="heading-commonly-used-values-for-ondelete">Commonly used Values for <code>on_delete</code></h4><ul><li><code>models.CASCADE</code></li><li><code>models.PROTECT</code></li><li><code>models.SET_NULL</code>and more...</li></ul></li><li>related_name<ul><li><code>related_name</code> attribute specifies the name of the reverse relation</li><li>If you do not provide <code>related_name</code> Django automatically created <code>related_name</code> for every <code>FK</code> automatically, whose default value is:<ol><li>[name of class]_set for <code>ForeignKey</code></li><li>[name_of_class] for <code>OneToOneField</code></li></ol></li></ul></li></ol>]]>

1.  One to One relationship (1-1)

A relation is said to be 1-1 if a row in Table A can have only one matching row in Table B

Let's take an example of simple 1-1 relationship between user and user_detail  table


Here, in this figure we can see that, a row from user table (Table A) can only reference  a row (1 row) for user_detail (Table B) through user_detail_id column on user table (Table A)

Practically speaking, all data stored on user_detail table (table B) could have been stored on user table (Table A) and we could have just ignored the relationship, but this relationship is quite useful when you have lot's of column in your table and you want to separate those columns in different table according to their business nature
I basically work with this relationship to make my data model/table more readable

Let's implement (1-1) relation on Django (OneToOneField)
# models.pyfrom django.db import modelsclass UserDetail(models.Model):    address = models.CharField(max_length=100)    phone_number = models.CharField(max_length=20)    date_of_birth = models.DateField()    github_username = models.CharField(max_length=50)class User(models.Model):    first_name = models.CharField(max_length=50)    middle_name = models.CharField(max_length=50, null=True, blank=True)    last_name = models.CharField(max_length=50)    email = models.EmailField()    # note: do not save password in plain text     password = models.CharField(max_length=50)    user_detail = models.OneToOneField(UserDetail,                           on_delete=models.CASCADE)
so using models.OneToOneField we can easily create up 1-1 relation between different models in Django. 

You could have switched the relationship as well, i.e 1-1 relation from UserDetail to User

Basic ORM to create data/rows for this relation
# import your model # i.e from app.models import UserDetail, Userdetail = UserDetail.objects.create(    address="Lake Street",    phone_number='123456',    date_of_birth='2000-01-01',    github_username='django')user = User.objects.create(    first_name='Django',    last_name='Django',    email="django@example.com",    password="django",    user_detail=detail  # reference to the user_detail instance created above)
2. One to Many Relationship (1-M)

One of the most common forms of relationships
A relationship is said to be 1-M if a row in Table A can have matching row in Table B but a row in Table B can only have one matching row in Table A
Let's take an example of simple 1-M relationship between address and user table



Here, in the figure we can see that a row in address (Table A) can be referenced by many rows from user (Table B). i.e a user can have only one address but a address can  be of multiple users
This can be simplified as 1 Address = Multiple Users but 1 User = 1 Address
Experiment: Lets take an imaginary requirement of  1 User= Multiple Address and 1 Address = 1 User, in such a case, we can reverse this relation and call it Multiple Address = 1 User and call this relation a Reverse One to Many Relation as shown in the figure below



Now, there lies a big confusion on the 1-M and Reverse 1-M, because both looks same. Infact, both of them looks same, but the only difference occurs when you look the relationship from table point of view. i.e In the reverse 1-M figure, we named it Reverse relation because we looked the relation from address point of view, but if you had looked the relation from user point of view, then it would have been a normal 1-M relation
How you prepare your 1-M relation matters when you try to perform db query for the data

Let's implement (1-M) relation on Django (ForeignKey)
from django.db import modelsclass Address(models.Model):    name = models.CharField(max_length=100)    latitude = models.CharField(max_length=100)    longitude = models.CharField(max_length=100)class User(models.Model):    email = models.EmailField()    name = models.CharField(max_length=50)    password = models.CharField(max_length=50)    address = models.ForeignKey(Address, on_delete=models.CASCADE)
Basic ORM to create rows for this relation
address = Address.objects.create(    name="Lake Street",    latitude='1.1',    longitude='2.2',)# or to get already created object# address = Address.objects.get(name='Lake Street')user = User.objects.create(    name='Django',    email="django@example.com",    password="django",    address=address  # reference to the address instance from above)
3. Many to Many Relationship (M-M)

A row in Table A can have many matching rows in Table B and vice versa
A many-to-many relation can be defined as a one-to-many relation linked by an intermediate table
Under the hood this relation is created using two 1-M relation. i.e 1-M and M-1
Let's take an example of simple M-M relationship between user and address  table



As you can see in the figure, the relation between user and address is maintained by an intermediate table Table C, this way we can achieve a relation where a user can have multiple address and a address can have multiple user

Let's implement (M-M) relation on Django (ManyToManyField)
from django.db import modelsclass Address(models.Model):    name = models.CharField(max_length=100)    latitude = models.CharField(max_length=100)    longitude = models.CharField(max_length=100)class User(models.Model):    email = models.EmailField()    name = models.CharField(max_length=50)    password = models.CharField(max_length=50)    address = models.ManyToManyField(Address)

This looks so simple, isn't it? But i can feel a big confusion. We discussed that a M-M relation would need an intermediate table but on the Django end we just created two models without an intermediate one, This is due to the awesome implementation of Django where, Django automatically creates an intermediate table when we define our field with models.ManyToManyField, but don't worry you can always tell models.ManyToManyField to point to some custom intermediate table or you can even implement M-M with just 1-M and M-1 relation without even using models.ManyToManyField

Basic ORM to create rows for this relation
address = Address.objects.create(    name="Lake Street",    latitude='1.1',    longitude='2.2',)# or to get already created object# address = Address.objects.get(name='Lake Street')# first create user objectuser = User.objects.create(    name='Django',    email="django@example.com",    password="django",)# add address to user/user to addressuser.address.add(address)# to remove address from user/user from addressuser.address.remove(address)
Implementing M-M without models.ManyToManyField
By using just 1-M relation and an intermediate table let's try to create M-M relations
from django.db import modelsclass Address(models.Model):    name = models.CharField(max_length=100)    latitude = models.CharField(max_length=100)    longitude = models.CharField(max_length=100)class User(models.Model):    email = models.EmailField()    name = models.CharField(max_length=50)    password = models.CharField(max_length=50)# intermediate tableclass UserAddress(models.Model):    user = models.ForeignKey(User, on_delete=models.CASCADE)    address = models.ForeignKey(Address, on_delete=models.CASCADE)
Basic ORM for this custom way
address = Address.objects.create(    name="Lake Street",    latitude='1.1',    longitude='2.2',)user = User.objects.create(    name='Django',    email="django@example.com",    password="django",)user_address = UserAddress.objects.create(    user=user,    address=address,)
Relation field Arguments

on_delete
As you can see we used on_delete argument on our OneToOneField and ForeignKey field, but what does it do?

When an object/row referenced by ForeignKey/OneToOneField is deleted, Django will emulate the behaviour of SQL constraint specified by the on_delete argument
e.g.1 You have a ForeignKey and want to delete the row when the object referenced by foreign key gets deleted

 from django.db import models class Info(models.Model):           name=models.CharField(max_length=20)           user= models.ForeignKey(User, on_delete=models.CASCASE)
  Here, The Info objects/rows gets deleted when the referenced user gets deleted on the User table
Commonly used Values for on_delete

models.CASCADE
models.PROTECT
models.SET_NULLand more...


related_name

related_name attribute specifies the name of the reverse relation
If you do not provide related_name Django automatically created related_name for every FK automatically, whose default value is:
[name of class]_set for ForeignKey
[name_of_class] for OneToOneField


]]>

Django Models Part 2 (Models Relationship)

When talking about LimitOffsetPagination in django rest framework, it handles limit as strictly positive integer only (1,2,3,4.......). Whenever you send any non positive numbers/negative numbers including zero (0) to the limit query LimitOffsetPagin...

<![CDATA[When talking about <code>LimitOffsetPagination</code> in django rest framework, it handles <code>limit</code> as strictly positive integer only <code>(1,2,3,4.......)</code>. Whenever you send any <code>non positive numbers/negative numbers</code> including <code>zero (0)</code> to the <code>limit query</code> <code>LimitOffsetPagination</code> will ignore this limit value and will work with it's own customizable <code>default_limit</code> attribute which indeed can be customized using <code>PAGE_SIZE</code> settings for <code>REST_FRAMEWORK</code><h2 id="heading-lets-talk-about-my-scenario">Let's talk about my scenario</h2>Whenever i send <code>limit=0</code> params for the pagination, it ignores this values and sends/returns me whole lot of data(according to <code>default_limit</code>). I wanted to change this behaviour of the <code>LimitOffsetPagination</code> class so that the pagination class return <code>empty data</code> i.e <code>zero data</code> when i send <code>limit=0</code> params<h3 id="heading-so-lets-customize-the-limitoffsetpagination-class">so, lets customize the <code>LimitOffsetPagination</code> class</h3><pre><code class="lang-py">from rest_framework.pagination import LimitOffsetPagination, _positive_intclass LimitZeroNoResultsPagination(LimitOffsetPagination): def get_limit(self, request): if self.limit_query_param: try: return _positive_int( request.query_params[self.limit_query_param], strict=False, cutoff=self.max_limit ) except (KeyError, ValueError): pass return self.default_limit</code></pre>If, you compare what we customized in this class then you can see we changed <code>strict=False</code> for the <code>_positive_int</code> functionNote: <code>_positive_int</code> is a private function, i do not promote using private func but in this case i needed it so please use this responsibly.So, when you use this Pagination class for your API's and use <code>limit=0</code> then you will see this<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1647056226646/d2RGAt-iC.png" alt="limit-zero-no-results-paginations.png" /><h3 id="heading-where-do-i-use-this">Where do i use this ?</h3>I use this <code>limit=0</code> whenever i want extra data from the API like the <code>total count</code> but don't want it's data<h4 id="heading-tested-on">Tested on</h4><ul><li>Django(3.0.3) and Django Rest Framework(3.11.0)</li><li>Django(4.0.2) and Django Rest Framework(3.13.1)</li></ul>]]>

LimitOffsetPagination in django rest framework, it handles limit as strictly positive integer only (1,2,3,4.......). Whenever you send any non positive numbers/negative numbers including zero (0) to the limit query LimitOffsetPagination will ignore this limit value and will work with it's own customizable default_limit attribute which indeed can be customized using PAGE_SIZE settings for REST_FRAMEWORK
Let's talk about my scenario
Whenever i send limit=0 params for the pagination, it ignores this values and sends/returns me whole lot of data(according to default_limit). I wanted to change this behaviour of the LimitOffsetPagination class so that the pagination class return empty data i.e zero data when i send limit=0 params
so, lets customize the LimitOffsetPagination class
from rest_framework.pagination import LimitOffsetPagination, _positive_intclass LimitZeroNoResultsPagination(LimitOffsetPagination):    def get_limit(self, request):        if self.limit_query_param:            try:                return _positive_int(                    request.query_params[self.limit_query_param],                    strict=False,                    cutoff=self.max_limit                )            except (KeyError, ValueError):                pass        return self.default_limit
If, you compare what we customized in this class then you can see we changed strict=False for the _positive_int function
Note: _positive_int is a private function, i do not promote using private func but in this case i needed it so please use this responsibly.
So, when you use this Pagination class for your API's and use limit=0 then you will see this

Where do i use this ?
I use this limit=0 whenever i want extra data from the API like the total count but don't want it's data
Tested on

Django(3.0.3) and Django Rest Framework(3.11.0)
Django(4.0.2) and Django Rest Framework(3.13.1)
]]>

Django Rest Framework: LimitZeroNoResultsPagination custom pagination

While working with Django+Django Rest Framework, you might have come up in a problem that occurrence of Errors/ValidationErrors from Django Model or some internals will not response a valid json your API consumer was expecting.
For example:
Errors/Va...

<![CDATA[While working with Django+Django Rest Framework, you might have come up in a problem that occurrence of Errors/ValidationErrors from Django Model or some internals will not response a valid <code>json</code> your API consumer was expecting.For example:Errors/ValidationErrors from Django Model or some internals will output something like<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1646840079461/d5SrIsvNT.png" alt="django-error-debug-mode-example.png" />This looks so ugly (on debug mode only!), but with <code>DEBUG=False</code> as well, you will get something like<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1646840429795/-ujo5wyau.png" alt="500-error-example.png" />So, let's create up a custom exception handler for Django Rest Framework which will catch exceptions from those above mentioned scenarios and convert them to something much more prettier which can be easily transformed to <code>json</code> <pre><code class="lang-py">from django.core.exceptions import NON_FIELD_ERRORS as DJ_NON_FIELD_ERRORSfrom django.core.exceptions import ValidationError as DjValidationErrorfrom rest_framework.exceptions import ValidationError as DRFValidationErrorfrom rest_framework.views import api_settingsfrom rest_framework.views import exception_handler as drf_exception_handlerDRF_NON_FIELD_ERRORS = api_settings.NON_FIELD_ERRORS_KEYdef handle(exc, context): # translate django validation error which ... # .. causes HTTP 500 status ==&gt; DRF validation which will cause 400 HTTP status if isinstance(exc, DjValidationError): data = exc.message_dict if DJ_NON_FIELD_ERRORS in data: data[DRF_NON_FIELD_ERRORS] = data[DJ_NON_FIELD_ERRORS] del data[DJ_NON_FIELD_ERRORS] exc = DRFValidationError(detail=data) return drf_exception_handler(exc, context)</code></pre>and add this exception handler function as your default exception handler on django rest framework settings on your <code>settings.py</code> file<pre><code class="lang-py">REST_FRAMEWORK = { # ..... 'EXCEPTION_HANDLER': 'path_to_your_exception_hander' # ...}</code></pre>Now, the internal Django validation error that you raise from models or anywhere maybe will look like this;<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1646840847549/3BFL9mI8f.png" alt="error-400-bad-request.png" />Tested on<ul><li>Django(3.0.3) and Django Rest Framework(3.11.0)</li><li>Django(4.0.2) and Django Rest Framework(3.13.1)</li></ul>]]>

json your API consumer was expecting.
For example:Errors/ValidationErrors from Django Model or some internals will output something like

This looks so ugly (on debug mode only!),  but with DEBUG=False as well, you will get something like

So, let's create up a custom exception handler for Django Rest Framework which will catch exceptions from those above mentioned scenarios and convert them to something much more prettier which can be easily transformed to json  
from django.core.exceptions import NON_FIELD_ERRORS as DJ_NON_FIELD_ERRORSfrom django.core.exceptions import ValidationError as DjValidationErrorfrom rest_framework.exceptions import ValidationError as DRFValidationErrorfrom rest_framework.views import api_settingsfrom rest_framework.views import exception_handler as drf_exception_handlerDRF_NON_FIELD_ERRORS = api_settings.NON_FIELD_ERRORS_KEYdef handle(exc, context):    # translate django validation error which ...    # .. causes HTTP 500 status ==> DRF validation which will cause 400 HTTP status    if isinstance(exc, DjValidationError):        data = exc.message_dict        if DJ_NON_FIELD_ERRORS in data:            data[DRF_NON_FIELD_ERRORS] = data[DJ_NON_FIELD_ERRORS]            del data[DJ_NON_FIELD_ERRORS]        exc = DRFValidationError(detail=data)    return drf_exception_handler(exc, context)
and add this exception handler function as your default exception handler on django rest framework settings on your settings.py file
REST_FRAMEWORK = {     # .....    'EXCEPTION_HANDLER': 'path_to_your_exception_hander'     # ...}
Now, the internal Django validation error that you raise from models or anywhere maybe will look like this;

Tested on

Django(3.0.3) and Django Rest Framework(3.11.0)
Django(4.0.2) and Django Rest Framework(3.13.1)
]]>

Convert Django Validation Errors to DRF compatible Errors

When creating a web application you will come up with a need to have some sort of mechanism to store your data permanently either on a filesystem or a Database. For this  article/tutorial we will have a look inside storing your data on a Database. Da...

Django Models

Django model is the single, definite source of information about your data
It contains the essential fields and behaviors of the data you're storing
Django model is some sort of your Database table representation a db table --> a django model
We write django models on a class based style i.e using Python Class syntax. So, Each model is a Python class that subclassed django.db.models.Model
Each attributes(valid DB type) of the model represents a database field 
With all this, Django gives us an automatically generated database access API that let's us create, retrieve, update and delete objects using ORM. Thus, you hardly need to write any raw SQL. SQL stands for Structured Query Language used to communicate with a Database
This doesn't mean Django uses some sorts of magic to communicate with a Database. Under the hood Django create raw SQL for every operations(basically CRUD) to communicate with a Database
Django models lies inside models.py file on your Django apps. Each Django app can have multiple models/tables inside a models.py

Don't get confused with models.py and Model class we are talking. models.py is a python file which is inside every Django apps and Model Class is a Python class we create inside the models.py file

Basic Example of a Django Model

Lets take an example of User model which has username, first_name, last_name,  attributes/field

under your models.py, let's create our first model as follows,
from django.db import models# we need to create a class which subclasses django.db.models.Model# so let's create a class which inherits models.Modelclass User(models.Model):         username = models.CharField(max_length=50)        first_name = models.CharField(max_length=30)        last_name = models.CharField(max_length=30)
Note,

Each field is specified as class attributes, and each attributes maps to a database column
Creating attributed like age=10 will not be reflected in our Database since Django will not know how to process it and map to a database column. This means, we need to use attribute type provided by Django only. (Advanced: You can create your own fields as well, but trust me fields provided by Django will be enough for nearly all field types you will ever need)

The model class we just created will create a database table like this; 
CREATE TABLE app_user(          "id" serial NOT NULL PRIMARY KEY,          "username" varchar(30) NOT NULL,          "first_name" varchar(30) NOT NULL,          "last_name" varchar(30) NOT NULL,);

Don't get confused on how to generate this SQL, we need some commands to create a intermediate file (called migrations) which we will apply to our database (called migrate)

This is really awesome, we didn't write a single line of SQL, but we got the corresponding SQL statement to create our table. But,

we didn't add id attribute/field on our Model class, but this is included on the SQL, this is because Django will automatically add a Primary Key as id by default. Don't worry we can always customize this behavior but let's leave Django upon itself to do this good work 
we created our Model class as User but the SQL seems to have created app_user table, this is because on default behavior, django will craft a table name for your automatically based on your app name and Model class name. In our case, let's assume we create a django app as app and our Model class as User, so this means django will create app_user table. This behavior can be customized by overriding the Model class Meta information

Before jumping on commands to reflect our Django Model class to our database, let's first configure our database settings so that Django can use it and do the hard work.
Databases in Django

Django officially supports
PostgreSQL  (will need PostgreSQL>=9.5 and python package psycopg2>=2.5.4). psycopg2 is a PostgreSQL adapter for Python programming language
MariaDB (added in Django 3.0. Django supports MariaDB>=10.1)
MySQL (MySQL>=5.7 for Django 3.2  and required python adapter mysqlclient>=1.3.12)
Oracle (oracle>=12.12 and cx_oracle>=6.0 python driver required)
SQlite (SQlite>=3.8.3)


SQlite is a file based database. You don't need any Python adapters to work with SQlite database, since SQlite module is integrated into python itself. This means, to work with SQlite database, just write python code using sqlite3 module. Due to this reason Django will work under the hood with SQlite Database without any special environment setups. 

Since, working with SQlite initially to learn is pretty easy we will configure SQlite in our Project. Don't worry, integrating other databases is easy as well which we will focus on other articles.
By default, when creating a django project, under settings.py Django configures your Project to work with SQlite
# settings.pyDATABASES = {    'default': {        'ENGINE': 'django.db.backends.sqlite3',        'NAME': BASE_DIR / 'db.sqlite3',    }}
Notes;

ENGINE refers to the corresponding database backends/code/mappings for our preferred Database
We can add multiple database configurations inside this settings. Multiple database are used for data replication, optimization, aggregating data from multiple sources e.t.c, whose configurations might look like,
DATABASES = {  'default': {      'ENGINE': 'django.db.backends.sqlite3',      'NAME': BASE_DIR / 'db.sqlite3',  }, 'read_replica': {      'ENGINE': 'django.db.backends.sqlite3',      'NAME': BASE_DIR / 'db_replica.sqlite3',  },  'analytics_db': {      'ENGINE': 'django.db.backends.sqlite3',      'NAME': BASE_DIR / 'analytics_db.sqlite3',  }}

When connecting to other databases special/extra connection parameters will be required, let's take an example of PostgreSQL
DATABASES = {  'default': {      'ENGINE': 'django.db.backends.postgresql',      'NAME': 'db_name',      'USER': 'db_user',      'PASSWORD': 'db_password',      'HOST': '127.0.0.1',      'PORT': '5432',  }}

So we checked our configurations and now let's head to the actual process of reflecting our Model Class to our Database as a Database table
Django Migrations (Migration framework)

Migrations are Django's way of propagating changed you make to your models into your database table
available commands:
python manage.py makemigrations responsible for creating new migrations based on changes you made to your models. This is an intermediate Python file django created before taking changes to the actual database server. Think of migration file as a history tracker (GIT) for your models. You create migrations after you make any changes to the models which should reflect to your database. Migrations files are created and placed under your apps migrations folder
python manage.py migrate responsible to pick the created migrations files and to peform apply/unapply operations which gets reflected to your database.
python manage.py sqlmigrate [app_name] [migration_file_name] which displays SQL statements for the migrations created using makemigrations command
python manage.py showmigrations which lists project's migrations and their status (i.e if it is applied to database or not)


So, the rule of thumb is first your create your migrations by using python manage.py makemigrations command and then apply those changes to database with python manage.py migrate

Reminder: Did you perform makemigrations and migrate command?

Model Field Options
Model field options are the options we can pass to individual model attribute classes. In previous example when we used models.CharField we used max_length option to tell django that the field should only have data lenght of upto given max_length. There are more options that we can pass to our model attributes depending upon our requirements, some of commonly used model options are:

null(default=False) when not provided it defaults to False, i.e: null value is not allowed
blank(default=False)
db_column used to create/customize column name on the Database table which if not provided defaults to the attribute name
default (used to provide default value to the attribute incase a value is not provided when adding a new object/row to a model/table). default can be a constant value or a callable object like python functions, this python function should return a value which can be used a default value for the attribute
unique(default=False) if true the field value must be unique throughout the table
validators a list of validators to run for this field

A simple example of Model using different model options
from django.db import modelsdef dummy_default_extra_data():    return "Additional Information and data"class DummyModel(models.Model):    first_name = models.CharField(max_length=50)    # assume, middle_name can be null    middle_name = models.CharField(max_length=50, blank=True, null=True)    last_name = models.CharField(max_length=50)    # date_of_birth is long so create a dob for column name,    # but, use date_of_birth inside django    date_of_birth = models.DateTimeField(db_column='dob')    # assume, email_notification is allowed by default    email_notification = models.BooleanField(default=True)    # extra_data default as a function,    # (you can't use lambda function here)    extra_data = models.TextField(default=dummy_default_extra_data)    # assume, passport_number should be unique    passport_number = models.CharField(max_length=100,unique=True)
ORM (Object Relational Mapper)

ORM Helps us write queries(simple or advanced) using object oriented paradigm of your favourite programming language 
Django ORM helps us to communicate with our database without using any SQL commands.

Abstract away the database system, so switching from MySQL to PostgreSQL is pretty easy

For now, to practice ORM(communicate with DB) we will not create any views or any complicated python code, instead we will use a shell provided by Django to run our ORM code. This django shell is an advance version of a Normal Python shell but Django modules are already loaded inside this shell.

You can open django shell using command python manage.py shell

For now, lets assume a simple model, we will use this model to understand ORM code
from django.db import modelsclass Information(models.Model):        name = models.CharField(max_length=50)        age = models.IntegerField()        is_active = models.BooleanField(default=False)
Once, you have created your models django provides you with a default Manager called objects through which you can you can perform database operations. You can always customize or add more Managers to your models which we will see in future articles.

Don't forget, we will be getting familiar with ORM inside django shell for now. So open up the django shell

Creating Objects/ Adding row to DB table

save() method
   # assuming Information model belongs to practice app    from practice.models import Information    obj = Information()   obj.name = "John"   obj.age = 15   obj.save()

create() method
  # assuming Information model belongs to practice app   from practice.models import Information   obj = Information.objects.create(name = "John")

Retrieving objects / get row/s from DB table

get() a single row. Can return/work with only single row/object
  # assuming Information model belongs to practice app   from practice.models import Information  john_obj =  Information.objects.get(name="John")  # will throw error if no row matched or multiple row is matched.   # get a object with non existing row to see the error  check_error = Information.objects.get(name="Nothing")

all() to retrieve all rows from table, which returns an iterable queryset which can be looped to retrive every objects
  # assuming Information model belongs to practice app   from practice.models import Information  queryset = Information.objects.all() # actual ORM  for obj in queryset:        print(obj, obj.name, obj.age)

filter() to retrive multiple rows (a queryset) but with certain filters/ SQL where statement
 # assuming Information model belongs to practice app  from practice.models import Information # get all objects/rows with age=15 queryset = Information.objects.filter(age=15)  for obj in queryset:        print(obj, obj.name, obj.age)

Updating objects/ update rows of DB table

single update/ single row update
     # first get the object which you want to update     # lets get the John and update his age to 20     obj = Information.objects.get(name="John")     obj.age = 20 # update age     obj.save()

Multiple objects/rows update at once
   # lets update every rows to is_active=True    updated = Information.objects.all().update(is_active=True)   print(updated)

Deleting a object/ a row from DB table

Single object delete/ single row delete
    # first get a object, and delete    # lets delete John    john_obj = Information.objects.get(name="John")    john_obj.delete()

Multiple objects/rows delete at once
 # delete every objects from DB deleted = Information.objects.all().delete() # delete every rows whose is_active=False deleted = Information.objects.filter(is_active=False).delete()

Raw SQL
When working sometimes you may need to perform raw SQL instead of the ORM. This can come up when you need to write advanced SQL, or maybe use some native DB feature which Django ORM doesn't support or maybe the raw SQL is pretty fast than the ORM, whatever can be the reason and its really accepted to write raw SQL as well, but i suggest to stick to ORM as much as possible.

raw() which maps to models attributes automatically
 data = Information.objects.raw(                "SELECT id,name,age FROM practice_information"             )

You can also perform SQL directly,
    from django.db import connection    with connection.cursor() as cursor:             cursor.execute("SELECT * FROM practice_information;")             rows = cursor.fetchall()             print(rows)
Whats next?
In the next article we will see more about the models relations/DB table relationship and advance guides on lookups and QuerySet
]]>

Django Models Part I (Database Setup,  Models and ORM)

When working with web frameworks at some point rendering data directly through your controller or views is not efficient. Let's take an example of code snippet from our first article in this series Django Setup, Architecture and Hello World which loo...

<![CDATA[When working with web frameworks at some point rendering data directly through your controller or views is not efficient. Let's take an example of code snippet from our first article in this series <a target="_blank" href="/django-setup-architecture-and-hello-world">Django Setup, Architecture and Hello World</a> which looks like<pre><code>from django.http import HttpResponsedef hi_view(request): response = """ &lt;html&gt; &lt;body&gt; &lt;h1&gt;Hello world&lt;/h1&gt; &lt;/body&gt; &lt;/html&gt; """ return HttpResponse(response)</code></pre>Here we trying to send whole bunch of HTML code from the views itself. This might look easy and so clean to see in this example but trust me as your project grows up and when you will have 100's and 1000's of HTML code this method will be pain and unmanageable. So how do we write templates in a manageable way and make it dynamic as well? The answer is through the help of <code>Template System</code> provided by the framework.<h3 id="django-template">Django Template</h3><ul><li>A template can have some static HTML parts and some dynamic content to be inserted in between the HTML</li><li>A very efficient and convenient way of generating HTML dynamically</li><li>Django has built-in backend for its own template system which is called <code>Django Template Language (DTL)</code> and also for the popular alternative <code>Jinja2</code></li></ul><blockquote>For the sake of simplicity we will be using <code>Django Template Language (DTL)</code> which is preconfigured on <code>settings.py</code> when creating our project using <code>django-admin</code> command line utility <code>i.e: django-admin startproject project_name</code> You may have already heard about <code>Jinja</code> if you are from the <code>Flask</code> background. Let me know through <code>RFA form or comments</code> if i should make some tutorial on <code>Jinja</code></blockquote><h3 id="so-where-are-template-engine-configured">So where are template engine configured?</h3>If you open up your <code>settings.py</code> file or if you followed me through <a target="_blank" href="/django-setup-architecture-and-hello-world">Django Setup, Architecture and Hello World</a> then you will find your <code>settings.py</code> file under <code>meme/settings.py</code> since we created <code>meme</code> django project you will see something like<pre><code>TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')] , 'APP_DIRS': True, 'OPTIONS': { # .... many options here ... }, },]</code></pre>You can see <code>BACKEND</code> key which points to dotted path for <code>DjangoTemplates</code> and other settings there like <code>DIRS</code> where the template engine will look for the html files<h3 id="lets-get-to-know-last-checklist-before-we-jump-in">Let's get to know last checklist before we jump in</h3><ul><li>To pass any value <code>(some dynamic contents like blog post, user info fetched from the DB e.t.c)</code> from view <code>(view function)</code> to the template <code>(html files)</code> we pass it as <code>context</code>. </li><li><code>Context</code> means a plain <code>dictionary</code> of key and value <code>(K:V)</code> i.e <code>{'name':'John'}</code></li><li>You can always provide as much template directory on your <code>settings.py</code> under <code>TEMPLATEs</code>--&gt;<code>DIRS</code></li><li>Since <code>APP_DIRS=True</code> in our above settings, the template finder will search inside our <code>INSTALLED_APPS</code>--&gt;<code>templates/</code> folder as well.</li><li>So this means, you can add your templates under the directory provided in <code>DIRS</code> or under <code>templates/</code> directory under your <code>app folder</code></li></ul><blockquote>So, where should i actually put my <code>HTML files</code>? The simple answer is if your <code>HTML file</code> is is for local app use only then put it inside <code>templates/</code> folder of your apps or else if the <code>HTML file</code> is used globally in all your apps then put it under the <code>DIRS</code> folder which is usually <code>templates/</code> folder inside your project directory</blockquote><h3 id="loading-and-rendering-a-template">Loading and rendering a template</h3>First let's create a simple template under our <code>DIRS</code> directory or under <code>templates/</code> inside our app.To make it more clear, lets create a new app named <code>smile</code> through help of dango command <code>python manage.py startapp smile</code> and register this app to the <code>settings.py</code> file and as soon as you register your app create <code>templates</code> folder inside your app and create a <code>HTML file</code> <code>smile.html</code><blockquote>We created a new app, so do you remember as soon as we create a new app we need to add this to the <code>INSTALLED_APPS</code> on our <code>settings.py</code> file</blockquote>Under your <code>smile/templates/smile.html</code> or if create any <code>HTML file</code> you like.<pre><code> &lt;html&gt; &lt;body&gt; &lt;h1&gt;Today's special joke&lt;/h1&gt; &lt;h1&gt; {{ joke }}&lt;/h1&gt; &lt;/body&gt; &lt;/html&gt;</code></pre>But, whats the <code>{{ joke }}</code> thing inside this <code>HTML file</code>. This is a way to insert dynamic content to the <code>HTML file</code>. This dynamic content or values are sent from <code>views</code> in the form of <code>context</code> we talked earlier<blockquote>If your template doesn't have any dynamic contents to be inserted then that's fine as well, many of your page can have a static HTML as well</blockquote>So, lets use and render this templates <code>create a view function</code><pre><code># views.pyfrom django.http import HttpResponsefrom django.template import loaderdef joke_view(request): # load the template that you just created template = loader.get_template(template_name='smile.html') # create context context = { 'joke': 'This is really funny joke !!' } result = template.render(context, request) return HttpResponse(result)</code></pre>Now, quickly create up a URL path for this view functions like we did on our previous tutorial and you should see something like this when you visit your URL<img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1624114690872/2uovuaCXn.png" alt="django-template-and-context-initial-preview.png" /><h3 id="but-wait-there-are-shortcuts-for-easy-rendering-of-templates">But wait, there are shortcuts for easy rendering of templates</h3>The <code>view function joke_view()</code> we just created can also be written as <pre><code>from django.shortcuts import renderdef joke_view(request): # create context context = { 'joke': 'This is really funny joke !!' } return render(request, template_name="smile.html", context=context)</code></pre><h3 id="more-on-context-rendering-and-working-with-templates">More on Context rendering and working with Templates</h3><h4 id="variables">Variables</h4><ul><li>Outputs/prints the value from the context</li><li>Variables are surrounded by <code>{{ }}</code> <code>(just like we did it just above)</code></li></ul><h5 id="examples">Examples</h5>Lets assume HTML template to be <code>Hi, i am from {{ location }} and i love {{ lang }}.</code>So,<ul><li><code>context={'location':'Earth','lang':'Python'}</code> on this HTML template would render to <code>Hi, i am from Earth and i love Python.</code></li><li><code>context={'location':'Mars','lang':'Javascript'}</code> on this HTML template would render to <code>Hi, i am from Mars and i love Javascript.</code></li></ul><h4 id="tags">Tags</h4><ul><li>A tag can be used to output content</li><li>It can be used to perform control structure <code>i.e: if/else, loops</code></li><li>It can do many things to make your template dynamic</li><li>Tags are surrounded by <code>{% %}</code></li><li>Some tags require ending tags where as some doesn't need it<ul><li><code>{% csrf_token %}</code> has no ending tag</li><li><code>{% if user.is_authenticated %}Hello, {{ user.username }}.{% endif %}</code> has ending tag</li></ul></li></ul><h5 id="examples">Examples</h5><ul><li><code>for</code> loops over each item in an array<pre><code>{% for language in language_list %} &lt;li&gt;{{ language }}&lt;/li&gt;{% endfor %}</code></pre> where <code>language_list</code> is a iterable sent from view function as a context</li><li><code>if</code><pre><code class="lang-html">{% if language_list %} Number of language: {{ language_list|length }}{% else %} &lt;h1&gt;No Languages found.&lt;/h1&gt;{% endif %}</code></pre> it even supports <code>elif</code> don't forget to try it</li><li><code>now</code> displays current date and/or time<pre><code> It is {% now "jS F Y H:i" %}</code></pre></li></ul><h4 id="filters">Filters</h4><ul><li>Filter transform the values of variables and tag arguments</li></ul><h5 id="examples">Examples</h5><ul><li><code>add</code> adds the arguments to the value<pre><code>{{ number|add:"10" }}</code></pre> would output 100 if the value of number is 90. The value of number is sent as context from the view function as <code>context={'number':90}</code></li><li><code>capfirst</code> capitalizes the first character of the value<pre><code> {{ name|capfirst }}</code></pre></li><li><code>default</code> provides a default value if existing value evaluates to False<pre><code> {{ country|default:"Not Selected" }}</code></pre> If country is empty <code>"" (empty string)</code> then output will be Not Selected</li></ul><h4 id="comments">Comments</h4><ul><li>Comments are placed in <code>{# #}</code> which are not rendered on templates during rendering process</li></ul><h5 id="examples">Examples</h5><pre><code class="lang-html">{# this is a comment and will not be rendered #}</code></pre><h3 id="last-note">Last Note</h3>We looked into <code>tags</code> and <code>filters</code> and saw some examples. I tried to make it easy as possible and lastly want to let you know there are so many builtin tags and filters inside django. Please have a look into official django docs <a target="_blank" href="https://docs.djangoproject.com/en/3.2/ref/templates/builtins/">https://docs.djangoproject.com/en/3.2/ref/templates/builtins/</a> to see the complete list.<blockquote>You can always create your own template tags and filter, trust me they make working with templates very easy</blockquote>]]>

Django Setup, Architecture and Hello World which looks like
from django.http import HttpResponsedef hi_view(request): response = """ <html> <body> <h1>Hello world</h1> </body> </html> """ return HttpResponse(response)
Here we trying to send whole bunch of HTML code from the views itself. This might look easy and so clean to see in this example but trust me as your project grows up and when you will have 100's and 1000's of HTML code this method will be pain and unmanageable. 
So how do we write templates in a manageable way and make it dynamic as well? The answer is through the help of Template System provided by the framework.
Django Template

A template can have some static HTML parts and some dynamic content to be inserted in between the HTML
A very efficient and convenient way of generating HTML dynamically
Django has built-in backend for its own template system which is called Django Template Language (DTL) and also for the popular alternative Jinja2

For the sake of simplicity we will be using Django Template Language (DTL) which is preconfigured on settings.py when creating our project using django-admin command line utility i.e: django-admin startproject project_name 
You may have already heard about Jinja if you are from the Flask background. Let me know through RFA form or comments if i should make some tutorial on Jinja

So where are template engine configured?
If you open up your settings.py file or if you followed me through Django Setup, Architecture and Hello World then you will find your settings.py file under meme/settings.py since we created meme django project you will see something like
TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')] , 'APP_DIRS': True, 'OPTIONS': { # .... many options here ... }, },]
You can see BACKEND key which points to dotted path for DjangoTemplates and other settings there like DIRS where the template engine will look for the html files
Let's get to know last checklist before we jump in

To pass any value (some dynamic contents like blog post, user info fetched from the DB e.t.c) from view (view function) to the template (html files) we pass it as context. 
Context means a plain dictionary of key and value (K:V) i.e {'name':'John'}
You can always provide as much template directory on your settings.py under TEMPLATEs-->DIRS
Since APP_DIRS=True in our above settings, the template finder will search inside our INSTALLED_APPS-->templates/ folder as well.
So this means, you can add your templates under the directory provided in DIRS or under templates/ directory under your app folder

So, where should i actually put my HTML files? The simple answer is if your HTML file is is for local app use only then put it inside templates/ folder of your apps or else if the HTML file is used globally in all your apps then put it under the DIRS folder which is usually templates/ folder inside your project directory

Loading and rendering a template
First let's create a simple template under our DIRS directory or under templates/ inside our app.
To make it more clear, lets create a new app named smile through help of dango command python manage.py startapp smile and register this app to the settings.py file and as soon as you register your app create templates folder inside your app and create a HTML file smile.html

We created a new app, so do you remember as soon as we create a new app we need to add this to the INSTALLED_APPS on our settings.py file

Under your smile/templates/smile.html or if create any HTML file you like.
 <html> <body> <h1>Today's special joke</h1> <h1> {{ joke }}</h1> </body> </html>
But, whats the {{ joke }} thing inside this HTML file. This is a way to insert dynamic content to the HTML file. This dynamic content or values are sent from views in the form of context we talked earlier

If your template doesn't have any dynamic contents to be inserted then that's fine as well, many of your page can have a static HTML as well

So, lets use and render this templates create a view function
# views.pyfrom django.http import HttpResponsefrom django.template import loaderdef joke_view(request): # load the template that you just created template = loader.get_template(template_name='smile.html') # create context context = { 'joke': 'This is really funny joke !!' } result = template.render(context, request) return HttpResponse(result)
Now, quickly create up a URL path for this view functions like we did on our previous tutorial and you should see something like this when you visit your URL

But wait, there are shortcuts for easy rendering of templates
The view function joke_view() we just created can also be written as 
from django.shortcuts import renderdef joke_view(request): # create context context = { 'joke': 'This is really funny joke !!' } return render(request, template_name="smile.html", context=context)
More on Context rendering and working with Templates
Variables

Outputs/prints the value from the context
Variables are surrounded by {{ }} (just like we did it just above)

Examples
Lets assume HTML template to be Hi, i am from {{ location }} and i love {{ lang }}.So,

context={'location':'Earth','lang':'Python'} on this HTML template would render to Hi, i am from Earth and i love Python.
context={'location':'Mars','lang':'Javascript'} on this HTML template would render to Hi, i am from Mars and i love Javascript.

Tags

A tag can be used to output content
It can be used to perform control structure i.e: if/else, loops
It can do many things to make your template dynamic
Tags are surrounded by {% %}
Some tags require ending tags where as some doesn't need it
{% csrf_token %} has no ending tag
{% if user.is_authenticated %}Hello, {{ user.username }}.{% endif %} has ending tag


Examples

for loops over each item in an array
{% for language in language_list %} <li>{{ language }}</li>{% endfor %}
 where language_list is a iterable sent from view function as a context

if
{% if language_list %} Number of language: {{ language_list|length }}{% else %} <h1>No Languages found.</h1>{% endif %}
 it even supports elif don't forget to try it

now displays current date and/or time
 It is {% now "jS F Y H:i" %}

Filters

Filter transform the values of variables and tag arguments

Examples

add adds the arguments to the value
{{ number|add:"10" }}
 would output 100 if the value of number is 90. The value of number is sent as context from the view function as context={'number':90}
capfirst capitalizes the first character of the value
 {{ name|capfirst }}

default provides a default value if existing value evaluates to False
 {{ country|default:"Not Selected" }}
 If country is empty "" (empty string) then output will be Not Selected

Comments

Comments are placed in {# #} which are not rendered on templates during rendering process

Examples
{# this is a comment and will not be rendered #}
Last Note
We looked into tags and filters and saw some examples. I tried to make it easy as possible and lastly want to let you know there are so many builtin tags and filters inside django. Please have a look into official django docs https://docs.djangoproject.com/en/3.2/ref/templates/builtins/ to see the complete list.

You can always create your own template tags and filter, trust me they make working with templates very easy
]]>

Django Templates, Context, Template Tags and filters

When a page is requested, Django under the hood created a HttpRequest object, this HttpRequest object contains meta information about the request.
This is the same request object we talked when we created our view function def profile_view(request):....

<![CDATA[When a page is requested, Django under the hood created a <code>HttpRequest object</code>, this HttpRequest object contains meta information about the request.This is the same request object we talked when we created our view function <code>def profile_view(request):...</code> (check type of request to confirm i.e <code>print(type(request)) # must be HttpRequest class</code>).When a view function receives a HttpRequest object as its first argument, this view function must return and <code>HttpResponse object</code>.A sample view,<pre><code class="lang-py">def profile_view(request): # first parameter HttpRequest Object return HttpResponse("Hello World") # view returned HttpResponse Object</code></pre><h3 id="heading-the-httprequest-object">The HttpRequest object</h3>Many of us might just ignore this Request object thinking its of no use, but trust me there are lots of meta information about our request, which we may need in our program/view function to properly execute our logic.Some of the attributes and methods of HttpRequest objects are:<ol><li>HttpRequest.path (<code>request.path</code> in our view function, which give us path i.e: /profile/)</li><li>HttpRequest.path (<code>request.method</code> in our view function, which gives us Uppercase request method i.e: GET, POST, HEAD)</li><li>HttpRequest.GET (<code>request.GET</code> in our view function, which gives us all HTTP GET parameters in dict like object)</li><li>HttpRequest.POST (<code>request.POST</code> in our view function, which gives us all HTTP POST parameters in dict like object)</li><li>HttpRequest.FILES (<code>request. [Text](Link) FILES</code> in our view function, which gives us all uploaded files from HTML form in a dict like object)</li><li>HttpRequest.headers (<code>request.headers</code> in our view function, which gives us all HTTP headers in a dict like object)</li><li>HttpRequest.user (<code>request.user</code> in our view function, which gives us currently authenticated user. This attribute is set from middleware. We will look into this in later section of our series)</li></ol>It consist of some useful methods as well i.e: <code>HttpRequest.get_host()</code> <code>HttpRequest.get_port()</code> <code>HttpRequest.is_secure() #https or not</code> which you can try and experiment yourself.<h3 id="heading-the-httpresponse-object">The HttpResponse object</h3>We learnt about HttpRequest object, which was automatically created by the Django itself and get passed to the view function. But on the other hand, its our duty as a programmer to return and <code>HttpResponse object</code> from view function like we did in previous example.<pre><code class="lang-py">from django.http import HttpResponseresponse = HttpResponse("Hello World")</code></pre>we can also add our content incrementally<pre><code class="lang-py">response = HttpResponse()response.write("hello ")response.write("world")</code></pre><h3 id="heading-jsonresponse-object">JsonResponse object</h3>It is also possible to have a JSON encoded response. <pre><code class="lang-py">from django.http import JsonResponseresponse = JsonResponse({"message":"Hi from djangotherightway.com"})</code></pre><blockquote>But, remember everything under the hood is a <code>HttpResponse()</code> </blockquote>complete example,<pre><code class="lang-py">from django.http import JsonResponsedef message_view(request): return JsonResponse({"message":"Hi from djangotherightway.com"})</code></pre><blockquote>if you want to serialize and response non-dict objects then make sure you include safe=False in JsonResponse <code>JsonResponse([1,2,3],safe=False)</code></blockquote><h3 id="heading-returning-404-errors-from-httpresponse">Returning 404 errors from HttpResponse</h3>Every Http response must have a status code. 404 is one of the status code frequently used to denote that the requested page was not found<pre><code class="lang-py">from django.http import HttpResponse, HttpResponseNotFounddef home_view(request): if some_condition: return HttpResponseNotFound("Page not found") else: return HttpResponse("Page found")</code></pre><h4 id="heading-lets-take-some-examples">Let's take some examples</h4><ul><li>Finding our request method in our view function</li></ul><pre><code class="lang-py">def home_view(request): if request.method == 'GET': # do something for GET elif request.method == 'POST': # do something for POST here else: # fallback? or and error response?</code></pre><ul><li>Returning custom HTTP status code</li></ul><pre><code class="lang-py">from django.http import HttpResponsedef home_view(request): if some_condition: return HttpResponse(status=403) # 403 means permission denied else: return HttpResponse(status=200) # 200 means OK</code></pre><h3 id="heading-but-what-are-http-status-code">But, what are Http status code?</h3><ul><li>Status code are some numbers issued by server in <code>response</code> to a client <code>request</code></li><li>Status code are divided up into five groups as follows where first digit refers to the category of the response<ul><li>1XX (informational response)</li><li>2XX (Successful)</li><li>3XX (Redirection)</li><li>4XX (Client error)</li><li>5XX (Server error)</li></ul></li><li>Examples;<ul><li>If server responds with status code <code>404</code> means it lies to <code>Client error</code> group and <code>404</code> means <code>Page Not Found</code></li><li>If server responds with status code <code>500</code> means it lies to <code>Server error</code> group and <code>500</code> means <code>Internal Server Error</code></li></ul></li></ul><blockquote>Now being a backend engineer there lies a confusion, on how to select a status code. Actually this totally depends on the situation you are in and the requirements you are in(<code>has nothing to do with web framework or stacks you are working on</code>) but we always should follow a standard widely accepted by the community. Let's try to understand it more with an example;<ul><li>Status code 3XX means <code>Redirection</code> category, to be more specific let's assume <code>308</code> status code which means <code>Permanent Redirection</code>. So to inform a client of a redirection you simply respond with a <code>308</code> status code and a <code>Location</code> to where the client should redirect. This way client simply performs a redirection because client knows the use case of <code>308</code> status code. But what is a client? Is't this a client side software created by engineers? So, it's a client side engineer duty to implement those, but what if we make changes on status code(<code>maybe 200 instead of 308</code>) to perform this same operation? This is also possible</li><li>To perform the same redirection work, now server will send <code>200</code> status code with some data <code>{'redirect_to':'https://djangotherightway.com'}</code>. This way on the client side we simply implement a logic where we check for <code>redirect_url</code> on <code>200 status</code> and implement redirection. On a JS client side you will redirect a user to other location using a simple code <code>window.location.replace("https://djangotherightway.com");</code></li></ul></blockquote>So, does this mean we can use any status code for performing operations? The simple answer would be No, this is a suggestion only and my suggestion is <code>Let's follow standards to make our community much more stronger</code>, but what about the example i just explain above? Well, some case might arise up when you need to customize according to your need and may need to skip the standard but try to be on the standard as much as possible<code>Standard Matters</code> because since <code>3XX</code> means a <code>redirection</code> have you ever noticed your browser will automatically redirect you to another location incase your browser gets <code>3XX</code>. Browser does this for making user experience good and doesn't mean browser will react on every status code they see from the server.Do you want to see this browser behaviour in action? type <code>https://djangotherightway.com/learn</code> in the browser and you will be redirected to <code>https://djangotherightway.com/series/learn</code> all with the help of a simple status code <code>301</code> which means <code>Moved Permanently</code>]]>

HttpRequest object, this HttpRequest object contains meta information about the request.This is the same request object we talked when we created our view function def profile_view(request):... (check type of request to confirm i.e print(type(request)) # must be HttpRequest class).When a view function receives a HttpRequest object as its first argument, this view function must return and HttpResponse object.
A sample view,
def profile_view(request):             # first parameter HttpRequest Object    return HttpResponse("Hello World") # view returned HttpResponse Object
The HttpRequest object
Many of us might just ignore this Request object thinking its of no use, but trust me there are lots of meta information about our request, which we may need in our program/view function to properly execute our logic.
Some of the attributes and methods of HttpRequest objects are:

HttpRequest.path (request.path in our view function, which give us path i.e: /profile/)
HttpRequest.path (request.method in our view function, which gives us Uppercase request method i.e: GET, POST, HEAD)
HttpRequest.GET  (request.GET in our view function, which gives us all HTTP GET parameters in dict like object)
HttpRequest.POST  (request.POST in our view function, which gives us all HTTP POST parameters in dict like object)
HttpRequest.FILES (request. [Text](Link) FILES in our view function, which gives us all uploaded files from HTML form in a dict like object)
HttpRequest.headers (request.headers in our view function, which gives us all HTTP headers in a dict like object)
HttpRequest.user (request.user in our view function, which gives us currently authenticated user. This attribute is set from middleware. We will look into this in later section of our series)

It consist of some useful methods as well i.e: HttpRequest.get_host() HttpRequest.get_port() HttpRequest.is_secure() #https or not which you can try and experiment yourself.
The HttpResponse object
We learnt about HttpRequest object, which was automatically created by the Django itself and get passed to the view function. But on the other hand, its our duty as a programmer to return and HttpResponse object from view function like we did in previous example.
from django.http import HttpResponseresponse = HttpResponse("Hello World")
we can also add our content incrementally
response = HttpResponse()response.write("hello ")response.write("world")
JsonResponse object
It is also possible to have a JSON encoded response. 
from django.http import JsonResponseresponse = JsonResponse({"message":"Hi from djangotherightway.com"})

But, remember everything under the hood is a HttpResponse() 

complete example,
from django.http import JsonResponsedef message_view(request):  return JsonResponse({"message":"Hi from djangotherightway.com"})

if you want to serialize and response non-dict objects then make sure you include safe=False in JsonResponse JsonResponse([1,2,3],safe=False)

Returning 404 errors from HttpResponse
Every Http response must have a status code. 404 is one of the status code frequently used to denote that the requested page was not found
from django.http import HttpResponse, HttpResponseNotFounddef home_view(request):    if some_condition:        return HttpResponseNotFound("Page not found")    else:        return HttpResponse("Page found")
Let's take some examples

Finding our request method in our view function

def home_view(request):    if request.method == 'GET':        # do something for GET    elif request.method == 'POST':        # do something for POST here    else:        # fallback? or and error response?

Returning custom HTTP status code

from django.http import HttpResponsedef home_view(request):    if some_condition:        return HttpResponse(status=403) # 403 means permission denied     else:        return HttpResponse(status=200) # 200 means OK
But, what are Http status code?

Status code are some numbers issued by server in response to a client request
Status code are divided up into five groups as follows where first digit refers to the category of the response
1XX (informational response)
2XX (Successful)
3XX (Redirection)
4XX (Client error)
5XX (Server error)

Examples;
If server responds with status code 404 means it lies to Client error group and 404 means Page Not Found
If server responds with status code 500 means it lies to Server error group and 500 means Internal Server Error


Now being a backend engineer there lies a confusion, on how to select a status code. Actually this totally depends on the situation you are in and the requirements you are in(has nothing to do with web framework or stacks you are working on) but we always should follow a standard widely accepted by the community. Let's try to understand it more with an example;

Status code 3XX means Redirection category, to be more specific let's assume 308 status code which means Permanent Redirection. So to inform a client of a redirection you simply respond with a 308 status code and a Location to where the client should redirect. This way client simply performs a redirection because client knows the use case of 308 status code. But what is a client? Is't this a client side software created by engineers? So, it's a client side engineer duty to implement those, but what if we make changes on status code(maybe 200 instead of 308) to perform this same operation? This is also possible
To perform the same redirection work,  now server will send 200 status code with some data {'redirect_to':'https://djangotherightway.com'}. This way on the client side we simply implement a logic where we check for redirect_url on 200 status and implement redirection. On a JS client side you will redirect a user to other location using a simple code window.location.replace("https://djangotherightway.com");

So, does this mean we can use any status code for performing operations? The simple answer would be No, this is a suggestion only and my suggestion is Let's follow standards to make our community much more stronger, but what about the example i just explain above? Well, some case might arise up when you need to customize according to your need and may need to skip the standard but try to be on the standard as much as possible
Standard Matters because since 3XX means a redirection have you ever noticed your browser will automatically redirect you to another location incase your browser gets 3XX. Browser does this for making user experience good and doesn't mean browser will react on every status code they see from the server.
Do you want to see this browser behaviour in action? type https://djangotherightway.com/learn in the browser and you will be redirected to https://djangotherightway.com/series/learn all with the help of a simple status code 301 which means Moved Permanently
]]>

Request and Response in Django

A clean URL is really important for a good quality web application. You can design your own URL style i.e url can contain / or - anything there is no any restriction but these are the things i follow (some examples),

/profile/<username>/ instead of ...

<![CDATA[A clean URL is really important for a good quality web application. You can design your own URL style <code>i.e url can contain / or - anything</code> there is no any restriction but these are the things i follow (some examples),<ol><li><code>/profile/&lt;username&gt;/</code> instead of <code>/profile/&lt;db_primary_key_id&gt;/</code> to view user profile</li><li><code>/hello-world/</code> instead of <code>/helloworld/</code></li><li><code>/accounts/change-password/</code> instead of <code>/profile/&lt;username&gt;/account/settings/change-password/</code> for accounts password change</li><li><code>/blogs/?page=1</code> instead of <code>/blogs/page-1/</code> for paginations.</li></ol><blockquote>You can follow any pattern, but make it readable and consistent in your project</blockquote><h3 id="heading-creating-a-url-on-django">Creating a URL on Django</h3>To create a URL on Django you simple create a path and point that path to a view function like we did in previous turorials.Here are some examples,<pre><code class="lang-py">from django.urls import pathfrom profile.views import profile_viewfrom accounts.views import change_password_viewurlpatterns = [ path('/profile/', profile_view), path('/accounts/change-password/',change_password_view)]</code></pre>As you can see we use <code>path()</code> function to create our URLs. The path function take arguments where we define the path of url and the view function that it points.<h3 id="heading-capturing-values-from-url">Capturing Values from URL</h3>Let's assume a URL path <code>/profile/&lt;username&gt;/</code> here <code>&lt;username&gt;</code> part is dynamic and we need to capture this value on our URL and pass it to the view function.For this purpose we use <code>Path Converters</code>. Django already provides us some path converters in default, they are: <code>str</code> <code>int</code> <code>slug</code> <code>uuid</code> <code>path</code>. A/c to the type we need, we can select a path converter and add it to the URL like below,<pre><code class="lang-py"># urls.pyfrom django.urls import pathfrom profile.views import user_profile_detail_viewurlpatterns = [ path('/profile/&lt;str:username&gt;/', user_profile_detail_view) # we used &lt;str&gt; path converter and assigned the value to username]</code></pre>since we need to grab the captured <code>username</code> on our view function as well, we can write our view function as, <pre><code class="lang-py"># profile/views.pydef user_profile_detail_view(request, username): # we added username argument on our view function # print(type(username)) # do this for every path converters to see tha magic. i.e: using &lt;int&gt; converter would give you &lt;int&gt; type # get this username info from DB # prepare output # send output as HttpResponse ....</code></pre><blockquote>We can always create our own custom path converters if the default converters do not satisfy our need. </blockquote><h3 id="heading-using-regular-expressions-in-urls">Using regular expressions in URLs</h3>Sometime we may need to use regular expression in our URL since everytime the simple <code>path()</code> wont satisfy our need.To create regular expression on url path use <code>re_path()</code> instead of <code>path()</code><pre><code class="lang-py">from django.urls import path, re_pathfrom blog.views import all_blogs_for_year_viewurlpatterns = [ re_path(r'^blogs/(?P&lt;year&gt;[0-9]{4})/$', all_blogs_for_year_view),]</code></pre><h3 id="heading-how-does-urlconf-work">How does URLconf work</h3>Django consist of <code>ROOT_URLCONF</code> settings on your projects <code>settings.py</code> file. This is the one and only URL config file your django will look for. All urls in our project must be inside the defined <code>ROOT_URLCONF</code> file. You might come up with a question, There can be as many django apps in the project and they cna have their own urls, but if django can only look into the <code>ROOT_URLCONF</code> file, then how does our logic fit up. The answer is, you can have <code>n</code> numbers of URL files in your project, but through some way you need to integrate those urls on your <code>ROOT_URLCONF</code> file.<blockquote>If incoming Request Object has <code>urlconf</code> attribute set (this can be from middlewares), then django will use this instead of <code>ROOT_URLCONF</code>, but dont worry about it for now.</blockquote>Remember these things, <ol><li>in request <code>http://127.0.0.1:8000/profile/</code>, Django will look only <code>/profile/</code> in your URL configurations file</li><li>In request <code>http://127.0.0.1:8000/profile/?id=123</code>, Django will only <code>/profile/</code> in your URL configrations file</li><li>It doesn't look at the request method as well, All request methods. like <code>HEAD</code> <code>POST</code> <code>GET</code> will land to the same view function. You can from some way find the request method on your view function and perform the logic accordingly. i.e: <code>post method</code> on <code>/profile/</code> will update your profile but <code>get</code> on <code>/profile/</code> will display your profile information. We will look into this in later tutorials</li></ol><h3 id="heading-including-other-urlconfs">Including other URLconfs</h3>As our project grows up, we split our <code>url</code> files or group them for readability. <pre><code class="lang-py">from django.urls import include, pathfrom profile.views import self_profile_viewextra_extra_url_patterns = [ path("/me/",self_profile_view)]urlpatterns = [ # this is our main urlpattern list path("/profile/",include(extra_extra_url_patterns)) # include the patterns # this will create url ==&gt; /profile/ + /me/ from extra_extra_url_patterns = /profile/me/ is the final URL created # and you can also include, other urls.py file from your app path("world/",include('world.urls')) # you do not need to import world.urls as you can simply write the dotted path of your url file # so, this means, inside your world app, there will be urls.py file : world/urls.py]</code></pre>]]>

i.e url can contain / or - anything there is no any restriction but these are the things i follow (some examples),

/profile/<username>/ instead of /profile/<db_primary_key_id>/ to view user profile
/hello-world/ instead of /helloworld/
/accounts/change-password/ instead of /profile/<username>/account/settings/change-password/ for accounts password change
/blogs/?page=1 instead of /blogs/page-1/ for paginations.

You can follow any pattern, but make it readable and consistent in your project

Creating a URL on Django
To create a URL on Django you simple create a path and point that path to a view function like we did in previous turorials.Here are some examples,
from django.urls import pathfrom profile.views import profile_viewfrom accounts.views import change_password_viewurlpatterns = [ path('/profile/', profile_view), path('/accounts/change-password/',change_password_view)]
As you can see we use path() function to create our URLs. The path function take arguments where we define the path of url and the view function that it points.
Capturing Values from URL
Let's assume a URL path /profile/<username>/ here <username> part is dynamic and we need to capture this value on our URL and pass it to the view function.For this purpose we use Path Converters. Django already provides us some path converters in default, they are: str int slug uuid path. A/c to the type we need, we can select a path converter and add it to the URL like below,
# urls.pyfrom django.urls import pathfrom profile.views import user_profile_detail_viewurlpatterns = [ path('/profile/<str:username>/', user_profile_detail_view) # we used <str> path converter and assigned the value to username]
since we need to grab the captured username on our view function as well, we can write our view function as, 
# profile/views.pydef user_profile_detail_view(request, username): # we added username argument on our view function # print(type(username)) # do this for every path converters to see tha magic. i.e: using <int> converter would give you <int> type # get this username info from DB # prepare output # send output as HttpResponse ....

We can always create our own custom path converters if the default converters do not satisfy our need. 

Using regular expressions in URLs
Sometime we may need to use regular expression in our URL since everytime the simple path() wont satisfy our need.To create regular expression on url path use re_path() instead of path()
from django.urls import path, re_pathfrom blog.views import all_blogs_for_year_viewurlpatterns = [ re_path(r'^blogs/(?P<year>[0-9]{4})/$', all_blogs_for_year_view),]
How does URLconf work
Django consist of ROOT_URLCONF settings on your projects settings.py file. This is the one and only URL config file your django will look for. All urls in our project must be inside the defined ROOT_URLCONF file. You might come up with a question, There can be as many django apps in the project and they cna have their own urls, but if django can only look into the ROOT_URLCONF file, then how does our logic fit up. The answer is, you can have n numbers of URL files in your project, but through some way you need to integrate those urls on your ROOT_URLCONF file.

If incoming Request Object has urlconf attribute set (this can be from middlewares), then django will use this instead of ROOT_URLCONF, but dont worry about it for now.

Remember these things, 

in request http://127.0.0.1:8000/profile/, Django will look only /profile/ in your URL configurations file
In request http://127.0.0.1:8000/profile/?id=123, Django will only /profile/ in your URL configrations file
It doesn't look at the request method as well, All request methods. like HEAD POST GET will land to the same view function. You can from some way find the request method on your view function and perform the logic accordingly. i.e: post method on /profile/ will update your profile but get on /profile/ will display your profile information. We will look into this in later tutorials

Including other URLconfs
As our project grows up, we split our url files or group them for readability. 
from django.urls import include, pathfrom profile.views import self_profile_viewextra_extra_url_patterns = [ path("/me/",self_profile_view)]urlpatterns = [ # this is our main urlpattern list path("/profile/",include(extra_extra_url_patterns)) # include the patterns # this will create url ==> /profile/ + /me/ from extra_extra_url_patterns = /profile/me/ is the final URL created # and you can also include, other urls.py file from your app path("world/",include('world.urls')) # you do not need to import world.urls as you can simply write the dotted path of your url file # so, this means, inside your world app, there will be urls.py file : world/urls.py]
]]>

A clean URL is really important for a good quality web application. You can design your own URL style i.e url can contain / or - anything there is no any restriction but these are the things i follow (some examples),

/profile// instead of ...

URL designing and  URL kwargs in Django

Installing python
First of all, Python is required.
Python is high level, interpreted general purpose programming language.
Install Python on your system from Official Python Download 

We will not cover in depth about python in this series, but let ...

<![CDATA[<h5 id="installing-python">Installing python</h5>First of all, Python is required.Python is high level, interpreted general purpose programming language.Install Python on your system from <a target="_blank" href="https://www.python.org/downloads/">Official Python Download</a> <blockquote>We will not cover in depth about python in this series, but let me know if i should (Will try to cover some basics in future updates)</blockquote><h5 id="database-setup">Database Setup</h5>As as web programmer, we will need some sort of database for persistant storage. Some might call, we could just use some sorts of caching for a small specific purpose web application but we will require a database sooner or later in the project. The good news is, we can skip this for now because Python already includes implementation of a lightweight database called SQLite.You can know more about this File based database from <a target="_blank" href="https://www.sqlite.org/index.html">https://www.sqlite.org/index.html</a>. To learn about the Python API for SQLite DB go to <a target="_blank" href="https://docs.python.org/3/library/sqlite3.html">https://docs.python.org/3/library/sqlite3.html</a>. This includes tutorials to create a SQLite database and perform some database operations. <blockquote>Don't worry for now about Database installation(MYSQL,POSTGRES,ORACLE) for Django. We will learn about it in another chapter of this series.</blockquote><h5 id="installing-django">Installing Django</h5>The easiest way to install django is through pip. pip is package installer for Python. If you are using python&gt;=3.4 then pip is automatically installed. Learn more about pip from <a target="_blank" href="https://en.wikipedia.org/wiki/Pip_(package_manager">Wikipedia</a>).<ol><li>from your terminal <code>pip install django</code></li><li>Confirm installation from pip <code>pip list</code> [on the terminal]</li><li>Django installation will make django-admin command line utility available in your shell. <code>django-admin</code> [on the terminal] to check if its working</li></ol>If everything worked fine in this steps, then we can be sure Django has been successfully installed, but we can confirm this installation from import statements as well.On the Python shell [not on the terminal directly] <code>i.e: Shell that opens after you type python or python3 according to your installation on the system</code> do the following. If this runs without a problem, we can confirm that our Python interpreter can see the installed Django<pre><code>import djangodjango.get_version()</code></pre><h3 id="django">Django</h3><h5 id="creating-a-django-project">Creating a Django Project</h5>For the sake of this series, we will assume a Project containing some specific features. Lets assume a project called <code>Meme</code>. This project simply allows user to upload Meme on the web application.<code>django-admin startproject meme</code>This will create a Django Project pre-configured to run instantly, which will create the following folders and files.<pre><code>. manage.py meme __init__.py asgi.py settings.py urls.py wsgi.py1 directory, 6 files</code></pre>Django comes up with pre build/pre configured server for development purpose. You can run your development server using <code>python manage.py runserver</code>. This will run your django server on <code>8000</code> port on default. You can always configure this according to your need. When navigating to the django deployed address, which is usually <code>http://127.0.0.1:8000/</code> you will see the output <img src="https://cdn.hashnode.com/res/hashnode/image/upload/v1623423319133/czsUAZKnCr.png" alt="djangoDefaultPage.png" /><blockquote>Congrats !!! Your Django is Up and Running</blockquote><h5 id="django-apps">Django Apps</h5>Django app is a Python Package which contains some features which can be reused in another project as well. For an example. (Completely Imaginary example)<ol><li>Facebook is a project and (fb chat, fb groups, fb games) can be called application of this project. </li><li>Instagram is a project and (stories, IGTV) can be called application of this project.</li></ol>So, a Django app is a smaller unit of the Django project which consist of some specific feature set. Trust me, dividing features under smaller apps is lot more effective in terms of readability and reusability.<h5 id="creating-django-apps">Creating Django Apps</h5><code>python manage.py startapp [NAME_OF_APP]</code> so, in our case lets create a app named world in our existing project, just to demonstrate some <code>hello world</code><code>python manage.py startapp world</code> This would create some new files and folders in our project as follows, <pre><code>. manage.py meme __init__.py asgi.py settings.py urls.py wsgi.py world __init__.py admin.py apps.py migrations __init__.py models.py tests.py views.py3 directories, 13 files</code></pre>After this is done, we need a last thing to be done so that our app is recognized by the Django Project. So, head over to <code>meme/settings.py</code> and add your newly created django app to the list of installed appps<pre><code>INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'world' # ===&gt;&gt; Add your newly created app here]</code></pre>Don't worry about the apps already being registered in the <code>INSTALLED_APPS</code>. Those apps are the most useful apps django has provided to us. For an example: <code>django.contrib.auth</code> provides us <code>DB table</code>,<code>signup</code>,<code>signin</code> features for our Users under the hood. This is actually what peoples mean to say when they talk about <code>Rapid Application Development in Django</code>. We can always customize this app according to our need, but trust me a <code>MVC</code> or <code>POC</code> project including some <code>Production application</code> would never need to customize these apps. This works perfectly !!!<h5 id="creating-our-first-view">Creating our first view</h5>Let's assume a URL <code>/hi/</code> would return a response <code>Hello World</code>. i.e: when users navigates to <code>http://127.0.0.1:8000/hi/</code> would output <code>hello world</code>Open file, <code>world/views.py</code><pre><code>from django.http import HttpResponse# create a function based view# First parameter is a Django Request Object,# so for convention we write request.# We could have written just r or abcd instead of request in func parameterdef hi_view(request): response = HttpResponse() # create a Response Object response.content = "Hello world" return response # or this could be written as # return HttpResponse("hello world")</code></pre>So, we created our first view. We now need a URL to be assigned to this view. i.e <code>/hi/</code> would point to <code>def hi_view(request):....</code>Lets update our URLs from <code>meme/urls.py</code>. This is also our root url configuration. i.e: Django looks this file for URL configs<blockquote>You can view your root url config file registered in django from <code>ROOT_URLCONF</code> settings inside <code>meme/settings.py</code></blockquote><pre><code>from django.contrib import adminfrom django.urls import path# import our view function which is in world appfrom world.views import hi_viewurlpatterns = [ path('admin/', admin.site.urls), # create a URL path /hi/ path('hi/', hi_view)]</code></pre>But wait, you can see a URL path <code>/admin/</code> already being registered when we created our project. Dont worry about it for now. We will see about it in upcoming part in this series.So now, lets run our server and head over to <code>http://127.0.0.1:8000/hi/</code>. We can see the page displaying <code>hello world</code> which came from <code>hi_view function</code>Lets add some HTML into our output so that we can display <code>hello world</code> formatted inside proper HTML tag<pre><code>from django.http import HttpResponsedef hi_view(request): response = """ &lt;html&gt; &lt;body&gt; &lt;h1&gt;Hello world&lt;/h1&gt; &lt;/body&gt; &lt;/html&gt; """ return HttpResponse(response)</code></pre>We might get confused looking this code thinking we will write every HTML inside this function. But in later section of this series we will learn to manage HTML templates of our project. So dont get confused for now.<h5 id="managepy">manage.py</h5>We used manage.py to run our server, create new apps, but what exactly is this manage.py ?<code>manage.py</code> is a command line utility provided by Django to manage django project. We provide commands to the <code>manage.py</code> like <code>runserver</code>, <code>startapp</code>, <code>shell</code> and it runs the command script. The good news is we can create our own custom management commands as well.If you want to navigate and deep dive, Have a look inside, <code>runserver</code> code from <a target="_blank" href="https://github.com/django/django/blob/master/django/core/management/commands/runserver.py#L24">Django Github Runserver Command</a><blockquote>run <code>python manage.py</code> to see all available commands on your project</blockquote>]]>

First of all, Python is required.Python is high level, interpreted general purpose programming language.
Install Python on your system from Official Python Download 

We will not cover in depth about python in this series, but let me know if i should (Will try to cover some basics in future updates)

Database Setup
As as web programmer, we will need some sort of database for persistant storage. Some might call, we could just use some sorts of caching for a small specific purpose web application but we will require a database sooner or later in the project. 
The good news is, we can skip this for now because Python already includes implementation of a lightweight database called SQLite.
You can know more about this File based database from https://www.sqlite.org/index.html. 
To learn about the Python API for SQLite DB go to https://docs.python.org/3/library/sqlite3.html. This includes tutorials to create a SQLite database and perform some database operations. 

Don't worry for now about Database installation(MYSQL,POSTGRES,ORACLE) for Django. We will learn about it in another chapter of this series.

Installing Django
The easiest way to install django is through pip. pip is package installer for Python. If you are using python>=3.4 then pip is automatically installed. Learn more about pip from Wikipedia).

from your terminal pip install django
Confirm installation from pip pip list [on the terminal]
Django installation will make django-admin command line utility available in your shell. django-admin [on the terminal] to check if its working

If everything worked fine in this steps, then we can be sure Django has been successfully installed, but we can confirm this installation from import statements as well.
On the Python shell [not on the terminal directly] i.e: Shell that opens after you type python or python3 according to your installation on the system do the following. If this runs without a problem, we can confirm that our Python interpreter can see the installed Django
import djangodjango.get_version()
Django
Creating a Django Project
For the sake of this series, we will assume a Project containing some specific features. Lets assume a project called Meme. This project simply allows user to upload Meme on the web application.
django-admin startproject meme
This will create a Django Project pre-configured to run instantly, which will create the following folders and files.
. manage.py meme __init__.py asgi.py settings.py urls.py wsgi.py1 directory, 6 files
Django comes up with pre build/pre configured server for development purpose. You can run your development server using python manage.py runserver. This will run your django server on 8000 port on default. You can always configure this according to your need. When navigating to the django deployed address, which is usually http://127.0.0.1:8000/ you will see the output 


Congrats !!! Your Django is Up and Running

Django Apps
Django app is a Python Package which contains some features which can be reused in another project as well.
For an example. (Completely Imaginary example)

Facebook is a project and (fb chat, fb groups, fb games) can be called application of this project. 
Instagram is a project and (stories, IGTV) can be called application of this project.

So, a Django app is a smaller unit of the Django project which consist of some specific feature set. Trust me, dividing features under smaller apps is lot more effective in terms of readability and reusability.
Creating Django Apps
python manage.py startapp [NAME_OF_APP] 
so, in our case lets create a app named world in our existing project, just to demonstrate some hello world
python manage.py startapp world This would create some new files and folders in our project as follows, 
. manage.py meme __init__.py asgi.py settings.py urls.py wsgi.py world __init__.py admin.py apps.py migrations __init__.py models.py tests.py views.py3 directories, 13 files
After this is done, we need a last thing to be done so that our app is recognized by the Django Project. So, head over to meme/settings.py and add your newly created django app to the list of installed appps
INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', 'world' # ===>> Add your newly created app here]
Don't worry about the apps already being registered in the INSTALLED_APPS. Those apps are the most useful apps django has provided to us. For an example: django.contrib.auth provides us DB table,signup,signin features for our Users under the hood. This is actually what peoples mean to say when they talk about Rapid Application Development in Django. We can always customize this app according to our need, but trust me a MVC or POC project including some Production application would never need to customize these apps. This works perfectly !!!
Creating our first view
Let's assume a URL /hi/ would return a response Hello World. i.e: when users navigates to http://127.0.0.1:8000/hi/ would output hello world
Open file, world/views.py
from django.http import HttpResponse# create a function based view# First parameter is a Django Request Object,# so for convention we write request.# We could have written just r or abcd instead of request in func parameterdef hi_view(request): response = HttpResponse() # create a Response Object response.content = "Hello world" return response # or this could be written as # return HttpResponse("hello world")
So, we created our first view. We now need a URL to be assigned to this view. i.e /hi/ would point to def hi_view(request):....
Lets update our URLs from meme/urls.py. This is also our root url configuration. i.e: Django looks this file for URL configs

You can view your root url config file registered in django from ROOT_URLCONF settings inside meme/settings.py

from django.contrib import adminfrom django.urls import path# import our view function which is in world appfrom world.views import hi_viewurlpatterns = [ path('admin/', admin.site.urls), # create a URL path /hi/ path('hi/', hi_view)]
But wait, you can see a URL path /admin/ already being registered when we created our project. Dont worry about it for now. We will see about it in upcoming part in this series.
So now, lets run our server and head over to http://127.0.0.1:8000/hi/. We can see the page displaying hello world which came from hi_view function
Lets add some HTML into our output so that we can display hello world formatted inside proper HTML tag
from django.http import HttpResponsedef hi_view(request): response = """ <html> <body> <h1>Hello world</h1> </body> </html> """ return HttpResponse(response)
We might get confused looking this code thinking we will write every HTML inside this function. But in later section of this series we will learn to manage HTML templates of our project. So dont get confused for now.
manage.py
We used manage.py to run our server, create new apps, but what exactly is this manage.py ?
manage.py is a command line utility provided by Django to manage django project. We provide commands to the manage.py like runserver, startapp, shell and it runs the command script. The good news is we can create our own custom management commands as well.
If you want to navigate and deep dive, Have a look inside, runserver code from Django Github Runserver Command

run python manage.py to see all available commands on your project
]]>

Django Setup, Architecture and  Hello World

&quot;En-Rich&quot; your Python testing

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

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.

Hello, Python

Python Jobs 💼