Category: Programming

As we all know, Django is a Python framework used for building complex web applications. Yet, it can also be used for building simple ones. In this tutorial, I’m going to show you how I built an English dictionary app, a simple Django project for beginners.

It takes time for a beginner to fully understand how Django works. But the key is consistency. If you keep building projects, you will gradually know enough to be dangerous with Django.

Scroll to the end to see the full code on GitHub!

A Dictionary App?

A dictionary is an application used to get a particular word’s meaning. No matter how proficient we are in English, some words are far beyond our understanding. There are also words we may not know how to pronounce efficiently, especially those originating from a different language.

Furthermore, we may want to know a synonym or antonym of a given word. This is where a dictionary comes in handy. With a dictionary, we get to know not only the meaning of a word but how it is pronounced, what parts of speech it belongs to, and how it is used in a sentence. Students, no doubt, appreciate the importance of having a dictionary.

How Will We Get The Data?

How will we build this dictionary app so that when users search for a particular word, they get the meaning?

We have two options. Either we use PyDictionary, a Python module and an API that scrapes an online dictionary website or we perform the web scraping ourselves. None of these methods comes without a drawback.

Recommended: Is Web Scraping Legal?

The drawback is the challenge that comes with web scraping. Many websites sometimes change their HTML structures to prevent people or bots from accessing their content. So, if an API is not actively maintained, it can quickly become useless. This is the case with PyDictionary. Therefore, we are going to perform web scraping.

Doing so will undoubtedly gain some valuable experience in web scraping, a very broad concept in Python programming. Still, we are at the mercy of website owners. They can change the HTML structures of their websites unexpectedly.

Prerequisites

This tutorial assumes you are familiar with Python, HTML, and Bootstrap. If not, please you are required to have at least a basic knowledge before attempting this project. Basic knowledge of Django, though not required, can speed up the learning process.

Getting started

Create a new folder for this project. Then you do the following:

1. Create a virtual environment
   python3 -m venv .venv
2. Activate the virtual environment
   source .venv/bin/activate
3. Install the required libraries in the virtual environment
   pip install django tzdata requests bs4
4. Create a requirements.txt file to keep a record of the module versions.
   pip freeze > requirements.txt

Creating Django Project and Application

i. Creating the project
django-admin startproject project .
This creates a folder called project in the current directory.

ii. Creating the application
python3 manage.py startapp dictionary
The manage.py file is an executable file used to run Django commands

iii. Applying migrations
python3 manage.py migrate

iv. Checking to see if the installation was successful
python3 mange.py runserver

Once you see the above image, you are good to go.

Registering the App

1. In settings.py file
   This step is important whenever an app is created. Navigate to the project folder. Open the settings.py file and scroll down to the INSTALLED_APPS section.

 # Application definition INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # custom app 'dictionary', ]

We have registered the app in the settings.py file. The settings.py file is used to configure the whole project.

2. In the urls.py file
   Open the urls.py file in the project folder and add this:

 from django.contrib import admin from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('dictionary.urls')), ]

We have registered the app-level URL. Let’s now create it.

Creating the App URL

This will be done inside the dictionary folder. Create a urls.py file inside the folder and add this:

from django.urls import path
from . import views urlpatterns = [ path('', views.homeView, name='home'), path('search', views.searchView, name='search'),
]

“from . import views” tells Django to import the views.py file residing in the dictionary folder.

The empty string indicates the home page URL which is http://127.0.0.1:8000/ if you are using the local server.

This is where users will be directed when the web page is opened.

For the 'search' string, the URL will be http://127.0.0.1:8000/search. We will be creating two functions in the views.py file as indicated.

Notice the name argument in the path() function, this is another way to refer to the URLs in the template files without using the exact URLs.

Creating Views

In this file, we are going to perform the web scraping we mentioned earlier. The first function, the homeView() is fairly simple. We just render the index.html page once the app is opened.

from django.shortcuts import render
import requests
from bs4 import BeautifulSoup as bs # Create your views here. def homeView(request): return render(request, 'index.html')

But the searchView() function is a little bit complex. We want to display three things when a user searches for the meaning of a word: meaning, synonyms, and antonyms.

So, we perform web scraping on two online dictionary websites. The first will display the meaning and the second will display the synonyms and antonyms.

def searchView(request): word = request.GET['search'] response = requests.get(f'https://dictionary.com/browse/{word}') response2 = requests.get(f'https://thesaurus.com/browse/{word}') if response: soup_1 = bs(response.text, 'html.parser') meaning = soup_1.find_all('div', {'value': '1'}) meaning_1 = meaning[0].getText() else: word = f'Sorry, we couldn\'t find your word {word} in our records.' meaning = '' meaning_ = '' if response2: soup_2 = bs(response2.text, 'html.parser') synonyms = soup_2.find_all('a', {'class': 'css-1kg1yv8 eh475bn0'}) synonym_list = [] for i in range(len(synonyms)): synonym_list.append(synonyms[i].text.strip()) antonyms = soup_2.find_all('a', {'class': 'css-15bafsg eh475bn0'}) antonym_list = [] for i in range(len(antonyms)): antonym_list.append(antonyms[i].text.strip()) else: synonym_list = '' antonym_list = '' results = { 'word': word, 'meaning': meaning_1, 'synonyms': synonym_list, 'antonyms': antonym_list } return render(request, 'search.html', results)

