DEV Community: Elkanah Malonza

A Beginners Guide to Contributing to an Existing Git Repository

Elkanah Malonza — Mon, 17 Oct 2022 11:18:51 +0000

A Git repository helps an individual and organizations to store a collection of files of various different versions of a Project. These files are usually imported from the repository into the local server of the user for update and modifications. Git is also used for coordinating work among programmers collaboratively developing source code during software development.

As an inexperienced newcomer, new to an organization, working with git command can be very overwhelming. This article is a guide to help a newbie make their first contribution in an existing organization Git repository. It can also be used by an expert as a reference guide. Let's get into it.

Prerequisites

Git installed in your computer
GitHub account or any other software repository

NOTE: For the purpose of this blog we will be working with this repository: https://github.com/MalonzaElkanah/To-Do-Flask on a Linux distro PC.

Step 1: Initialize the project folder

The first step is to create a folder for the project and give it the same name as the project. For example, I will open the terminal and create a folder called ‘to-do app’. I use the command ‘mkdir’ to create a folder in Ubuntu OS. After creating the folder, use the ‘cd’ command to navigate into the folder.

We need to turn the new folder to a local repository for the project. Using the ‘git init’ command, we will create an empty Git repository. This command will create a .git directory with sub-directories for objects , refs/heads , refs/tags , and template files.

Step 2: Connect the local repo to the remote repo

So far your local repository is not linked to the remote project repository. To connect to the project remote repository, use the ‘git remote add’ command on the terminal of your local repository. The git remote add command takes two arguments:

A remote name, for example, origin
A remote URL, for example, https://github.com/user/repo.git

