DEV Community: Mukumbuta

DevOps - NGINX Configuration

Mukumbuta — Thu, 30 Jan 2025 02:04:31 +0000

Introduction

As part of my DevOps learning journey, I was tasked with setting up and configuring NGINX on a fresh Ubuntu server. This exercise tested my ability to deploy a simple web server, configure it to serve a custom webpage and make it accessible to the public. In this blog post, I will walk you through my approach, the challenges I faced, and what I learned from the experience.

Approach & Steps Taken

Step 0: Setting Up a Domain Name

The first step I took was to buy a domain name from godaddy.com, created a subdomain and pointed it to the VPS.

Step 1: Setting Up an Ubuntu Server

The second step was to get an Ubuntu server up and running. I chose Namecheap VPS with the following specifications:

OS: Ubuntu 22.04 LTS
CPU: 8 CPU
RAM: 12GB
Storage: 32GB
Public IP: Assigned automatically

I connected to the server using SSH:

ssh myusername@my-server-ip

Step 2: Installing NGINX

Once inside the server, I updated the package list and installed NGINX:

sudo apt update && sudo apt upgrade -y
sudo apt install nginx -y

To verify that NGINX was installed and running, I used:

sudo systemctl status nginx

Opening http://server-IP/ in a browser confirmed that NGINX was serving its default welcome page.

Step 3: Configuring NGINX to Serve a Custom Web Page

The next step was to create an Nginx server block for this specific task.
A server block in Nginx is a configuration section that defines how Nginx handles requests for a specific domain or IP address.

I then created a symbolic link in Nginx by linking the configuration file from /etc/nginx/sites-available/ to /etc/nginx/sites-enabled/. This allows Nginx to recognize and use the configuration when it reloads.

sudo ln -s /etc/nginx/sites-available/devops /etc/nginx/sites-enabled/

The folowing step was to replace the default NGINX page with a custom one. I created a file index.html file:

sudo nano /var/www/html/index.html

I then coded in the appropriate HTML according to the task.
After saving the file (CTRL + O, then Enter, then X), I restarted NGINX to apply the changes:

sudo systemctl restart nginx

Visiting http://server.gateway.tumingle.com/ in a browser now displayed the custom message.

Step 4: Configuring Firewall for Public Access

To ensure that my server was accessible from the internet, I checked the firewall settings and allowed HTTP traffic:

sudo ufw allow 'Nginx Full'
sudo ufw enable
sudo ufw status

This confirmed that traffic on port 80 was open.

The last step was to issue an SSL certificate using certbot/nginx combination using the command:

sudo certbot --nginx -d server.gateway.tumingle.com.

Now I could view the site over HTTPS.

Challenges & How I Overcame Them

1. NGINX Not Running After Installation

At first, NGINX failed to start. Running sudo systemctl status nginx showed a port conflict. The issue was caused by another web service running on port 80. I resolved it by stopping the conflicting service:

sudo systemctl stop apache2
sudo systemctl disable apache2
sudo systemctl restart nginx

2. Firewall Blocking HTTP Requests

Even after configuring NGINX, my site was inaccessible. Checking the firewall rules (sudo ufw status) revealed that port 80 was not open. Enabling the necessary firewall rules fixed this.

3. HTML Page Not Updating

After editing index.html, my browser still showed the old page. This was due to caching. I cleared the cache with CTRL + SHIFT + R and also restarted NGINX:

sudo systemctl restart nginx

What I Learned from This Experience

Understanding Web Server Basics – I learned how to install, configure, and manage NGINX, which is a fundamental skill for DevOps engineers.
Working with Firewalls – Managing firewall rules was a key takeaway, ensuring my server was accessible while maintaining security.
Troubleshooting and Debugging – Debugging issues with services like NGINX, checking logs, and resolving conflicts helped improve my problem-solving skills.
Cloud and Server Administration – Setting up a cloud-based virtual machine, securing it, and hosting a web application is essential knowledge for anyone entering the DevOps field.

How This Task Contributes to My Professional Growth

This exercise gave me hands-on experience with NGINX deployment, an essential skill for DevOps Engineers. It also reinforced my ability to troubleshoot issues and work with Linux servers, which are crucial in modern cloud environments.

Conclusion

Completing the DevOps Stage 0 - NGINX Configuration task was a valuable learning experience. It reinforced my understanding of web server deployment, Linux administration, and troubleshooting. This hands-on practice has prepared me for more advanced DevOps and cloud computing challenges.

Next Steps:

Deploy a similar setup using Docker to containerize the application.
Explore load balancing with NGINX for handling multiple requests efficiently.
Automate the setup using Ansible or Terraform.

This task has been an exciting first step in my DevOps journey, and I look forward to learning more! 🚀

What’s Next for You?

Have you ever set up NGINX on a server? What challenges did you face? Let me know in the comments!

References

How to Use Git-flow in Your Workflow

Mukumbuta — Wed, 31 Aug 2022 22:41:23 +0000

Hi.
By now, am sure you know there are two principle ways to manage software projects and and optimize a team's workflow in GIT, i.e, Git-Flow and Github Flow, just in case you forgot.
In this article I will dwell on how to use Git-Flow.

Git-flow is simply a git branching model in which instead of having just one main branch, we can have two branches main and development.
That sounds pleasant, Yes?
I know, that's why I should be quick to mention that it has some paticluar use cases. According to luca mezzalira (2014), Git-flow is suggested to be used when your software has the concept of release because it’s not the best decision when you work in Continuous Delivery or Continuous Deployment environment where this concept is missing.

In Git-flow:
main tracks officail release history whereas, development allows for the integration of feature branches.

TIP: Tag all commits to the main branch with version numbers.

First of all one developer creates an empty develope branch and pushes it to the server.

`$ git branch development`
`$ git push -u origin development`

How to make development branch the base branch

To change the base branch from main to devlopement:

Head over to github.com
On your repository, head over to settings
Click on Branches
Click on the forward and reverse arrows icon
Choose developementin the drop-down menu
Select 'I understand...'

Congratulations! You have just changed the base braanch of your respository from main to development

Now, other devs can then clone the central repository and create a tracking branch for development
Instead of branching off of main, feature branches branch off development.
That is to say, development is now the parent of feature branches.
When a feature is complete, the feature branch is merged back into development(This is what is known as 'Feature Branch Workflow').

Spoiler alert: Feature branches must never interact directly with main.

How to create a feature branch

To create a feature branch, head over to your terminal and enter the following commands:

`$ git checkout developement`
`$ git checkout -b feture_branch_name`

Or, you can use the git-flow extention library like so:

`git flow feature start feature_branch_name`

You can then continue with the normal usage of Git.
When dvelopement work on a feature is complete, it's now time to merge feature_branch_name into development like so:

`$ git checkout dvelopement`
`$ git merge feature_branch_name`

Or using the git-flow extention like so:

`$ git flow feature finish feature_branch_name`

Now assuming we have a repository already setup with a main branch, we can demonstrate Feature Branch Flow like so:

`$ git checkout main`
`$ git checkout -b development`
`$ git checkout -b feature_branch_name`

Then run the following commands:

`$ git checkout development`
`$ git merge feature_branch_name`
`$ git checkout main`
`$ git merge development`
`$ git branch -d feature_branch_name`

Release branch

Once development has acquired enough features for a release, we can then fork a release branch off of development.

The beauty of using a dedicated branch to prepare releases makes it possible for one team to polish the current release while another team continues working on features for the next release.

Release branches are based on the development branch. Below are a series of commands for creating a release branch:

Without the git-flow extensions:

`$ git checkout develop`
` $ git checkout -b release/0.1.0`

When using the git-flow extensions:

`$ git flow release start 0.1.0`

You should be able to see some text that goes something like: "Switched to a new branch 'release/0.1.0'"

You can now merge release branch into main and development and delete the branch.

To finish a release branch, use the following methods:

Without the git-flow extensions:

`$ git checkout main`
`$ git merge release/0.1.0`

With the git-flow extension:

`$ git flow release finish '0.1.0'`

That's it!

Mastering Python For Web Development.

Mukumbuta — Wed, 04 May 2022 10:42:38 +0000

Python, is a practical language, and so practice is the major key for any aspiring developer to excel at programming in python. Python offers a concise and clear syntax which is easy to write and understand. Most developers and learners prefer Python for web development since it is a very powerful tool which has been used to back some of the world's most common products and services. Python offers many frameworks used in web developments such as Django, Flask, Cherrypy, Pyramid, that has been used to power some of the most successful websites such as Google, Netflix, NASA and many more.

Why Use Python For Web Development.

Django is published under BSD license, which assures the web applications can be used and modified freely without experiencing problems. It is free and open source.
Django integrates a lot of efficient ways to perform unit tests.
Django is fully customizable, developers can adapt to it easily by creating modules or overridden framework methods.
Uses the Don't Repeat Yourself (DRY) principle which keeps the code simple and clear without having to copy/paste the same code elsewhere.
Using python in this framework allows you to have benefits from all Python libraries and assures a very good readability.
Django is supported by a good community which means that you can easily resolve issues and fix bugs quickly as a result of many code examples that shows good practices. Django Framework Django is a high-level python web framework that allows rapid development and clean practical design which was released in 2005 and named after a jazz guitarist Django Reinhardt. It was first started in 2003 by Adrian Holovaty and Simon Willison as an internal project at Lawrence Journal-World newspaper and was released in July, 2005. Using Django it is easier to build a better web app faster and with less code plus its free and open source. Some of the Features of Django

Complete: Strives to provide almost everything that developers require to help them develop their sites from consistent design patterns to extensive updated documentations.

Versatile: Some organizations uses Django to build all sort of things from content management system to social networks to scientific computing platforms to new sites.

Secure: Emphasizes on security by assisting developers to avoid many common mistakes by providing a framework to protect the website automatically. Also gives a secure way to manage user accounts and passwords.
Scalable: Many of the busiest websites uses Django's ability to quickly and flexibly scale to meet the heaviest traffic demands.
Maintainable: Applies design principles and patterns that encourage the creation of maintainable and reusable code. By making use of Don't Repeat Yourself (DRY) principle so there is no unnecessary duplication, reducing the amount of code.
Portable: written in Python which runs on multiple platforms including Windows, Linux, Mac OS applications plus Django is well supported by many web-hosting providers that provides specific infrastructure and documentation for hosting Django sites.
Django Installation Process
In order to be able to use Django, you need to install the following Software:
• Python
• PIP which facilitates the installation of Django and other important packages
• Django
• Virtual environment
Installation of Python
Depending on the operating system, Windows, Unix/Linux and Mac OS Python can be installed on each operating system.

Install PIP
PIP is important as it handles the packages installation, performs updates, and removes all the Python package extensions.
Windows Download it from Here Then you install PIP from executable and remember to choose the correct python installation folder.
Unix/Linux Run the following commands to be able to install PIP.
root: wget https://raw.github.com/pypa/pip/master/contrib/get-pip.py
root: python3 get-pip.py
Mac OS Open up your terminal and run the get-pip.py file as shown below.
$ curl -O https://raw.github.com/pypa/pip/master/contrib/get-pip.py
$ sudo python3 get-pip.py
Note that: To confirm whether pip is installed in your P.C, open your terminal and run the command pip --version or pip3 --version. If you get the pip version then it is safe to say that it has been installed.
:~ $ pip --version
pip 20.3.4 from/usr/lib/python3/dist-packages/pip (python 3.9)
:~ $ pip3 --version
pip 20.3.4 from/usr/lib/python3/dist-packages/pip (python 3.9)
In any case you are not getting any result after executing the above command or you did manage to install pip run the command sudo apt install pip or sudo apt install pip3 on your terminal
Installation of Django
Django for Windows To install Django with PIP, open command prompt then go to Scripts directory where Python folder is and install Django by running the below command.
C:\Python33\Scripts\pip.exe install django=="X.X"
Django for Linux At the root level on your terminal execute the following codes.
root: compgen -c | grep pip
root: alias pip=pip-3.2
: pip install django=="1.6"
Django for Mac OS We install Django by running the command pip install django=="1.6" on the terminal.
$ cd usr/local/bin
ln -s ../../../Library/Frameworks/Python.framework/Version/3.3/bin/pip3
pip
$ pip install django=="1.6"
Installing Virtual Environment(Virtualenv)
We are creating a virtual environment to have a separate working environment for our new project. In order to install virtualenv, lets run pip or pip3 then using PIP we run pip install virtualenv. To check if virtualenv is installed the run the command virtualenv--version.
:~ $ virtualenv--version
virtualenv 20.10.0
Creating Our First Project with Django
• Before we start to use Django, lets create a folder/directory for this project on the Desktop by running the following command on the terminal.
:~ $ pwd
user/home/muks
:~ $ ls
Desktop Documents Downloads Pictures Music
:~ $ cd Desktop/
:~ Desktop $ mkdir demo_django
:~ Desktop $ ls
demo_django
:~ Desktop $ cd demo_django
~ Desktop/demo_django $
• Under our new directory, lets create virtual environment by using the command virtualenv
~ Desktop/demo_django $ virtualenv env
• Make sure you activate the environment using source /bin/activate.
:~ Desktop/demo_django $ source env/bin/activate
• Inside our same created directory lets install Django by running pip install django.
:~ Desktop/demo_django $ pip install django
Collecting django
• Lets begin our project by running the command django-admin startproject django_project1 which will create our project files on django_project1 and manage.py file.
:~ Desktop/demo_django $ django-admin startproject django_project1
:~ Desktop/demo_django $ ls django_project1 env manage.py
• Now let make columns and tables in the database using the migration and migrate commands ./manage.py makemigrations and then ./manage.py migrate.

[env] ~ Desktop/demo_django $ ./manage.py makemigrations
• Consequently, as we are working on the project's main container directory on the manage.py file lets run ./manage.py runserver which runs on port 8000 by default but if we specify the port number it won't run on default e.g ./manage.py runserver 7000
[env] :~ Desktop/demo_django $ ./manage.py runserver
Performing system checks...

System check identified no issues (0 silenced).
May 1, 2022 - 10:51:11
Django version 4.0.2, using settings 'django_project1.settings'
Starting development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.
Next, visit https://127.0.0.1:8000/ which will display the page shown below.

• On the terminal to create a superuser run Python3 manage.py createsuperuser or ./manage.py createsuperuser and fill in the name the user, give an email, and set a password. Now, running your server ./manage.py runserver it will allow you to access the Django admin panel for your project.

[env]:~ Desktop/demo_django $./manage.py createsuperuser

Username : admin
Email address: admin.admin@email.com
Password:
Password (again):
Superuser created successfully.
• Now try visit https://127.0.0.1:8000/admin to check if you can be able to log in on the login admin page.
Login page for Admin Fill out your details on the page i.e., the username and password that we created earlier:

Admin page: You can then view and explore your admin panel

The Ultimate Python Tutorial For Beginners

Mukumbuta — Sun, 24 Apr 2022 15:49:18 +0000

Python is a powerful, yet very simple, multi-purpose, high level programming language which is used in various aspect of technology. To cite but a few examples, Python is used in web developemnt, software development, and Data Science and Machine learning. This tutorial, which by the way,is beginner friendly, will explain all the fundamental concepts of python [programming.

Introduction to Python Programming language
Python is developed by Guido van Rossum. He named it Python after the comedy television show Monty Python’s Flying Circus. Guido van Rossum started implementing Python in 1989 and officially released in 1991.

Features of Python programming language
Readability: Python is a very readable language.
Easy to Learn: Learning python is easy as this is a expressive and high level programming language, which means it is easy to understand the language and thus easy to learn.
Cross platform: Python is available and can run on various operating systems such as Mac, Windows, Linux, Unix etc. This makes it a cross platform and portable language.
Open Source: Python is a open source programming language.
Large standard library: Python comes with a large standard library that has some handy codes and functions which we can use while writing code in Python.
Free: Python is free to download and use. This means you can download it for free and use it in your application. It is also open source which means you can freely distribute copies of this software, read its source code and modify it.
Supports exception handling: If you are new, you may wonder what is an exception? An exception is an event that can occur during program exception and can disrupt the normal flow of program. Python supports exception handling which means we can write less error prone code and can test various scenarios that can cause an exception later on.
Advanced features: Supports generators and list comprehensions. We will cover these features later.
Automatic memory management: Python supports automatic memory management which means the memory is cleared and freed automatically. You do not have to bother clearing the memory.

What we can do with Python
You may be wondering what all are the applications of Python. There are so many applications of Python, here are some of the them.

Web development – Web framework like Django and Flask are based on Python. They help you write server side code which helps you manage database, write backend programming logic, mapping urls etc.
Machine learning – There are many machine learning applications written in Python. Machine learning is a way to write a logic so that a machine can learn and solve a particular problem on its own. For example, products recommendation in websites like Amazon, Flipkart, eBay etc. is a machine learning algorithm that recognises user’s interest. Face recognition and Voice recognition in your phone is another example of machine learning.
Data Analysis – Data analysis and data visualisation in form of charts can also be developed using Python.
Scripting – Scripting is writing small programs to automate simple tasks such as sending automated response emails etc. Such type of applications can also be written in Python programming language.
Game development – You can develop games using Python.
Development Embedded applications.
Desktop applications – You can develop desktop application in Python using library like TKinter or QT.

How to install Python
Python installation is pretty simple, you can install it on any operating system such as Windows, Mac OS X, Ubuntu etc.
To install the Python on your operating system, go to this link: which is the official Python website and it will detect the operating system and based on that it would recommend you to download Python. Always rememeber to download the latest version of Python (Python 3.8 or higher).
Installation steps are pretty simple. You just have to accept the agreement and finish the installation.
It must be noted, however, that most operating systems come with Python already installed. To check if you have python installed, go toyour terminal and type:
$ python --version

*Install an IDE *
In order to run Python code, you will need an IDE. Popular once include: VSCode, PyCharm, Atom, etc,. You can go ahead and install an IDE of your choice.
For newbies, IDE stands for Integrated Development Environment. It is a software that consolidates the basic tools that are required to write and test programs in a given language.
Typically, an IDE contains a code editor, a compiler or interpreter and a debugger. You can access all these at the same place through the IDE GUI.

Comments in Python Programming
Comments are an essential part of, not just Python, but any programming language. Although they do not change the outcome of a program.
A comment is text that doesn’t affect the outcome of a code, it is just a piece of text to let someone know what you have done in a program or what is being done in a block of code. This is especially helpful when someone else has written a code and you are analysing it for bug fixing or making a change in logic, by reading a comment you can understand the purpose of code much faster then by just going through the actual code.
To write a comment in Python, simply use a hashtag before the comment as shown below:

*# This is just a text, it won't be executed.*

print("Python comment example")
Output:
Python comment example*

Types of Comments in Python
There are two types of comments in Python.

Single line comment
Multiple line comment

Single line comment
In python we use # special character to start the comment as in shown below:
#This is just a comment. Anything written here is ignored by Python

Multi-line comment:
To have a multi-line comment in Python, we use triple single quotes at the beginning and at the end of the comment, as shown below.

*'''
This is a
multi-line
comment
*'''

Python Comments Example
In this Python program we are seeing three types of comments. Single line comment, multi-line comment and the comment that is starting in the same line after the code.

*'''
We are writing a simple program here
First print statement.
This is a multiple line comment.
'''
print("Hello World!")

# Second print statement
print("I’m learning python programming")
print("Welcome to the world of coding.") # Third print statement*

Output:
Hello World!
I’m learning python programming
Welcome to the world of coding.

NOTE: When # character is encountered inside quotes, it is not considered as comment. For example:
print("#this is not a comment")
**Output:*
#this is not a comment

Python Variables with examples
Variables are used to store data, they take memory space based on the type of value we assigning to them. Creating variables in Python is simple, you just have write the variable name on the left side of = and the value on the right side, as shown below. You do not have to explicitly mention the type of the variable, python infer the type based on the value we are assigning.

    *number = 100      #number is of type int
str = "Mukumbuta"      #str is of type string*

Identifiers in Python
There are some basic rules that one have to follow when naming variables (also known as Identifiers) in Python.

The name of the variable must always start with either a letter or an underscore (_). For example: _str, str, num, _num are all valid name for the variables.
The name of the variable cannot start with a number. For example: 9num is not a valid variable name.
The name of the variable cannot have special characters such as %, $, # etc, they can only have alphanumeric characters and underscore (A to Z, a to z, 0-9 or _ ).
Variable name is case sensitive in Python. this means number is different from NUM.

Python Variable Example
num = 100
str = "The Ultimate Guide"
print(num)
print(str)
Output:
100
The ultimate Guide

We can also assign multiple variables in a single statement in Python like so:
x = y = z = 99
print(x)
print(y)
print(z)
Output:
99
99
99

Concatination in python
*x = 10
y = 20
print(x + y)

p = "Hello"
q = "World"
print(p + " " + q)*

Output:
30
Hellow World

NOTE: If you attempt to use the + operator with variable x and p, the program will throw and error on your face that gose somethinglike:
unsupported operand type(s) for +: 'int' and 'str'

Data Types
A data type defines the type of data, for example 100 is an integer data while “Hello” is a String type of data. The data types in Python are divided in two categories:

Immutable data types – Values cannot be changed.
Mutable data types – Values can be changedImmutable data types in Python are:
1. Strings
2. Tuple
3. Numbers Mutable data types in Python are:
4. Dictionaries
5. Lists
6. Sets

Python Keywords and Identifiers with examples
In this article, we will discuss Keywords and Identifiers in Python with the help of examples.
A python keyword is a reserved word which you can’t use as a name of your variable, class, function etc. These keywords have a special meaning and they are used for special purposes in Python programming language. For example – Python keyword “while” is used for while loop thus you can’t name a variable with the name “while” else it may cause compilation error.
To get the list of keywords on your system, open command prompt (terminal on Mac OS) and type trhe following:

    *$ Python 3.6
...
>>> help()
Welcome to Python 3.6's help utility!
...
help> keywords*

Output:
*Here is a list of the Python keywords. Enter any keyword to get more help.

False def if raise
None del import return
True elif in try
and else is while
as except lambda with
assert finally nonlocal yield
break for not

class from or

continue global pass*

Example of Python keyword
In the following example we are using while keyword to create a loop for displaying the values of variables num as long as they are greater than 5.
num = 10
while num>5:
print(num)
num -= 1
Output:
10
9
8
7
6

Numeric Data Type in Python
Integers
In Python 3, there is no upper bound on the integer number which means we can have the value as large as our system memory allows.
# Integer number
num = 100
print(num)
print("Data Type of variable num is", type(num))
Output:

Long Data Type
Long data type is deprecated in Python 3 because there is no need for it, since the integer has no upper limit, there is no point in having a data type that allows larger upper limit than integers.
Float Data type
Values with decimal points are the float values, there is no need to specify the data type in Python. It is automatically inferred based on the value we are assigning to a variable. For example here fnum is a float data type.
# float number
fnum = 34.45
print(fnum)
print("Data Type of variable fnum is", type(fnum))
Output:
34.45
Data Type of variable fnum is, float

Complex Numbers
Numbers with real and imaginary parts are known as complex numbers. Unlike other programming language such as Java, Python is able to identify these complex numbers with the values. In the following example when we print the type of the variable cnum, it prints as complex number.

complex number

cnum = 3 + 4j
print(cnum)
print("Data Type of variable cnum is", type(cnum))

Output:

Python Data Type – String
String is a sequence of characters in Python. The data type of String in Python is called “str”.
Strings in Python are either enclosed with single quotes or double quotes.
_# Python program to print strings and type

   f_word = "First String"
   s_word = 'Second String'
   # displaying string s and its type
   print(f_word)
   print(type(f_word))

   # displaying string s_word and its type
   print(s_word)
   print(type(s_word))_

Output:

Python Data Type – Tuple
Tuple is immutable data type in Python which means it cannot be changed. It is an ordered collection of elements enclosed in round brackets and separated by commas.
_# tuple of integers
f_tuple = (1, 2, 3, 4, 5)
#prints entire tuple
print(f_tuple)
#tuple of strings
t2 = ("hi", "hello", "bye")
#loop through tuple elements
for s in t2:
print (s)

 #tuple of mixed type elements
 t3 = (2, "Lucy", 45, "Steve")
 '''
 Print a specific element
 indexes start with zero
 '''
 print(t3[2])_

Output:

Python Data Type – List
List is similar to tuple, it is also an ordered collection of elements, however list is a mutable data type which means it can be changed unlike tuple which is an immutable data type.
A list is enclosed with square brackets and elements are separated by commas.
_# list of integers
f_list = [1, 2, 3, 4, 5]
#prints entire list
print(f_list)

 #list of strings
 s_list = ["Apple", "Orange", "Banana"]
 # loop through list elements
 for x in s_list:
     print (x)

 # List of mixed type elements
 c_list = [20, "Mukumbuta", 15, "The Ultimate Guide"]
 '''
 Print a specific element in list
 indexes start with zero
 '''
 print("Element at index 3 is:",c_list[3])_

Output:

Python Data Type – Dictionary
Dictionary is a collection of key and value pairs. A dictionary doesn’t allow duplicate keys but the values can be duplicate. It is an ordered, indexed and mutable collection of elements.
The keys in a dictionary doesn’t necessarily to be a single data type, as you can see in the following example that we have 1 integer key and two string keys.
_# Dictionary example

 dict = {1:"Mukumbuta","lastname":"Singh", "age":31}

 # prints the value where key value is 1
 print(dict[1])
 # prints the value where key value is "lastname"
 print(dict["lastname"])
 # prints the value where key value is "age"
 print(dict["age"])_

Output:

Python Data Type – Set
A set is an unordered and unindexed collection of items. This means when we print the elements of a set they will appear in the random order and we cannot access the elements of set based on indexes because it is unindexed.
Elements of set are separated by commas and enclosed in curly braces.
*# Set Example
myset = {"hi", 2, "bye", "Hello World"}

 # loop through set
 for a in myset:
     print(a)

 # checking whether 2 exists in myset
 print(2 in myset)

 # adding new element
 myset.add(99)
 print(myset)_

Output:

Python conditionals
The If statement
If statements are control flow statements which helps us to run a particular code only when a certain condition is satisfied. For example, you want to print a message on the screen only when a condition is true then you can use if statement to accomplish this in programming. In this section, we will learn about the IF statement.
There are other control flow statements available in Python such as *if..else, if..elif..else,
nested if_ etc. However in this guide, we will only cover the if statements, other control statements are covered in separate tutorials.
Syntax of If statement in Python
The syntax of if statement in Python is pretty simple.
if condition:
block_of_code

Python – If statement Example
flag = True
if flag==True:
print("Welcome")
print("To")
print("TheUltimateGuide.com")
Output:
Welcome
To
TheUltimateGuide.com
In the above example we are checking the value of flag variable and if the value is True then we are executing few print statements. The important point to note here is that even if we do not compare the value of flag with the ‘True’ and simply put ‘flag’ in place of condition, the code would run just fine so the better way to write the above code would be:
flag = True
if flag:
print("Welcome")
print("To")

Now we understand better how if statement works. The output of the condition would either be true or false. If the outcome of condition is true then the statements inside body of ‘if’ executes, however if the outcome of condition is false then the statements inside ‘if’ are skipped. Lets take another example to understand this:
flag = False
if flag:
print("You Guys")
print("are")
print("Awesome")
The output of this code is none, it does not print anything because the outcome of condition is ‘false’.
Python if example without boolean variables
In the above examples, we have used the boolean variables in place of conditions. However we can use any variables in our conditions. For example:
num = 100
if num < 200:
print("num is less than 200")
Output:**
_num is less than 200

Python If else Statement Example
In this guide, we will learn another control statement ‘if..else’.
We use if statements when we need to execute a certain block of Python code when a particular condition is true. If..else statements are like extension of ‘if’ statements, with the help of if..else we can execute certain statements if condition is true and a different set of statements if condition is false. For example, you want to print ‘even number’ if the number is even and ‘odd number’ if the number is not even, we can accomplish this with the help of if..else statement.

Syntax
if condition:
block_of_code_1print("TheUltimateGuide.com)
else:
block_of_code_2
block_of_code_1: This would execute if the given condition is true
block_of_code_2: This would execute if the given condition is false

If-else example in Python
num = 22
if num % 2 == 0:
print("Even Number")
else:
print("Odd Number")
Output:
Even Number

Syntax of if elif else statement in Python
This way we are checking multiple conditions.
if condition:
block_of_code_1
elif condition_2:
block_of_code_2
elif condition_3:
block_of_code_3
...
...
else:
block_of_code_n

Example
In this example, we are checking multiple conditions using if..elif..else statement.
num = 1122
if 9 < num < 99:
print("Two digit number")
elif 99 < num < 999:
print("Three digit number")
elif 999 < num < 9999:
print("Four digit number")
else:
print("number is <= 9 or >= 9999")
Output:

Python Nested If else statement
In this part of the tutorial, we will learn the nesting of the control statements we covered above.
When there an if statement (or if..else or if..elif..else) is present inside another if statement (or if..else or if..elif..else) then we call this nested control statements.
Nested if..else statement example
Here we have a if statement inside another if..else statement block. Nesting control statements makes us to check multiple conditions:
num = -99
if num > 0:
print("Positive Number")
else:
print("Negative Number")
#nested if
if -99<=num:
print("Two digit Negative Number")
Output:
Negative Number
Two digit Negative Number

Python for Loop explained with examples
A loop is a used for iterating over a set of statements repeatedly. In Python we have three types of loops for, while and do-while. In this guide, we will learn for loop and the other two loops are covered in the separate tutorials.
Syntax of For loop in Python
for in :

# body_of_loop that has set of statements
# which requires repeated execution
Here is a variable that is used for iterating over a . On every iteration it takes the next value from until the end of sequence is reached.
Lets take few examples of for loop to understand the usage.
Python – For loop example
The following example shows the use of for loop to iterate over a list of numbers. In the body of for loop we are calculating the square of each number present in list and displaying the same.

Program to print squares of all numbers present in a list

List of integer numbers

 _numbers = [1, 2, 4, 6, 11, 20]_

variable to store the square of each num temporary

 _sq = 0_

iterating over the given list

 _for val in numbers:_

calculating square of each number

_sq = val * val_

displaying the squares

_print(sq)_

Output:
1
4
16
36
121
400

Function range()
In the above example, we have iterated over a list using for loop. However we can also use a range() function in for loop to iterate over numbers defined by range().
range(n): generates a set of whole numbers starting from 0 to (n-1).
For example: range(8) is equivalent to [0, 1, 2, 3, 4, 5, 6, 7]
range(start, stop): generates a set of whole numbers starting from start to stop-1.
For example: range(5, 9) is equivalent to [5, 6, 7, 8]
range(start, stop, step_size): The default step_size is 1 which is why when we didn’t specify the step_size, the numbers generated are having difference of 1. However by specifying step_size we can generate numbers having the difference of step_size.
For example: range(1, 10, 2) is equivalent to [1, 3, 5, 7, 9]
Lets use the range() function in for loop:

Python for loop example using range() function
Here we are using range() function to calculate and display the sum of first 5 natural numbers.

Program to print the sum of first 5 natural numbers

variable to store the sum

 _sum = 0

iterating over natural numbers using range()

  for val in range(1, 6):

calculating sum

       sum = sum + val

displaying sum of first 5 natural numbers

       print(sum)_

Output:
15

For loop with else block
In Python we can have an optional ‘else’ block associated with the loop. The ‘else’ block executes only when the loop has completed all the iterations. Lets take an example:
for val in range(5):
print(val)
else:
print("The loop has completed execution")
Output:
0
1
2
3
4
The loop has completed execution
Note: The else block only executes when the loop is finished.

Nested For loop in Python
When a for loop is present inside another for loop then it is called a nested for loop. Lets take an example of nested for loop.
for num1 in range(3):
for num2 in range(10, 14):
print(num1, ",", num2)
Output:
0 , 10
0 , 11
0 , 12
...
Python While Loop
While loop is used to iterate over a block of code repeatedly until a given condition returns false. The main difference between a for loop and a while loop is that we use while loop when we are not certain of the number of times the loop requires execution, on the other hand when we exactly know how many times we need to run the loop, we use for loop.

Syntax of while loop
while condition:
#body_of_while
The body_of_while is set of Python statements which requires repeated execution. These set of statements execute repeatedly until the given condition returns false.

Flow of while loop

First the given condition is checked, if the condition returns false, the loop is terminated and the control jumps to the next statement in the program after the loop.
If the condition returns true, the set of statements inside loop are executed and then the control jumps to the beginning of the loop for next iteration. These two steps happen repeatedly as long as the condition specified in while loop remains true.

Python – While loop example
Here is an example of while loop. In this example, we have a variable num and we are displaying the value of num in a loop, the loop has a increment operation where we are increasing the value of num. This is very important step, the while loop must have a increment or decrement operation, else the loop will run indefinitely, we will cover this later in infinite while loop.
num = 1
# loop will repeat itself as long as
# num < 10 remains true
while num < 10:
print(num)
#incrementing the value of num
num = num + 3
Output:
1
4
7

Python – while loop with else block
We can have a ‘else’ block associated with while loop. The ‘else’ block is optional. It executes only after the loop finished execution.
num = 10
while num > 6:
print(num)
num = num-1
else:
print("loop is finished")_
Output:
10
9
8
7
loop is finished

Python Functions
In this guide, we will learn about functions in Python. A function is a block of code that contains one or more Python statements and used for performing a specific task.
Why use function in Python?
Like we've already established, a function is a block of code that performs a specific task. Lets discuss what we can achieve in Python by using functions in our code:

Code re-usability: Lets say we are writing an application in Python where we need to perform a specific task in several places of our code, assume that we need to write 10 lines of code to do that specific task. It would be better to write those 10 lines of code in a function and just call the function wherever needed, because writing those 10 lines every time you perform that task is tedious, it would make your code lengthy, less-readable and increase the chances of human errors.
Improves Readability: By using functions for frequent tasks you make your code structured and readable. It would be easier for anyone to look at the code and be able to understand the flow and purpose of the code.
Avoid redundancy: When you no longer repeat the same lines of code throughout the code and use functions in places of those, you actually avoiding the redundancy that you may have created by not using functions.

Syntax of functions in Python
Function declaration:
def function_name(function_parameters):
function_body # Set of Python statements
return # optional return statement

Calling the function:

when function doesn't return anything

function_name(parameters)
OR

when function returns something

variable is to store the returned value

variable = function_name(parameters)

Python Function example
Here we have a function add() that adds two numbers passed to it as parameters. Later after function declaration we are calling the function twice in our program to perform the addition.
_def add(num1, num2):
return num1 + num2

   sum1 = add(100, 200)
   sum2 = add(8, 9)
   print(sum1)
   print(sum2)_

Output:
300
17

Default arguments in Function
Now that we know how to declare and call a function, lets see how can we use the default arguments. By using default arguments we can avoid the errors that may arise while calling a function without passing all the parameters. Lets take an example to understand this:
In this example we have provided the default argument for the second parameter, this default argument would be used when we do not provide the second parameter while calling this function.
*# default argument for second parameter
def add(num1, num2=1):
return num1 + num2

sum1 = add(100, 200)
sum2 = add(8) # used default argument for second param
sum3 = add(100) # used default argument for second param
print(sum1)
print(sum2)
print(sum3)*
Output:
300
9
101

Types of functions
There are two types of functions in Python:

Built-in functions: These functions are predefined in Python and we need not to declare these functions before calling them. We can freely invoke them as and when needed.
User defined functions: The functions which we create in our code are user-defined functions. The add() function that we have created in above examples is a user-defined function.

Python Numbers
In this guide, we will see how to work with numbers in Python. Python supports integers, floats and complex numbers.
An integer is a number without decimal point for example 5, 6, 10 etc.
A float is a number with decimal point for example 6.7, 6.0, 10.99 etc.
A complex number has a real and imaginary part for example 7+8j, 8+11j etc.
Example: Numbers in Python

Python program to display numbers of

different data types

       *# int
       num1 = 10
       num2 = 100
       print(num1+num2)

       # float
       a = 10.5
       b = 8.9
       print(a-b)

       # complex numbers
       x = 3 + 4j
       y = 9 + 8j8
       print(y-x)*

Output:
110
1.5999999999999996
(6+4j)

Python List with examples
In this guide, we will discuss lists in Python. A list is a data type that allows you to store various types data in it. List is a compound data type which means you can have different-2 data types under a list, for example we can have integer, float and string items in a same list.

Create a List in Python
Lets see how to create a list in Python. To create a list all you have to do is to place the items inside a square bracket [] separated by comma,.
#list of floats
num_list = [11.22, 9.9, 78.34, 12.0]
# list of int, float and strings
mix_list = [1.13, 2, 5, "TheUltimateGuide", 100, "hi"]
# an empty list
nodata_list = []
As we have seen above, a list can have data items of same type or different types. This is the reason list comes under compound data type.

Syntax to access the list items:
list_name[index]
Example:
*# a list of numbers
numbers = [11, 22, 33, 100, 200, 300]

    # prints 11
    print(numbers[0])

    # prints 300
    print(numbers[5])

    # prints 22
    print(numbers[1])*

Output:
11
300
22

Python Strings
A string is usually a bit of text (sequence of characters). In Python we use ” (double quotes) or ‘ (single quotes) to represent a string. In this guide we will see how to create, access, use and manipulate strings in Python programming language.

How to create a String in Python
There are several ways to create strings in Python.

We can use ‘ (single quotes), see the string str in the following code.
We can use ” (double quotes), see the string str2 in the source code below.
Triple double quotes “”” and triple single quotes ”’ are used for creating multi-line strings in Python. See the strings str3 and str4 in the following example.

lets see the ways to create strings in Python
```
str = 'TheUltimateGuide'
print(str)

str2 = "Mukumbuta"
print(str2)
```

multi-line string

    str3 = """Welcome to 
              TheUltimateGuide.com
           """
    print(str3)

    str4 = '''This is a tech 
              blog
           '''
    print(str4)*

Output:
*TheUltimateGuide

      Mukumbuta

      Welcome to 
      TheUltimateGuide.com

      This is a tech 
      blog*

How to access strings in Python
A string is nothing but an array of characters so we can use the indexes to access the characters of a it. Just like arrays, the indexes start from 0 to the length-1.
You will get IndexError if you try to access the character which is not in the range. For example,
if a string is of length 6 and you try to access the 8th char of it then you will get this error.
You will get TypeError if you do not use integers as indexes, for example if you use a float as an index then you will get this error.
*str = "Timothy"

displaying whole string

print(str)

displaying first character of string

print(str[0])

displaying third character of string

print(str[2])

displaying the last character of the string

print(str[-1])*

Python String Operations
Lets see the operations that can be performed on the strings.

Concatenation of strings in Python
The + operator is used for string concatenation in Python. Lets take an example to understand this:
*str1 = "One"
str2 = "Two"
str3 = "Three"

    # Concatenation of three strings
    print(str1 + str2 + str3)*

Output:
OneTwoThree

Python Membership Operators in Strings
in: This checks whether a string is present in another string or not. It returns true if the entire string is found else it returns false.
not in: It works just opposite to what “in” operator does. It returns true if the string is not found in the specified string else it returns false.
*str = "Welcome to TheUltimateGuide.com"
str2 = "Welcome"
str3 = "Mukumbuta"
str4 = "XYZ"

        # str2 is in str? True
        print(str2 in str)

        # str3 is in str? False
        print(str3 in str)*

        # str4 not in str? True
        print(str4 not in str)*

Output:
True
False
True

Python Tuple with example
In Python, a tuple is similar to Lists except that the objects in tuple are immutable which means we cannot change the elements of a tuple once assigned. On the other hand, we can change the elements of a list.

How to create a tuple in Python
To create a tuple in Python, place all the elements in a () parenthesis, separated by commas. A tuple can have heterogeneous data items, a tuple can have string and list as data items as well.

Example – Creating tuple
In this example, we are creating few tuples. We can have tuple of same type of data items as well as mixed type of data items. This example also shows nested tuple (tuples as data items in another tuple).
*# tuple of strings
my_data = ("hi", "hello", "bye")
print(my_data)

    # tuple of int, float, string
    my_data2 = (1, 2.8, "Hello World")
    print(my_data2)

    # tuple of string and list
    my_data3 = ("Book", [1, 2, 3])
    print(my_data3)

    # tuples inside another tuple
    # nested tuple
    my_data4 = ((2, 3, 4), (1, 2, "hi"))
    print(my_data4)*

Output:
('hi', 'hello', 'bye')
(1, 2.8, 'Hello World')
('Book', [1, 2, 3])
((2, 3, 4), (1, 2, 'hi'))
Empty tuple:
# empty tuple
my_data = ()

Tuple with only single element:
Note: When a tuple has only one element, we must put a comma after the element, otherwise Python will not treat it as a tuple.

a tuple with single data item

my_data = (99,)
If we do not put comma after 99 in the above example then python will treat my_data as an int variable rather than a tuple.

How to access tuple elements
We use indexes to access the elements of a tuple. Lets take few example to understand the working.

Accessing tuple elements using positive indexes
We can also have negative indexes in tuple, we have discussed that in the next section. Indexes starts with 0 that is why we use 0 to access the first element of tuple, 1 to access second element and so on.
*# tuple of strings
my_data = ("hi", "hello", "bye")

    # displaying all elements
    print(my_data)

    # accessing first element
    # prints "hi"
    print(my_data[0])

    # accessing third element
    # prints "bye"
    print(my_data[2])*

Output:
('hi', 'hello', 'bye')
hi
bye
Note:

TypeError: If you do not use integer indexes in the tuple. For example my_data[2.0] will raise this error. The index must always be an integer.
IndexError: Index out of range. This error occurs when we mention the index which is not in the range. For example, if a tuple has 5 elements and we try to access the 7th element then this error would occurr.

Python Dictionary with examples
Dictionary is a mutable data type in Python. A python dictionary is a collection of key and value pairs separated by a colon (:), enclosed in curly braces {}.

Python Dictionary
Here we have a dictionary. Left side of the colon(:) is the key and right side of the : is the value.
mydict = {'StuName': 'Peter', 'StuAge': 30, 'StuCity': 'Agra'}

Accessing dictionary values using keys in Python
To access a value we can can use the corresponding key in the square brackets as shown in the following example. Dictionary name followed by square brackets and in the brackets we specify the key for which we want the value.
mydict = {'StuName': 'Ajeet', 'StuAge': 30, 'StuCity': 'Agra'}
print("Student Age is:", mydict['StuAge'])
print("Student City is:", mydict['StuCity'])
Output:

Loop through a dictionary
We can loop through a dictionary as shown in the following example. Here we are using for loop.
mydict = {'StuName': 'Steve', 'StuAge': 4, 'StuCity': 'Agra'}
for e in mydict:
print("Key:",e,"Value:",mydict[e])

Output:

Python OOPs Concepts
Python is an object-oriented programming language. What this means is we can solve a problem in Python by creating objects in our programs. In this guide, we will discuss OOPs terms such as class, objects, methods etc. along with the Object oriented programming features such as inheritance, polymorphism, abstraction, encapsulation.

Objects in Python
An object is an entity that has attributes and behaviour. For example, Ram is an object who has attributes such as height, weight, color etc. and has certain behaviours such as walking, talking, eating etc.

Classes in Python
A class is a blueprint for the objects. For example, Ram, Shyam, Steve, Rick are all objects so we can define a template (blueprint) class Human for these objects. The class can define the common attributes and behaviours of all the objects.
Methods
As we discussed above, an object has attributes and behaviours. These behaviours are called methods in programming.

Example of Class and Objects
In this example, we have two objects; Ram and Steve that belong to the class Human
Object attributes: name, height, weight
Object behaviour: eating()

Code:
*class Human:
# instance attributes
def init(self, name, height, weight):
self.name = name
self.height = height
self.weight = weight
# instance methods (behaviours)
def eating(self, food):
return "{} is eating {}".format(self.name, food)

creating objects of class Human

ram = Human("Ram", 6, 60)
steve = Human("Steve", 5.9, 56)

accessing object information

print("Height of {} is {}".format(ram.name, ram.height))
print("Weight of {} is {}".format(ram.name, ram.weight))
print(ram.eating("Pizza"))
print("Weight of {} is {}".format(steve.name, steve.height))
print("Weight of {} is {}".format(steve.name, steve.weight))
print(steve.eating("Big Kahuna Burger"))*

Output:
Height of Ram is 6
Weight of Ram is 60
Ram is eating Pizza
Weight of Steve is 5.9
Weight of Steve is 56
Steve is eating Big Kahuna Burger

How to create Class and Objects in Python
In this tutorial, we will see how to create classes and objects in Python.

Class definition in Python
A class is defined using the keyword class.
Example
In this example, we are creating an empty class DemoClass. This class has no attributes and methods.
The string that we mention in the triple quotes is a docstring which is an optional string that briefly explains the purpose of the class.
*class DemoClass:
"""This is my docstring, this explains brief about the class"""

this prints the docstring of the class

print(DemoClass.doc)*

Output:
This is my docstring, this explains brief about the class

Creating Objects of class
In this example, we have a class MyNewClass that has an attribute num and a function hello(). We are creating an object obj of the class and accessing the attribute value of object and calling the method hello() using the object.
*class MyNewClass:
"""This class demonstrates the creation of objects"""

# instance attribute

num = 100

  
  
  instance method


def hello(self):

    print("Hello World!")

creating object of MyNewClass

obj = MyNewClass()

prints attribute value

print(obj.num)

calling method hello()

obj.hello()

prints docstring

print(MyNewClass.doc)*

Output:
100
Hello World!
This class demonstrates the creation of objects

Python Constructors – default and parameterized
A constructor is a special kind of method which is used for initializing the instance variables during object creation. In this guide, we will see what is a constructor, types of it and how to use them in the python programming with examples.

Constructors in Python
Constructor is used for initializing the instance members when we create the object of a class.
For example: We have an instance variable num which we are initializing in the constructor. The constructor is being invoked when we create the object of the class (obj in the following example).
*class DemoClass:
# constructor
def init(self):
# initializing instance variable
self.num=100

# a method

def read_number(self):

    print(self.num)

creating object of the class. This invokes constructor

obj = DemoClass()

calling the instance method using the object obj

obj.read_number()*

Output:
100

Syntax of constructor declaration
As we have seen in the above example that a constructor always has a name init and the name init is prefixed and suffixed with a double underscore(). We declare a constructor using def keyword, just like methods.
_def __init(self):
# body of the constructor_

Types of constructors in Python
We have two types of constructors in Python.
1. Default constructor – this is the one, which we have seen in the above example. This constructor doesn’t accept any arguments
2. Parameterized constructor – constructor with parameters is known as parameterized constructor.

Python – default constructor example
Note: An object cannot be created if we don’t have a constructor in our program. This is why when we do not declare a constructor in our program, python does it for us. Lets have a look at the example below.

Example: When we do not declare a constructor
In this example, we do not have a constructor but still we are able to create an object for the class. This is because there is a default constructor implicitly injected by python during program compilation, this is an empty default constructor that looks like this:
*def init(self):
# no body, does nothing.

Code:
class DemoClass:
num = 101

# a method

def read_number(self):

    print(self.num)

creating object of the class

obj = DemoClass()

calling the instance method using the object obj

obj.read_number()*

Output:
101

Declaring a constructor example
In this case, python does not create a constructor in our program.
*class DemoClass:
num = 101

# non-parameterized constructor

def init(self):

    self.num = 999

  
  
  a method


def read_number(self):

    print(self.num)

creating object of the class

obj = DemoClass()

calling the instance method using the object obj

obj.read_number()*
Output:
999

Python – Parameterized constructor example
When we declare a constructor in such a way that it accepts the arguments during object creation then such type of constructors are known as Parameterized constructors. As you can see that with such type of constructors we can pass the values (data) during object creation, which is used by the constructor to initialize the instance members of that object.
*class DemoClass:
num = 101

# parameterized constructor

def init(self, data):

    self.num = data

  
  
  a method


def read_number(self):

    print(self.num)

creating object of the class

this will invoke parameterized constructor

obj = DemoClass(55)

calling the instance method using the object obj

obj.read_number()

creating another object of the class

obj2 = DemoClass(66)

calling the instance method using the object obj

obj2.read_number()*
Output:
55
66
With that, we've covered most of the basics to get us started programming in Python. What now...?! Simple.
Learn... Practice... Repeat...
OK, that looks like an infinite loop.

Introduction to Scikit-Learn

Mukumbuta — Wed, 06 Apr 2022 22:31:30 +0000

In this article, we will be discussing Scikit learn. Scikit is an open-source Python library which provides a range of supervised and unsupervised machine learning algorithms. Besides this, Scikit also contains very powerful packages which include:
 NumPy
 Matplotlib
 SciPy
The above packages must be installed (using the Terminal) and imported in order to implement Scikit learn. In the same way, we need to import Scikit. Scikit is built upon SciPy (Science Python) which, also, must be installed.
To install SciPy, type the command below in the Terminal:
Pip install scipy
Scikit-learn comes from sample datasets, such as iris and digits. To use the afore mentioned, we need to import SVM (Support Vector Machine). SVM is a form of machine learning which is used to analyze data.
We can take digits dataset and it will categorize the numbers for us. Let’s consider the code below:

_import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import svm

digits= datasets.load_digits()
print(digits.data)_

The Output of the above code will be:
[[ 0. 0. 5. ..., 0. 0. 0.]
[ 0. 0. 0. ..., 10. 0. 0.]
[ 0. 0. 0. ..., 16. 9. 0.]
...,
[ 0. 0. 1. ..., 6. 0. 0.]
[ 0. 0. 2. ..., 12. 0. 0.]
[ 0. 0. 10. ..., 12. 1. 0.]]

The imported libraries above gives us access to the features that can be used to classify digits sample. The same can be done with images. Let’s consider the following line of code:

_import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import svm

digits= datasets.load_digits()
print(digits.target)
print(digits.images[0])_

OUTPUT:
[0 1 2 ..., 8 9 8] // target of the data
[[ 0. 0. 5. 13. 9. 1. 0. 0.] // image of the data
[ 0. 0. 13. 15. 10. 15. 5. 0.]
[ 0. 3. 15. 2. 0. 11. 8. 0.]
[ 0. 4. 12. 0. 0. 8. 8. 0.]
[ 0. 5. 8. 0. 0. 9. 8. 0.]
[ 0. 4. 11. 0. 1. 12. 7. 0.]
[ 0. 2. 14. 5. 10. 12. 0. 0.]
[ 0. 0. 6. 13. 10. 0. 0. 0.]]

In the output above, both the digits and the image of the digits are printed.
digits.target give the ground truth for the digit dataset, i.e., the number corresponding to each digit image. It should be mentioned that data is always a 2D array which has a shape (n_sample, n_features) even though the original data may have had a different shape. In the case of digits, each original sample is an image of shape (8, 8) which can be accessed using digits.image.
A look at learning and predicting
Using the above work where we have used a dataset sample of 10 possible classes (digits from 0 - 9), we will need to predict the digits when the image is given. To achieve this, we need an estimator which helps to predict the classes to which unseen samples belong. An estimator is a Python object that implements classification using the methods:
fit(x,y) and predict(T). Let’s consider the following example:

import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import svm
digits= datasets.load_digits() // dataset
clf = svm.SVC(gamma=0.001, C=100)
print(len(digits.data))
x,y=digits.data[:-1],digits.target[:-1] // train the data
clf.fit(x,y)
print('Prediction:', clf.predict(digits.data[-1])) //predict data
plt.imshow(digits.images[-1],cmap=plt.cm.gray_r,
interpolation="nearest")
plt.show()

OUTPUT:
_1796
Prediction: [8]

Image Here…_

In the above example, we had first found the length and loaded 1796 examples. Next, we have used this data as a learning data, where we need to test the last element and first negative element. Also, we need to check whether the machine has predicted the right data or not. For that, we had used Matplotlib where we had displayed the image of digits.
In a nutshell, we have digits data, we got the target, we fit and predict it and that’s all.
Now, we can go ahead and visualize the target labels with an image as in the code below:

_import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn import svm

digits= datasets.load_digits()
//Join the images and target labels in a list
images_and_labels = list(zip(digits.images, digits.target))

//for every element in the list
for index, (image, label) in enumerate(images_and_labels[:8]):
//initialize a subplot of 2X4 at the i+1-th position
plt.subplot(2, 4, index + 1)
//Display images in all subplots
plt.imshow(image, cmap=plt.cm.gray_r,interpolation='nearest')
//Add a title to each subplot
plt.title('Training: ' + str(label))
//Show the plot
plt.show()
_
OUPUT:

Images here…

As can be seen in the code above, we have used the ‘zip’ function to join the images and target labels in a list and then save it into a variable, images_and_labels.
Then we have indexed the first eight elements in a grid of 2 by 4 at each position and displayed the images with the help of Matplotlib and added the title as ‘training’.

Technical Guide To Getting Started in Data Science

Mukumbuta — Mon, 04 Apr 2022 01:09:20 +0000

In this guide, “The Ultimate Guide to Getting Started in Data Science”, we will explain more about How to get started in Data Science.
What does a Data Scientist do?
Data science is the study of how to use advanced analytics and scientific principles to get valuable information from data for business decision-making, strategic planning, and other purposes, such as making better business decisions.
To begin with, Data Scientists need data. It could be finance, healthcare, sports, government, industry, research, entertainment, or software engineering – everyone is producing more and more valuable data. Data is so valuable to businesses because it tells them what people want or need. Besides, it tells exactly who likes their product, when they’re buying it, how they’re buying it, how often they’re buying it.
A data scientist’s job is to turn simple, raw, and unprocessed data into an information gold mine. Essentially, data scientists take an ugly big pile of messy data and turn it into a polished conclusion that everyone can understand. Then they give recommended actions to take based on their conclusions.
Below is step-by-step guide on how to get started in data science.
STEP 1: Learn a Programming Language
First things first, if you want to becoming a data scientist, you must learn a programming language. To help you with choosing a programming language among so many, here are a few, but useful tips.
SUPPORTIVE: You want to make sure there’s a big community for it, which you can turn to for advice, like on stack exchange.
POPULAR: You want lots of pre-written code (libraries) that you can integrate into your own code, like on github. This way, for example, you don’t have to understand how to create a graph from scratch, you can just select the graph you want and feed in your data.
EASY: You also want a language that’s easy to write in, so you don’t make little mistakes that then result in bugs you may spend hours trying to find. This means it’s very easy for you and others to review what you’ve done.
FAST: You want to be able to write programs fast. You want to spend your time analyzing the data not writing code. The faster the programming language lets you create prototypes the better.
POWERFUL: You want to have the option to do long and complex tasks that still run fast and that can be easily integrated into other platforms.
Considering these qualities, the most common programming languages used by data scientists are Python and R. Some other viable ones are JavaScript, C++, Matlab, and SAS. Of course, if you feel more comfortable using another language by all means, do so, at the end of the day whatever you’re fastest in and most comfortable with is what’s best for you!
So now that you have the skills to make your computer crunch data, visualization will set you up to do great analysis and creating comprehensive reports.
Step 2: Make Graphics Your New Best Friends
Visualizations serve two purposes for a data scientist:
 They let you analyze data more easily They make it much easier to communicate what you’ve done with others
 Visualizations play a very important role during your analysis because they let you literally see how your data behaves.
The more you do this, the better you’ll get at being able to differentiate true information (signal) against ones that are just produced through chance (noise).
So, as a data scientist, you’ll be creating the visualizations both to help guide your analysis as well as to visualize results. Once you’ve completed your analysis, if you have to create a report or presentation, you can then pick out the ones that actually say something valuable.
So how can you practice creating and reading these types of graphs? Matplotlib as an amazing library for Python is the answer and a must know for every aspiring data scientist. So I’d highly recommend learning to use that to start making visualizations.
Step 3: Learn How to Analyze Data
A good thing to learn alongside of creating and reading the above types of graphs is how to analyze data. The only way to properly analyze data is to be able to filter, group, drop, aggregate, or manipulate it in other ways. Otherwise, you won’t be able to correctly control and contextualize your analysis, or have the ability to zoom in when answering very specific questions.
Fortunately, Python also has an amazing library for data analysis, called Pandas, that you can just freely download and then use in Python. You can probably start to see why I like Python so much.
As a data scientist you’re going to need data. That data is usually stored in a database. Therefore, you’ll need to learn how to interact with a database.
The most common database type you’ll encounter is an SQL-based database. There are very many different databases that are based on SQL, such as PostgreSQL, Big Query, or MySQL.
SQL databases are also very nice to use because it will speed things up a lot when you start processing, formatting, or even doing part of your analysis in your query, rather than taking out the data and doing all of it afterwards.
Did you follow the steps above? Boom!! You ‘re a Data Scientist.

Connecting Python to PostgreSQL Database

Mukumbuta — Fri, 01 Apr 2022 13:41:44 +0000

Hi. In this article, I'm going to explian how to connect a Python app to PostgreSQL database.
I should be quick to mention that before you can access PostgreSQL databases using Python, you must install one (or more) of the following packages in a virtual environment:
psycopg2: This package contains the psycopg2 module.
PyGreSQL: This package contains the pgdb module.
Both of these packages support Python's portable SQL database API. This means that if you switch from one module to another, you can reuse almost all of your existing code (the code sample below demonstrates how to do this).

Setting up the Python virtual environment and installing a PostgreSQL package

To set up the Python virtual environment and install a PostgreSQL package, follow these steps:
Log in to your account using SSH

To create a virtual environment, type the following command:
virtualenv connectDB

To activate the virtual environment, type the following command:
source connectDB/bin/activate

The command prompt now starts (connectDB) to indicate that all the operations are now in the Python virtual environment.
We will then update pip before we use to install psycopg2.

To update pip, enter the following command:
pip install -U pip

To install psycopg2 package, enter the following command:
pip install psycopg2

To install pygresql package, type the following command:
pip install pygresql

Having installed PostgreSQL packages in the virtual environment, we are ready to work with actual databases. Let's now demonstrate how to connect to a database with the following sample Python code and switch between the different SQL package implementations using the portable SQL database API.

#!/usr/bin/python 
from __future__ import print_function 
hostname = 'localhost' 
username = 'username' 
password = 'password' 
database = 'dbname'

def doQuery(conn): 
  cur = conn.cursor() 
  cur.execute( "SELECT fname, lname FROM employee" ) 
  for firstname, lastname 
     in cur.fetchall() : 
       print( firstname, 
         lastname ) 
               print( "Using psycopg2:" )

import psycopg2 
myConnection = psycopg2.connect( host=hostname, user=username, password=password, dbname=database ) 
doQuery( myConnection ) 
myConnection.close()
print( "Using PyGreSQL (pgdb):" )


import pgdb 
myConnection = pgdb.connect( host=hostname, user=username, password=password, database=database ) 
doQuery( myConnection ) 
myConnection.close()

This example creates a series of Connection objects that opens the same database using different PostgreSQL modules. Because both of these modules use the portable SQL database API interface, they are able to use the code in the doQuery() function without any modifications.
When you have a Connection object associated with a database, you can create a Cursor object. The Cursor object enables you to run the execute() method, which in turn enables you to run raw SQL statements (in this case, a SELECT query on a table named employee).
This example creates a Connection object that opens the PostgreSQL database using the specified parameters. Once you have a Connection object associated with the database, you can query the database directly using raw SQL statements (in this case, a SELECT query on a table named employee). The getresult() method reads the result data returned by the query. Finally, the close() method closes the connection to the database.
It is clear, from the above code sample, that Python's portable SQL database API makes it easy to switch between PostgreSQL modules in your code. We only twerk with import and connect to use a different module.
I really hope this was helpful

Solving Concurrency With PostgreSQL

Mukumbuta — Thu, 31 Mar 2022 12:34:54 +0000

Databases are an organized way for enterprises to store and use their data. Since most of the data used in an organizational structure are related or interlinked, relational database solutions have been an accepted form of data management for a long time.
A Relational Database Management System (RDBMS) is a system that allows an organization to manage and administer its relational database.
One of the problems that Relational Database Management Systems are solving is concurrency. Usually a developer wants the application to be able to serve multiple users at the same time without going offline for either maintenance or for reconciliation of daily transactional activities in the support system.
Users want to have access to their records and analytical system and see up-to-date records, as to what just happened an instant ago. In the dawn of online and contact-less payment systems and what not, users want to be able to see the bank activities as they happen. In response to this scenario, developers have to give users this experience and let them have everything at their finger tips by providing dashboards that show data that updates in real real-time by sending confirmation text messages immediate the user makes a payment.
The issue will then be how can a developer build such a system that knows how to implement such features? This is where PostgreSQL comes in.
PostgreSQL is the world's most advanced open source relational database, and as a Relational Database Management System (RDBMS), PostgreSQL can handle concurrency and diverse workloads. PostgreSQL can be used to implement transactional system of records and at the same time deliver data analytics.
To be able to achieve the implementation of these activities on top of the same technology, the manager or developer needs a way to express simple transactions and complex analytics aswel. Here is where the developer needs a Structured Query Language (SQL). The Transaction Control Language part of SQL allows the developer to implement concurrency in the application.
With SQL, the developer can easily implement the CRUD operations. CRUD stands for Create, Read, Update, and Delete.
With SQL, a single statement can take care of a number of rows at the same. This is because SQL is excellent at batching operations. The CRUD operations of the application covers the system of records aspect of the activities and other adminstrative use-cases like creating users, groups, and data organization.
It must be mentioned, though, that some activities are had to implement with SQL. But with Postgres, we access to several extensions that gives us the power to process data right from the database.In distributed systems, the computation can be sent whether data is already, or send the data to the computation nodes.
The beauty of Postgres is that it gives the developer power to choose either to retrieve the data and then process it in the application nodes or choose to process the data right where it is, in the database.
In conclusion, in order to effect concurrency in your application, that is versatile in terms of architecture (CRUD, System of Records, Analyticand Dashboards), and that is powerful in terms of computation, Postgres is the answer. So, if you're not sure with what transactional system to use, and when scaling your application to impossible volumes, try Postgres.

DEV Community: Mukumbuta

DevOps - NGINX Configuration

Introduction

Approach & Steps Taken

Step 0: Setting Up a Domain Name

Step 1: Setting Up an Ubuntu Server

Step 2: Installing NGINX

Step 3: Configuring NGINX to Serve a Custom Web Page

Step 4: Configuring Firewall for Public Access

Challenges & How I Overcame Them

1. NGINX Not Running After Installation

2. Firewall Blocking HTTP Requests

3. HTML Page Not Updating

What I Learned from This Experience

How This Task Contributes to My Professional Growth

Conclusion

What’s Next for You?

References

How to Use Git-flow in Your Workflow

How to make development branch the base branch

How to create a feature branch

Release branch

Mastering Python For Web Development.

The Ultimate Python Tutorial For Beginners

complex number

Program to print squares of all numbers present in a list

List of integer numbers

variable to store the square of each num temporary

iterating over the given list

calculating square of each number

displaying the squares

Program to print the sum of first 5 natural numbers

variable to store the sum

iterating over natural numbers using range()

calculating sum

displaying sum of first 5 natural numbers

when function doesn't return anything

when function returns something

variable is to store the returned value

Python program to display numbers of

different data types

lets see the ways to create strings in Python

multi-line string

displaying whole string

displaying first character of string

displaying third character of string

displaying the last character of the string

a tuple with single data item

creating objects of class Human

accessing object information

this prints the docstring of the class

instance method

creating object of MyNewClass

prints attribute value

calling method hello()

prints docstring

creating object of the class. This invokes constructor

calling the instance method using the object obj

creating object of the class

calling the instance method using the object obj

a method

creating object of the class

calling the instance method using the object obj

a method

creating object of the class

this will invoke parameterized constructor

calling the instance method using the object obj

creating another object of the class

calling the instance method using the object obj

Introduction to Scikit-Learn

Technical Guide To Getting Started in Data Science

Connecting Python to PostgreSQL Database

Solving Concurrency With PostgreSQL