We import the requests module which uses the get() method to scrape the contents of the two websites.

Recommended: My First Python Get Request

The result is a cruel HTML code staring at you. BeautifulSoup, invaluable for web scraping does its job well to pull the data out of the HTML content. This now makes it possible to search the parsed data.

For our first search using the find_all() method from BeautifulSoup, we want a text wrapped in a div tag with the value 1. This is where the website owners kept the meaning of a particular word on the dictionary.com website.

So, we use the getText() method to get the text.

The second and third searches look similar to the first but instead of a div, we search in a tag. The words were kept in a tag to make it easy for visitors to be redirected to that particular word if they want to find the definition.

Instead of searching for a value, we search for a CSS class. We then append the results to their respective variables. If you are new to web scraping, you may wonder how we know where those particular words reside.

The answer is found in a browser’s developer tools, preferably Chrome Developer Tools. This is the reason I suggest familiarizing yourself with HTML before attempting this project.

Finally, we render the results on the search.html page. Notice the else statements. This is run if the word is not found on the website. Let’s now create the HTML files.

Creating Templates

Create a folder named templates in the current directory (not in the project or app folder). Then go to the settings.py file to let Django know of this development. In the file, import the os module. Then scroll to the TEMPLATES section and add this:

TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], # add these 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, },
]

Then create three files in the templates folder:

• base.html,
• index.html, and
• search.html.

The main HTML files will inherit from the base.html file. Open the base.html file and add the following:

<!DOCTYPE html>
<html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>Dictionary App</title> <!-- CSS only --> <!-- we are getting bootstrap5 from the CDN --> <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.2.0-beta1/dist/css/bootstrap.min.css" rel="stylesheet">
</head> <body> <div class="container mt-4"> <div class="row"> <div class="mt-4 p-5 bg-success text-white rounded mb-3"> <h1>Django English Dictionary</h1> </div> <div class="col-md-12"> {% block content %} <!-- here we will inject the content of every page that inherits from the base page --> {% endblock %} </div> </div> </div>
</body> </html>

Then, in the index.html add the following:

<!-- the index page is inheriting from the base page -->
<!-- the extends tags are used for inheriting from the base page -->
{% extends 'base.html' %} <!-- the block content tags for containing content of the page -->
{% block content %} <form action="search"> <div class="input-group"> <input type="text" required class="form-control" name="search" placeholder="Search your favorite word......."> <div class="input-group-append"> <button class="btn btn-success" type="submit"> Search </button> </div> </div> </form> {% endblock %}

Recall in the searchView() function, we send a GET request to get the word input by our user from a form that bears the name 'search.' Can you now see it in the form?

There will be a problem if you use it otherwise. Finally, add the following to the search.html file.

<!-- SEARCH.HTML -->
{% extends 'base.html' %}
{% block content %} <div> <h2 align="center"> {{ word | title }} </h2> <br> <p> <b>Meaning: </b>{{meaning}} </p> <br> <p> <b>Synonyms: </b> {{ synonyms }}
</p>
<br>
<p> <b>Antonyms: </b> {{ antonyms }} </p> <p><a href="{% url 'home' %}>Home</a></p> </div>
{% endblock %}

We use Django templating language to render the results of the searchView() function to the HTML. Alright, we are done. Run the server once again and you should see something similar to the images below.

That is the index.html web page. Once you search for a word, the search.html page is displayed as you can see below.

Do you see how each of the pages inherits everything in the base.html file?

Conclusion

We have successfully come to the end of this project. I strongly believe you have learned a lot of things you can apply to your projects. If certain things aren’t clear you may wish to read other project articles.

The full code can be found on my GitHub page https://github.com/finxter/django_dictionary. Have a wonderful day.

Recommended: How I Built a Weather App Using Three Python Frameworks

As a Python developer, I’ve always been fascinated by the simplicity and versatility of the language. Python has always been my go-to language for all my programming needs, from its clean syntax to the vast array of libraries available. I recently had to work on a project requiring me to convert numbers to their hexadecimal, octal, and binary representations. While there are several ways to do this in Python, I discovered the f-string Python Hex, Oct, and Bin methods, which turned out to be the most efficient and straightforward approach. In this blog post, I’ll share my personal experience with this method and show you how to use it to convert numbers efficiently.

A Short Overview (Promised)

Python’s f-strings, also known as “formatted string literals”, have been introduced in Python 3.6 and offer a more efficient and readable way to format strings. They improve upon the older string formatting methods, such as using %-formatting and the str.format() method.

One of the key advantages of f-strings is their ability to handle various numeric representations, such as hexadecimal (hex), octal (oct), and binary (bin).