The easiest way to get the remote-url is to add ‘.git’ to the remote repository link, For Example: [https://github.com/MalonzaElkanah/To-Do-Flask] repo, add ‘.git’ at the end to create the remote url, [https://github.com/MalonzaElkanah/To-Do-Flask.git ].
You can also get the remote-url from the repo page:

After using the ‘git remote add’ command, use the ‘git remote -v’ command to verify the remote repo connection:

Step 3: Get the files from remote repo

We need to download the remote repository files in order to start making contributions. The ‘git fetch --all’ command is a primary command used to download all contents from a remote repository.

The files have been downloaded to the local repository and stored in the .git folder. The files are not available in our project folder because we have not selected any remote branch. Assuming the remote repository you will be working in contains a couple of branches, you can switch between these branches using ‘git checkout’ command.
For instance, currently the to-do app has one branch, ’main’ branch, so the command to switch to that branch will be: git checkout main

Now all the files that belong to the main branch are available in your local project folder.
To find out what branches are available in your local repository and what the current branch name is, execute ‘git branch’ command.

Step 4: Updating Remote repo from local repo changes

If you have made modifications to the content of the project file and/or added new files to the project folder, you can update the changes to the remote repository. To view the modified files use the ‘git status’ command. For example, I have modified the README.md file and added requirements.txt file.

To push the changes:

Use the ‘git add .’ command to make all new files(in this case, requirements.txt) to be tracked by git. To add a specific file/folder use ‘git add <file/folder-name>’, for instance, in our example we will use: git add requirements.txt
Then, use the ‘git commit’ to 'stage' changes to the project that will be stored in a commit. That is, the command captures a snapshot of the project's currently staged changes. The command has several option
- -a option for committing a snapshot of all changes in the working directory.
- -m option for passing a commit message.
- --amend option for modifying the last commit. Instead of creating a new commit, staged changes will be added to the previous commit. For instance, the commit statement for our to-do app will be: git commit -a -m "Added Project requirements, updated README.md"
‘git push’ command will upload local repository content to a remote repository. It will transfer all commits from your local repository to a remote repository.

For instance, to push our to-do app local changes:

Step 5: update the local repo to match remote repo content

When different people are working on the same project or you are working on the same project from multiple PCs, sometimes the remote repository is ahead in terms of commits in comparison to local repository.
The ‘git pull’ command is used to fetch and download content from a remote repository and immediately update the local repository to match that content.

Step 6: Creating remote branches

In a Collaboration project, programmers don’t usually work on the main branch. When a programmer wants to add a new feature or fix a bug, no matter how big or how small, they spawn a new branch to encapsulate the changes. When the features are complete or bugs fixed they merge the branch to the main.

In order to create a new branch locally, use the ‘git checkout -b’ command. To create a branch from another branch using git checkout, use the following syntax: git checkout -b <new_branch> <old_branch>
In our project I will create a ‘sqlalchemy_orm’ branch from the main branch.

For now the new branch only exists in the local repository. To update the remote repository about the new branch, use the ‘git push –set-upstream origin <new_branch>’ command.

Every change you commit will be pushed to the new branch unless you merge the branch with another or you switch to another branch.

End Note

The objective of this article was to give step by step instruction to contribute to an existing repository for a beginner. There are other git commands not mentioned above that were irrelevant to the guide but are as much important. It's wise to know at least what they do just in case you get any conflict when working with above git commands.

HAPPY CODING!

The Ultimate Guide to Getting Started in Data Science

Elkanah Malonza — Sat, 02 Apr 2022 20:07:28 +0000

Data science generally refers to the process of working out insights from large datasets of unstructured data. This means using predicative analytics, statistics and machine learning to wade through the mass of data.

The practice of data science, may seem to have started in the last decade, but it has been with us for a while longer. Data science began in statistics. In recent years, its popularity has grown considerably due to innovations in data collection, technology, and mass production of data worldwide. Part of the evolution of data science from statistics is the inclusion of concepts such as machine learning and artificial intelligence.

In this article, we’ll share a concise summary of the concepts of which a beginner needs to get started in data science. Let me highlight them before we get started:

Data Scientist Role and Responsibilities
Python for Data Science
Data Visualization
SQL for Data Science
Statistics for Data Science
Data Exploration
Machine Learning for Data Science
Model Deployment

1. Data Scientist Role and Responsibilities

For you to be a data scientist you must first definitely know the roles and responsibilities of data scientists. How they design data modeling processes, create algorithms and predictive models to extract the data the business needs, and help analyze the data and share insights with peers. You must know the process for gathering and analyzing data, For Instance:

Capture the data
Process the data
Analyze the data
Communicate the results
Maintain the data

2. Python for Data Science

Python is a programming language that is easy to learn. Its syntax is easy and code is very readable. Python has a lot of applications. It's used for developing web applications, data science, rapid application development, and so on. Python allows you to write programs in fewer lines of code than most of the programming languages thus its popularity grew rapidly in Data Science.

Python also has tools and processes used by data scientists to format, process, and query their data. They include:

Pandas - Pandas provides fast, flexible, and expressive data structures to make working with relational or labeled data more intuitive. It performs well with tabular type of data (such as SQL tables or Excel spreadsheets) and is really good with time-series data (like, say, temperatures taken on a hourly basis).
NumPy - NumPy adds big data-manipulation tools to Python such as large-array manipulation and high-level mathematical functions for data science. NumPy is best at handling basic numerical computation such as means, averages, and so on. It also excels at the creation and manipulation of multidimensional arrays known as tensors or matrices.
Matplotlib - It provides a Python object-oriented API for embedded plots into applications using general-purpose GUI interfaces. You can make elaborate and professional-looking graphs, and even build “live” graphs that update while your application is running.
Seaborn - Seaborn is a python graphic library built on top of matplotlib. It allows to make your charts prettier with less code.
Regular Expressions - Regular expressions are huge time-savers for programmers. They allow you to specify a pattern of text to search for or filter.

3. Data Visualization

Data visualization is the representation of data through use of common graphics, such as charts, plots, info-graphics, and even animations. These visual displays of information communicate complex data relationships and data-driven insights in a way that is easy to understand.
Their are different Data Visualization Tools in data science. We have already explored data visualization python tools such as Matplotlib and Seaborn in above section. Their are other data visualization tools that do not require coding, for instance:

Tableau (https://www.tableau.com/) - Based on Dashboards which act as a data visualization tool where users can easily analyze trends and statistics. It can be a powerful way of communicating results of a Data Science project.
Infogram (https://infogram.com/app/) - Web-based visualization environment; infographic environment. Multiple PDF/PNG or HTML-based templates;
Flourish (https://flourish.studio/examples/) - Another web-based visualization environment.
Datawrapper (https://www.datawrapper.de/) - Web-based visualization and map creation environment.

4. SQL for Data Science

SQL (Structured Query Language) is a database computer language designed for managing data in relational database. A database is an organized collection of data stored and accessed electronically. Small databases can be stored on a file system, while large databases are hosted on computer clusters or cloud storage. There are lots of different database systems, for instance: MySQL, Oracle Database, Microsoft SQL Server, IBM DB2, Sybase, PostgreSQL, etc.

In Data Science, SQL is used for performing various operations on the data stored in the databases like updating records, deleting records, creating and modifying tables, views, etc. SQL is also the standard for the current big data platforms that use SQL as their key API for their relational databases.

5. Statistics for Data Science

Having Statistics knowledge in data science will make it easy for you to make insight in data. Statistics provides you with the tools and methods to perform data analysis. Its important to learn the following statistics concepts:

Mean, Variance, Standard Deviation
Random variables
Probability Theory
Descriptive Statistics
Bayes Theorem
Linear Regression
Gauss-Markov Theorem
Over- and Under-Sampling
Confidence intervals
Statistical significance
Inferential Statistics
Central Limit Theorem & Law of Large Numbers

6. Data Exploration

Data exploration is the initial step in data analysis, where users explore a large data set in an unstructured way to uncover initial patterns, characteristics, and points of interest. Exploration Data analysis(EDA) is important because it helps in:

Spotting mistakes and missing data.
Checking of assumptions.
Selection of appropriate models.
Mapping out the underlying structure of the data.
Identifying the important variables and their relations.

People are not very good at looking at a column of numbers or a whole spread-sheet and then determining important characteristics of the data. Exploratory data analysis techniques have been devised as an aid in this situation.

Exploratory data analysis involves use of non-graphical or graphical Methods. Non-graphical methods generally involve calculation of summary statistics(Statistics concepts mentioned above), while graphical methods obviously summarize the data in a diagrammatic way(Visualization concepts mentioned above).

7. Machine Learning for Data Science

Machine Learning(ML) is a branch in artificial intelligence where a set of Algorithms, gives a Computers the ability to learn from data on their own without any human intervention. Computers learn, grow, adapt, and develop by themselves when they are fed with relevant data, without relying on explicit programming. Without data, there is very little that Machines can learn. Example of a ML System is YouTube and Netflix Video Recommendation.

In Data Science, Machine Learning is used for the analysis of data and extraction of useful information from it. Machine Learning basically automates the process of Data Analysis and makes data-informed predictions in real-time without any human intervention.
Learning how to build ML models in data science is important. You should know and implement the following ML Concepts:

Pipeline
Linear Regression, Perceptron, and Neural Networks
Logistic Regression
Decision Tree
Naive Bayes
Support Vector Machines(SVM)
Ensemble Learning
Random Forest
Boosting Algorithms
Advanced Ensemble Learning
Hyper-parameter Tuning
Unsupervised Machine Learning
K - Means Clustering
Hierarchical Clustering

8. Model Deployment

For your data science and machine learning project to be available to other users, you need to deploy it. Their are a couple of technologies required to accomplish this:

Streamlit - This is an open-source python framework for building web apps for Machine Learning and Data Science. You can instantly develop web apps and deploy them using streamlit.
Amazon Web Services (AWS) - This cloud computing platform that where you can deploy your data science model. AWS services can offer tools such as compute power, database storage and content delivery services.
Flask - This is a web application framework written in Python. It has multiple modules that make it easier for a web developer to write applications.
FastAPI - FastAPI is a modern, fast, high-performance, web framework for building APIs with Python. If you want share your data science model as a REST interface, this is the right tool for you.

END NOTE

Data science is the process of asking interesting questions, and then answering those questions using data. Being comfortable with above skills will help you to solve data science problems.

To begin your career in data science, at least be comfortable with python programming language, be able perform data analysis, manipulation, and visualization with pandas and learn machine learning fundamentals.

Python for everyone: Mastering Python The Right Way

Elkanah Malonza — Fri, 04 Mar 2022 10:59:09 +0000

In the recent years Python has become one of the most popular programming language. This has not happened by accident, but mainly because:

Its easy to learn and use - Python has an English-like syntax, making it easier to read and understand the code.
Python is free - Python comes under the OSI approved open-source license. This makes it free to use and distribute. Who doesn't like free stuff?
Improves Productivity - We have mentioned that Python is a very simple language. Its simplicity make Developers to focus on solving the problem thus spending less time understanding the syntax or behavior of the programming language, improving productivity.
Libraries Support - due to its vast application, Python standard library is huge, you can find almost all the functions needed for your task. And if you don't find, Python external libraries has over 200,000+ packages.
its portable - You can run Python program in different platform(even your smartphone) without changing a single line of code to adjust to platform dependency issues. You only write once and run it anywhere.

After analyzing the above pros I can comfortably say Python is for Everyone. It is a great choice for beginners up to professionals. You still don't believe me!! Okay, lets check at the areas you can apply python programming language:

Big Data and data science,
artificial intelligence, machine learning and neural networks,
physical computing (Raspberry Pi computer) and Embedded Applications
Web Development
Scripts and Automation
Game Development
Desktop GUI
Web Scraping Applications
Business Applications
Audio and Video Applications

The objective of this article is not to sell Python, the language practically sells itself, but to guide you on the core concepts you need to master before you can officially call yourself a Python GURU. Mastering this concepts will make it easier for you to venture in above Python application fields.The concepts are basics and intermediate, easy stuff.

The basic concepts that we will discuss are:

Data types - Numbers, Strings, Boolean,
Python Operators - Arithmetic Operators, Comparison Operators, Boolean Operators
Variables and Keywords
Flow Control Statements - if statements, while loops, for loops
Function - Inbuilt Functions, defining a function, arguments, anonymous functions,
Python Data Types - Lists, Tuples, Sets, Dictionaries
Classes and Objects, Inheritance,
Handling the error and exceptions - try.. except.. else.. finally..
importing libraries
String in-depth
Number in-depth
Date and Time

The intermediate-level concepts that we will discuss are:

Regular Expressions (regexes)
File Operations
Making your own module/library

1.1 Data types

You need to master data types. This are category for values. In Python every value belongs to exactly one data type. You need to learn how to declare them. Most common data type in python are:

String - This is a text values. Always surround your string in quotes. For Example:
'Hello, I am learning Python'
Integer - This is any whole number, positive or negative. For Example:

23
-21

Float - This is just any valid number that contains a decimal point. For Example:

33.341416
-575.6474562
0.425

Boolean - this is a data type that can be one of two values: either True or False. For Example:

True
False

1.2 Python Operators

Python offers many different operators for working with and comparing data types. For Example:

Arithmetic Operators - This operators are for doing arithmetic; addition, subtraction, multiplication, division, and others.

**  Exponent 
%   Modulus/remainder 
//  Integer division/floored quotient 
/   Division 
*   Multiplication 
-   Subtraction 
+   Addition

Comparison Operators - This compares two values and evaluate down to a single Boolean value. For Example:

==  Equal to
!=  Not equal to
<   Less than
>   Greater than
<=  Less than or equal to
>=  Greater than or equal to

'hello' == 'hello' # True
'hello' == 'Hello' # False

Boolean Operators - This operators compare Boolean values. and - binary operator(always take two Boolean values) that evaluates an expression to True if both Boolean values are True, otherwise, it evaluates to False. For Example:

True and True   # True
True and False  # False
False and False # False

or - binary operator that evaluates an expression to True if either of the two Boolean values is True . If both are False , it evaluates to False. For Example:

True or True    # True
True or False   # True
False or False  # False

not - Evaluates to the opposite Boolean value. For Example:

not True    # False
not False   # True

1.3 Variables and Keywords

A variable is like a box in the computer’s memory where you can store a single value that can be accessed later. We create a variable by using variable name, an equal sign (assignment operator), and the value to be stored. For Example:
name = 'Elkanah Malonza'

Rules of creating a variable

It can be only one word.
It can use only letters, numbers, and the underscore ( _ ) character.
It can’t begin with a number.
It cannot be a keyword. keywords have special meaning in any programming language. Here is a list of keywords in Python.

1.4 Flow Control Statements

Flow control statements decides which Python instructions to execute under which conditions. Flow control statements often start with a part called the condition, and followed by a block of code called the clause. Condition are Boolean expressions that when evaluates to true execute the clause.

1.4.1 if...elif..else statements
An if statement’s clause will execute if the statement’s condition is True and skipped if the condition is False.
It can be optionally followed by several elif statement , if you have a case where you want one of many possible clauses to execute.
if clause can be optionally followed by an else statement. The else clause is executed only when the if statement’s and/or elif statement condition is False .

if name == 'Elkanah':
    print('Hello Elkanah')
elif name == 'Malone':
    print('Hello Malone')
else:
    print('Hello')

1.4.2 while loops
The code in a while clause will be executed over and over, as long as the while statement’s condition is True.
For Example:

count = 0
while count < 5:
    print('Hello, world.')
    count = count + 1

A break Statements can be used to break out program execution of a while loop’s clause early.

count = 0
while count < 5:
    print('Hello, world.')
    if count == 3:
        break
    count = count + 1

A continue statement causes program execution to immediately jumps back to the start of the loop and reevaluates the loop’s condition.

count = 0
while count < 5:
    count = count + 1
    if count == 3:
        continue
    print(count)

1.4.3 for loops and the range() Function
For loops are used to execute a block of code only a certain number of times.

for i in range(10):
    print('Malone Ten Times')

1.5 Function

Functions provide a way to compartmentalize your code into small tasks that can be called from multiple places within an app. It also make you avoid duplicating code.

1.5.1 Inbuilt Functions
This are function that are provided by python by default. Example:

print('I love Python')
name = input("Enter Your Name: ")
print(name)
len(name)

All in in-built functions in Python 3.7

1.5.2 Defining a function
You can also define your own functions

def intro():
    print("Hello Stranger.")
    print("I love Python.")

intro()

1.5.3 Function with arguments

You can also define your own functions that accept arguments.

def add(x,y):
    z = x + y
    print(z)

add(3,8) # 11

Return Values and return Statements

def add(x,y):
    return x + y

add(2,3) # 5

Defining optional parameters with defaults

def add(x=0,y=0):
    return x + y

add() # 0
add(4) # 4
add(2,3) # 5

1.5.4 Using keyword arguments (kwargs)
You can tell the function which parameter will have what value by using the syntax parameter = value in the code that’s calling the function.

def divide(x,y):
    return x/y

divide(y=2, x=3) # 1.5
divide(x=2, y=3) # 0.6666666666666666

1.5.5 *args - Passing in an arbitrary number of arguments
You can also design the function so that it accepts any number of arguments, use *args as the parameter name.
Whatever you pass in becomes a tuple named args inside the function. A tuple is an immutable list (a list you can’t change).

def sorter(*args):
    newlist = list(args)
    # Sort and show the list.
    newlist.sort()
    return newlist

sorter(2, 0.42, -42,4.24, 25, 5)

1.5.6 Anonymous Functions/lambda functions.
The anonymous because function doesn’t need to have a name.
Syntax: Lambda arguments : expression

percent = lambda n : f"{n:.2%}"
print(percent(.6)) # 60.00%

1.6 Python Data Structures

1.6.1 Lists
A list is a value that contains multiple values in an ordered sequence. A list begins with an opening square bracket and ends with a closing square bracket, []. Values inside the list are also called items which are separated with commas. Example:

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

To get individual values in a List we use Indexes. Example:

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
print(subjects[0]) # Maths 
print(subjects[0]) # Physics

List have methods like append(), insert(), pop(), remove()... etc, that can be of use when writing python code. You need to master all of them.

1.6.2 Tuples
A tuple is just an immutable list. In other words, a tuple is a list, but after it’s defined you can’t change it.
Tuples are typed with parentheses, ( and ) , instead of square brackets, [ and ].

subjects = ('History', 'Geography', 'Biology', 'Physics', 'Maths')
num = (5, 7, 8, 5, 3, 8, 5, 2, 1, 8, 5, 7)

List methods and techniques that modified list data won't work with tuple but the rest will.

1.6.3 Sets
Python Sets is also a means of organizing data. The difference between a set and a list is that the items in set have no specific order. Even though you may define the set with the items in a certain order, none of the items get index numbers to identify their positions.

To define a set, use curly braces where you would have used square brackets for a list and parentheses for a tuple. For example:

subjects = {'Maths', 'Physics', 'Biology', 'Geography', 'History'}
num = {5, 7, 8, 5, 3, 8, 5, 2, 1, 8, 5, 7}

You can’t change the order of items in a set, so you cannot use .sort() to sort the set or .reverse() to reverse its order.

1.6.1 Dictionaries
Like a list, a dictionary is a collection of many values, but unlike indexes for lists, indexes for dictionaries can use many different data types, not just integers.
Indexes for dictionaries are called keys, and a key with its associated value is called a key-value pair.
In code, a dictionary is typed with braces, {}. Example:

person = {
    "name": "Elkanah",
    "gender": "Male",
    "height": "5.9 Foot",
    "weight": "67 kg",
}

You can access these values through their keys:

print(person["name"]) # Elkanah
print(person["height"]) # 5.9 Foot

Like lists, Dictionaries too have methods for instance clear(), copy(), fromkeys(), get(), items(), keys(), pop(), popitem(), setdefault(), update() and values() . This methods are used to manage data in a Dictionary. You need to know how to use them.

1.7 Classes and Objects, Inheritance

Like functions, classes also allow you to compartmentalize code and data.
Class - A piece of code from which you can generate a unique object, where each object is a single instance of the class.
Attribute - A characteristic of an object that contains information about the object.
Method - A Python function that’s associated with the class. It defines an action that object can perform.
Example:

class Dog:
    def __init__(self, age, name):
        self.age = age
        self.name = name

    def change_name(self, new_name):
        self.name = new_name

    def display_name(self):
        print(self.name)

    def display_age(self):
        print(self.age)


puppy = Dog(3, 'TOM')
puppy.display_age()
puppy.display_name()
puppy.change_name("Cindy")
puppy.display_name()

Inheritance
inheritance is defined by creating sub-classes within a class.
Syntax:

class parent:
   statements
class child(parent):
   statements

Sub-classes inherit all the attributes and methods of some higher-level main class, or parent class, which is usually referred to as the base class.

class Quadrilateral:
    def __init__(self, a, b, c, d):
        self.a = a
        self.b = b
        self.c = c
        self.d = d

    def perimeter(self):
        p = self.a + self.b + self.c + self.d
        print("perimeter: ", p)


q1 = Quadrilateral(4, 5, 7, 9)
q1.perimeter()


class Rectangle(Quadrilateral):
    def __init__(self, a, b):
        super(Rectangle, self).__init__(a, b, b, a)

    def area(self):
        area = self.a * self.b
        print("Area:", area)


r1 = Rectangle(20, 10)
r1.perimeter()
r1.area()

1.8 Handling the error and exceptions - try..except..else..finally

Getting an error, or exception, in your Python program means the entire program will crash. You don’t want this to happen in real-world programs. Example:
dummy_file = open('random_file.csv')
# FileNotFoundError: [Errno 2] No such file or directory: 'random_file.csv'

Above program creates a FileNotFoundError and stops executing. We want the program to detect errors, handle them, and then continue to run. That's where try...except...else...finally... Statements comes in.

try:
    # Open file and shows its name.
    dummy_file = open('random_file.csv')
    print(dummy_file.name)
except Exception:
    print("Sorry, File named random_file.csv Does not Exist.")

Being Specific about Exceptions Sometimes we need to catch a specific error. For Instance, FileNotFoundError in above code. You add the exception name after the except statement.

try:
    # Open file and shows its name.
    dummy_file = open('random_file.csv')
    print(dummy_file.name)
except FileNotFoundError:
    print("Sorry, File named random_file.csv Does not Exist.")

One Try statement can be followed by multiple except statement.

try:
    ...
except FileNotFoundError:
    print("Sorry, File named random_file.csv Does not Exist.")
except Exception as e:
    print(e)

else block Code in this block will be executed if no exceptions raised

try:
    ...
except FileNotFoundError:
    print("Sorry, File named random_file.csv Does not Exist.")
except Exception as e:
    print(e) 
else:
    # Continue on here only if no exceptions raised

finally block if included, the code in this block will run whether an exception occurs or not.

try:
    try to do this
except:
    if x happens, stop here
except Exception as e:
    if something else bad happens, stop here
else:
    if no exceptions, continue on normally here
finally:
    do this code no matter what happened above

1.9 Importing libraries

Python comes with a set of modules called the standard library - which is a Python program that contains a related group of functions that can be embedded in your programs. Before you can use the functions in a module, you must import the module with an import statement.
Example: the random module has random number–related functions,

import random

for i in range(15):
    print(random.randint(1, 10))

Example: the math module has mathematics related functions

import math

print(math.sqrt(81))

1.10 String In-depth

In data types you learnt about string data type. In python, You can do more with strings other than write, print, and access strings. You can extract partial strings from string values, add or remove spacing, convert letters to lowercase or uppercase, check that strings are formatted correctly, etc. This is easily done by use of different string method, indexes and slices and other in-built functions. Example of indexes, slices and in-built functions.
s[i:j:k] - A slice of s from i to j with step k.
min(s) - The smallest (lowest) item of string s, uses Ascii (space is smaller than a-z,A-Z)
max(s) - The largest (highest) item of string s.

Their are over 30 string methods in python. They will come in handy if you know how to use them. Here are a few of them:

'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'

1.11 Numbers in-depth

You can also do more with int and float Data types other than declaring them and doing arithmetic operation on them. Below are in-built function that can manipulate Numbers in python.

abs(x) - Returns the absolute value of number x (converts negative numbers to positive)
bin(x) Returns a string representing the value of x converted to binary.
float(x) Converts a string or number x to a the float data type
format(x,y) - Returns x formatted as directed by format string y.
hex(x) - Returns a string containing x converted to hexadecimal, prefixed with 0x.
int(x) - Converts x to the integer data type by truncating (not rounding) the decimal point and any digits after it.
max(x,y,z ...) - Takes any number of numeric arguments and returns whichever one is the largest.
*min(x,y,z ...) * - Takes any number of numeric arguments and returns whichever one is the smallest.
oct(x) - Converts x to an octal number, prefixed with 0o to indicate octal.
round(x,y) - Rounds the number x to y number of decimal places.

If you want to do complex math operation on numbers like trigonometry, hyperbolic, powers and logarithms, angular conversions, constants like pi and e, import the math module. Below are some of the methods and attributes of math module:

'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc'

1.12 Date and time

To work with dates and times, you typically need to use the datetime module.

Import the datetime module with nickname dt* import datetime as dt

1.12.1 Working with Dates

A date consisting of month, day, and year (no time information). variable = datetime.date(year, month, day)
Store today's date in a variable named today.* today = dt.date.today()
Store some other date in a variable called birth_date* birth_date = dt.date(2019, 12, 31)
Accessing Month, Day and Year

print(birth_date.month)
print(birth_date.day)
print(birth_date.year)

1.12.2 Working with times

A time consisting of hour, minute, second, microsecond, and optionally time zone information if needed (but no date).
If you want to work strictly with time data, use the datetime.time class. The basic syntax for defining a time object using the time class is variable = datetime.time([hour,[minute,[second,[microsecond]]]])
all the arguments are optional

midnight = dt.time() # 00:00:00
just_morning = dt.time(06,09,00)

1.12.3 Working with date and time

A single item of data that includes date, time, and optionally time zone information. variable = datetime.datetime(year, month, day, hour, [minute, [second, [microsecond]]])
The month, day, and year are required. The rest are optional and set to zero in the time if you omit them.

import datetime as dt
new_years_eve = dt.datetime(2019,12,31,23,59)
print(new_years_eve)

1.12.4 Formatting Strings for Dates and Times
The default date display is yyyy-mm-dd, but you can format dates and times however you want using f-strings. Learn how to use the right directives in f-strings and you will display date and time the way you like. Example:

print(f"{birth_date:%A, %B %d, %Y}")
today_s_date = f"{today:%m/%d/%Y}"
print(today_s_date) # 03/03/2022

**
1.12.5 Time Delta**

The timedelta happens automatically when you subtract one date from another to get the time between.

new_year = dt.date(2022, 1, 1)
birth_day = dt.date(2022, 5, 27)
days_between = birth_day - new_year

You can also define any timedelta (duration) using this syntax: datetime.timedelta(days=, seconds=, microseconds=, milliseconds=, minutes=, hours=, weeks=) If you omit an argument, its value is set to zero.

import datetime as dt
new_years = dt.date(2022,1,1)
duration = dt.timedelta(days=146)
print(new_year + duration) # 2022-05-27

import datetime as dt
now = dt.datetime.now()
birthdatetime = dt.datetime(1997, 1, 19, 6, 00)
age = now - birthdatetime
print(age) # 9174 days, 15:13:05.474595
print(type(age)) # <class 'datetime.timedelta'>

2. Intermediate Python

2.1 Regular Expressions (regexes)

Regular expressions are huge time-savers for programmers. They allow you to specify a pattern of text to search for or filter.

All the regex functions in Python are in the re module.
import re
Passing a string value representing your regular expression to re.compile() returns a Regex pattern object
A Regex object’s method search() looks for the first instance, findall() looks for all matching instance and
the sub() method for substituting all matching strings
with string specified.
Example: Matching Kenya Phone Numbers (+254)712345678 | 0765-432-123 | 0722004445

import re

def extract_phone_num(text):
    kenya_pattern = r"(\(\+\d{3}\)\d{9})|(\d{4}-\d{3}-\d{3})|(\d{10})"
    matching = re.compile(kenya_pattern)
    return matching.findall(text)


my_text = "(+254)734423363 0714-134-941This is 0756464654 just a text with random 0756464654 Kenyan Phone Numbers " \
          "(+254)718306114 0718-306-114 blah 0756464654 blah 07013-213-311 0756464654"
print(extract_phone_num(my_text))

Result:
[('(+254)734423363', '', ''), ('', '0714-134-941', ''), ('', '', '0756464654'), ('', '', '0756464654'), ('(+254)718306114', '', ''), ('', '0718-306-114', ''), ('', '', '0756464654'), ('', '7013-213-311', ''), ('', '', '0756464654')]

Now that you know the basic steps for creating and finding regular expression objects with Python. You need to learn some more powerful pattern-matching capabilities. Learn the regex symbols used in patterns. For Instance: r"(\(\+\d{3}\)\d{9})|(\d{4}-\d{3}-\d{3})|(\d{10})". Learn how to make your search Case-sensitive and substituting strings matched.

2.2 File Operations

File Operations involves how to use Python to create, read, and save files on the hard drive. The files can be both text or binary files. It also involves organize preexisting files on the hard drive For Instance: copying, renaming, moving, or compressing them.
File Paths
But before you learn how to code file operations, you should be comfortable working with file paths in Python. The path module in os module makes it simple to work with file paths.
The os.path methods and attributes that make it easy to work with files paths are:

'abspath', 'altsep', 'basename', 'commonpath', 'commonprefix', 'curdir', 'defpath', 'devnull', 'dirname', 'exists', 'expanduser', 'expandvars', 'extsep', 'genericpath', 'getatime', 'getctime', 'getmtime', 'getsize', 'isabs', 'isdir', 'isfile', 'islink', 'ismount', 'join', 'lexists', 'normcase', 'normpath', 'os', 'pardir', 'pathsep', 'realpath', 'relpath', 'samefile', 'sameopenfile', 'samestat', 'sep', 'split', 'splitdrive', 'splitext', 'stat', 'supports_unicode_filenames', 'sys'

Learn how to work with above attributes and methods.
Their are others os methods apart from those found in os.path that used to manage files and file paths. Example:

os.getcwd() - get current working directory
os.chdir(<path>) - change directory
os.makedirs(<path>) - create new folder/directory
os.listdir(path) - returns a list of filename strings for each file in the path argument.

The File Reading/Writing Process
If you are comfortable working with folders and file paths, lets specify the location of files to read and write.
The following are functions for opening, reading and writing Text files.

open() - function to return a File object. default read mode
open('', 'w') - open file for writing. Replace 'w' with 'a' to open file in append mode.
read() - method on the File object to read its content.
readlines() - method to get a list of string values from the file, one string for each line of text.
write() - method on the File object to write content.
close() - Close the file by calling the method on the File object. Example:

file_x = open('/users/path_to_folder/my_file.txt')
file_x.readlines()
file_x.close()
file_x = open('/users/path_to_folder/my_file.txt', 'w')
file_x.write('Hello world!\n') 
file_x.close()

shelve Module
You can save variables in your Python programs to binary shelf files using the shelve module.

# Save
shelfFile = shelve.open(<filename>)
cats = ['Zophie', 'Pooka', 'Simon']
shelfFile['cats'] = cats
shelfFile.close()
# Open
shelfFile = shelve.open('mydata')
shelfFile['cats']
# ['Zophie', 'Pooka', 'Simon']
shelfFile.close()

Organizing File
import shutil # shell Utility

shutil.copy('source', 'destination') - will copy a single file
shutil.copytree(source, destination) - will copy the folder with all of its files and sub-folders
shutil.move(source, destination) - will move file from source to destination.
os.unlink(path) - will delete the file at path .
os.rmdir(path) - will delete the folder at path . This folder must be empty of any files or folders.
shutil.rmtree(path) - will remove the folder at path , and all files and folders it contains will also be deleted
Safe Deletes with the send2trash Module

import send2trash
send2trash.send2trash('bacon.txt')

Walking THROUGH a Directory Tree

os.walk() - will return three values on each iteration through A for loop
A string of the current folder’s name
A list of strings of the folders in the current folder
A list of strings of the files in the current folder Example:

import os

for folderName, subfolders, filenames in os.walk('/home/malone/PycharmProjects'):
    print('The current folder is ' + folderName)
    for subfolder in subfolders:
        print('SUBFOLDER OF ' + folderName + ': ' + subfolder)
        for filename in filenames:
            print('FILE INSIDE ' + folderName + ': ' + filename)
            print('')

2.3 Making your own module/library

We have already mentioned that modules are collections of pre-written code that you can import and use in your own code.
A module is just a file with a .py filename extension. The name of the module is the same as the filename without the .py file extension. Yeah, it is that simple.

Example if I have a python file named email_app.py, inside the file are function like send_email(), inbox(), sent_box() and drafts() and Global Variables like EMAIL and PORT. I can import this module as:

import email_app
email_app.inbox()
print(email_app.PORT)

Conclusion

After going through the above Python concepts and learning them in details (I was just pointing them out, I didn't go into details), you will find it easy for you to venture in Data Science, Web Development and Other Python fields without a hustle. Their are some interesting topics like Web Scrapping, Scheduling Tasks and Launching Programs, Creating and manipulating binary files(PDFs, Word Doc, Excel, CSV Files), Network Programming, Sending Emails and Manipulating Images that I have left out. This topics are easy because all you do is import the respective module and working with their methods and attributes. But if you have not mastered the basics, they will definitely be hard.

Introduction to Data Structures and Algorithms With Python

Elkanah Malonza — Mon, 21 Feb 2022 10:52:16 +0000

Python provides data types that provides a flexible way to access and organize multiple data. They are called Data Structures. Data Structures are a specialized means of organizing and storing data in computers in such a way that we can perform operations on the stored data more efficiently.
A Data structure is a particular way of organizing data in a computer so that it can be used effectively. It is a specialized format for organizing, processing, retrieving and storing data.
Algorithm on the hand is a set of well-defined instructions in calculation or to solve a particular problem.

The basic Python data structures in Python include:

Lists
Tuples
Sets
Dictionaries

Their some data structures that are user-defined (not part of python data types). They include:

Stack - LIFO
Queues - FIFO
Linked Lists
Hash Tables
Trees
Graphs

1. Lists

A list is a value that contains multiple values in an ordered sequence. A list begins with an opening square bracket and ends with a closing square bracket, []. Values inside the list are also called items which are separated with commas. For example:

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

To get individual values in a List we use Indexes. Example:

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
# subjects[0] will evaluate to Maths
print(subjects[0]) # Maths 
# subjects[1] will evaluate to Physics
print(subjects[0]) # Physics

The integer inside the square brackets that follows the list is called an index. The first value in the list is at index 0 , the second value is at index 1 , the third value is at index 2 , and so on.

NOTE: Python will give you an IndexError error message if you use an index that exceeds the number of values in your list value.

Lists can also contain other list values.

food = [['tea', 'coffee', 'water'], ['beef', 'pork', 'mutton', 'fish', 'chicken'], ['rice', 'pasta']]
beverage = food[0]
print(beverage) # ['tea', 'coffee', 'water']
# print individual value
print(food[1][3]) # 'fish'

The first index dictates which list value to use, and the second indicates the value within the list value. Example:
food[1][3] # 'fish'

negative indexes

You can also use negative integers for the index. The integer value -1 refers to the last index in a list, the value -2 refers to the second-to-last index in a list, and so on. Example:

num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
print(num[-1]) # 0
print(num[-2]) # 9
print(num[-5]) # 6

Slicing a List to get a Sub-lists A slice can get several values from a list, in the form of a new list. A slice is typed between square brackets, like an index, but it has two integers separated by a colon.

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
print(subjects[1:4]) # ['Physics', 'Biology', 'Geography']

The first integer in a slice is the index where the slice starts. The second integer is the index where the slice ends but will not include it.

Leaving out the first index is the same as using 0 , or the beginning of the list. Leaving out the second index is the same as using the length of the list, which will slice to the end of the list.

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
print(subjects[:3]) # ['Maths', 'Physics', 'Biology']
print(subjects[3:]) # ['Geography', 'History']

Changing Values in a List with Indexes

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subject[0] = 'Mathematics'
print(subject) # ['Mathematics', 'Physics', 'Biology', 'Geography', 'History']

Adding two lists using + operator

core_subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
supplementary_subjects = ['Programming', 'Sports', 'Communication']
subjects = core_subjects + supplementary_subjects
print(subjects)  
['Maths', 'Physics', 'Biology', 'Geography', 'History', 'Programming', 'Sports', 'Communication']

Replicating a list using * operator

num = [1, 3, 5]
print(num*3) # [1, 3, 5, 1, 3, 5, 1, 3, 5]

Removing Values from Lists with del Statements

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
del subjects[2]
print(subjects) # ['Maths', 'Physics', 'Geography', 'History']

Using for Loops with Lists

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
for sub in subjects:
    print(sub)

The in and not in Operators You can determine whether a value is or isn’t in a list with the in and not in operators.

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']

print('Physics' in subjects) # True

print('Physics' not in subjects) # False

print('Programming' in subjects) # False

print('Programming' not in subjects) # True

Getting a List’s Length with len()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
print(len(subjects))

Multiple Assignment using Lists

You can assign multiple variables with the values in a list in one line of code.

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
maths, physics, bio, geo, history = subjects
print(geo) # 'Geography'
print (physics) # 'Physics'

Converting Types with the list() Functions

line1 = 'hello'
line1_list = list(line1)
print(line1_list) # ['h', 'e', 'l', 'l', 'o']

subjects = ('History', 'Geography', 'Biology', 'Physics', 'Maths')
subjects = list(subjects) # ['History', 'Geography', 'Biology', 'Physics', 'Maths']

List Methods

append() - Adds an item to the end of the list.
clear() - Removes all items from the list, leaving it empty.
copy() - Makes a copy of a list.
count() - Counts how many times an element appears in a list.
extend() - Appends the items from one list to the end of another list.
index() - Returns the index number (position) of an element within a list.
insert() - Inserts an item into the list at a specific position.
pop() - Removes an element from the list, and provides a copy of that item that you can store in a variable.
remove() - Removes one item from the list.
reverse() - Reverses the order of items in the list.
sort() - Sorts the list in ascending order. Put reverse=True inside the parentheses to sort in descending order.

index()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
print(subject.index('Physics')) # 1

append()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subject.append('Programming') 
print(subject) # ['Maths', 'Physics', 'Biology', 'Geography', 'History', 'Programming']

insert()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subject.insert('Programming', 1) 
print(subject) # ['Maths', 'Programming', 'Physics', 'Biology', 'Geography', 'History']

remove()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subject.remove('Biology') 
print(subject) # ['Maths', 'Physics', 'Geography', 'History']

NOTE: If the value appears multiple times in the list, only the first instance of the value will be removed.

sort()

# Arrange in alphabetical order
subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subjects.sort() 
print(subjects) # ['Biology', 'Geography', 'History', 'Maths', 'Physics' ]

# Arrange in numeric order
random_num = [5, 5, 3, 8, 2, 1, 8, 0, 7]
random_num.sort() # [0, 1, 2, 3, 5, 5, 7, 8, 8]

You can also pass True for the reverse keyword argument to have sort() sort the values in reverse order.

random_num = [5, 5, 3, 8, 2, 1, 8, 0, 7]
random_num.sort(reverse=True) # [8, 8, 7, 5, 5, 3, 2, 1, 0]

you cannot sort lists that have both number values and string values in them, since Python doesn’t know how to compare these values.
sort() uses “ASCIIbetical order” rather than actual alphabetical order for sorting strings. This means uppercase letters come before lower-case letters.

spam = ['Alice', 'ants', 'Bob', 'badgers', 'Carol', 'cats']
spam.sort() # ['Alice', 'Bob', 'Carol', 'ants', 'badgers', 'cats']

you need to sort the values in regular alphabetical order, pass str.lower for the key keyword argument in the sort() method call.

spam = ['a', 'z', 'A', 'Z']
spam.sort(key=str.lower) # ['a', 'A', 'z', 'Z']

pop()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']

# remove last subject
last_subject = subjects.pop()
print(subjects) # ['Maths', 'Physics', 'Biology', 'Geography']
print(last_subject) # 'History'

# remove first subject
first_subject = subjects.pop(0)
print(subjects) # ['Physics', 'Biology', 'Geography']
print(first_subject) # 'Maths'

count()

num = [5, 7, 8, 5, 3, 8, 5, 2, 1, 8, 5, 7]
num_count = num.count(5)
print(num_count) # 4

extend()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
supplementary_subjects = ['Programming', 'Sports', 'Communication']
subjects.extend(supplementary_subjects)
print(subjects) # ['Maths', 'Physics', 'Biology', 'Geography', 'History', 'Programming', 'Sports', 'Communication']

clear()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subjects.clear()
print(subjects) # [ ]

reverse()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subjects.reverse()
print(subjects) # ['History', 'Geography', 'Biology', 'Physics', 'Maths']

copy()

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subject_copy = subjects.copy()
print(subject_copy) # ['Maths', 'Physics', 'Biology', 'Geography', 'History']

2. Tuple

A tuple is just an immutable list. In other words, a tuple is a list, but after it’s defined you can’t change it. Tuples are typed with parentheses, ( and ) , instead of square brackets, [ and ]. Example:

subjects = ('History', 'Geography', 'Biology', 'Physics', 'Maths')
num = (5, 7, 8, 5, 3, 8, 5, 2, 1, 8, 5, 7)

List methods and techniques that modified list data won't with tuple but other methods will work:

print(num.count(5)) # 4
print(type(subjects)) # <class 'tuple'>
print(len(num)) # 12
print('Physics' in subjects) # True

Converting to Tuple Types with tuple() Functions

subjects = ['Maths', 'Physics', 'Biology', 'Geography', 'History']
subjects = tuple(subjects)
print(subjects) # ('Maths', 'Physics', 'Biology', 'Geography', 'History')

3. Sets

Python Sets is also a means of organizing data. The difference between a set and a list is that the items in set have no specific order. Even though you may define the set with the items in a certain order, none of the items get index numbers to identify their positions.

To define a set, use curly braces where you would have used square brackets for a list and parentheses for a tuple. For example:

subjects = {'Maths', 'Physics', 'Biology', 'Geography', 'History'}
num = {5, 7, 8, 5, 3, 8, 5, 2, 1, 8, 5, 7}

You can’t change the order of items in a set, so you cannot use .sort() to sort the set or .reverse() to reverse its order. You can use len() to determine size of set and in operator to check if an item exists.

add() - You can add a single new item to a set

subjects = {'Maths', 'Physics', 'Biology', 'Geography', 'History'}
subjects.add('Programming')
print(subjects) # {'Maths', 'Physics', 'Biology', 'Geography', 'History', 'Programming'}

update() - add multiple items to a set

subjects = {'Maths', 'Physics', 'Biology', 'Geography', 'History'}
subjects.update(['Programming', 'Sports', 'Communication'])
print(subjects) # {'Maths', 'Physics', 'Biology', 'Geography', 'History', 'Programming', 'Sports', 'Communication'}

copy() - replicate a set

subjects = {'Maths', 'Physics', 'Biology', 'Geography', 'History'}
subjects_copy = subjects.copy('Programming')
print(subjects_copy) # {'Maths', 'Physics', 'Biology', 'Geography', 'History'}

4. Dictionary

Like a list, a dictionary is a collection of many values, but unlike indexes for lists, indexes for dictionaries can use many different data types, not just integers. Indexes for dictionaries are called keys, and a key with its associated value is called a key-value pair.
In code, a dictionary is typed with braces, {}. Example:

person = {
"name": "Elkanah",
"gender": "Male",
"Height": "5.9 Foot",
"Weight": "67 kg",
}

You can access these values through their keys:

print(person["name"]) # Elkanah
print(person["height"]) # 5.9 Foot

Unlike lists, items in dictionaries are unordered. It does not matter in what order the key-value pairs are typed in a dictionary:

person = {"name": "Elkanah", "gender": "Male", "Height": "5.9 Foot","Weight": "67 kg",}
person2 = {"Height": "5.9 Foot", "name": "Elkanah", "Weight": "67 kg", "gender": "Male",}

print(person==person1) # True

Changing the value of a key in dictionary

person = {"name": "Elkanah", "gender": "Male", "Height": "5.9 Foot","Weight": "67 kg",}
person["name"] = "Malonza"
print(person) # {"name": "Malonza", "gender": "Male", "Height": "5.9 Foot","Weight": "67 kg",}

Dictionary Methods

clear() - Empties the dictionary by remove all keys and values.
copy() - Returns a copy of the dictionary.
fromkeys() - Returns a new copy of the dictionary but with only specified keys and values.
get() - Returns the value of the specified key, or None if it doesn’t exist.
items() - Returns a list of items as a tuple for each key-value pair.
keys() - Returns a list of all the keys in a dictionary.
pop() - Removes the item specified by the key from the dictionary, and stores it in a variable.
popitem() - Removes the last key-value pair.
setdefault() - Returns the value of the specified key. If the key does not exist: insert the key, with the specified value.
update() - Updates the value of an existing key, or adds a new key-value pair if the specified key isn’t already in the dictionary.
values() - Returns a list of all the values in the dictionary.

The keys(), values(), and items() Methods - will return list-like values of the dictionary’s keys, values, or both keys and values.

spam = {'color': 'red', 'age': 42}

v = spam.values()
print(v) # dict_values(['red', 42])

k = spam.keys()
print(k) # dict_keys(['color', 'age'])

kv = spam.items()
print(kv) # dict_items([('color', 'red'), ('age', 42)])

The get() Method - takes two arguments: the key of the value to retrieve and a fallback value to return if that key does not exist.

picnicItems = {'apples': 5, 'cups': 2}
print(picnicItems.get('cups', 0)) # 2
print(get('cups', 0)) # 2

The setdefault() Method - set a value in a dictionary for a certain key only if that key does not already have a value.

spam = {'name': 'Pooka', 'age': 5}

spam.setdefault('color', 'black')
print(spam) # {'color': 'black', 'age': 5, name: 'Pooka'}

spam.setdefault('color', 'white')
print(spam) # {'color': 'black', 'age': 5, name: 'Pooka'}

update() method - to add a new item to a dictionary, or to change the value of a current key.

spam = {'name': 'Pooka', 'age': 5}

spam.update({'color': 'black'})
print(spam) # {'color': 'black', 'age': 5, name: 'Pooka'}

spam.update({'color': 'white'})
print(spam) # {'color': 'white', 'age': 5, name: 'Pooka'}

copy() method - make a copy of a data dictionary to work with.

spam = {'name': 'Pooka', 'age': 5}
spam_copy = spam.copy()
print(spam_copy) # {name: 'Pooka', 'age': 5}

clear() method - remove all key-value pairs from a dictionary without deleting the entire dictionary

spam = {'name': 'Pooka', 'age': 5}
spam.clear()
print(spam) # {}

pop() method - Removes the item specified by the key from the dictionary, and stores it in a variable.

spam = {'color': 'Black', 'name': 'Pooka', 'age': 5}
color = spam.pop("color")
print(spam) # {name: 'Pooka', 'age': 5}
print(color) # Black

popitem() method -Remove the last key-value pair from a dictionary

spam = {'color': 'Black', 'name': 'Pooka', 'age': 5}
color = spam.popitem()
print(spam) # {name: 'Pooka', 'age': 5}
print(color) # ('age', 5)

fromkeys() method - Returns a new copy of the dictionary but with only specified keys and values

spam = {'color': 'Black', 'name': 'Pooka', 'age': 5}
spam1 = dict.fromkeys(spam.keys())
print(spam1) # {'color': None, 'name': None, 'age': None}

results = dict.fromkeys(['Maths', 'Physics', 'Biology', 'Geography', 'History'])
print(results) # {'Maths': None, 'Physics': None, 'Biology': None, 'Geography': None, 'History': None}

5. Stack

A stack is a linear data structure that follows the principle of Last In First Out (LIFO). This means the last element inserted inside the stack is removed. Stack has one end where the insertion and deletion happens i.e. from the top of the stack.
operation in stack data structures

push() - Pushing (storing) an element on the stack
pop() - Removing (accessing) an element from the stack
peek() - get the top data element of the stack, without removing it.
isEmpty() - check if stack is empty.
isFull() - check if stack is full.

Example:


# Creating a stack
def stack():
    stack = []
    return stack

# Creating an empty stack
def isEmpty(stack):
    return len(stack) == 0

# Adding items into the stack
def push(stack, item):
    stack.append(item)
    print("pushed item: " + item)

# Removing an element from the stack
def pop(stack):
    if (isEmpty(stack)):
        return "stack is empty"
    return stack.pop()

stack = stack()
push(stack, "me")
push(stack, "we")
push(stack, "us")

print("popped item: " + pop(stack))
print("stack after popping an element: ", stack)

'''output
pushed item: me
pushed item: we
pushed item: us
popped item: us
stack after popping an element:  ['me', 'we']
'''

6. Queues

A Queue is a linear data structure that follows the principle of First In First Out (FIFO). This means the first element inserted inside the stack is removed first. Stack has two end where one is for insertion (enqueue) and the other is for deletion (dequeue).

operations in queue data structure

enqueue() − add (store) an item to the queue.
dequeue() − remove (access) an item from the queue.
peek() − Gets the element at the front of the queue without removing it.
isFull() − Checks if the queue is full.
isEmpty() − Checks if the queue is empty.

Example:

class Queue:

    def __init__(self):
        self.queue = []

    # Add an element
    def enqueue(self, item):
        self.queue.append(item)

    # Remove an element
    def dequeue(self):
        if len(self.queue) < 1:
            return None

        return self.queue.pop(0)

    # Check the first element in a Queue
    def peek(self):
        if len(self.queue) < 1:
            return None

        return self.queue[0]

    # Check if the Queue is Empty
    def isEmpty(self):
        return len(self.queue) < 1

    # Display  the queue
    def display(self):
        print(self.queue)

    def size(self):
        return len(self.queue)

q = Queue()

q.enqueue(0)
q.enqueue(2)
q.enqueue(0)
q.enqueue(2)
q.enqueue(2)

q.peek()
q.display()

q.dequeue()

print("After removing an element")
q.peek()
q.display()

''' output
0
[0, 2, 0, 2, 2]

After removing an element
2
[2, 0, 2, 2]
'''

7. Linked List

linked list is a linear data structure where data are connected together via links. It consists of nodes where each node contains a data field and a reference(link) to the next node in the list.

Operations in linked list

Insertion − Adds an element at the beginning of the list.
Deletion − Deletes an element at the beginning of the list.
Display − Displays the complete list.
Search − Searches an element using the given key.
Delete − Deletes an element using the given key.


class Node:
    def __init__(self, dataval=None):
        self.dataval = dataval
        self.nextval = None


class SLinkedList:
    def __init__(self):
        self.headval = None

    def listprint(self):
        printval = self.headval
        while printval is not None:
            print (printval.dataval)
            printval = printval.nextval

list = SLinkedList()
list.headval = Node("Mon")
e2 = Node("Tue")
e3 = Node("Wed")

# Link first Node to second node
list.headval.nextval = e2

# Link second Node to third node
e2.nextval = e3

list.listprint()
'''output
Mon
Tue
Wed
'''

8. Hash Tables

Hash table is a data structure that implements an associative array abstract data type, a structure that can map keys to values. A hash table uses a hash function to compute an index, also called a hash code, into an array of buckets or slots, from which the desired value can be found.
In a hash table, data is stored in an array format, where each data value has its own unique index value. Access of data becomes very fast if we know the index of the desired data.

Operations in hash tables

Search − Searches an element in a hash table.
Insert − inserts an element in a hash table.
delete − Deletes an element from a hash table.

Example

hashTable = [[],] * 10

def checkPrime(n):
    if n == 1 or n == 0:
        return 0

    for i in range(2, n//2):
        if n % i == 0:
            return 0

    return 1

def getPrime(n):
    if n % 2 == 0:
        n = n + 1

    while not checkPrime(n):
        n += 2

    return n

def hashFunction(key):
    capacity = getPrime(10)
    return key % capacity

def insertData(key, data):
    index = hashFunction(key)
    hashTable[index] = [key, data]

def removeData(key):
    index = hashFunction(key)
    hashTable[index] = 0

insertData(123, "make a circle")
insertData(456, "a big circle")
insertData(789, "like a sufuria")
print(hashTable)

removeData(123)
print(hashTable)

'''output

[[], [], [123, 'make a circle'], [], [], [456, 'a big circle'], [], [], [789, 'like a sufuria'], []]

[[], [], 0, [], [], [456, 'a big circle'], [], [], [789, 'like a sufuria'], []]

'''

9. Trees

Tree represents the nodes connected by edges, Binary tree or binary search tree to be specifically. Binary Tree is a special data structure used for data storage purposes. A binary tree has a special condition that each node can have a maximum of two children.

Terms used in Binary Tree.

Path − Path refers to the sequence of nodes along the edges of a tree.
Root − The node at the top of the tree is called root. There is only one root per tree and one path from the root node to any node.
Parent − Any node except the root node has one edge upward to a node called parent.
Child − The node below a given node connected by its edge downward is called its child node.
Leaf − The node which does not have any child node is called the leaf node.
Subtree − Subtree represents the descendants of a node.
Visiting − Visiting refers to checking the value of a node when control is on the node.
Traversing − Traversing means passing through nodes in a specific order.
Levels − Level of a node represents the generation of a node. If the root node is at level 0, then its next child node is at level 1, its grandchild is at level 2, and so on.
keys − Key represents a value of a node based on which a search operation is to be carried out for a node.

Operations in Binary Trees

Insert − Inserts an element in a tree/create a tree.
Search − Searches an element in a tree.
Preorder Traversal − Traverses a tree in a pre-order manner.
Inorder Traversal − Traverses a tree in an in-order manner.
Postorder Traversal − Traverses a tree in a post-order manner.

10. Graphs

A graph is a pictorial representation of a set of objects where some pairs of objects are connected by links. The interconnected objects are represented by points termed as vertices, and the links that connect the vertices are called edges.
Formally, a graph is a pair of sets (V, E), where V is the set of vertices and E is the set of edges, connecting the pairs of vertices.

Terminologies in Graphs

Vertex − Each node of the graph is represented as a vertex. In the following example, the labeled circle represents vertices. Thus, A to G are vertices. We can represent them using an array as shown in the following image. Here A can be identified by index 0. B can be identified using index 1 and so on.
Edge − Edge represents a path between two vertices or a line between two vertices. In the following example, the lines from A to B, B to C, and so on represents edges. We can use a two-dimensional array to represent an array as shown in the following image. Here AB can be represented as 1 at row 0, column 1, BC as 1 at row 1, column 2 and so on, keeping other combinations as 0.
Adjacency − Two node or vertices are adjacent if they are connected to each other through an edge. In the following example, B is adjacent to A, C is adjacent to B, and so on.
Path − Path represents a sequence of edges between the two vertices. In the following example, ABCD represents a path from A to D.

Operations in graphs

Add Vertex − Adds a vertex to the graph.
Add Edge − Adds an edge between the two vertices of the graph.
Display Vertex − Displays a vertex of the graph.

Introduction to Modern Python

Elkanah Malonza — Sat, 12 Feb 2022 19:11:38 +0000

Python is an interpreted high-level general-purpose programming language. Its a general purpose language meaning it has a range of potential uses like:

Web and Internet Development
Database Access
Desktop GUIs
Scientific & Numeric
Education
Network Programming Software & Game Development

The advantage of using python programming language compared to other language are:

Friendly and easy to Learn - Python is an easily readable and simple to understand language for developers.
Free - Python is developed under an OSI-approved open source license, making it freely usable and distributable, even for commercial use.
Highly Compatible - python plays well with others and can runs everywhere.
Lots of libraries - Python's standard library and the community-contributed modules allow for endless possibilities (This is the main reason why I wake, eat, drink, sleep and dream Python everyday). Example NumPy and TensorFlow Python Library is used for everything from data visualization, machine learning, data science, natural language processing, and complex data analysis.
Wide Application - we have already mentioned how python is a general purpose language with a wide range of application from web development to scientific applications.

In this article we are going to cover the basic concepts to get you started with python. We will cover:

Python Expressions
Data Types
Variables
Comments
Inbuilt Functions
Putting all together - Your First Python Program

1. Python Expressions

A sequence of operands and operators, likex + y - 5, is called an expression. 1 + 2 is called an expression, which is the most basic kind of programming instruction in the language. Expressions can always evaluate down to a single value.

Python supports the following operators for combining data objects into expressions:

   **  -   Exponent
   %   -   Reminder
   //  -   Integer division/floored quotient ( 22 // 8 = 2)
   /   -   Division (22/8 = 2.75)
   *   -   Multiplication
   +   -   Addition
   -   -   Subtraction

The above operators are arranged in their order of operations or precedence which is similar to the order in mathematics. You can use parentheses to override the usual precedence. Examples of expressions:

5 * 2 
5 ** 2 
5 % 2 
5 / 2 
5 // 2 
5+2 
5-2
((1.618034**10)-(1-1.618034)**10)/(5**(1/2))

2. Data Types

A data type is a category for values, and every value belongs to exactly one data type. Python data types are:

Integers - This are values that are whole numbers. Examples: -2 , -1 , 0 , 1 , 2 , 3 , 4 , 5
Floating-point numbers - this are numbers with a decimal point. Example: 3.142, 1.25 , -1.0 , ‐ -0.5 , 0.0 , 0.5 , 1.0 , 1.25
Strings - This are text values, defined by surrounding your string in single quote. Examples: 'a' , 'aa' , 'aaa' , 'Hello!' , '11 cats'

3. Variables

Variables are used to store information to be referenced and manipulated in a computer program. You’ll store values in variables with an assignment statement which consists of a variable name, an equal sign (assignment operator) and the value to be stored. In buffer = 54, then a variable named buffer will have the integer value 54 stored in it. Example:

data = 53 # initializing a variable
buffer = 62
buffer = 37 # overwriting the variable
data = buffer + data # they can be used with expression
name = 'malonza' # a variable holding strings

A variable name can be of any length as long as they follow the following rules:

It can be only one word.
It can use only letters, numbers, and the underscore ( _ ) character.
It can’t begin with a number.

a = 23 # valid

 _name = 'john' # valid

zoo3 = 'lazy' # valid

4. Python Comments
Python ignores comments when the code is executed, and you can use them to write notes or remind yourself what the code is trying to do.

Any text for the rest of the line following a hash mark ( # ) is part of a comment.

# Program to add two numbers
x, y = 2, 3
x+y

Using 3 single quotes at the beginning and end of a block of text make the text a comment.This style of commenting your code can transverse multiple line unlike using the hash(#).

''' 
A Random text with
multiple lines to show you how to add
comment in multiple line of code
'''

5. Built-in Function
A function is a block of organized, reusable code that is used to perform a single, related action.
A built-in function is a function that is provided as part of a high-level language (python in this instance) and can be executed by a simple reference with specification of arguments.
The print() Function
The print() function displays the string value inside the parentheses on the screen. Example:

print("Hello World!")
name = 'Malonza '
print(name)

The input() Function
The input() function waits for the user to type some text on the keyboard and press enter.

name = input()
print(name)

The len() Function
You can pass the len() function a string value (or a variable containing astring), and the function evaluates to the integer value of the number of characters in that string.

names = "Elkanah Malonza"
len(name)

The str(), int(), and float() Functions

The str() , int() , and float() functions will evaluate to the string, integer, and floating-point forms of the value you pass, respectively.

str(0)
'0'
str(-3.14)
'-3.14'
int('42')
42
int('-99')
-99
int(1.25)
1
int(1.99)
1
float('3.14')
3.14
float(10)
10.0

6. Putting all together - Your First Python Program

Now it’s time to create your first program!

Open a file/text editor such as Notepad or sublime text and type the following into it:

name = input("What is your Name: ")
print("Wow!, You name is ", len(name), "Long.")
dob = int(input("When were you born", name, ": ")) # the int() function to convert the input() value to integer
age = 2019 - dob
print("You are ", age, "years old.")
print("THanks ", name, "for choosing Python3.")
print("Bye!")

Once you’ve entered your source code, save it as hello.py

open a Terminal or command line interface and move to the hello.py file location using cd command.

cd [path_to_the_file_location]

To run or execute the file type the following command and press enter:

python3 hello.py

HAPPY CODING!!