DEV Community: Naftal Rainer

Tracking My Progress With The Data Science Marathon (Week 2).

Naftal Rainer — Tue, 05 Apr 2022 23:47:00 +0000

Welcome to week 2 - a continuation of my progress series.
The previous week was quite a marathon and from that my guess is that this coming week will be more challenging but I'm still prepared because Once you begin, there's no quitting.

Monday

This is Day 6 of the data science marathon.
I did an introduction to scikit-learn with main focus on ensemble algorithms.
One thing that I always find fascinating is that every time I take a beginner approach towards learning, I always encounter totally new concepts. Today I learnt about the simplicity of the Scikit-learn API design where I looked at the basic interfaces, the submodules of Scikit-learn i.e

Datasets : sklearn.datasets
Preprocessing : sklearn.preprocessing
Impute : sklearn.impute
Feature Selection : sklearn.feature_selection
Linear Models : sklearn.linear_model
Ensemble Methods : sklearn.ensemble
Clustering : sklearn.cluster
Matrix Decomposition : sklearn.decomposition
Manifold Learning : sklearn.manifold
Metrics : sklearn.metrics
Pipeline : sklearn.pipeline
Model Selection : sklearn.model_selection

Ensemble learning on the other hand is the process by which multiple models, such as classifiers or experts, are strategically generated and combined to solve a particular computational intelligence problem

Tuesday

For day 7, my focus was on XGBoost Algorithm which is an ensemble learning technique to build a strong classifier from several weak classifiers in series.
XGBoost stands for “Extreme Gradient Boosting” and it is an optimized distributed gradient boosting library designed to be highly efficient, flexible, and portable to implement Machine Learning algorithms under the Gradient Boosting framework. It provides a parallel tree boosting to solve many data science problems in a fast and accurate way.

Stay tuned for Wednesday and the rest of the week.

Hope you have a great and fruitful day! 👋 🌱

For any errors observed in this article, please mention them in the comments. 🧑🏻‍💻

The Ultimate Guide to Getting Started in Data Science.

Naftal Rainer — Sun, 03 Apr 2022 19:21:38 +0000

Data Science is an inter-disciplinary field whose true foundation lies in Mathematics, Computer Science and Business.
This makes it a broad discipline with a fast growing track in recent years.
>Image by towards data science.

The definition of data science has varied with the advancement in technology from company to company over time.

There is no definite path for getting started in Data Science because all it takes is the desire to pursue and the will to get started after which passion and commitment will drive you to success which is the end game for any learning activity.

>Big data era by promptcloud.com

In the current data era, zillions of data is generated and shared across different devices in different formats hence the need for data science which enables people to harness and get insights from these data with one main objective of decision making; data-based decision making which implies making decisions that are supported and backed up with data as evidence. (The opposite would be intuition-based decision making).

As a beginner in this field, one is always confused about what to learn or where to begin. This is a major setback especially to the self taught programmers(data scientist) who may end up wasting a lot of time or resources before getting to the right track and worst of all he/she may hit a dead end and give up which should not be the case when there's proper guidance and mentorship.
This article gives a basic road map to acquiring skills that are super relevant in the field of data science as listed below:

1.) Mathematics and statistics.

Mathematics is said to be the backbone of modern civilization and a remarkably efficient source of new concepts and tools to understand the “reality”.
Therefore mathematics is applicable to every dimension of our daily life. Some mathematical aspects come in handy when manipulating data. This is the stage where one needs to familiarize with the following:

Linear Algebra Concepts: such as vectors and matrices, linear combinations, linear dependence and independence, matrix transformations, inverse and transpose of a matrix.
Calculus Concepts: such as derivatives, integrations, differential equations, series e.t.c most of which can be computed using a programming language but it's good to know the math behind it.

In statistics, basic concepts such as descriptive statistics e.g. Mean, Median & Mode and distributions e.g. Normal, Poisson & Chi-square among others are necessary for data insight derivation. Having an understanding of variance and standard deviation also proves to be important for Confidence Interval Estimation and hypothesis testing. Probability probability concepts are necessary for determining chances and possibility variations.
Same as above, the statistical computations can be handled using a programming language but it's also good to know the math behind it as well as the interpretation of key factors and figures.

2.) Programming Skills.

These skills are applied on General purpose languages which are used more extensively for the purpose of implementing various algorithms. There are several programming languages for data science as well such as python, R, MATLAB, e.t.c
python is the most popular and is majorly used for statistical modelling)
Python for data science involves four different fields:

Data collection - here python facilitates the acquiring of data to be used in the data science projects and the libraries involved are selenium and scrapy.
Data analysis - in this python is used to clean and transform data to get some insights and the libraries used are NumPy and pandas.
Data Visualization - this creates visualization from our data such as bar plots and pie charts and the libraries used are matplotlib, seaborn
Model building – this is all about machine learning and application of some mathematical concepts and libraries such as sci-kit learn and Tensor Flow.

Databases.

Besides python, there are languages used to perform various operations on different databases.
There's the use of Structured Query Language (SQL) which requires familiarity with the core concepts of relational databases and queries which requires the knowledge of:

Data Definition Language (DDL) commands such as create, alter, drop, truncate and rename.
Data Manipulation Language (DML) commands such as select, insert, update and delete, DCL statements such as grant and revoke.
Transaction Control Language (TCL) commands such as commit and rollback. Also, we should know how to join tables.

There's also the Non-Relational Database also referred to as NoSQL which stores information in a dynamic, non-normalized and a more flexible manner. MongoDB, Redis, Aerospike and Couchbase are examples of non-relational databases.
Click here for the differences between Relational and Non-Relational Databases.

Data Visualization.

This is important in communicating findings to people and for Exploratory Data Analysis. The tools used include PowerBi, Tableau and python packages e.g. seaborn

Finally, there are a lot of resources and sites online that provides a basic and credible foundation for data science at a cost and some for free e.g. Datacamp, Simplilearn, IBM Data Science and youtube

For mentorship, Data Science East Africa has delivered appropriately.

conclusion.

Image by Scratch.mit.edu
Remember document every step you go through successfully i.e. write articles which helps with concept mastery and as you reach the peak of your journey, be a mentor you wish you had to someone else who's at the early stages.

I hope you found it encouraging. For any errors observed in this article, please mention them in the comments. 🧑🏻‍💻

Hope you have a happy coding time! 👋 🌱👨‍💻👩‍💻

Tracking My Progress With The Data Science Marathon (Week 1).

Naftal Rainer — Thu, 31 Mar 2022 21:19:13 +0000

This is going to be my new norm - articulating every experience I gain in tech to help me track my progress and map out my thought process.
I earlier on applied for a program entitled " The Data Science and Machine learning Marathon" offered by Data Science East Africa and Lux Tech Academy. Luckily, I was accepted and enrolled into the ten- day program which begun on 28th March 2022.
It's been a worthy marathon as we (The participants) have gotten to learn, unlearn and relearn which is the basic cycle of education. So far I've gotten to learn new ways, unlearn the myths and outdated facts then relearn the updates and that which I may have forgotten. The experience is amazing I tell you.
True to the title, it has been a herculean task trying to compress several months work into ten days with one thing in mind, diligence, because I was determined to do one thing - get it right.
So now I'm at day 4 and here's the breakdown of all the activities undertaken so far.

Monday

This was our first day and my excitement and energy was unmatched. We interacted via Slack, where I met my new pals from different countries and that meant something to me - diversity. (These fellows form very good accountability partners).
It was beginner friendly and didn't quite pose a challenge to me since I was past that stage but one thing was quite outstanding; despite being an introductory phase, I still came across something new in learning Git to be precise.
So Day 1 was all about:

Introduction to Python, Mastering Python basics.
Notebooks and anaconda interaction.
Version Control Systems, Git, GitHub, BitBucket, GitLab etc.

Tuesday

Day 2 was all about databases. I dived deep into SQL which has always been my preference for a long time and more interestingly got introduced to Postgres and MongoDb which broadened my view of databases and was accompanied by this piece How To Choose An Efficient Storage For Data.

Wednesday

Day 3 was all about the data science basic packages i.e Pandas, NumPy, Matplotlib and Seaborn.
These are the frequently used packages when manipulating data.

NumPy - is a python library used to perform mathematical operations on arrays and matrices.
Pandas - is a python library mainly used for data analysis and associated manipulation of tabular data in Dataframes. Pandas allows importing data from various file formats such as comma-separated values, JSON, Parquet, SQL database tables or queries, and Microsoft Excel. For more information visit LOADING DATA FOR PROCESSING IN PYTHON...
Matlotlib - is a comprehensive python library for creating static, animated, and interactive visualizations in Python.
Seaborn - Is built on top of matplotlib and integrates closely with pandas data structures to make statistical graphics in Python. Seaborn aids in exploration and understanding of the data at hand.

Thursday

For Day 4, I handle something entirely new to me and that is the pyforest package.
The pyforest package is an open-source module that helps users to automatically import the packages required for Data Science analysis jobs and building Machine Learning algorithms. For this reason, it's said to be helpful to a lazy programmer. (At this point I am that lazy programmer because I really liked it 😁😁.

I also learned how to connect Python to MySQL and access my database using python scripts. This is so cool.
Below is a sample script for the process.

import mysql.connector

mydb = mysql.connector.connect(
    host="localhost",
    user="root",
    password="*******",
    database="boatsdb",
    port = 3306
)
print("Hey, i think i'm connected")
#Cursor
cur = mydb.cursor()
#Execute the query
cur.execute("SELECT ID,NAME FROM boats where name = %s", ("Nathan",))

rows = cur.fetchall()

for r in rows:
    print(f" ID ={r[0]} NAME = {r[1]} ")

#Close the cursor
cur.close()
#Close the connection
mydb.close()

Friday

Day 5 was all about documenting the work done. As you know one fine way of testing mastery is either through teaching or writing. So I chose the writing way and this was the result:
The Ultimate Guide to Getting Started in Data Science.

Almost coming to the end of the week and awaiting to tackle what the program has for me. My greatest appreciation goes to Mbaabu Harun Mwendwa who is the mastermind of this program and a hearty appreciations to my readers with whom I'm able to share my progress.

Hope you have a great and fruitful day! 👋 🌱

For any errors observed in this article, please mention them in the comments. 🧑🏻‍💻

How To Choose An Efficient Storage For Data.

Naftal Rainer — Tue, 29 Mar 2022 20:59:35 +0000

We are in a data-driven world where data is exchanged through users in the internet everyday via several interconnected devices and appliances which generate a lot of assorted data in real-time every second.
Every minute 1.7 MB of data is created for every person on the planet as indicated by the IBM Research Editorial.
This is made possible by the emergence of IoT - a giant network of connected things and people – all of which collect and share data about the way they are used and about the environment around them. That includes an extraordinary number of objects of all shapes and sizes.
Therefore there's need to harness, collect the large and ever-increasing volumes of data collected from our daily activities and store them for future and easy reference and access.

The choice of how and where to store that data is influenced by the factors indicated below.

i) The form of data collected
Data collected can either be structured, unstructured or semi-structured.

Structured Data - is quantitative data consisting of numbers and values which are highly organized.
Unstructured Data - is qualitative data, cannot be processed and analyzed via conventional data tools and methods since they lack a predefined data model and consists of sensors, text files, audio and video files, etc.
Semi-structured Data - is a combination of both structured and unstructured data which do not have a predefined data model and is more complex than structured data, yet easier to store than unstructured data(e.g., JSON, CSV, XML)
Semi-structured data uses “metadata” (e.g., tags and semantic markers) to identify specific data characteristics and scale data into records and preset fields.

ii) The kind of database collected

A database is an organized collection of structured information or data and can be categorized into:

Relational Database - A relational database organizes data into tables which can be linked to create defined relationships for easy data access. It is often referred to as SQL. Oracle, MySQL, PostgreSQL and SQLite are examples of relational databases.
Non-Relational Database - is qualitative data, cannot be processed and analyzed via conventional data tools and methods since they lack a predefined data model and consists of sensors, text files, audio and video files, etc. It is often referred to as NoSQL which stores info in a dynamic, non-normalized and a more flexible manner. MongoDB, Redis, Aerospike and Couchbase are examples of non-relational databases.

The comparison between SQL and NoSQL is displayed below:

How to choose

This choice is based on the kind of data expected and how it is stored.
For example: A lot of unstructured data, or aggregate information with nesting such as HTML or hierarchical data would best fit in a NoSQL database.
A relational database would require a lot of tables and joints which makes it expensive to pull out aggregates. SQL database is more efficient for a structured data since it easily handles redundancy therefore it's space efficient.

Conclusion
I hope you found it interesting. For any errors observed in this article, please mention them in the comments. 🧑🏻‍💻

Hope you have a great day! 👋 🌱

PYTHON DATA STRUCTURES..

Naftal Rainer — Thu, 14 Oct 2021 15:32:59 +0000

The most basic data type in python is the sequence. This involves storing data in a particular structure which is characterized by an index and values; where the index reference the position of the element/value in the structure.
The indices referencing start from 0 the structures permit some common operations such as indexing, slicing, adding, multiplying among others.
There are around six built in types of sequences but the most common are lists, dictionaries, tuples and sets.

Python Lists.

Lists are ordered sequence of comma – separated items within a square bracket. The square bracket indicates the beginning and the end of the specified list.

Creating a List.

A list is created when values enclosed in a square brackets are assigned to a variable as shown below:
List_1 = [ ] - This creates an empty list.
List_2 = [ 1, 2, 3, 4, 5, 6 ] - A list containing numbers.
List_3 = [ “a”, “b”, “c”, “d”, “e”, “f” ] -A list containing alphabets
The items contained within the list can be of different data types e.g. numbers, strings or even a list itself.
List_4 = [ “Monday”, “Wednesday”, 890, 325, [1998, 1999, 2002], “Sunday” ]

Accessing List Values.

To access an element(s) at a given position in a list, use the square bracket for slicing with the specific index to obtain the target value. Indexing out of the bounds of possible list values will result into a n IndexError.

List_2 = [ 1, 2, 3, 4, 5, 6 ]
List_3 = [ “a”, “b”, “c”, “d”, “e”, “f”  ]       
print ("List _1[0]: ", List _1[0]) 
print ("List _2[1:5]: ", List _2[1:5])

When the above code is executed, it results to :-

List_1[0] :  1
List_2[1:5] :  [“b”, “c”, “d”, “e”, “f”  ]

Update Lists.

To update a single or multiple values of a list, assign the slice on the left hand side of the assignment to the list to update at a specific index.

#Empty List
List_1 = [ ] 

#Add 3 to the beginning of the empty list .
List_1 [0]  = 3
print(List_1)

List_2 = [ 1, 2, 3, 4, 5, 6 ]
print ("Value at index 3 :" , List_2 [ 3])
List_2 [ 3] = "Mathematics"
print ("New value at index 3 :" , List_2 [ 3])

When the above code is executed, it results to :-

Value at at index 3 : 4
 New value at index 3 : Mathematics

Delete List Elements.

To delete/remove a list element, use either del statement if you know the actual element to delete or remove() method if you aren't exactly aware of the element to remove.

List_5 = [1, 3.14, “abc”, 5, 7, 8]
print(List before deleting value at index 2 : ", List_5)

del List_5[2]
print("List after deleting value at index 2 : ", List_5)

The above code will result into:-

List before deleting value at index 2 :  [1, 3.14, "abc", 5, 7, 8]

List after deleting value at index 2 :  [1, 3.14, 5, 7, 8]

Basic List Operations .

The list structure accepts basic multiplication, addition, subtraction and the resultant structure is a list as well.
Lists can be added and multiplied in the same way as strings. The output is a result of concatenation and repetition just like in strings.

List_2 = [ 1, 2, 3, 4, 5, 6 ]
Print(List_2 + [7,8,9])

Num = [9,8,7]
Print(num * 3)

Which produces the following output:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

[9,8,7,9,8,7,9,8,7]

To check whether a given element exists in a list, the in operator is used. It returns True if the item exists and False if it doesn’t.

Num = [9,8,7]
print(8 in Num)
print(3 in Num)

When the above code is executed, it results in:

True
False

We can also use the not operator to check if an item is not in a list.
Evaluate the code below to check the output.

Num = [9, 8, 7]
Print( not 4 in Num )
Print( 4 not in Num )
Print( not 8 in Num )
Print( 8 not in Num )

List Slicing.

List slicing is the truncation of the list at a given range specified by an index.
Lets use the following list to perform various slicing operations.

List_5 = [1, 3.14, "abc", 5, 7, 8]

# To print the entire list items
print(List_5[:])

# To print from a given index (say 2 )  to  the end.
print(List_5[2:])

# To print from a given index (say 2 )  to  another index (say 4).
print(List_5[2:4])

# To print from the beginning  to  the second last item.
print(List_5[ : -1])

# To print from the beginning  to  the third last item.
print(List_5[ : -1])

# To print from a given index (say 1)   to  the second last item.
print(List_5[ 1 : -1])

# To reverse the list
print(List_5[ : : -1])

The various outputs will be as outlined below

[1, 3.14, 'abc', 5, 7, 8]
['abc', 5, 7, 8]
['abc', 5]
[1, 3.14, 'abc', 5, 7]
[1, 3.14, 'abc', 5]
[3.14, 'abc', 5, 7]
[8, 7, 5, 'abc', 3.14, 1]

Python Dictionaries.

Dictionaries are key – value items enclosed within a curly braces. Each key is separated from its value by a colon (:). A pair of key and value forms a dictionary item. The items are separated by commas and enclosed in curly braces. The curly braces indicates the beginning and the end of the specified dictionary.
Dictionary keys are very unique and are used to reference the given values which may not be unique and can be of any data type. They are of immutable data types such as strings, numbers or tuples. Key duplication isn’t supported.
The dictionary values have no restrictions and can be any python object.

Dictionaries are generally unordered i.e. the order of items in a dictionary will not necessarily be the order in which we put them during creation. This is because python internally rearranges the elements in order to optimize performance.

Creating Dictionaries:

# Empty Dictionary
dict = { }

# Dictionary with data
dict = { ‘food’ : ‘Pilau’ , ‘drink’: ‘Soda’, ‘fruit’: ‘strawberry’}

Each entry consist of a pair of items separated by a colon. The first part is called the key i.e food, drink, fruit and the second part is the value i.e Pilau, Soda, Strawberry.

Accessing Values of a Dictionary.

To access a given dictionary value, use Square brackets along with the key to obtain its value.

dict = { ‘food’ : ‘Pilau’ , ‘drink’: ‘Soda’, ‘fruit’: ‘strawberry’}

print ("dict[‘food’]: " ,  dict[‘food’])
 print ("dict[‘fruit’]: " ,  dict[‘fruit’])

When the above code is executed, it produces the following result –

dict[‘food’]:  Pilau
 dict[‘fruit’]: strawberry

Accessing dictionary data using a key that is not part of the dictionary generates an error.

Modifying a Dictionary Value.

A dictionary can be modified by adding a new entry (key – value pair), changing an existing entry or deleting an existing entry as shown.

dict = { ‘food’ : ‘Pilau’ , ‘drink’: ‘Soda’, ‘fruit’: ‘strawberry’}

# To add new entry to the dictionary
dict['age'] = 28

#  To change `drink` from soda to water use:
dict['drink'] = water

When deleting an entry, you can either remove individual dictionary elements or clear the entire dictionary contents.
To delete a specific entry, use the del statement and specify the index of the element. When del statement is used on a dictionary without defining the key attribute then the entire dictionary is deleted. However, to only clear the dictionary contents and preserve the dictionary itself us the clear function. This clears every element and returns an empty dictionary.

dict = { ‘food’ : ‘Pilau’ , ‘drink’: ‘Soda’, ‘fruit’: ‘strawberry’}

# Remove entry with key ‘fruit
del dict[‘fruit’]

#  Remove all entries  in the dictionary
del dict

# Remove all entries of the dictionary.
dict.clear()

Copying Dictionaries.

Use the copy() method to copy a dictionary.

dict = { ‘food’ : ‘Pilau’ , ‘drink’: ‘Soda’, ‘fruit’: ‘strawberry’}

d = dict.copy()

The in operator.

The in operator checks if a given item is a key in the dictionary.
Referring to a key that is not in the dictionary produces an error and using the in operator to first check for the availability of the key prevents the error.

dict = { ‘food’ : ‘Pilau’ , ‘drink’: ‘Soda’, ‘fruit’: ‘strawberry’}

# Check if a given letter/word is a key in dict
letter = input( ‘Enter a letter / word’)
if letter in dict
    print(“The value is: ’ , dict[letter]
else:
    print(“Not in dictionary”)

Looping in dictionaries is similar to that of lists

for key in dict
    print(key)      # Keys
    print(dict[key])    # Values

Manipulating Lists of Keys and Values.

Using the dictionary d = {‘A’:1, ‘B’:2}

d = {‘A’:1, ‘B’:2}

# To generate a list from the dictionary keys
list(d)

# To generate a list from the dictionary values
list(d.values())

# # To generate a list from the dictionary keys – values pair
list(d.items())

When executed, it produces the following output.

['A', 'B']
[1, 2]
[('A', 1), ('B', 2)]

The pair returned by d.items() are called tuples.

The dict() function can also create a dictionary. It’s almost like the opposite of the items method above.

d  = dict([(‘z’,26), (‘x’,24)])
Print(d)

This will output the following dictionary:-

{'z': 26, 'x': 24}

Dictionary comprehensions.

This works similar to the list comprehensions.
For example, to create a dictionary from a list of words, where the values are the length of the words.

d = {s : len(s) for s in words}

Python Tuple.

A tuple is a sequence of immutable python objects that are enclosed within parenthesis and separated by comma.
Tuple is similar to list. Only difference is that list is enclosed between square bracket, tuple between parenthesis and List have mutable objects whereas Tuple have immutable objects.
Tuples are immutable, i.e. they cannot be updated and are considered read-only lists.

Why Use Tuple?

Processing of Tuples are faster than Lists.
It makes the data safe as Tuples are immutable and hence cannot be changed.
Tuples are used for String formatting.

Creating Tuples.

Tuples are created by:

use of brackets If Parenthesis/bracket is not given with a sequence, it is by default treated as Tuple.

b = (1,2,'T',7.9)
c="a",10,20.9 
print(b)
print(c)

Output:-

(1, 2, 'T', 7.9)
("a",10,20.9)

Tuples are immutable, therefore one can only create a new tuple from portions of an existing tuple.
But there can exist an empty Tuple also which contains no element.

tuple_1 = ()

For a single valued tuple, there must be a comma at the end of the value.

tuple_1=(103,)

Accessing Tuples

Tuples just like lists are accessed using index referencing.

tuple_1=(103,104,105,106)
tuple_2=('Marina', 'Naftal','Joanne','Alex')

print(tuple_1[0])
print(tuple_1[0:2])
print(tuple_2[-3:-1])
print(tuple_1[0:])
print(tuple_2[:2])

This will output:

103
(103, 104)
('Naftal', 'Joanne')
(103, 104, 105, 106)
('Marina', 'Naftal')

Deleting Tuple Elements

Tuples being immutable, it is impossible to remove individual elements from it.
To explicitly remove an entire tuple, use del statement.

tuple_2 = ('Marina', 'Naftal','Joanne','Alex')
del tuple_2

Tuple Operations Operations performed on a tuple can be given as:

Adding a tuple

Tuple elements can be added together using the concatenation operator (+) to join the two tuples.

tuple_1=(103,104,105,106)
tuple_2=('Marina', 'Naftal','Joanne','Alex')
tuple_3=tuple_1+tuple_2
print(tuple_3)

This results into:-

(103, 104, 105, 106, 'Marina', 'Naftal', 'Joanne', 'Alex')

Replicating a Tuple

This means repeating the tuple elements and can be done using '*' operator.

tuple_4=(10,20,30);
print(tuple_4*2)

This results into:-

(10, 20, 30, 10, 20, 30)

Python Sets.

A set is a data structure with the following properties

The elements are unordered.
The elements are unique. i.e. appear only once.
The elements are unindexed.

Sets can be of any data type and are used when:

The order of data doesn’t matter.
Unique elements are required.

Creating Sets.

Sets are created by

use of curly brackets, e.g.

a = {1,5,'s',1.5}
print(a)
print(b)

The following code produces the output:-

{1, 's', 5, 1.5}

Use of a constructor, e.g

f = set([2,3,4])
print(f)

Which produces the following output:-

{2, 3, 4}

Set Operations

Finding the length of a set

This is done using the len() function.

f = set([2,3,4])
print(len(f))

This will produce:

Accessing elements of a set.

Set elements can only be accessed using loops but not indices.

a = {1,5,'s',1.5}
for x in a:
    print(x)

Adding elements to a set.

The add() function allows the addition of a single element to a set.
The update() function allows the addition of more than one element to a set.

c = set()
c.add(8)
print(c)
c.update([1,5,'s',1.5])
print(c)

When executed it produces the following results:

{8}
{1, 1.5, 5, 8, 's'}

Removing elements from a set.

a) remove() function removes elements from the set specified as a parameter.
b) discard() function is used to remove an element when it's existence in the set is not assured.
c) pop() function is used to remove a random element from the set.

c = { 1, 1.5, 5, 8, 's'}
c.remove(1.5)
print(c)

The result is:-

{1, 5, 8, 's'}

Union of sets.

Se union is the concatenation of two or more sets into a single set.
To unite sets, we use the pipeline symbol (|) or we can apply the union method as shown below.

c = { 1, 1.5, 5, 8, 's'}
f = {10, 2, 3, 4}
d = {7,'i','p',45}
print(c|f)
print(c.union(d))
print(c|f|d)

Execution of the above code results to:-

{1, 1.5, 2, 3, 5, 4, 8, 10, 's'}
{1, 1.5, 5, 7, 8, 's', 45, 'i', 'p'}
{1, 1.5, 2, 3, 5, 4, 7, 8, 10, 's', 45, 'i', 'p'}

Intersection of sets.

Intersection applied on two or more sets is the formation of a new set consisting of only common elements present in the merged sets.
This is done using the ampersand symbol (&) or by using the intersection method as shown below.

c = { 1, 10, 5, 8, 's'}
f = {10, 2, 3, 4,5}
d = {7,'i','p','s'}

print(c&f)
print(c.intersection(d))

# Results into an empty set
print(c.intersection(d,f))

Output:-

{10, 5}
{'s'}
set()

Difference of sets.

Set difference applied on two or more sets produces a new set of elements that are present in only one of those sets. This is achieved using the '-' symbol or the difference() method.

c = { 1, 10, 5, 8, 's'}
f = {10, 2, 3, 4,5}
d = {7,'i','p','s'}

print(c-f)
print(f-c)
print(c.difference(d))
print(c.difference(d,f))

When the code above is run, it generates the following output:-

{8, 1, 's'}
{2, 3, 4}
{8, 1, 10, 5}
{1, 8}

Frozen sets.

A frozen set is a locked set whose values cannot be modified. i.e. one cannot add or remove values from a frozen set. It's immutable.
A frozen set is created using the frozenset() function.

a = {1,3,5,7,'y',89}
b = frozenset(a)
print(b)

This outputs:

frozenset({1, 'y', 3, 5, 7, 89})

An error is generated when one tries to add or remove an element from a frozen set.

b.add(8)

Output:-

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'

LOADING DATA FOR PROCESSING IN PYTHON...

Naftal Rainer — Sun, 10 Oct 2021 16:26:01 +0000

According to Wikipedia, Data mining is an important process of extracting and discovering patterns in large data sets involving methods at the intersection of machine learning, statistics, and database systems.
It is, therefore, necessary in any machine learning convention to get the acquired data into our system. The data might be a log file, dataset file, or database which may be obtained from different multiple sources.
In this article, we’ll look at the different methods of loading different formatted data from a variety of sources, including CSV files and SQL databases.
We’ll majorly focus on python pandas extensive library methods for loading external data as well as loading scikit – learn and seaborn’s inbuilt datasets.

Loading a sample dataset.

This involves loading data from preexisting datasets either in the scikit learn package or the seaborn package. The packages embeds some small toy datasets. The datasets are refered to as “toy” datasets because they are smaller and cleaner than the datasets we come across in the real world.

The sklearn.datasets comes with a few small standard datasets that do not require downloading any file from some external website.

Sample datasets from sklearn include:
load_boston() - Load and return the Boston house-prices dataset. It contains 503 observations on Boston housing prices and a good dataset for exploring regression algorithms.

load_iris() - Load and return the iris dataset.It contains 150 observations on the measurements of Iris flowers. It is a good data‐ set for exploring classification algorithms.

load_diabetes() - Load and return the diabetes dataset (regression).

load_digits([n_class]) - Load and return the digits dataset (classification). load_digits Contains 1,797 observations from images of handwritten digits. It is a good data‐ set for teaching image classification.

load_linnerud() - Load and return the linnerud dataset (multivariate regression).

# Load scikit-learn's datasets 
from sklearn import datasets

# Load digits dataset
digits = datasets.load_digits()

To load Iris dataset use:

from sklearn.datasets import load_iris
data = load_iris()
data.target[[10, 25, 50]]

Seaborn on the other hand comes with a few important datasets in the library. When Seaborn is installed, the datasets download automatically.Some of the datasets have a small amount of preprocessing applied to define a proper ordering for categorical variables.

To see a list of available datasets use get_dataset_names().

# Import the seaborn module
import seaborn as sns
sns.get_dataset_names()

The above line of code will generate the following output −

['anagrams', 'anscombe', 'attention', 'brain_networks', 'car_crashes', 
'diamonds', 'dots', 'exercise', 
'flights', 'fmri', 'gammas', 'geyser', 'iris', 
'mpg', 'penguins', 'planets', 'tips', 'titanic']

Seaborn contains relational (table-format) datasets.
With the help of the load_dataset() function you can load the required dataset.

import pandas as pd
import seaborn as sns
df = sns.load_dataset('tips')
print df.head()

The above line of code will generate the following output −

   total_bill  tip   sex    smoker day  time   size
0    16.99    1.01   Female  No    Sun  Dinner  2
1    10.34    1.66   Male    No    Sun  Dinner  3
2    21.01    3.50   Male    No    Sun  Dinner  3
3    23.68    3.31   Male    No    Sun  Dinner  2
4    24.59    3.61   Female  No    Sun  Dinner  4

Loading a File Using the Pandas Library.

Pandas is a diverse data analysis library that offers various functions for reading files of different formats into our script for data manipulation.
The various reader functions include:

read_csv
read_excel
read_hdf
read_sql
read_json
read_html
read_stata
read_clipboard
read_pickle
read_msgpack
read_gbq

CSV and Textual Files
CSV (comma-separated values) is data that is generally reported in tabular form and has values in a row separated by a comma.
Text files also contains tabular data separated by spaces or tabs and stored in a file with a .txt extension.
types (generally with the extension .txt).
For this,pandas provides a set of functions specific for this to load a local or hosted CSV.

read_csv
read_table

CSV files may use other characters as separators, like tabs. Panda's sep = ' ' parameter allows us to define the delimiter used in the file.

# Load library
import pandas as pd

# Create URL
url = 'https://tinyurl.com/titanic-csv'

# Load dataset
dataframe = pd.read_csv(url)

# View first two rows
dataframe.head(2)

The above line of code will generate the following output −

    PassengerId Pclass  Name    Sex Age SibSp   Parch   Ticket  Fare    Cabin   Embarked
0   892 3   Kelly, Mr. James    male    34.5    0   0   330911  7.8292  NaN Q
1   893 3   Wilkes, Mrs. James (Ellen Needs)    female  47.0    1   0   363272  7.0000  NaN S
2   894 2   Myles, Mr. Thomas Francis   male    62.0    0   0   240276  9.6875  NaN Q
3   895 3   Wirz, Mr. Albert    male    27.0    0   0   315154  8.6625  NaN S
4   896 3   Hirvonen, Mrs. Alexander (Helga E Lindqvist)    female  22.0    1   1   3101298 12.2875 NaN S

N/B : For a locally stored csv file, the url is the referenced location of the file in your working directory. For example if the csv file (named sample_1) is located in 'c:\users\rainer\desktop' location, then the url to be used will be:

# Create url
url = 'c:\\users\\rainer\\desktop\\sample_1.csv'

# Load dataset
dataframe = pd.read_csv(url)

CSV files are tabulated data in
which the values on the same column are separated by commas. But since CSV files are considered text files,
you can also use the read_table() function while specifying the delimiter.

# Create url
url = 'c:\\users\\rainer\\desktop\\sample_1.csv'

# Load dataset
dataframe = pd.read_table(url, sep = ',')

Example

Create a small csv file in your working directory and save it as sample_1.csv

sample_1.csv

item, white,blue,red,yellow
ruler,1,3,5,2
cup,2,5,9,2
pen,6,1,4,0
book,4,1,2,1

# Load dataset
dataframe = pd.read_csv('sample_1.csv')
print(dataframe)

This will generate:

  item   white  blue  red  yellow
0  ruler       1     3    5       2
1    cup       2     5    9       2
2    pen       6     1    4       0
3   book       4     1    2       1

Loading Data from Microsoft Excel Files
The excel spreadsheet contains data in tabular form. Pandas provides the read_excel() function to load data of this format (.xls and .xlsx).
This can be achieved through pd.read_excel('data.xls') which returns the DataFrame composed of the data tabulated in the spreadsheets. However, if you need to load the data in a spreadsheet, then specify the name of the specific sheet or the number of the sheet (index) just as the second argument as shown
pd.read_excel('data.xls','Sheet2') or pd.read_excel('data.xls',1)
To do it practically, open an Excel file and enter the data shown in the figure below:

Sheet1

Sheet2

After entering the data into a spreadsheet, save and load onto jupyter notebook or preferred python manipulation tool using:

import pandas as pd

# Load file into Data variable
Data = pd.read_excel("Book1.xlsx","Sheet1")

# Print 
Print(Data.head())

The output generated is

NAME     AGE BEST COLOR  BOOK NO.  PAGE
0     Edwin   5yrs      Green         7  2404
1  Muuo Ian   6yrs     Purple         8  2405
2      Joel   5yrs     Orange         9  2406
3      Mush   5yrs      Red          10  2407
4  Nyandeng  10yrs      Green        11  2408

To view other sheets available, just specify the sheet number.

import pandas as pd

# Load file into Data variable
Data = pd.read_excel("Book1.xlsx","Sheet2")

# Print 
Print(Data.head())

The output generated is

NAME    AGE BEST COLOR BOOK NO.  PAGE
0       Fred  10yrs     Yellow       25  2410
1     Bianca  13yrs       Blue       26  2412
2     Martin   6yrs      Green       27  2413
3  Genevieve   3yrs     Violet       28  2414
4      Karen  12yrs     Yellow       29  2415

CSV and Excel files are the most common data file formats used though there are so many formats available. Stay put for the next article which will cover the loading of data in the JSON format and from a database using Pandas Library.

Untill then, goodbye 👋👋👋. Happy Coding Week Ahead!!!

Python List Comprehensions

Naftal Rainer — Wed, 11 Aug 2021 16:53:57 +0000

Hello readers, welcome to python article which involves handling python list comprehensions.
A list is a python data type that contains mutable elements enclosed within square brackets.
The elements contained may be of different data types or even other lists.

L = [123,'abc',[99,100],1.38]
Print(L[2][1])

Why are list comprehensions preferred?

List comprehensions can be used for mapping and filtering hence eliminating the need to use a different approach for each scenario.
They can be used to rewrite loops and map() calls.

Built-in List Functions

len – Returns the number of items in the list.
sum - Returns the sum of items in the list.
min - Returns the minimum of items in the list.
max - Returns the maximum of items in the list.
append – appends a passed object into an existing list.
Count - Returns the number of times an object/item appears in a list.
extends - appends the sequence contents to the list.

For example

Average = sum(L)/len(L)

Creating Lists

Apart from the explicit declaration of lists just like in the first example above, we can input a list using the keyboard or accept it as a piped input from another program.

List_1 = eval(input(‘Enter a list’))
Print(‘The first element is : ‘, L[0])

We can as well obtain lists through conversion of other data types as shown below;

Tuples

tuple_a =('abc',456,3.14,'mary')
list(tuple_a)

Output

['abc', 456, 3.14, 'mary']

Sets

set_a = {1,'efg',9.8}
list(set_a)

Output

[1, 'efg', 9.8]

Dictionaries
For a dictionary we can get the key, value and items separately

# Create the dictionary d
d = {'A':404, 'B':911}

# Generates the keys of d
list(d)

# Generate values
list(d.values())

# Generate items – key – value pairs
list(d.items())

Output

['A', 'B']
[404, 911]
[('A', 404), ('B', 911)]

Comprehensions
Using list comprehensions is a faster and a very powerful way to create lists with predefined conditions.
Declaration is done using square brackets but in this case, instead of assigning intrinsic values, a condition is given to produce a matching output just like the set builder notation in mathematics.

syntax

newlist = [expression for item in iterable if condition == True]

The condition only accepts the items that valuate to True.
The condition is however optional and can be omitted.
A few examples are as shown;

L = [i for i in range(5)]
Print(L)

Output

[0,1,2,3,4]

To print a number of a certain type e.g ten zeros

[0 for i in range(10)]

Output

[0,0,0,0,0,0,0,0,0,0]

To print squares of numbers within a specified range

[i**2 for i in range(1,8)]

Output

[1,4,9,16,25,36,49]

To multiply elements of a list by a constant.

L = [2,4,9,4,61] 
[i*10 for i in L]

Output

 [20, 40, 90, 40, 610]

Duplicating string characters

string = 'Hello World' 
 [c*2 for c in string]

Output

['HH', 'ee', 'll', 'll', 'oo', '  ', 'WW', 'oo', 'rr', 'll', 'dd']

w = ['one', 'two', 'three', 'four', 'five', 'six']
[m[0] for m in w]

Output

['n', 'w', 'h', 'o', 'i', 'i']

You can also use control structures within a list comprehension to save time and efficiency of program as shown;

L = [2,4,9,4,61]
[i for i in L if i>5]

Output

[9, 61]

w = ['one', 'two', 'three', 'four', 'five', 'six']
[m[1] for m in w if len(m)==3]

Output

['n', 'w', 'i']

To conclude:
List comprehensions can accomplish complex tasks without using an overly complicated code and the good part is that you can do all that in one line.

Encrypting And Decrypting PDF Files Using Python...

Naftal Rainer — Mon, 02 Aug 2021 13:30:55 +0000

Portable Document Format (PDF) is one of the most widely used file formats by online accessories.
Most of the documents e.g. eBooks, scanned documents e.t.c uses this pdf format for storage and sharing purposes.

For the purpose of sharing in various platforms and media, a document is exposed to so many threats such as information leakage and access by unauthorized individuals. It is therefore necessary for one to encrypt his/her documents to prevent such avoidable occurrences and exposure.

Python being a resourceful programming language offers a very awesome module known as PyPDF2 to encrypt and decrypt pdf files hence hence enhancing security of contained information.

The PyPDF2 library is capable of:

Extracting document information e.g. title, page number e.t.c
Splitting and merging documents.
Cropping Pages.
Encryption and decryption.

PyPDF2 is not an in-built library therefore it needs to be installed before use by:

pip3 install PyPDF2

The files used in the code implementations below are found here
Encrypting a PDF file
File encryption entails addition of a password to a document thereby allowing access to only authorized people.

To do this, we'll follow the following steps:
Step 1: Open the pdf using the reader object.
Step 2: Create a copy of the original file by iterating through
every page and adding it to the new pdf file.
Step 3: Encrypt the new pdf file.

The Code Implementation

# Import the required module and sub-modules
from PyPDF2 import PdfFileWriter
from PyPDF2 import PdfFileReader

# Create a PdfFileWriter object
result = PdfFileWriter()

# Open the pdf file to encrypt
file = PdfFileReader('Magazine.pdf')

# Retrieve the number of pages to iterate in the original document
length = file.numPages

# Iterates through every page and adds it to the new file (a copy of the original)
for i in range(length):
    pages = file.getPage(i)
    result.addPage(pages)

# Creates a variable password.
password = 'pam&Lab890'

# Encrypt the file using the created password 
result.encrypt(password)

# Open a new file 'Magazines.pdf' and write the encrypted pdf file
with open('Magazines.pdf','wb') as f:
    result.write(f)

This creates a similar copy of the original file (may have a different name as specified) that requires a set password to enable access.

Decrypting a PDF file
Decryption unlocks a document with a given password and converts it to a pdf file that does not require a password key to access.

The file decryption steps are almost analogous to that of encryption.

Step 1: Open the pdf using the reader object.
Step 2: Encrypt the new pdf file.
Step 3: Create a copy of the original file by iterating through

every page and adding it to the new pdf file.

The Code Implementation

# Import the required module and sub-modules
from PyPDF2 import PdfFileWriter
from PyPDF2 import PdfFileReader

# Create a PdfFileWriter object
result = PdfFileWriter()

# Open the password - secured pdf file to decrypt
file = PdfFileReader('Magazines.pdf')

# Creates a variable password.  
password = 'pam&Lab890'

# First, check if the file is encrypted then proceed if encrypted
if file.isEncrypted:

    # Decrypt the file using the givenpassword 
    file.decrypt(password)

     # Iterates through every page and adds it to the new file    
    for i in range(31):
        pages = file.getPage(i)
        result.addPage(pages)

    # Open a new file 'Magazines1.pdf' and write the encrypted 
        pdf file
    with open('Magazines1.pdf','wb') as f:
        result.write(f)

    print('File decrypted successfully')

else:

    print('File is not encrypted')

If you guys found this post helpful then save it so you can refer anytime 😊. For those who wanna learn more about PyPDF2 module and functionalities, just give a recommendation of the specific area (whether merging, splitting e.t.c) in the comment section below.
Happy Coding Week! 👨‍💻 👩‍💻

Introduction To Python Functions.

Naftal Rainer — Fri, 30 Jul 2021 11:51:25 +0000

Writing codes can be more exciting when you realize that there's a way in which you can well organize your codes and make them reusable. This can be made possible by functions.

Functions are building blocks in python. A function is a sequence of well-organized reusable statements (codes) that perform a specific task.
A function can be modified and called by other functions, assigned to a variable, passed as an argument, returned from a function.
A function may take input and perform logical operations/ series of tasks and may return a response when called.

Benefits of using a function.
1.) A large program can be divided into functions where each function performs a specific task.
(Modularization).
2.) Splitting programs into functions makes them easier to manage, maintain and debug.
3.) Functions improve the understandability and readability of a large program.
4.) Functions enable code reusability.

Types of a function
1.) Built-in functions
2.) User defined functions.

Defining a function
A function is defined in order to provide the required functionality using the def keyword . The definition consists of the function name, the function parameters, the function body and the return value.
The syntax is as follows:

def functionName( arguments):
    block of statements to be executed
    return value

The pass statement – can be used as a place holder in a function when a function is declared but the codes constituting its body isn’t stated. This creates a function that is syntactically correct but has no performs no action.

def service(studentName): 
       pass # Remember to implement this!

Parameters and arguments
A parameter is the variable defined within the parentheses during function definition while an argument the value passed to the function when it is called. The value may be a variable, and object or another function.

# Here x and y are the function parameters
   def add(x,y):
    return x+y

# Here 8 and 3 are arguments
  add(8,3)

Calling a function
A function may be called by stating its name and passing arguments to the parameter space in its parenthesis.

# Function definition is here 
def displayName (name): 
"This prints a passed string into this function" 
print (name) 
return 

#  To call the displayName function
displayName ("Marty") 
displayName ("Stephen")

The output is as follows

Marty
Stephen

Function Arguments.
You can call a function by using the following types of formal arguments-

Required arguments Required arguments are the arguments passed to a function in correct positional order. Here, the number of arguments in the function call should match exactly with the function definition.

def displayName (name): 

"This prints a passed string into this function" 
print (name) 
return 
#  To call the displayName function

displayName ()

When the above code is executed it produces an error since it lacks a positional argument

However, when given the required positional argument, it runs smoothly.

def displayName (name): 
    print (name) 
    return 

displayName('Annabelle')  # Gives an error

The output is:

Annabelle

Keyword arguments Keyword arguments are related to the function calls. When you use keyword arguments in a function call, the caller identifies the arguments by the parameter name. This allows you to skip arguments or place them out of order because the Python interpreter is able to use the keywords provided to match the values with parameters.

def roomArea(width, length):
    return length * width


# Now you can call roomArea function 
Print(roomArea(length = 50, width = 40))

Default arguments Creates a function that can be called with fewer arguments than it is defined to allow i.e the it assumes the default value if a value is not provided in the function call for that argument.

An example is as shown below:

# Function definition is here 
def displayInfo(city,address = 40400): 
    "This prints a passed info into this function" 
    print ("city: ", city) 
    print ("Address: ", address)
    return 

#  To call the displayName function

displayInfo('Nairobi', address = 1020) 
displayInfo('Paris' )

The output is as shown:

city:  Nairobi
Address:  1020

city:  Paris
Address:  40400

Variable-length arguments Sometimes one may need to pass a function of more arguments than specified in the definition. These arguments are called variable-length arguments and are unnamed in the function definition.

Syntax for a function with non-keyword variable arguments is given below

def functionname(formal_argument, *variable_tuple ): 
    "Code statements"  
    return [expression]

An asterisk (*) is placed before the variable name that holds the value of all the non keyword arguments.
For example:

def matchScores(roundNo, *score):
    print('Current Round: ', roundNo)

    for i in score:
        print('Score: ',i)           

    return

matchScores(5)
matchScores(9,20,40,30)

The output is:

Current Round:  5

Current Round:  9
Score:  20       
Score:  40       
Score:  30

Anonymous Function The def and return keywords are not used when declaring this type of function. Small functions may be implicitly created using lambda keyword. Lambda forms takes any no of arguments but only returns one type of value and cannot contain multiple expressions or commands. It requires an expression and parameters just like any other function. A lambda function may shorten the normal function to a single line expression as shown:

# To add two variable values

def add(x, y)
    return x + y

# Using lambda function

lambda x, y : x + y

# To double the value of a variable

def double(x):
    return x * 2

# Using lambda function

lambda x, y : 2 * x

lambda can also be used with conditional statements

minimum = lambda x, y : x if x < y else y

print(minimum(3,9))

This produces an output of 3 which is the smallest amongst the given parameters.

Away from function arguments, there are various amazing ways of applying functions to get a given task handled and have a minimized codes as well.

The Map Function
The map function applies a given function to each element of a sequence and returns a modified list.
It's syntax is:

map(function, input_list)

def square(list1):
    myList = []

    for i in list1:
        myList.append(i**2)
    return myList

print(square([2,3,4,5,6]))

This produces an output of:

[4, 9, 16, 25, 36]

The same output can be achieved by the following function:

myList = [2,3,4,5,6]

print(list(map(lambda x : x**2, myList)))

The Filter Function
From the name, it filters items out of a sequence in relation to the given conditions.

It's syntax is:

filter(function, input_list)

def myFunc(list1):
    myList = [x for x in list1 if x > 2]
    return myList

print(myFunc([0,2,5,3,7,9]))

The output is:

[5, 3, 7, 9]

On applying the filter function to obtain the same result:

myList = [0,2,5,3,7,9]

print( list( filter( lambda x: x > 2, myList)))

Functions support various support operations such as being passed as an argument, returned from a function, modified and assigned to a variable. This is a fundamental concept to understand before delving into creating python decorators (A decorators is a design pattern in python that allows a user to add new functionalities to an existing object without modifying it’s structure).

Being passed as an argument
A function can take in other functions as it’s arguments. This enables the argumented function to input data into the defined function.

def stringFunction():
    return "Hello World!"

def worldSplit(stringFunction):
    func = stringFunction()
    return func.split()

print(worldSplit(stringFunction))

Output

['Hello', 'World!']

The above function worldSplit(stringFunction): takes in stringFunction(): as an argument and returns a list composed of stringed words from the argument function.

Returned from a function
A function can as well return another function and the ultimate output will be code executed from the returned function as shown below.

def print_function():
    def helloWorld():
        return "Hello World"
    return helloWorld()
output = print_function()
print(output)

Output is

Hello World

From the above code we get to see that a function can also be assigned to a variable:
output = print_function()

That’s it for now. Stay tuned as we’ll get to learn about python decorators in my next article.
If you guys found this post helpful then save it so you can refer anytime 😊.
Happy Coding! 👨‍💻 👩‍💻

INTRODUCTION TO PYTHON

Naftal Rainer — Sat, 24 Jul 2021 13:35:48 +0000

Getting started in coding can be tough. Choosing which language to learn can as well be tough. Staying true and consistent to your language of choice can equally be tough. But despite all these tough conditions it's only passion that can drive us through.
In a world of over 500 programming languages, I find python the most interesting due it's simplicity and versatility. It's wide scope of applications is even more meritorious. In Python programming language, you will find that it can be easier than ever to learn about coding and to even read it like a professional.

Brief History
Python is an interpreted high-level general-purpose programming language developed in the late 1980s Guido van Rossum and released for public in 1991.
Its name was derived from the BBC TV show Monty Python's Flying Circus and has so far had release of various streams of versions from the early version 2.0, version 3.0 up to the latest version 3.9.6 and it can be downloaded from www.python.org Mac OS X systems as well as those with Ubuntu will already have Python preloaded. You will simply need to download a text interpreter to get started.
It is quite different from other programming languages in its syntax and semantics which focuses on code simplicity and readability. This is made possible by its well-defined English keywords and minimal punctuation dependence. For example, python uses whitespace indentation for delimiting code blocks instead of curly brackets and semicolons aren't required for statement termination unlike in c and c++ amongs others.
In general, python is kept much simpler and you may find it is easier to read through the lines and see what you are doing.
Python programs are written in files having a .py filename extension which is supported by various operating systems e.g. Windows, Linux/UNIX, macOS and more.

Desirable Python features are:

Python is really interactive. This makes it easier for testing the functionality of a program. This may be done by modularization - extracting out small bits of code and testing to see if they work. You can also bundle it with a development environment called IDLE.

Python has numerous libraries. This widens a programmer’s scope enabling him/her to work with other programming tools required for different fields such as web development, data science, machine learning e.t.c. to enable different functionalities e.g. connecting with web servers.

Python is platform independent. Python programs can be run on any unit including Unix, Linux, Windows, and Mac OS X.
Python is extensible. It is easy to extend into other modules like C or C++ and write snippets to perform various functions.

Python is open Source. The product is free to download, use, make modifications and redistribute. It is under an open source license so others are able to use it

Easy to debug. Errors can be caught quickly since data types are dynamically typed, when you mix types together that don’t match, it will raise an exception for you to notice. You can group the codes into packages and modules if needed.

Applications of python

Python has various uses across applications, platforms, and services as discussed below.

Web and Internet Development

Web development is one of the areas where python shines as it offers numerous Frameworks such as Django and Pyramid,Micro-frameworks such as Flask and Bottle and Advanced content management systems such as Plone and django CMS. These frameworks which enhances functionality and implementation have been used to power some of the world’s most popular sites such as Spotify, Mozilla, Reddit, the Washington Post and Yelp.

Python's standard library supports many Internet protocols:

HTML and XML 2.JSON
E-mail processing.
Support for FTP, IMAP, and other Internet protocols.
Easy-to-use socket interface.

Artificial Intelligence

Python contains some of the top libraries for machine learning and artificial intelligence which a whole new approach to problem-solving.
Python for machine learning development can run on any platform including Windows, MacOS, Linux, Unix, and many others. this saves time and money for tests on various platforms and makes the overall process more simple and convenient.

Automation

Python has range of libraries, tools, and frameworks available to bolster your programming efforts in task automation e.g. selenium , smtplib library, beautiful soup etc. which automation efforts simpler and more intuitive.

IoT

Python is scalable, expandable, portable, and embeddable. This makes Python system-independent and allows it to accommodate multiple single board computers, irrespective of the operating system or architecture.

Game Development.
Scientific and Numeric Applications.
Software Development.
Data science.

Python is capable of handling almost any development requirement

Getting Started with Python

After understanding some of the benefits of python, it's time to get started with it. In order to learn some of the great steps that are needed to create a python program, we need to set up the environment

Installing Python:

The installation procedure involves downloading the official Python .exe installer and running it on your system
https://www.python.org/downloads/. For windows users, Select a link to download either the Windows x86-64 executable installer or Windows x86 executable installer.

Add python to path variables:
Setting up the Python path to system variables alleviates the need for using full paths. It instructs Windows to look through all the PATH folders for “python” and find the install folder that contains the python.exe file.
When running the installer, select the Install launcher for all users and Add Python 3.7(or the version of your choice) to PATH checkboxes which places the interpreter in the execution path automatically.
If your version of the Python installer does not include the Add Python to PATH checkbox or if you have not selected that option, then you have to do it manually by following the steps bellow.

1.Go to control panel.

open the System Properties window.
Navigate to the Advanced tab and select Environment Variables.
Under System Variables, find and select the Path variable.
Click Edit.
Select the Variable value field. Add the path to the
python.exe file preceded with a semicolon
Click OK and close all windows.

By setting this up, you can execute Python scripts like this: Python script.py

Instead of this: C:/Python34/Python script.py

For more information check the site below
https://www.educative.io/edpresso/how-to-add-python-to-path-variable-in-windows

Verify if Python Was Installed On Windows
Navigate to the directory in which Python was installed on the system. For example if it is C:\Users\Username\AppData\Local\Programs\Python\Python3.7.
Double-click python.exe.
The output should be similar to what you can see below:

Install Text Editor:
A code editor is a tool that is used to write and edit code. They are usually lightweight and can be great for learning especially for a beginner.

1.) Visual Studio Code
Visual Studio Code (VS Code) is a free and open-source IDE created by Microsoft that can be used for Python development.
https://code.visualstudio.com/download

2.) Sublime Text
Sublime Text is a popular code editor that supports many languages including Python.
https://www.sublimetext.com/download

3.) Atom
Atom is a highly customizable open-source code editor developed by Github that can be used for Python development
https://atom.io/

4.) Thonny
Thonny is a simple UI Python dedicated IDE that comes with Python 3 built-in. Once you install it, you can start writing Python code
https://thonny.org/

5.) Pycharm
PyCharm is a Jetbrain-powered IDE for professional developers
https://www.jetbrains.com/pycharm/download/

Hello World

"Hello world" is usually the first example for any programming language.

To write and run a simple program, start IDLE and open up a new window (choose New Window under the File Menu), create a new file and save as hello.py in your desired program folders then enter the following code.

print("Hello World!")

Save the document (CTRL + S) then execute.
When using the IDLE commands, under the Run menu, choose Run Module (or press F5). IDLE will ask you to save the file if haven't done so.
To execute hello.py from the command prompt (CMD)
first launch the Command Prompt on Windows or Terminal on macOS or Linux then, navigiate to the folder containing the file.

After that, type the following command to execute the hello.py file:

python3 hello.py

If everything is okay then it will execute with no errors and should display the following message on the screen.

Hello World!

Every program has got a structure that defines it's building blocks and so does python. These are constructs and patterns used to develop programs in any programming language and they include:

input
This is data from an external source (outside environment) that is fed into the program for it to manipulate and process. The various sources may be sensors, keyboard, data from other programs, files e.t.c.
output
This is the result of a program process which is displayed on a screen or stored in a file.
sequential execution
This is an orderly execution of scripted statements.
conditional execution
This is the execution of a given block of statements if a specified condition is met.
repeated execution
Perform some set of statements repeatedly, usually with some variation.
reuse
This involves writing a given set of codes once and then use them in several instances of the program whenever necessary.

Comments
A comment is an information intended to explain to a reader what a given code (or sequence of codes) does. They have no effect in the program therefore can never generate any error unless if written in a wrong syntax.

A single-line comment is written using the # character.

Multi-line comment span several lines and can be written using triple quotes.

#This is a single line comment

'''
Author: Naftal Rainer
Date: 23/07/2021
'''

A very good use of the multiline comments is to comment out parts of a code. A programmer may want to modify part of a program and retain the old code in case the changes don’t effect. The programmer would then comment out the old code so that it is still there if needed, and it will be ignored when the new program is executed.

Variables
Variables are named memory locations where data is stored for referencing and manipulation by programs. In simple terms, variables are containers for storing data

The equal sign (=) is used to assign values to variables.
The operand to the left of the = operator is the name of the variable and the operand to the right of the = operator is the value stored in the variable


# X is the variable name and 2 is the value assigned

x = 2

# y is the variable name and 100 is the value assigned

y = 100

# name is the variable name and "Naftal" is the value assigned

name = "Naftal"

Python variables are not declared explicitly since the declaration happens automatically when a value is assigned to the variable.

Data Types
Python has various standard data types that are used to define the operations possible on them and the storage method for each of them.
The standard data types-

1.) Strings

Strings are a data type in Python for dealing with text. They are a set of characters enclosed within quotation marks.
Various operations can be performed on strings using the various string methods available.

Creating a string - A string is created by enclosing text in quotes. You can use either single quotes,', or double quotes, ". A triple-quote can be used for multi-line strings.
Here are some examples:

x = 'Hello'
y = "World"
m = """My name is Paul Mwasame and
       I find learning python to be super exciting."""

For string methods and apllications refer to w3schools

2.) Numbers

Number data types are the ones that will store the numeric values and are classified as:
-Complex (such as complex numbers)
-Float (floating point real values
-Long (long integers that can also be shown as hexadecimal and octal.)
-Int (signed integers)

It also involves numbers and simple mathematics in Python.
Common operators in python include:

Operator	Description
+	addition

-	subtraction

*	multiplication

/	division

**	exponentiation

%	modulo (remainder)

//	integer division

Python has a module called math that contains familiar math functions, including sin, cos, tan, exp, log, log10, factorial, sqrt, floor, and ceil.
For more information on number check programmiz.com

3.) List

Lists are one of the most versatile data types that you can work on in Python. It contains different items enclosed within square brackets and separated out with commas.
Lists are mutable and can contain elements of different data types and even other lists.

Creating lists - Use square brackets to indicate the start and end of the list, and separate the items by commas.

L = [1,2,3]

L2 = [1, 2.718, 'abc', [5,6,7]]

An empty list The empty list is [].
Long lists can span several lines like the one below:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,20,30, 
           40,50,60,70,80,90,100,200,300,400,500]

We can also use eval(input()) to allow the user to enter a list. Here is an example:

myList = eval(input('Enter a list: '))
print('The first element is ', myList[0])

For more on lists, check programmiz.com

4.) Tuple

Tuples are immutable lists enclosed in parentheses.

t = (1,2,3)

To convert an object into a tuple, use tuple() constructor.
The following example converts a list and a string into tuples:

t1 = tuple([12,25,93])
t2 = tuple('abcde')

The empty tuple is written as:

t1 = ();

To write a tuple with one element include a comma(,) after the element.

t1 = (5,)

To access tuple values at various indices, make use of the square brackets as shown below:

tuple1 = ('Nairobi', 'New York', 1997, 2000)
tuple2 = (1, 2, 3, 4, 5, 6, 7 )
print ("tup1[0]: ", tup1[0])
print ("tup2[1:5]: ", tup2[1:5])

Tuples are immutable hence no change can be made on them. However, one can take portions/slices of existing tuples and create a new tuple.
Get more operations on tuples here

5.) Dictionary

Dictionaries are key-value pairs and are surrounded by {}.

Creating dictionaries - To declare a dictionary we enclose it in curly braces, {}. Each entry consists of a pair separated
by a colon. The first part of the pair is called the key and can be of any data type and the second is the value. The key acts like an index.

# Empty dictionary
d = {}

dict = {'A':100, 'B':200}

# To change the value of A to 300
d['A']=300

-To access data at a given index say A, the key d['A'] gives value at index A.
-To add a new entry to the dictionary, we can just assign it, like below:
d['C']=500
-To delete an entry from a dictionary, use the del operator:
del d['A']

The order of items in a dictionary will not necessarily be the order in which put them into the dictionary. Python rearranges things in a dictionary in order to optimize