Handling hex, oct, and bin values in Python with f-strings is quite simple, thanks to the built-in support for these number systems. These can easily be incorporated into f-strings by using specific format specifiers within curly braces that contain the expressions to be evaluated and formatted at runtime. This allows you to seamlessly integrate hexadecimal, octal, and binary values into their strings without resorting to clumsier methods or additional function calls.

When working with f-strings in Python, you can use {variable:x} for hex, {variable:o} for oct, and {variable:b} for bin.

F-String Basics

One powerful feature of f-strings is their ability to format numbers in different bases, such as hexadecimal (hex), octal (oct), and binary (bin). To represent numbers in these formats, you can use the appropriate format specifier:

• Hexadecimal: {x:X}
• Octal: {x:o}
• Binary: {x:b}

For example, to convert an integer into its hexadecimal representation, you can use the following f-string:

x = 255
hex_string = f"x in hex is: {x:X}"
print(hex_string) # Output: "x in hex is: FF"

Similarly, for octal and binary representations, you can use the respective format specifiers within the f-string:

x = 255
oct_string = f"x in oct is: {x:o}"
bin_string = f"x in bin is: {x:b}"
print(oct_string) # Output: "x in oct is: 377"
print(bin_string) # Output: "x in bin is: 11111111"

Using f-strings, you can create more readable and efficient code when working with different number systems in Python .

Recommended: 7 Tips to Clean Code

Formatting Numerical Values with F-Strings

To format a number in hexadecimal with f-strings, you can use the format specifier {variable:x}. If you want zero padding, use the format specifier {variable:0Nx}, where N is the desired number of digit characters.

x = 255
hex_string = f"0x{value:02x}"
# Output: "0xff"

Similarly, to format a number in octal representation, use the format specifier {variable:o}.

y = 63
octal_string = f"0o{y:03o}"
# Output: "0o077"

For binary representation, you can use the format specifier {variable:b}.

z = 10
binary_string = f"0b{z:04b}"
# Output: "0b1010"

In addition to numerical formats, you can also use other format specifiers like:

• Decimal: {variable:d}
• Floating-point: {variable:.Nf} (where N is the number of decimal places to round)
• Percentage: {variable:.N%}

Hexadecimal Representation

You can easily represent numbers in hexadecimal notation using f-strings in Python. Hexadecimal is a base-16 numeric system that uses sixteen distinct symbols – 0-9 representing zero to nine and A-F for ten to fifteen. It is widely used in computer programming and digital electronics.

You can use the format specifier within curly braces to convert a number to its hexadecimal representation using f-strings. For example:

number = 255
hex_num = f"{number:x}"
print(hex_num) # Output: "ff"

The same can be achieved using the format() function:

number = 255
hex_num = format(number, 'x')
print(hex_num) # Output: "ff"

You can also include the 0x prefix by using the # flag in the format specifier:

number = 255
hex_num = f"{number:#x}"
print(hex_num) # Output: "0xff"

Hexadecimal representation can be helpful in various situations, such as when working with colors in CSS or addressing memory locations in computer systems.

Octal Representation

In Python, working with octal representations is smooth and straightforward thanks to built-in functions and f-strings. An octal number system has a base of 8, which means it uses eight symbols: 0, 1, 2, 3, 4, 5, 6, and 7. Converting between decimal and octal values can be accomplished with ease.

Recommended: Python Conversions: Decimal + Binary + Octal + Hex

To obtain the octal representation of an integer in Python, simply use the oct() function. This function takes an integer as input and returns its octal representation as a string:

octal_value = oct(42) # 42 in decimal equals '0o52' in octal

With f-strings, you can elegantly include octal values directly in your strings. To do this, use the format specifier {value:#o} within an f-string:

number = 42
formatted_string = f"The octal representation of {number} is {number:#o}"
# Output: "The octal representation of 42 is 0o52"

Here are some essential points to remember when working with octal representations in Python:

• Octal literals can be defined by adding a 0o prefix to the number: octal_number = 0o52.
• Using arithmetic operations on octal numbers works the same as on decimal numbers: result = 0o52 + 0o10.
• Convert between integer and octal string representations with the int() and oct() functions, respectively.

Binary Representation

In Python, f-strings are a convenient option for formatting strings, which can be used for various purposes like binary, octal, and hexadecimal representations. In this section, we’ll focus on the binary representation using f-strings.

To display a binary value of an integer using f-strings, you can use the formatting specifier b followed by the variable you want to convert inside the curly braces. The syntax looks like this: f"{variable:b}".

As an example, let’s say we want to display the binary representation of the number 5:

number = 5
binary_representation = f"{number:b}"
print(binary_representation) # Output: 101

Now, you can use a loop to display binary representations for a range of numbers. Let’s say we want to print binary values for numbers 0 to 5:

for i in range(6): print(f"{i} in binary is {i:08b}")

This will output the following:

0 in binary is 00000000
1 in binary is 00000001
2 in binary is 00000010
3 in binary is 00000011
4 in binary is 00000100
5 in binary is 00000101

Note the use of 08b within the f-string. The number 8 indicates the minimum width, and leading zeros are used to fill any remaining space. This ensures that binary values are displayed with a consistent width, making the output easier to read.

Conversion Functions

This section will focus on Python’s f-string capabilities for converting between hexadecimal, octal, and binary number systems. The primary goal is to make these conversions as simple as possible using f-string syntax.

Int to Hex, Oct, and Bin

When working with integers, you can easily convert them to their corresponding hexadecimal, octal, and binary representations using f-string formatting. Here are some examples:

hex_number = 255
oct_number = 127
bin_number = 101 hex_string = f"{hex_number:x}"
oct_string = f"{oct_number:o}"
bin_string = f"{bin_number:b}"

This simple f-string syntax allows you to convert integers to their corresponding representation within an f-string using the 'x', 'o', and 'b' format specifiers.

String to Hex, Oct, and Bin

For converting strings to their hexadecimal, octal, and binary representations, you can use the following approach:

import binascii text = "Hello, World!" # Convert the string to bytes
text_bytes = text.encode('utf-8') # Use binascii to convert bytes to hex, oct, and bin
hex_string = binascii.hexlify(text_bytes).decode('utf-8')
oct_string = "".join([f"{char:o}" for char in text_bytes])
bin_string = "".join([f"{char:08b}" for char in text_bytes])

In this example, we first convert the string to bytes using the 'utf-8' encoding. Then we utilize the binascii module to convert bytes to their hexadecimal representation. We use list comprehension and f-string formatting for octal and binary conversions to achieve the same result.

Incorporating f-strings allows you to conveniently and efficiently perform conversions between various number systems in Python. This technique can be particularly beneficial when dealing with data representation and manipulation tasks.

Formatting Specifiers and F-Strings

The formatted string literals allow you to embed expressions inside the string, which are evaluated and formatted using the __format__ protocol.

Formatting numbers in hex, oct, and bin is quite easy with f-strings. Here are some examples:

• Hexadecimal: f"{number:x}"
• Octal: f"{number:o}"
• Binary: f"{number:b}"

You have the option to add formatting specifiers and padding to your f-Strings. For instance, you can center the output and add zero-padding:

f" {data:^14s}" .format(f" {data:#04x}")

This snippet first converts the data to hexadecimal using {data:#04x} and then centers the output with {data:^14s} (from Stack Overflow).

Here’s a brief table that demonstrates how to format numbers using f-Strings:

Utilizing f-Strings and various formatting specifiers can help you efficiently manage complex string formatting tasks in your Python projects .

To keep boosting your Python skills and stay on track with the emerging technologies of the exponential age (e.g., ChatGPT), check out our free cheat sheets and email academy here:

Python provides an effective way of handling multiline strings, which you might have encountered when working with lengthy text or dealing with code that spans multiple lines. Understanding how to correctly write a raw multiline string in Python can be essential for maintaining well-structured and easily readable code.

Ordinarily, we express strings in Python using single or double quotes.

Recommended: Python Strings Made Easy

However, when it comes to multiline strings, Python offers a special syntax for defining these types of text. To create a multiline string, you can use triple quotes, either single or double, at the beginning and end of your string.

To correctly write a raw multiline string in Python, use the letter “r” before your opening triple quotes while enclosing your string with triple quotes. For example: r'''This is a raw\n Multiline String'''.

This denotes a raw string and preserves special characters such as backslashes (used for escape sequences) without interpreting them as part of the string. Doing so lets you easily and efficiently handle long strings spanning multiple lines in your Python code.

Understanding Raw Strings

In Python, raw strings are a convenient way to represent strings literally, without processing escape characters. This can be particularly useful when working with regular expressions or dealing with file system paths. To create a raw string, simply prefix the string literal with an r or R character.

For example, a regular string containing a backslash (such as in a file path) would need to be escaped:

normal_string = 'C:\\Users\\John\\Documents'

With raw strings, you don’t need to escape the backslashes:

raw_string = r'C:\Users\John\Documents'

Both of these variables will hold the same string value.

When it comes to creating raw multiline strings, you can use triple quotes """ or ''' combined with the raw string prefix to achieve the desired result. Here’s an example:

raw_multiline_string = r"""This is a
raw multiline string
with backslashes \t and \n
that are not escaped."""

This string will preserve the backslashes and newlines as they appear between the triple quotes.

It is important to note that raw strings cannot end with an odd number of backslashes, as the final backslash would escape the final quote character:

# This will raise a SyntaxError
invalid_raw_string = r"This is not valid\"

To deal with this limitation, you can concatenate a regular string with the final backslash:

valid_raw_string = r"This is valid" + "\\"

Multiline Strings

In Python, multiline strings are created using triple quotes, either three single quotes (''') or three double quotes ("""). This allows you to include quotes, tabs, and newlines within the string without using escape characters. Here is an example of a multiline string:

multiline_string = """This is a
multiline string in Python
with newlines, tabs, and "quotes"."""

If you want to create a raw multiline string, you’ll need to use a different approach, as the r prefix only works for single-line strings. One way to achieve this is by combining raw strings and parentheses, adding an r prefix to each part of the string. This will preserve the string’s escape characters:

raw_multiline_string = (r"on\e" r"\\tw\\o")

Keep in mind that when using parentheses, the line break will not be included in the string. You can manually add a line break using the \n escape character in the appropriate location like this:

raw_multiline_string_with_linebreak = (r"on\e" r"\n" r"\\tw\\o")

This method allows you to create raw multiline strings while preserving the escape characters and maintaining readability in your Python code.

Remember: it’s essential to use the r prefix for each part of the string to ensure it’s treated as a raw string. For more information, check out the discussion on Stack Overflow.

3 Ways to Combine Raw and Multiline Strings

In Python, you can combine raw and multiline strings to create a string that spans across multiple lines, while also preserving special characters and escape sequences. This section will explain different ways to achieve this combination.

One common approach is to use triple quotes for creating a multiline string. By using three single quotes (''') or three double quotes ("""), you can create a multiline string that retains any whitespace and can include special characters. To add a raw string, use the r prefix before the triple quotes:

raw_multiline_string = r"""This is a raw
multiline string with a backslash: \\
and a new line \n is just character literals."""

Another way to write a raw multiline string is by using parentheses and string concatenation. Each line of the string can be enclosed in single or double quotes, followed by a space to ensure a single whitespace character divides them. Add the r prefix before each quoted line to maintain the raw string format:

raw_multiline_string = (r"This is a raw" r" multiline string with a backslash: \\" r" and a new line \n is just character literals.")

Alternatively, you can use the + operator to concatenate multiple raw strings, creating a multiline string. This approach allows you to explicitly specify newline characters or other special characters as needed:

raw_multiline_string = (r"This is a raw" + "\n" r" multiline string with a backslash: \\" + "\n" r" and a new line \n is just character literals.")

With these techniques, you can create raw multiline strings that are easier to read and maintain in your Python code.

Multiline Raw String Use Cases and Examples

This section reviews some use cases and examples demonstrating how to correctly write a raw multiline string in Python.

Using raw multiline strings is beneficial when dealing with strings containing many backslashes or with regular expressions. In these scenarios, raw strings prevent the need to escape backslashes, making the code more readable.

Here’s a basic example of creating a raw multiline string:

multiline_raw_string = r"""This is a raw \
multiline string in Python. \\
You don't need to escape the backslashes \\."""

In this example, the backslashes are preserved in the text as they’re written, without the need to escape them, thanks to the r prefix before the triple quotes.

Now, let’s take a look at a specific use case with regular expressions:

Suppose you want to match a file path pattern in a text, using a regular expression. Without raw strings, you’d need to escape the backslashes:

import re pattern = 'C:\\\\Users\\\\[A-Za-z0-9]+\\\\Documents'
text = 'C:\\Users\\JohnDoe\\Documents\\example.txt' result = re.search(pattern, text)
print(result.group())

With raw strings, the regex pattern becomes more readable, as you don’t need to escape the backslashes:

import re pattern = r'C:\\Users\\[A-Za-z0-9]+\\Documents'
text = 'C:\\Users\\JohnDoe\\Documents\\example.txt' result = re.search(pattern, text)
print(result.group())

In both examples, the output is the same:

C:\Users\JohnDoe\Documents

These examples demonstrate the benefits of using raw multiline strings in Python, especially when working with text that contains special characters like backslashes or incorporating regular expressions in your code.

Feel free to check out our full guide on raw strings here:

Full Guide: Python Raw Strings: A Helpful Easy Guide

If you want to keep improving your programming skills, consider joining our free email academy (130,000 coders) by downloading your cheat sheets here:

Deploying a Machine Learning model as a web application makes it easy for others with little or no programming experience to use it.

In previous tutorials, where I explained how I created a house price prediction app and a loan eligibility app, we made use of Streamlit. Streamlit is easy to use. This is why it is a popular choice for data scientists.

In a world where learning one framework isn’t enough, won’t it be nice to learn how to accomplish this using Django?

Understandably, Django can be tough for beginners. The only remedy though is constant practice. If you have been going through some of my tutorials on Django, there is no doubt that you have become familiar with the process.

Therefore, in this tutorial, we will add to your knowledge by creating a machine learning application using Django. Guess what we will used for prediction? The famous Titanic dataset!

Developing Machine Learning Model

The Machine Learning classification problem aims to predict the survival of the passengers based on their attributes. There are multiple steps involved in creating a Machine Learning model. To keep things simple, we will skip those steps and focus on showing how to implement Machine Learning in Django.

Create a folder for this project. Then, inside the folder, create a file named model.py. This is where we will develop our model. You can download the dataset on my GitHub page.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from sklearn.linear_model import LogisticRegression
import pickle df = pd.read_csv('titanic.csv', index_col=0) # selecting the features we need
df = df[['Pclass', 'Sex', 'Age', 'SibSp', 'Parch', 'Fare', 'Embarked', 'Survived']] # encoding the column to a numberic value
df['Sex'] = df['Sex'].map({'male': 0, 'female': 1}) # converting the Age column to numberic type
df['Age'] = pd.to_numeric(df.Age) # filling the null values
df['Age'] = df.Age.fillna(np.mean(df.Age)) # creating additional features from Embarked columns after converting to dummy variables
dummies = pd.get_dummies(df.Embarked)
df = pd.concat([df, dummies], axis=1)
df.drop(['Embarked'], axis=1, inplace=True) X = df.drop(['Survived'], axis=1)
y = df['Survived'] # scaling the features
scaler = MinMaxScaler(feature_range=(0,1))
X_scaled = scaler.fit_transform(X) model = LogisticRegression(C=1)
model.fit(X_scaled, y) # saving model as a pickle
pickle.dump(model, open('titanic.pkl', 'wb'))
pickle.dump(scaler, open('scaler.pkl', 'wb'))

After importing the CSV file, we saw that there are missing values in the features selected. We simply fill them up with the mean of the values. We convert the Embarked column to a dummy variable. Then, we add them to the features.

We are using LogisticRegression as the Machine Learning algorithm to make this prediction. Finally, we save the model as a pickle object to be used later.

Creating Django Project

As covered in previous tutorials, the steps to set up a new Django project are as follows:

• create and activate a virtual environment
• install required libraries
• create a new Django project which we will call predictions
• create a requirements.txt file
• create a new app called titanic
• perform a migration to set up the database
• update settings.py

$ python3 -m venv venv
$ source venv/bin/activate
(venv) $ pip install django tzdata scikit-learn pandas numpy
(venv) $ pip freeze > requirements.txt
(venv) $ django-admin startproject venv_predictions .
(venv) $ python manage.py startapp titanic
(venv) $ python manage.py migrate
(venv) $ python manage.py runserver

The (venv) indicates that you are in the virtual environment. Don’t forget to include the dot which signifies creating the project in the current directory. You will see the image below if everything was installed successfully.

Open the settings.py file to let Django know that a new app is created. We will do so in the INSTALLED_APP section.

INSTALLED_APPS = [ 'django.contrib.admin', 'django.contrib.auth', 'django.contrib.contenttypes', 'django.contrib.sessions', 'django.contrib.messages', 'django.contrib.staticfiles', # custom app 'titanic',
]

Let’s configure the URLs for our website. Open the urls.py in the project folder and make it appear like this:

from django.contrib import admin
from django.urls import path, include urlpatterns = [ path('admin/', admin.site.urls), path('', include('titanic.urls')),
]

Let’s now configure the URLs for the app. Create a urls.py in the app folder.

from django.urls import path
from .views import home, result urlpatterns = [ path('', home, name='home'), path('result/', result, name='result'),
]

Let’s create another file in the app folder named predict.py. This is where we will use the pickled files to make predictions.

import pickle def getPrediction(pclass, sex, age, sibsp, parch, fare, C, Q, S): model = pickle.load(open('titanic.pkl', 'rb')) scaled = pickle.load(open('scaler.pkl', 'rb')) transform = scaled.transform([[pclass, sex, age, sibsp, parch, fare, C, Q, S]]) prediction = model.predict(transform) return 'Not Survived' if prediction == 0 else 'Survived' if prediction == 1 else 'error'

The function contains the exact number of features used to train the model.

Notice we first transform the values the user will input on the web page. Since the trained model was transformed, we have to do the same to any values the user enters. Finally, we return the results based on the prediction.

Alright, let’s head over to the views.py file in the app folder.

from django.shortcuts import render
from .prediction import getPrediction # Create your views here.
def home(request): return render(request, 'home.html') def result(request): pclass = int(request.GET['pclass']) sex = int(request.GET['sex']) age = int(request.GET['age']) sibsp = int(request.GET['sibsp']) parch = int(request.GET['parch']) fare = int(request.GET['fare']) embC = int(request.GET['embC']) embQ = int(request.GET['embQ']) embS = int(request.GET['embS']) result = getPrediction(pclass, sex, age, sibsp, parch, fare, embC, embQ, embS) return render(request, 'result.html', {'result': result})

The home() function simply renders the home.html which contains the form where our users will input some details. Then the result() function will get those details, make predictions, and renders the prediction result.

Notice that we made sure every detail corresponds to the features used in training the model.

The final step is templates. Create a folder bearing the name. Make sure you are doing so in the current directory. Then register it in the settings.py file.

TEMPLATES = [ { 'BACKEND': 'django.template.backends.django.DjangoTemplates', 'DIRS': [os.path.join(BASE_DIR, 'templates')], # add these 'APP_DIRS': True, 'OPTIONS': { 'context_processors': [ 'django.template.context_processors.debug', 'django.template.context_processors.request', 'django.contrib.auth.context_processors.auth', 'django.contrib.messages.context_processors.messages', ], }, },
]

Don’t forget to import the required module. Inside the templates folder, create a home.html file.

<!DOCTYPE html>
<html lang="en" dir="ltr"> <head> <meta charset="utf-8"> <title>Home</title> </head> <body> <h1 style= “color:blue”>Titanic Survival Prediction</h1> <form action="{% url 'result' %}"> {% csrf_token %} <p>Passenger Class:</p> <input type="text" name="pclass"> <br> <p>Sex:</p> <input type="text" name="sex"> <br> <p>Age:</p> <input type="text" name="age"> <br> <p>Sibsp:</p> <input type="text" name="sibsp"> <br> <p>Parch:</p> <input type="text" name="parch"> <br> <p>Fare:</p> <input type="text" name="fare"> <br> <p>Embark Category C:</p> <input type="text" name="embC"> <br> <p>Embark Category Q:</p> <input type="text" name="embQ"> <br> <p>Embark Category S:</p> <input type="text" name="embS"> <br> <input type="submit" value='Predict'> </form> </body>
</html>

This syntax "{% url 'result' %}" is Django templating language. It’s a link to the result.html. Remember the name argument in the path() function in urls.py? That is another way to refer to the result.html URL. The csrf_token is for security reasons. It’s mandatory when a form is created.

Can you now see it’s from this form we get those names in the result() function? It is here that the data will be collected and sent to the result() function which processes the data, makes predictions, and displays the result in the result.html.

We now create the result.html file in the templates folder.

<!DOCTYPE html>
<html lang="en" dir="ltr"> <head> <meta charset="utf-8"> <title>Result</title> </head> <body> <h1 style=“color:blue”>Prediction</h1> <p>Verdict: {{ result }} </p> </body>
</html>

It’s very simple. The {{ result }} is a variable that will be rendered to this web page. Go back to your result() function to recall if you have forgotten.

That’s it. We are done. Thanks for staying with me so far in this tutorial. Let’s check what we have done. Run the local server.

That is the home page. Everything in the form is displayed. Enter details and make predictions. Remember, only numbers will be in the form. If you are lost, check the dataset using Pandas.

If you encounter an error saying, “No such file or directory: 'titanic.pkl'”, you may have to manually run the model.py to generate the file.

Recommended: 5 Minutes to Pandas

Conclusion

Congratulations!! You are not only a data scientist but also a Django developer.

In this tutorial, we performed Machine Learning using Logistic Regression.

We demonstrated how to implement it using Django.

Exercise: As an assignment, can you use what you have learned to make predictions on the iris dataset, the hello world of data science? Give it a try using Django.

You are welcome.

This article summarizes Bill Gates’ article on “The Age of AI has begun” but focuses on the most important ideas for ease and speed of reading. I left the overall structure intact but reduced the text by approximately 70%.

Time savings with average reading speed: 9 minutes.

In the article, Bill Gates shared his thoughts on the revolutionary potential of artificial intelligence (AI) and its potential to address global inequities.

Gates compared the impact of AI to the invention of the graphical user interface in 1980, a critical turning point for modern computing.

He was astonished by OpenAI’s GPT model, which managed to score a 5 on an AP Biology exam, a remarkable feat that showcased its potential.

Gates believes that AI will transform how people work, learn, travel, receive healthcare, and communicate, with entire industries reorienting around it. He sees AI as a tool to reduce the world’s worst inequities, especially in health, education, and climate change.

Regarding global health, Gates envisions AI could help save the lives of millions of children who die each year from preventable causes. In the US, AI could be instrumental in improving education, particularly in boosting math skills for underprivileged students. Finally, AI could contribute to climate change solutions, given that the world’s poorest populations, who did the least to cause the problem, are the most affected.

Gates acknowledges that AI raises concerns around workforce displacement, privacy, bias, and other issues. However, he emphasizes the importance of governments and philanthropy in ensuring that AI reduces inequity

Artificial Intelligence

Artificial intelligence (AI) refers to models designed for specific tasks or services, like ChatGPT, while artificial general intelligence (AGI) is a software capable of learning any task or subject. AGI doesn’t exist yet, and its creation is still debated within the computing industry.

AI development has been a long-standing dream, and with machine learning and increased computing power, sophisticated AI is now a reality. The growth of AI will likely accelerate, similar to the rapid expansion of the software industry during the early days of personal computing. As more attention turns to AI, innovations will come faster, eventually making the pre-AI era seem like a distant memory.

Productivity

AI, like GPT, can help automate various tasks in jobs such as sales, service, or document handling, making work more efficient.

AI integrated into products like Microsoft Office will enhance tasks like writing emails and managing inboxes. Eventually, computers will be controlled using plain language rather than pointing and clicking.

This is what I found most exciting in the whole article:

AI advances will enable the creation of personal agents or digital personal assistants, streamlining scheduling, communications, and e-commerce across all devices. Company-wide agents will empower employees, making them more productive by providing relevant information and insights.

Increased productivity from AI can benefit society by freeing people up for tasks requiring human touch, such as teaching or patient care. Governments should help workers transition into new roles to address the changes brought by AI. By targeting global health and education, AI can help reduce inequity and address areas with significant needs.

Health

AI has the potential to significantly improve healthcare and the medical field. It can assist healthcare workers with tasks like paperwork, insurance claims, and drafting notes, increasing efficiency. In poor countries, AI can help health workers become more productive and enable patients to perform basic triage and seek appropriate treatment.

AI models in poor countries will need to be adapted for different diseases, languages, and challenges. Although AI adoption may take longer in healthcare due to necessary testing and regulation, AI can still significantly benefit the sector.

AI will also accelerate medical breakthroughs by analyzing large amounts of biological data, helping design drugs, and predicting side effects. The Gates Foundation aims to use AI tools to address health problems affecting the world’s poorest people, such as AIDS, TB, and malaria.

Additionally, AI-generated insights can improve agriculture in poor countries by developing better seeds, advising farmers, and creating drugs and vaccines for livestock. As climate change increasingly impacts subsistence farmers, AI-driven advances become even more crucial.

Education

While computers have not yet revolutionized education as hoped, AI-driven software in the next five to 10 years has the potential to transform teaching and learning.

AI can tailor content based on a student’s interests and learning style, provide immediate feedback, and assist teachers and administrators with tasks like assessing understanding and career planning.

Despite the potential of AI, learning will still rely on strong relationships between students and teachers. Ensuring that AI tools are available to low-income schools and training AI on diverse data sets to avoid bias is crucial.

Educators are already adapting to AI technologies, such as GPT, in their classrooms. While concerns about students using AI to write essays persist, some teachers have found ways to incorporate the technology into their teaching, such as using AI-generated drafts that students then personalize.

Risks and problems with AI

Current AI models have limitations, such as struggling with context and abstract reasoning, but these issues are expected to be largely fixed within a few years. There are non-technical concerns, like the potential misuse of AI and the possibility of AI running out of control.

However, recent AI advancements have not made these concerns more urgent.

Superintelligent AI, or artificial general intelligence (AGI), could be a profound change in the future, raising questions about its goals, potential conflicts with humanity’s interests, and whether its development should be prevented. Although AI has become more human-like in expression, it does not indicate meaningful independence.

Gates Book Tips: Three influential books on AI—Superintelligence by Nick Bostrom, Life 3.0 by Max Tegmark, and A Thousand Brains by Jeff Hawkins—provide thought-provoking perspectives on the subject, even if they don’t always agree with each other or the reader.

Next Frontiers

The future of AI will see an explosion of companies working on new uses and improvements in the technology, with advancements in both hardware and software. The development of specialized AIs and artificial general intelligence will be competitive areas.

The public discussion surrounding AI should be guided by three principles:

1. Balance fears about AI’s downsides with its potential to improve lives while guarding against risks and spreading benefits widely.
2. Governments and philanthropy should ensure AI reduces inequity, as market forces may not naturally produce AI products and services that help the poorest.
3. Recognize that AI’s limitations will be overcome, and this new technology can help people improve their lives globally.

The Age of AI presents opportunities and responsibilities, requiring rules to ensure AI’s benefits outweigh its downsides and are accessible to everyone, regardless of location or wealth.

Recommended: 7 Effective Prompting Tricks for ChatGPT

Once upon a time, I was a distributed systems researcher specializing in graph partitioning algorithms. Those were thrilling days, though I must admit I didn’t enjoy the daily commute and the time away from my family.

During that period, I delved deep into classic distributed systems conundrums like the Byzantine Generals Problem. When I discovered that Bitcoin—a peer-to-peer monetary system—offered a practical solution, I was excited.

My colleagues and I would spend hours over lunch breaks dissecting and discussing this groundbreaking resolution.

If you’re curious about this captivating problem and its ingenious solution, don’t miss today’s Finxter blog tutorial:

[Blog] How Bitcoin Solves the Byzantine Generals Problem

It’s a remarkable technical triumph that proves no challenge is insurmountable for dedicated and driven individuals. Just look at the success of Bitcoin—an anonymous coder created the 21st most capitalized currency in the world!

In the world of tech, we witness an ongoing battle between two formidable forces:

Giant 1 – Leviathan. This force represents the powerful centralization trends and winner-take-most economies in the tech and machine learning industries. Think big tech, big government, and big brother—those with the best data sets win.

Giant 2 – Atomos. This symbolizes the ever-strengthening decentralized infrastructures and systems, such as Bitcoin and decentralized social networks like PeerBrain. Atomos represents everyday coders like you and me. Derived from the ancient Greek word for “uncuttable” or “indivisible,” Atomos signifies the countless small, independent entities in a decentralized system.

I’m thankful for recent advancements in AI, as they’ll propel humanity toward hyper-efficiency and uncharted heights. Yet, I also appreciate the existence of counterbalancing forces like the indomitable Atomos, redistributing power from the few back to the many.

Decentralized money, energy production, and social networks are just the beginning of this promising trend, and its potential is immense!

If you’re eager to contribute to the growth of Atomos, consider checking out the Uniswap Automated Finance for Blockchain Engineers course. While the Ethereum ecosystem isn’t entirely decentralized yet, it could be—and that would serve as an effective countermeasure to centralized platforms.

We need more builders!

“A democracy is only as resilient as its people. An informed and engaged citizenry is the bedrock of a healthy democracy.”

The same holds true for decentralization!

To your success!
Chris

This email was part of our free email academy for exponential technologies. To stay ahead of the curve and remain on the right side of change, join our free email academy by downloading your cheat sheets for learning here: