DEV Community: Mark Gatere

Register Today 🔥

Mark Gatere — Thu, 26 Feb 2026 11:22:02 +0000

Julia Muiruri for Microsoft Azure

Feb 25

The JavaScript AI Build-a-thon Season 2 starts March 2!

#javascript #typescript #langchain #ai

Comments 1

3 min read

[Boost]

Mark Gatere — Tue, 11 Nov 2025 20:49:17 +0000

Igor Nosatov

Nov 11 '25

🔥 Why Your Deep Neural Network Fails at Layer 50 (And How ResNet Fixes It)

#ai #python #pytorch #machinelearning

Comments

5 min read

AWS 101: Your Easy Start to Amazon Web Services

Mark Gatere — Thu, 11 Apr 2024 21:16:04 +0000

I am excited to walk with you, step by step, in this AWS Series where we will cover everything AWS from the word go, to building our applications on the cloud... and this being the first article in this series, I can't wait for your feedback.

Set? Buckle up and let's kick off 🚀

What is Cloud Computing?

To understand what cloud computing is, let us first understand what a server is and what it comprises of.

A server is a powerful computer that provides data, services, or functionality to other computers, known as clients, over a network. In essence, servers host and share resources that clients can access. There are many types of servers, including web servers, mail servers, and file servers. Each type performs a specific function. For example, a web server hosts websites and makes them available to users on the internet. When you type a URL into your web browser, you’re actually sending a request to the site’s web server.

The image above is an image of how a server room would look like. In server rooms, there are cables, computer servers, cabinets, routers and networking switches etc. which normally take up a lot of space. Some challenges of having physical servers / server rooms include:

Paying for the space where the servers are located.
Paying for power supply, cooling and maintenance.
Adding and replacing hardware takes time.
Scaling is limited since the more your product / company grows, the more servers you need which requires more space.
Hiring of a 24/7 team to monitor the infrastructure.
How to deal with disasters? (earthquake, power shut down, fire etc.)

On the other hand, cloud computing is like "servers on the internet"; a server that can be accessed from anywhere. In traditional computing, we set up physical servers (like in the server room image above) to run our applications and store data. Cloud computing is now like having a similar server but a virtual one that still includes the software and networking capabilities, making accessing and storing data over the internet possible.
With cloud computing, these servers are owned and managed by a cloud service provider, like Amazon Web Services (AWS) - covered in this blog series, Google Cloud, Microsoft Azure and many others. These servers can be accessed and used over the internet to store data, run applications, or even run artificial intelligence services. The cloud provider, on the other hand, takes care of all the maintenance, upgrades, and security, allowing us to focus only on using the services and building our applications / products rather than managing the infrastructure.

Cloud computing therefore is, the on-demand delivery of compute power, database storage, application, and other IT resources through a cloud service provider with pay-as-you-go pricing. This means that you will only pay for the service you are using and only the resources you will be using hence you can provision exactly the right type and size of computing resources you need.
Additionally, as mentioned above, in cloud computing, you can access as many resources as you need e.g. accessing servers, storage, databases, application services etc. from anywhere, and almost instantly.

Amazon Web Services owns and maintains the network-connected hardware required for these application services, while you provision and use what you need via a web application.

In present digital age, most companies now have their server rooms in the cloud, eliminating the need for space, power supply, cooling, maintenance etc. which results in significant cost savings. Additionally, they don't have to hire a team to monitor the infrastructure because the cloud provider handles all the maintenance, upgrades, and security of the cloud. It’s like having your own tech team, but without the extra cost.

Did you know that you have actually been using the cloud, without even knowing? Tools like Gmail, which is an E-mail cloud service, where you ONLY pay for your emails stored (no infrastructure, etc.), Dropbox, Google Drive, iCloud which are cloud storage services, and even Netflix, which is actually built entirely on AWS and provides you a cloud service, which is to get video on-demand.

These cloud services are however very different from AWS, but in this series, we will learn what goes behind these services and how AWS can help us build these kind of cloud services.

The Deployment Models of the Cloud

In our cloud computing introduction, let us go one step further and discuss the different kinds of clouds. There are 3 different kinds of clouds out there:

Private Cloud - This is a cloud service used by a single organization, and not exposed to the public. This means that you have complete control over it since it meets specific business needs. An example of a Private Cloud provider is rackspace.
Public Cloud - As the name goes, this is a cloud service owned and operated by a third-party cloud service provider and delivered over the Internet, hence can be accessed and used by the public. The three famous Public Cloud providers are: Amazon Web Services (AWS), Google Cloud, and Microsoft Azure.
Hybrid Cloud - This is an approach where one can keep some servers on premises and extend some capabilities to the cloud. This means that we will have a hybrid of our own infrastructure and the cloud. In this approach, we will have control over sensitive assets in our private infrastructure.

The Characteristics of Cloud Computing

Another important thing we need to discuss are the characteristics of cloud computing. There are 5 characteristics of cloud computing:

On-demand self service - This means that users can provision resources and use them without any human interaction from the service provider.
Broad network access - This means that the resources are available over the network and can be accessed by diverse client platforms.
Multi-tenancy and resource pooling - This means that multiple customers can share the same infrastructure and applications on the cloud while still having security and privacy and all serviced from the same physical resources - They're going to share this entire data center of the cloud.
Rapid elasticity and scalability - This means that we can automatically and quickly acquire and dispose resources when needed and we can also quickly and easily scale based on demand.
Measured service - This means that the usage is measured, and we are going to pay exactly for what we have used.

Advantages of Cloud Computing

In the introduction section above, we have mentioned a number of advantages of using cloud computing as compared to having physical servers and in this section, let us explore further and understand the six main advantages of cloud computing:

Trade capital expense (CAPEX) for operational expense (OPEX) - This means that you don't own the hardware and you are going to pay on-demand hence reducing the Total Cost of Ownership (TCO) & Operational Expense (OPEX). This is like you are renting the service from the cloud provider.
Benefit from massive economies of scale - This means that, since a lot of customers are using the cloud platforms e.g. AWS, then the prices will be reduced by AWS over time because AWS will be more efficient at running due to its large scale.
Stop guessing capacity - Initially, we had to plan and buy servers in advance and hope that they would meet the capacity, but now we can actually scale automatically based on the actual measured usage for our application.
Increase speed and agility - We have increased speed and agility hence we can create, operate and do stuff right away.
Stop spending money running and maintaining data centers.
Go global in minutes - by leverage the Cloud provider's e.g. AWS' global infrastructure.

Problems solved by the Cloud

From our advantages above of using cloud computing, let us now discuss the problems we have solved:

Flexibility where we can change resource types when needed.
Cost-Effectiveness - Pay as you go, for what you use.
Scalability where we can accommodate larger loads by making hardware stronger or adding additional nodes.
Elasticity which is the ability to scale out and scale in when needed.
High-availability and fault-tolerance because we don't really on the one data center, but on the fleet of data centers all around the world.
Agility meaning that we can rapidly develop, test and launch software applications.

Types of Cloud Computing

The final topic we will discuss before we get into AWS cloud platform are the different types of cloud computing:

Infrastructure as a Service (IaaS) - This type provides building blocks for cloud IT; providing services such as networking, computers, and data storage space in its raw form. This type of cloud computing provides the highest level of flexibility and can easily be paralleled with traditional on-premises IT as migration is taking place.

Examples: Amazon EC2 (on AWS), GCP, Azure, Rackspace, Digital Ocean, Linode etc.

Platform as a Service (PaaS) - This type removes the need for an organization to manage the underlying infrastructure hence one can just focus on the deployment and management of their applications.

Examples: Elastic Beanstalk (on AWS), Heroku, Google App Engine (GCP), Windows Azure (Microsoft) etc.

Software as a Service (SaaS) - This type provides one with a completed product that is run and managed by the service provider. In most cases, people referring to Software as a Service are referring to end-user applications. In this type, you do not have to think about how the service is maintained or how the underlying infrastructure is managed; you only need to think about how you will use that particular piece of software. A good example is the email service where you can send and receive email without having to manage feature additions to the email product or maintain the servers and operating systems that the email program is running on.

Examples: Many of the AWS services (ex: Rekognition for Machine Learning), Google Apps (Gmail, Google Drive, ...), Dropbox, Zoom etc.

The image below shows the best comparison between the on-premises server, IaaS, Paas, and SaaS:

AWS Cloud Overview

The History

The concept of the cloud computing traces its roots back to 1993 but we won't start our discussion from that far. In 2002, Amazon established its subsidiary Amazon Web Services, which allowed developers to build applications independently. This was after they realized that the IT departments could be externalized. In 2004, AWS launched their first offering publicly, which was SQS. In 2006, AWS expanded their offering and they relaunched with the availability of SQS, S3 and EC2. In the same year, Google launched Google Docs, a SaaS model to edit and save documents online. In 2007, AWS expanded in Europe and has been expanding globally to-date with very many applications and services running on AWS.

According to Gartner Magic Quadrant, a platform that ranks the world’s top cloud companies in its new Magic Quadrant for Strategic Cloud Platform Services report, AWS was named as a leader in the 2022 Gartner Cloud Infrastructure & Platform Services (CIPS) Magic Quadrant for the 12th consecutive year.

AWS Cloud Use Cases

AWS enables you to build sophisticated, scalable applications which are applicable to a diverse set of industries.
Uses cases can include transferring your enterprise IT or using the cloud as a backup and storage or doing some big data analytics. One can also host a website or create a backend for your mobile and your social applications. We can as well use AWS and have your entire gaming servers running on the cloud.

AWS Global Infrastructure

AWS is global and in this section, we are going to learn a bit more specifics about how it works. In AWS, we have, AWS Regions, AWS Availability Zones, AWS Local Zones, AWS Data Centers, and AWS Edge Locations / Points of Presence.

AWS Console

Creating an AWS Account

The first thing to do is to create an AWS Account by heading over to aws.amazon.com and clicking the "Sign In to the Console" button.

On getting to the AWS Sign in page, since we have no existing AWS account, we will click the "Create a new AWS account" button at the bottom of the screen.

Below is how the AWS Sign up page looks like:

After successfully creating an AWS account following the instructions, you will be redirected to the console page where you can start working with the AWS services. The Console Home page will look like the image below but not exactly similar more so for them that will have created their AWS accounts for the first time.

Console and Services Tour

In the top right corner, we have the regions section with US East (N. Virginia): us-east-1 region selected.

As we mentioned previously, it is advisable to choose / select a region that is geographically closer to you to give you / your customers the lowest amount of latency.
On the Console Home we can also see a section with the "Recently visited" services and is empty for them that have created the account for the first time. On the Console Home, we also have other sections such as "AWS Health", "Cost and usage", "Build a solution" ...etc.
Next, on our top left corner, we have the "Services" button where on clicking the button, we get to see all the AWS services organized by category and also in alphabetical order.

At the top there is also a search bar where you can search for a service and get results for all the matches of the service or of your search including features where the searched term has been mentioned, in documentation, market place, Blogs etc.

It's also worth mentioning again that not all regions have all services and an addition to that, is that some services like the Route 53 are global services hence one cannot select a specific region for them while others have specific regions where they are available.

Learn more on the services offered by AWS per region

Shared Responsibility Model

As we wrap up the first article, I want to mention that Security and Compliance is a shared responsibility between AWS and the customer (cloud user). AWS responsibility is “Security of the Cloud” which means that AWS is responsible for protecting the infrastructure that runs all of the services offered in the AWS Cloud, while the Customer responsibility is “Security in the Cloud” which means that the customer's responsibility will be determined by the AWS Cloud services that they select. This determines the amount of configuration work the customer must perform as part of their security responsibilities.

Learn more about the AWS Shared Responsibility Model

That's it for the introduction to AWS - AWS 101: Your Easy Start to Amazon Web Services. 🥳
In this article, we have discussed what cloud computing is, a number of nitty gritty AWS concepts and terms, and how to get started with AWS by creating an account. We also had a sneak peak on the AWS Console Home and different sections on the console.
In the next article, we will kick off immediately with different AWS services and the first concept being understanding what IAM (Identity and Access Management) is and different IAM policies.

See you then. 🚀

Say hello to Big (O)h!

Mark Gatere — Tue, 06 Sep 2022 22:58:50 +0000

Oh or rather O, chosen by Bachmann to stand for Ordnung, meaning the Order of approximation.

"Wait, what is this guy saying?"

Helloooo and welcome back! Do not mind my curtain-raiser for this article for what we are going to be covering is super easy. It is known as The Big O notation.

According to wikipedia, the Big O notation is a mathematical notation that describes the limiting behavior of a function when the argument tends towards a particular value or infinity and characterizes functions according to their growth rates where different functions with the same growth rate may be represented using the same O notation.

Ooh oh! Not again. 😅
In simple terms, (as used in Data Structures), the Big O notation is a way of comparing two sets of code, super simple, right?

Assuming Code 1 and Code 2 accomplish exactly the same thing, how would you compare one to the other? Code 1 might be more readable while Code 2 can be more concise. Big O is a way of comparing Code 1 and Code 2 mathematically on their efficiency as they run.
Assuming too that you have a stopwatch, and we run Code 1 and start the stopwatch and the code runs for 15 seconds, then we reset the stopwatch and run Code 2 together with the stopwatch and it runs for 1 minute, based on this, we can say Code 1 is more efficient than Code 2. This is called Time Complexity.
The thing about Time Complexity that is interesting is that it is not measured in time. This is because if you took the same code and run it on a computer that runs twice as fast, it will complete twice as fast which does not make the code better but rather the computer is better. Time Complexity is therefore measured in the number of operations that it takes to complete something, a topic we will look deeper into with more examples in the course of the article.

In addition to Time Complexity, we also measure Space Complexity. Despite Code 1 running super fast comparatively, it possibly might be taking a lot of memory space and maybe Code 2, despite taking more time in execution, may be taking less space in memory. If preserving memory space is your most important priority and you don't mind having some extra Time Complexity, maybe Code 2 is better.
It is therefore best to understand both concepts to be able to address the most important priority when given an "interview question" on either of the concepts either being a program that runs super fast or either one that conserves memory space.

When dealing with Time Complexity and Space Complexity, there are three greek letters one will interact with: Ω (omega), Θ (theta), and O (omicron).

Assuming you have a list with seven items, and you are to build a for loop to iterate through it to find a specific number:

#Assuming we are looking for number '1', number '4' and number '7' in the list below using a for loop:

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

To get the number '1', we are going to find it in one operation, hence it's our best-case scenario but when we are looking for the number '7', we have to iterate through the entire list to find it, hence it's our worst-case scenario. If looking for the number '4', it's our average-case scenario.
When one is talking about the 'best-case scenario', that is referred to as Ω (omega), while talking about the 'average-case scenario', that's Θ (theta) and while talking about the worst-case scenario, that's O (omicron) which is the Big (0) since when measuring Big (o), we are always measuring the Worst case.
NOTE:

Technically when talking about Big O, we are talking mainly of the worst-case scenario.

To start with, we will mainly focus on the Time complexity.
We are gonna discuss different types of Big O notations as printed on my 'sweatshirt' below😅 (Never Mind! haha):

Below are images with some characteristics we will discuss for each notation on their complexities:

Link to the above Big (O) cheatsheet

Disclaimer: I have used Python code to explain each complexity.

O(n)

This is one of the easiest Big O to explain. Let's use some code to explain this:

def print_items(n):
    for i in range(n):
        print(i)
print_items(10)

0
1
2
3
4
5
6
7
8
9

The above print_items function is an example of something that is O(n). n stands for the number of operations. We passed in the function number 'n' and it ran n times or 'n' operations. Example When we use 10 for 'n' in our function above, we output 10 items (0 - 9) which means the number of operations 'n' is directly proportional to the number of items / elements we output.

Visualizing this on a graph:

   |                              *
   |                    O(n) *
 T |                    *
 i |               *
 m |          *
 e |     *
   |_*_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
                input size

O(n) is always proportional hence it will always be a straight line.

Drop Constants

There are a few ways in which we can simplify the Big O notation. The first one is known as the drop constant.
Using our previous example: print_items function, we are gonna add a second identical for loop below the original one:

def print_items(n):
    for i in range(n):
        print(i)

    for j in range(n):
        print(j)
print_items(10)

0
1
2
3
4
5
6
7
8
9
0
1
2
3
4
5
6
7
8
9

The above operation ran n + n times / 2n number of operations which we write as O(2n) but we can simplify this by dropping the constant 2 and writing it as O(n). We can therefore drop all constants, eg. O(10n), O(100n), O(10000n) == O(n).

O(n^2)

Adding a loop in another loop (nested for loop) using our previous example:

def print_items(n):
    for i in range(n):
       for j in range(n):
          print(i, j)
print_items(10)

0 0
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 0
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 0
2 1
2 2
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 0
3 1
3 2
3 3
3 4
3 5
3 6
3 7
3 8
3 9
4 0
4 1
4 2
4 3
4 4
4 5
4 6
4 7
4 8
4 9
5 0
5 1
5 2
5 3
5 4
5 5
5 6
5 7
5 8
5 9
6 0
6 1
6 2
6 3
6 4
6 5
6 6
6 7
6 8
6 9
7 0
7 1
7 2
7 3
7 4
7 5
7 6
7 7
7 8
7 9
8 0
8 1
8 2
8 3
8 4
8 5
8 6
8 7
8 8
8 9
9 0
9 1
9 2
9 3
9 4
9 5
9 6
9 7
9 8
9 9

The above function runs n * n == n^2 hence we get the O(n^2). By adding an extra for loop and taking the function deeper (my apologies, the output will be a bit longer but will easily help you to understand how this works out):

def print_items(n):
   for i in range(n):
      for j in range(n):
         for k in range(n):
            print(i, j, k)
print_items(10)
0 0 0
0 0 1
0 0 2
0 0 3
0 0 4
0 0 5
0 0 6
0 0 7
0 0 8
0 0 9
0 1 0
0 1 1
0 1 2
0 1 3
0 1 4
0 1 5
0 1 6
0 1 7
0 1 8
0 1 9
0 2 0
0 2 1
0 2 2
0 2 3
0 2 4
0 2 5
0 2 6
0 2 7
0 2 8
0 2 9
0 3 0
0 3 1
0 3 2
0 3 3
0 3 4
0 3 5
0 3 6
0 3 7
0 3 8
0 3 9
0 4 0
0 4 1
0 4 2
0 4 3
0 4 4
0 4 5
0 4 6
0 4 7
0 4 8
0 4 9
0 5 0
0 5 1
0 5 2
0 5 3
0 5 4
0 5 5
0 5 6
0 5 7
0 5 8
0 5 9
0 6 0
0 6 1
0 6 2
0 6 3
0 6 4
0 6 5
0 6 6
0 6 7
0 6 8
0 6 9
0 7 0
0 7 1
0 7 2
0 7 3
0 7 4
0 7 5
0 7 6
0 7 7
0 7 8
0 7 9
0 8 0
0 8 1
0 8 2
0 8 3
0 8 4
0 8 5
0 8 6
0 8 7
0 8 8
0 8 9
0 9 0
0 9 1
0 9 2
0 9 3
0 9 4
0 9 5
0 9 6
0 9 7
0 9 8
0 9 9
1 0 0
1 0 1
1 0 2
1 0 3
1 0 4
1 0 5
1 0 6
1 0 7
1 0 8
1 0 9
1 1 0
1 1 1
1 1 2
1 1 3
1 1 4
1 1 5
1 1 6
1 1 7
1 1 8
1 1 9
1 2 0
1 2 1
1 2 2
1 2 3
1 2 4
1 2 5
1 2 6
1 2 7
1 2 8
1 2 9
1 3 0
1 3 1
1 3 2
1 3 3
1 3 4
1 3 5
1 3 6
1 3 7
1 3 8
1 3 9
1 4 0
1 4 1
1 4 2
1 4 3
1 4 4
1 4 5
1 4 6
1 4 7
1 4 8
1 4 9
1 5 0
1 5 1
1 5 2
1 5 3
1 5 4
1 5 5
1 5 6
1 5 7
1 5 8
1 5 9
1 6 0
1 6 1
1 6 2
1 6 3
1 6 4
1 6 5
1 6 6
1 6 7
1 6 8
1 6 9
1 7 0
1 7 1
1 7 2
1 7 3
1 7 4
1 7 5
1 7 6
1 7 7
1 7 8
1 7 9
1 8 0
1 8 1
1 8 2
1 8 3
1 8 4
1 8 5
1 8 6
1 8 7
1 8 8
1 8 9
1 9 0
1 9 1
1 9 2
1 9 3
1 9 4
1 9 5
1 9 6
1 9 7
1 9 8
1 9 9
2 0 0
2 0 1
2 0 2
2 0 3
2 0 4
2 0 5
2 0 6
2 0 7
2 0 8
2 0 9
2 1 0
2 1 1
2 1 2
2 1 3
2 1 4
2 1 5
2 1 6
2 1 7
2 1 8
2 1 9
2 2 0
2 2 1
2 2 2
2 2 3
2 2 4
2 2 5
2 2 6
2 2 7
2 2 8
2 2 9
2 3 0
2 3 1
2 3 2
2 3 3
2 3 4
2 3 5
2 3 6
2 3 7
2 3 8
2 3 9
2 4 0
2 4 1
2 4 2
2 4 3
2 4 4
2 4 5
2 4 6
2 4 7
2 4 8
2 4 9
2 5 0
2 5 1
2 5 2
2 5 3
2 5 4
2 5 5
2 5 6
2 5 7
2 5 8
2 5 9
2 6 0
2 6 1
2 6 2
2 6 3
2 6 4
2 6 5
2 6 6
2 6 7
2 6 8
2 6 9
2 7 0
2 7 1
2 7 2
2 7 3
2 7 4
2 7 5
2 7 6
2 7 7
2 7 8
2 7 9
2 8 0
2 8 1
2 8 2
2 8 3
2 8 4
2 8 5
2 8 6
2 8 7
2 8 8
2 8 9
2 9 0
2 9 1
2 9 2
2 9 3
2 9 4
2 9 5
2 9 6
2 9 7
2 9 8
2 9 9
3 0 0
3 0 1
3 0 2
3 0 3
3 0 4
3 0 5
3 0 6
3 0 7
3 0 8
3 0 9
3 1 0
3 1 1
3 1 2
3 1 3
3 1 4
3 1 5
3 1 6
3 1 7
3 1 8
3 1 9
3 2 0
3 2 1
3 2 2
3 2 3
3 2 4
3 2 5
3 2 6
3 2 7
3 2 8
3 2 9
3 3 0
3 3 1
3 3 2
3 3 3
3 3 4
3 3 5
3 3 6
3 3 7
3 3 8
3 3 9
3 4 0
3 4 1
3 4 2
3 4 3
3 4 4
3 4 5
3 4 6
3 4 7
3 4 8
3 4 9
3 5 0
3 5 1
3 5 2
3 5 3
3 5 4
3 5 5
3 5 6
3 5 7
3 5 8
3 5 9
3 6 0
3 6 1
3 6 2
3 6 3
3 6 4
3 6 5
3 6 6
3 6 7
3 6 8
3 6 9
3 7 0
3 7 1
3 7 2
3 7 3
3 7 4
3 7 5
3 7 6
3 7 7
3 7 8
3 7 9
3 8 0
3 8 1
3 8 2
3 8 3
3 8 4
3 8 5
3 8 6
3 8 7
3 8 8
3 8 9
3 9 0
3 9 1
3 9 2
3 9 3
3 9 4
3 9 5
3 9 6
3 9 7
3 9 8
3 9 9
4 0 0
4 0 1
4 0 2
4 0 3
4 0 4
4 0 5
4 0 6
4 0 7
4 0 8
4 0 9
4 1 0
4 1 1
4 1 2
4 1 3
4 1 4
4 1 5
4 1 6
4 1 7
4 1 8
4 1 9
4 2 0
4 2 1
4 2 2
4 2 3
4 2 4
4 2 5
4 2 6
4 2 7
4 2 8
4 2 9
4 3 0
4 3 1
4 3 2
4 3 3
4 3 4
4 3 5
4 3 6
4 3 7
4 3 8
4 3 9
4 4 0
4 4 1
4 4 2
4 4 3
4 4 4
4 4 5
4 4 6
4 4 7
4 4 8
4 4 9
4 5 0
4 5 1
4 5 2
4 5 3
4 5 4
4 5 5
4 5 6
4 5 7
4 5 8
4 5 9
4 6 0
4 6 1
4 6 2
4 6 3
4 6 4
4 6 5
4 6 6
4 6 7
4 6 8
4 6 9
4 7 0
4 7 1
4 7 2
4 7 3
4 7 4
4 7 5
4 7 6
4 7 7
4 7 8
4 7 9
4 8 0
4 8 1
4 8 2
4 8 3
4 8 4
4 8 5
4 8 6
4 8 7
4 8 8
4 8 9
4 9 0
4 9 1
4 9 2
4 9 3
4 9 4
4 9 5
4 9 6
4 9 7
4 9 8
4 9 9
5 0 0
5 0 1
5 0 2
5 0 3
5 0 4
5 0 5
5 0 6
5 0 7
5 0 8
5 0 9
5 1 0
5 1 1
5 1 2
5 1 3
5 1 4
5 1 5
5 1 6
5 1 7
5 1 8
5 1 9
5 2 0
5 2 1
5 2 2
5 2 3
5 2 4
5 2 5
5 2 6
5 2 7
5 2 8
5 2 9
5 3 0
5 3 1
5 3 2
5 3 3
5 3 4
5 3 5
5 3 6
5 3 7
5 3 8
5 3 9
5 4 0
5 4 1
5 4 2
5 4 3
5 4 4
5 4 5
5 4 6
5 4 7
5 4 8
5 4 9
5 5 0
5 5 1
5 5 2
5 5 3
5 5 4
5 5 5
5 5 6
5 5 7
5 5 8
5 5 9
5 6 0
5 6 1
5 6 2
5 6 3
5 6 4
5 6 5
5 6 6
5 6 7
5 6 8
5 6 9
5 7 0
5 7 1
5 7 2
5 7 3
5 7 4
5 7 5
5 7 6
5 7 7
5 7 8
5 7 9
5 8 0
5 8 1
5 8 2
5 8 3
5 8 4
5 8 5
5 8 6
5 8 7
5 8 8
5 8 9
5 9 0
5 9 1
5 9 2
5 9 3
5 9 4
5 9 5
5 9 6
5 9 7
5 9 8
5 9 9
6 0 0
6 0 1
6 0 2
6 0 3
6 0 4
6 0 5
6 0 6
6 0 7
6 0 8
6 0 9
6 1 0
6 1 1
6 1 2
6 1 3
6 1 4
6 1 5
6 1 6
6 1 7
6 1 8
6 1 9
6 2 0
6 2 1
6 2 2
6 2 3
6 2 4
6 2 5
6 2 6
6 2 7
6 2 8
6 2 9
6 3 0
6 3 1
6 3 2
6 3 3
6 3 4
6 3 5
6 3 6
6 3 7
6 3 8
6 3 9
6 4 0
6 4 1
6 4 2
6 4 3
6 4 4
6 4 5
6 4 6
6 4 7
6 4 8
6 4 9
6 5 0
6 5 1
6 5 2
6 5 3
6 5 4
6 5 5
6 5 6
6 5 7
6 5 8
6 5 9
6 6 0
6 6 1
6 6 2
6 6 3
6 6 4
6 6 5
6 6 6
6 6 7
6 6 8
6 6 9
6 7 0
6 7 1
6 7 2
6 7 3
6 7 4
6 7 5
6 7 6
6 7 7
6 7 8
6 7 9
6 8 0
6 8 1
6 8 2
6 8 3
6 8 4
6 8 5
6 8 6
6 8 7
6 8 8
6 8 9
6 9 0
6 9 1
6 9 2
6 9 3
6 9 4
6 9 5
6 9 6
6 9 7
6 9 8
6 9 9
7 0 0
7 0 1
7 0 2
7 0 3
7 0 4
7 0 5
7 0 6
7 0 7
7 0 8
7 0 9
7 1 0
7 1 1
7 1 2
7 1 3
7 1 4
7 1 5
7 1 6
7 1 7
7 1 8
7 1 9
7 2 0
7 2 1
7 2 2
7 2 3
7 2 4
7 2 5
7 2 6
7 2 7
7 2 8
7 2 9
7 3 0
7 3 1
7 3 2
7 3 3
7 3 4
7 3 5
7 3 6
7 3 7
7 3 8
7 3 9
7 4 0
7 4 1
7 4 2
7 4 3
7 4 4
7 4 5
7 4 6
7 4 7
7 4 8
7 4 9
7 5 0
7 5 1
7 5 2
7 5 3
7 5 4
7 5 5
7 5 6
7 5 7
7 5 8
7 5 9
7 6 0
7 6 1
7 6 2
7 6 3
7 6 4
7 6 5
7 6 6
7 6 7
7 6 8
7 6 9
7 7 0
7 7 1
7 7 2
7 7 3
7 7 4
7 7 5
7 7 6
7 7 7
7 7 8
7 7 9
7 8 0
7 8 1
7 8 2
7 8 3
7 8 4
7 8 5
7 8 6
7 8 7
7 8 8
7 8 9
7 9 0
7 9 1
7 9 2
7 9 3
7 9 4
7 9 5
7 9 6
7 9 7
7 9 8
7 9 9
8 0 0
8 0 1
8 0 2
8 0 3
8 0 4
8 0 5
8 0 6
8 0 7
8 0 8
8 0 9
8 1 0
8 1 1
8 1 2
8 1 3
8 1 4
8 1 5
8 1 6
8 1 7
8 1 8
8 1 9
8 2 0
8 2 1
8 2 2
8 2 3
8 2 4
8 2 5
8 2 6
8 2 7
8 2 8
8 2 9
8 3 0
8 3 1
8 3 2
8 3 3
8 3 4
8 3 5
8 3 6
8 3 7
8 3 8
8 3 9
8 4 0
8 4 1
8 4 2
8 4 3
8 4 4
8 4 5
8 4 6
8 4 7
8 4 8
8 4 9
8 5 0
8 5 1
8 5 2
8 5 3
8 5 4
8 5 5
8 5 6
8 5 7
8 5 8
8 5 9
8 6 0
8 6 1
8 6 2
8 6 3
8 6 4
8 6 5
8 6 6
8 6 7
8 6 8
8 6 9
8 7 0
8 7 1
8 7 2
8 7 3
8 7 4
8 7 5
8 7 6
8 7 7
8 7 8
8 7 9
8 8 0
8 8 1
8 8 2
8 8 3
8 8 4
8 8 5
8 8 6
8 8 7
8 8 8
8 8 9
8 9 0
8 9 1
8 9 2
8 9 3
8 9 4
8 9 5
8 9 6
8 9 7
8 9 8
8 9 9
9 0 0
9 0 1
9 0 2
9 0 3
9 0 4
9 0 5
9 0 6
9 0 7
9 0 8
9 0 9
9 1 0
9 1 1
9 1 2
9 1 3
9 1 4
9 1 5
9 1 6
9 1 7
9 1 8
9 1 9
9 2 0
9 2 1
9 2 2
9 2 3
9 2 4
9 2 5
9 2 6
9 2 7
9 2 8
9 2 9
9 3 0
9 3 1
9 3 2
9 3 3
9 3 4
9 3 5
9 3 6
9 3 7
9 3 8
9 3 9
9 4 0
9 4 1
9 4 2
9 4 3
9 4 4
9 4 5
9 4 6
9 4 7
9 4 8
9 4 9
9 5 0
9 5 1
9 5 2
9 5 3
9 5 4
9 5 5
9 5 6
9 5 7
9 5 8
9 5 9
9 6 0
9 6 1
9 6 2
9 6 3
9 6 4
9 6 5
9 6 6
9 6 7
9 6 8
9 6 9
9 7 0
9 7 1
9 7 2
9 7 3
9 7 4
9 7 5
9 7 6
9 7 7
9 7 8
9 7 9
9 8 0
9 8 1
9 8 2
9 8 3
9 8 4
9 8 5
9 8 6
9 8 7
9 8 8
9 8 9
9 9 0
9 9 1
9 9 2
9 9 3
9 9 4
9 9 5
9 9 6
9 9 7
9 9 8
9 9 9

The above function run n * n * n times hence it becomes O(n^3) but using drop constants to simplify this, it can also be written as O(n^2).

Notice that the first and the last elements in the output of the function(s) respectively are: O(n) - 0, 9 || O(n^2) - 00, 99 || O(n^3) - 000, 999.

Visualizing it on a graph:

   |          *                  
   |  O(n^2) *              
 T |        *          
 i |       *     
 m |      *  
 e |    * 
   |_*_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
                input size

O(n^2) graph is steeper than the O(n) graph. This means that O(n^2) is a lot less efficient than O(n) from a Time Complexity standpoint.

   |          *                  *
   |  O(n^2) *              * 
 T |        *          *
 i |       *      * O(n)
 m |      *   *
 e |    * *
   |_*_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
                input size

Drop Non-Dominants

The second way to simplify the Big O notation is known as drop non-dominants.
Using the nested for loop example:

def print_items(n):
   for i in range(n):
      for j in range(n):
         print(i, j)
   for k in range(n):
      print(k)
print_items(10)
0 0
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
1 0
1 1
1 2
1 3
1 4
1 5
1 6
1 7
1 8
1 9
2 0
2 1
2 2
2 3
2 4
2 5
2 6
2 7
2 8
2 9
3 0
3 1
3 2
3 3
3 4
3 5
3 6
3 7
3 8
3 9
4 0
4 1
4 2
4 3
4 4
4 5
4 6
4 7
4 8
4 9
5 0
5 1
5 2
5 3
5 4
5 5
5 6
5 7
5 8
5 9
6 0
6 1
6 2
6 3
6 4
6 5
6 6
6 7
6 8
6 9
7 0
7 1
7 2
7 3
7 4
7 5
7 6
7 7
7 8
7 9
8 0
8 1
8 2
8 3
8 4
8 5
8 6
8 7
8 8
8 9
9 0
9 1
9 2
9 3
9 4
9 5
9 6
9 7
9 8
9 9
0
1
2
3
4
5
6
7
8
9

The above function ran twice. The first nested loop (i and j) ran O(n^2) while the second single loop (k) ran O(n). Hence the total number of the output is O(n^2) + O(n) which can also be written as O(n^2 + n).
The main thing of 'n' we are concerned about is "what happens when we start having 'n' as a very large number?" eg. when we have 'n' as 100, n^2 == 10000, hence as a percentage of the total number of operations, the stand-alone 'n' will still remain to be 100, which is a very small portion of the number of operations, hence it is insignificant. In the equation O(n^2 + n), 'n^2' is the dominant term while the stand-alone 'n' is the non-dominant, we drop the non-dominant and the notation remains to be O(n^2).

O(1)

In comparison to other Big Os we have covered, as 'n' gets bigger, the number of operations increases, but with this Big O...:

def add_items(n):
   return n + n
add_items(5)
10

...there is always a single operation, and an increase to 'n' does not lead to an increase in the number of operations(remains constant). return n + n + n == O(2) == O(1).
O(1) is also called constant time. This is because as 'n' increases, the number of operations will remain constant.
Visualizing it on a graph:

   |                              
   |                    
 T |                    
 i |               
 m |          
 e |              O(1) 
   |_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_ _ 
                input size

As 'n' increases, there is no increase in Time Complexity. This makes it the most efficient big(O). Anytime that you can make something O(1), it is as optimal as you can make it.

   |          *                  *
   |  O(n^2) *              * 
 T |        *          *
 i |       *      * O(n)
 m |      *   *
 e |    * *           O(1)
   |_*_*_*_*_*_*_*_*_*_*_*_*_*_*_*_ _ _ 
                input size

O(log n)

In demonstrating and explaining this, we will start with an example.
Assuming we have a list and looking for number '1' in the list:

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

The numbers should be sorted.
What we are going to do is to find the most efficient way of finding the number '1' from the list.
We will first divide the list into half and check whether the number is either in the first half or the second half. We will take the half with the number and do away with the other half. We will continue with the process till we find the number.

[1, 2, 3, 4] [5, 6, 7, 8] --- 1 is in the first half
[1, 2] [3, 4] --- 1 is in the first half
[1] [2] --- 1 is in the first half
1 --- We finally remain with the number

We then count how many steps we took to find the number:

1. [1, 2, 3, 4] [5, 6, 7, 8] --- 1 is in the first half
2. [1, 2] [3, 4] --- 1 is in the first half
3. [1] [2] --- 1 is in the first half

We took 3 steps to find the number from a total of 8 items(numbers).
2^3 = 8 == log2 8 = 3
8 -- Total items
3 -- Steps taken to arrive to the final number after dividing the number into halves
We can have an example like: log2 1,073,741,824 = 31 meaning that you can divide that number 31 times into halves to get to the final number despite which item you're looking for.
O(log n) is more efficient that O(n) but slightly less in efficiency than O(1).

O(nlog n)

This is a Big(O) used with some sorting algorithms like merge sort and quick sort. This is not an efficient Big(O), however, this is the most efficient that you can make a sorting algorithm, sorting various types of data besides numbers.

Different terms for input is a Big(O) concept that interviewers like to as kind of a gotcha question.

Let's start with an example having different parameters for the function:

def print_items(a, b):
    for i in range(a):
        print(i)

    for j in range(b):
        print(j)

When covering O(n), we mentioned dropping constants and hence you might think that because this has two loops in the function, it can be equated to O(2n) == O(n) WHICH IS WRONG.
Being that the function has two parameters, a - 'n1' cannot be equivalent to b - 'n2' hence the Big(O) is O(a + b).
Similarly:

def print_items(a, b):
    for i in range(a):
       for j in range(b):
          print(i, j)

...the Big(O) is O(a * b).

Big(O) of Lists

Assuming we have a list my_list = [11, 2, 23, 7]:
If we want to append a number 17 at the end, (my_list.append(17)), there will be no re-indexing of the original numbers in the list.
Same case applies when we want to pop the number from the list, (my_list.pop()), no re-indexing of the items will occur. This therefore becomes a Big(O) of O(1).

However, when we want to pop a number at the index of 0, (my_list.pop(0)), or insert a number at index 0, (my_list.insert(0, 13)), re-indexing of all the items in the list occurs. This therefore becomes a Big(O) of O(n).

What about inserting items at the middle of the list? (my_list.insert(1, 'Hi'))
Re-indexing of the items at the right of the inserted item occurs. It being at the middle cannot be referred to as O(1/2 n). This is because Big(O) measures worst case and secondly '1/2' is a constant, hence we drop the constant. Therefore the Big(O) of inserting and popping items from the middle of the list is O(n).

Looking for the item in a list

When looking for number 7 in the list my_list = [11, 3, 32, 7], we will iterate over the entire list till we find 7 in the list hence the Big(O) is O(n). But when we are looking for a number using an index from the list, (my_list[3]), we will find the number in the index without iterating, hence the Big(O) is O(1).

Wrapping Up

When we take n to be 100;
O(1) == 1
O(log n) == 7
O(n) == 100
O(n^2) == 10000

This means that O(n^2) compared to the other 3 is very inefficient. The spread becomes even bigger when 'n' becomes larger.

When we take n to be 1000;
O(1) == 1
O(log n) == 10
O(n) == 1000
O(n^2) == 1000000

Terminologies used to refer to the Big(O)s:

O(1) - Constant
O(log n) - Divide and Conquer
O(n) - Proportional (will always be a straight line)
O(n^2) - Loop within a loop

Summing it all up; We can now understand the chart below, that we had seen earlier in the course... however we didn't cover O(n!) and O(2^n) as they are not common and one has to intentionally write bad code to achieve.

Till Next time... Bye bye

Data Structures 101: Introduction to Data Structures and Algorithms.

Mark Gatere — Mon, 20 Jun 2022 23:53:05 +0000

Why do I need to learn Data Structures and Algorithms in the first place? Will I use them in my workspace?

Hello and welcome. We are going to demystify the importance of familiarizing oneself with data structures and algorithms and why the interviewers prefer them in the interviews.
Set? Buckle up and let's set off...

To start off, what is a Data Structure as well as an Algorithm?
From Wikipedia, a data structure is a data organization, management, and storage format that enables efficient access and modification. In simple terms, a data structure is a way of storing data in an efficient or structured manner. In the real world examples, we have examples like a book rack, kitchen cabinets and shoe racks.
In my Python from the word ...Go article, I have covered inbuilt python data structures which comprise: lists, dictionaries, tuples, and sets. Inbuilt data structures mean that they come with ready syntax to be used by the user. In addition to inbuilt data structures, we have user-defined data structures which comprise: array, stack, queue, linked list, tree, graph, and hashmap. This means that the user has to create them from scratch.
We will not go into depths on the inbuilt data structures but can be found explained in depths in the article.

What then is an algorithm?

An algorithm is a collection of steps to solve a particular problem which can be understood by non-technical people as well. There can be multiple ways and steps to solve a given problem hence there can be multiple algorithms for a specific problem.

Why are Data Structures and Algorithms important?

To start off, data structures and algorithms in interviews act as a clear demonstration to the interviewer on your problem-solving skills.
Secondly, data structures refer to the way we organize information on our computers and you can guess that the way we organize information can have a lot of impact on the performance. A good example is a library. Suppose, one wants to have a book on Calculus from a library, to do so, one has to first go to the math section, then to the Calculus section. If these books had not been organized in this manner and just distributed randomly then it would have been really a cumbersome process to find the book.
In addition, an Algorithm is a step-by-step process in solving a given task. They are developed to help perform a task more efficiently by one applying a predefined approach or methodology. If you write code as per your perception and judgement without applying any predefined algorithm, your code will probably be botched up after a certain time.

To sum up, they help one write efficient code and solve problems in optimal or near-optimal ways. Without them, one will be reinventing the wheel which is not always successfully.

Built-in Data Structures

List

Lists are data structures used to store data in a sequential manner.
They use square brackets.
Every single element in a list is indexed from index 0.
Negative indexing in lists is also supported where the last item in a list is given a -1 index. This helps access of elements from the last to the first.
Data in lists can be modified.
Example of a list:



sample_list = [3, 5, "hello", True, 4.76]
Output: [3, 5, "hello", True, 4.76]

Tuples

Tuples work like lists but data in tuples cannot be modified (immutable).
They use parenthesis/round brackets.
Example of a tuple:



sample_tuple = (1, 3, "Mark")
Output: (1, 3, "Mark")

Dictionaries

Data in dictionaries is stored as key-value pairs.
The pairs can be accessed, added, and deleted when needed.
Data is stored in curly braces.
Example:



sample_dict = {"first":"Mark", "Second":"Gatere"}
Output: sample_dict{'first': 'Mark', 'Second': 'Gatere'}

Sets

Sets, like dictionaries, use curly brackets.
They store a collection of unordered unique elements where each data element must be unique.
Example:



my_set = {1, 2, 3, 3, 4, 5, 5}
Output: {1, 2, 3, 4, 5}

User-defined data structures

Stack

Assuming you have a 'stack' of books, to get a book in the middle of the stack, one has to get the book at the top book first followed by the second book... to the book that the person wants to access. In Stack, this approach is known as LIFO (Last-in First-out).
This means that it is a linear data structure where elements are accessed only from the top position.
In Stack, elements can be pushed, accessed, and popped as required.



stack = ['first', 'second', 'third']
print(stack)

print()

# pushing elements
stack.append('fourth')
stack.append('fifth')
print(stack)
print()

# printing top
n = len(stack)
print(stack[n-1])
print()

# poping element
stack.pop()
print(stack)

------
(Output)

[‘first’, ‘second’, ‘third’]

[‘first’, ‘second’, ‘third’, ‘fourth’, ‘fifth’]

fifth

[‘first’, ‘second’, ‘third’, ‘fourth’]

Python from the word ...Go (Pt2)

Mark Gatere — Fri, 10 Jun 2022 12:37:07 +0000

Basics Part2

Helloooo there! Welcome back!!
Wait, are you new here? Don't worry, I got you covered. Here, we are breaking the flow. Have you checked "Python from the word ...Go" Basics Part1? It's an awesome resource to first check out if you are not familiar with Python's variables and data types which comprise a few in-built Python data structures.
They are really gonna come in handy for this section.

Set? Lets' go!!

In the previous module, we learnt about the fundamental Python data types and also covered some of the terms used when talking about code like variables, statements, expressions, functions, methods ...etc.
Most importantly, we covered how to perform actions on the data types (Both functions and methods for each data type).
Up until now, we were still scratching the surface. Every time we write code, we wrote it line by line and hence our interpreter would go line by line running each code up to the last line.

>>> #do something
>>> #do something
>>> #do something
>>> #do something

We are now going to incorporate the idea of running multiple lines over and over to discover the true power of programming for machines, haha!
Hence, in this section, we gonna talk about the idea of conditions and conditional logic. We gonna discuss more on looping and loops where we can perform actions multiple times over and over.
We are now going to break into a new world where instead of going from line by line in order, we gonna loop over till a condition is met.

Conditional Logic

We previously covered Boolean variables (True or False). When we come to conditional logic, Booleans are super important.
Example:
A person(a) wants to purchase a car from a company with specific conditions:

The car must be new.
The car must have a license.

Hence for person(a) to purchase the car:

is_new = True
is_licensed = True

In conditional logic, we use the 'if' keyword.
"If the car is new and licensed, then person(a) can purchase it".
Then, if any of the conditions in purchasing the car is not met, person(a) cannot purchase the car.

Example2:
Let's assume that for one to get into a specific event, the person has to be old(35 years and above). Create a program to only allow old people to the event.
If is_old = True, "allowed to get into the event."
For the syntax:

>>> is_old = True
>>> if is_old:
>>>   print("You are allowed to get in")
You are allowed to get in

>>> is_old = False
>>> if is_old:
>>>   print("You are allowed to get in")
#nothing will be printed out.

Note: Any code that comes after the colon in the condition is automatically indented hence run if the condition is True whereas any code that ain't indented after the condition is not under the condition and hence run separately.
Example:

>>> is_old = True
>>> if is_old:
>>>   print("You are allowed to get in")
>>> print("Hello there")
You are allowed to get in
Hello there

>>> is_old = False
>>> if is_old:
>>>   print("You are allowed to get in")
>>> print("Hello there")
Hello there

What if when a condition is not met(False), we want to perform another condition?

Here is an example:
I leave my house;
If it's cloudy, I bring an umbrella;
otherwise, I bring sunglasses.

We use the keyword 'else'.

Using our example of letting people in for the event, we can add:
If is_old = True, "allowed to get into the event.", otherwise if is_old = False, "not allowed to get in",

>>> is_old = True
>>> if is_old:
>>>   print("You are allowed to get in")
>>> else:
>>>   print("Not allowed in")
You are allowed to get in

>>> is_old = False
>>> if is_old:
>>>   print("You are allowed to get in")
>>> else:
>>>   print("Not allowed in")
Not allowed in

What if by chance you have more than one condition?

Example:
I'm in a restaurant;
If I want meat, I order steak;
otherwise, If I want Pasta, I order spaghetti and meatballs;
otherwise, I order salad.

For such cases, we use the 'elif' keyword (else if).
Using a different example.

A person(b) wants to order chicken pizza. If there is no chicken pizza, the person(b) can order beef pizza; otherwise, if there is none, the person(b) can order rice.

>>> chicken_pizza = True
>>> beef_pizza = True

>>> if chicken_pizza:
>>>   print("Serve me chicken pizza.")
>>> elif beef_pizza:
>>>   print("Serve me beef pizza.")
>>> else:
>>>   print("Serve me rice.")
Serve me chicken pizza.

--------------------------------------------------
>>> chicken_pizza = False
>>> beef_pizza = True

>>> if chicken_pizza:
>>>   print("Serve me chicken pizza.")
>>> elif beef_pizza:
>>>   print("Serve me beef pizza.")
>>> else:
>>>   print("Serve me rice.")
Serve me beef pizza.

--------------------------------------------------
>>> chicken_pizza = False
>>> beef_pizza = False

>>> if chicken_pizza:
>>>   print("Serve me chicken pizza.")
>>> elif beef_pizza:
>>>   print("Serve me beef pizza.")
>>> else:
>>>   print("Serve me rice.")
Serve me rice.

"For a person to be legalized to drive a car in public, one must have a national identification card and a driving license."
These are two conditions that one must have to avoid being fined by the cops.
To develop such a program, we must have both conditions True hence we can use the keyword 'and' to check whether both conditions are True.
When using 'and' both conditions must be True to execute the condition, if any of them is False, the program will run the 'elif' and 'else' part.

>>> has_id = True
>>> has_license = True

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Allowed to drive

--------------------------------------------------
>>> has_id = False
>>> has_license = True

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

--------------------------------------------------
>>> has_id = True
>>> has_license = False

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

Python Indentation

The interpreter in python finds meaning in the spacing hence indentation(tabs) and white spaces in python is essential.

Truthy Vs Falsy

In python, whenever there's a value, the interpreter recognizes that as True. Otherwise, when there's a zero(0) or no value, python interpreter recognizes that as False.
These are referred to as Truthy and Falsy values.

>>> print(bool('hello'))
>>> print(bool(5))
>>> print(bool(''))
>>> print(bool(0))
>>> print(bool(None))
True
True
False
False
False

All values are considered "truthy" except the following; which are considered "falsy":

None
False
0
0.0
0j
Decimal(0)
Fraction(0, 1)
[] - an empty list
{} - an empty dict
() - an empty tuple
'' - an empty str
b'' - an empty bytes
set() - an empty set
range(0) - an empty range
Objects for which:
- obj.__bool__() returns False
- obj.__len__() returns 0

Note: A "truthy" value will satisfy the check performed by if or while statements. We use "truthy" and "falsy" to differentiate from the bool values True and False.
Example:

>>> has_id = 'hello'
>>> has_license = 5

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Allowed to drive

--------------------------------------------------
>>> has_id = 'hello'
>>> has_license = 0

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

--------------------------------------------------
>>> has_id = None
>>> has_license = True

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

--------------------------------------------------
>>> has_id = True
>>> has_license = ''

>>> if has_id and has_license:
>>>   print("Allowed to drive")
>>> else:
>>>   print("Not allowed to drive")
Not allowed to drive

A good though not perfect example on the use of "truthy" and "falsy" application is in forms or in keying in log in credentials.

When a field is set to as 'a required field', the system expects the field to be "truthy" hence should not be left blank as this will lead to it being assigned "falsy".

Ternary Operator (Conditional Expression)

This is another way to do conditional logic. This works the same as 'if statements' but can in a way be referred to as a 'shortcut' so can only be used in certain conditional logic.
In this mode, we start with the condition then incorporate the "if statement".
"condition_if_true" if condition else "condition_if_false"

Example:
Let's use an example to determine if a user is your friend (eg. on Facebook whether the user can message you).

>>> is_friend = True
>>> can_message = "Message allowed" if is_friend else "not allowed to message"
>>> print(can_message)
Message allowed

>>> is_friend = True
>>> can_message = "Message allowed" if is_friend else "not allowed to message"
>>> print(can_message)
not allowed to message

Short Circuiting

Previously we saw how to use the 'and' keyword to validate whether both statements are True:

>>> is_friend = True
>>> is_user = True
>>> print(is_friend and is_user)
True

>>> is_friend = True
>>> is_user = False
>>> print(is_friend and is_user)
False

In short circuiting, the interpreter ignores one part of the condition(despite it being false) and returns either True or False.
Example, using the 'or' keyword, if the first part of the condition is True the interpreter returns True without checking the second part.
When we use the 'and' keyword, when the the first part of the statement is False, the interpreter ignores(short circuits) the second part and returns False.
An example using the 'or' keyword:

>>> is_friend = True
>>> is_user = False
>>> print(is_friend or is_user)
True

>>> is_friend = True
>>> is_user = True
>>> print(is_friend or is_user)
True

>>> is_friend = False
>>> is_user = True
>>> if is_friend or is_user:
>>>   print("Best friends forever")
Best friends forever

>>> is_friend = False
>>> is_user = True
>>> if False or is_user:
>>>   print("Best friends forever")
>>> else:
>>>   print("Never friends")
Best friends forever

>>> is_friend = True
>>> is_user = False
>>> if False or is_user:
>>>   print("Best friends forever")
>>> else:
>>>   print("Never friends")
Never friends

>>> if True or True:
>>>   print("Best friends forever")
>>> else:
>>>   print("Never friends")
Best friends forever

Logical Operators

We have looked at a few logical operators previously 'and' and 'or'. A logical operator allows us to perform logic between two things.
Other logical operators include:

Greater than >
Less than <
Equal to ==
Greater than or equal to >=
Less than or equal to <=
Not equal to != (Opposite of equal to)
not keyword / Function - It negates the statement. Can also be written with bracket: not().

They return either True or False:

>>> print(4 > 5)
False

>>> print(4 < 5)
True

>>> print(4 == 5)
False

>>> print(1 >= 0)
True

>>> print(1 <= 0)
False

>>> print(0 >= 0)
True

>>> print(0 != 0)
False

>>> print(not(True))
False

>>> print(not True)
False

>>> print(not False)
True

>>> print(not(1 == 1))
False

>>> print(not(1 != 1))
True

Note: A single equal sign = symbol is used in assigning values to variables hence to use the "equal to" operator for comparison, we use a double == symbol.

>>> print('a' > 'b')
False

>>> print('a' > 'A')
True

But why/how is 'a' > 'b' False; and 'a' > 'A' True?

In the case of strings, Python compares the ASCII values of the characters. Hence, 'a' ASCII value is 97, 'b' is 98 and 'A' ASCII value is 65 that's why 'a' is greater than 'A' and 'b' is greater than 'a'.

*optional
In the case of, print('abc' < 'bac'), the result will be True. (Though this is a bit beyond the scope of the course).
This kind of comparison uses lexicographical ordering: first the first two items are compared, and if they differ this determines the outcome of the comparison; if they are equal, the next two items are compared, and so on, until either sequence is exhausted.

Lexicographical ordering for strings uses the Unicode code point number to order individual characters.

>>> print(1 < 2 < 3 < 4)
True

>>> print(1 < 2 > 3 < 4)
False

Exercise1 (Done below)

You have been hired by a gaming company to create a program for a game where the character has magic powers and is an expert.
If the character has magic and is an expert, the output should be "You are a master magician". Otherwise, if the character has magic but is not an expert, the output should be "At least you're getting there". Else, if the character has no magic, the output should be "You need magic powers".

>>> print("Enter '1'(Yes) or '0'(No) for each question.")
>>> has_magic = bool(int(input("Does the character has magic? ")))
>>> is_expert = bool(int(input("Is the character an expert? ")))

>>> if has_magic and is_expert:
>>>   print("You are a master magician.")
>>> elif has_magic and not is_expert:
>>>   print("At least you're getting there.")
>>> elif not has_magic:
>>>  print("You need magic powers.")
Enter '1'(Yes) or '0'(No) for each question.
Does the character has magic? _1_
Is the character an expert? _1_
You are a master magician.

(Re-run the program)
Enter '1'(Yes) or '0'(No) for each question.
Does the character has magic? _0_
Is the character an expert? _1_
You need magic powers.

(Re-run the program)
Enter '1'(Yes) or '0'(No) for each question.
Does the character has magic? _1_
Is the character an expert? _0_
At least you're getting there.

'is' keyword

Unlike the double equal sign ==, which compares the equality in values, is is a keyword that checks if the location in memory where one value is stored is the same as the other's.
Example:

>>> print(True == 1)
>>> print('' == 1)
>>> print('1' == 1)
>>> print([] == 0)
>>> print(10 == 10.0)
>>> print([] == [])
>>> print([1, 2, 3] == [1, 2, 3])
True
False
False
False
True
True
True

>>> print(True is 1)
>>> print('' is 1)
>>> print('1' is 1)
>>> print([] is 0)
>>> print(10 is 10.0)
>>> print([] is [])
>>> print([1, 2, 3] is [1, 2, 3])
False
False
False
False
False
False
False

>>> print(True is True)
True

>>> print('1' is '1')
True

>>> print(10 is 10)
True

Once a list is created, it is stored in different memory space hence print([] is []) or print([1, 2, 3] is [1, 2, 3]) will always evaluate to False.

All Data Structures in Python are stored in different memory locations.

For Loops

Loops are one of the most powerful features of a programming languages. The concept of looping allows us to run lines of code over and over till we accomplish a specific task.
In creating a for loop, we use the keyword 'for'.
Example: for i in 'name':
'i' in the loop is a variable for each element in the loop and can be any different name: for item in 'name':, for teddy in 'name': and is created for each item in 'name'(iterable).
An iterable is something that can be looped over.

>>> for item in 'name':
>>>    print(item)
n
a
m
e

>>> for item in [1, 2, 3, 4]:
>>>    print(item)
1
2
3
4

>>> name = 'Mark'
>>> for i in name:
>>>    print(i)
M
a
r
k

>>> for item in {1, 2, 3, 4}:
>>>    print(item)
1
2
3
4

>>> for item in (1, 2, 3, 4):
>>>    print(item)
1
2
3
4

>>> for item in (1, 2, 3, 4):
>>>    print(item)
>>>    print(item)
>>>    print(item)
>>> print("Hello")

1
1
1
2
2
2
3
3
3
4
4
4
Hello

>>> for item in (1, 2, 3, 4):
>>>    print(item)
>>>    print(item)
>>>    print(item)
>>> print(item)
1
1
1
2
2
2
3
3
3
4
4
4
4

Nested for loops

>>> for item in (1, 2, 3, 4, 5):
>>>     for x in ['a', 'b', 'c']:
>>>         print(item, x)
1 a
1 b
1 c
2 a
2 b
2 c
3 a
3 b
3 c
4 a
4 b
4 c
5 a
5 b
5 c

Iterables

An iterable is an object or a collection that can be iterated over (looped over).
An iterable can be a list, tuple, dictionary, set and string. This means that one can go one by one checking each item in the collection.

Iterating over a dictionary

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user:
>>>     print(item)
name
age
can_swim

When we iterate over a dictionary we only get the keys but can use the dictionary methods to loop over the dictionary items which includes its values.

One is 'x.items()' where we get the key-value pairs in tuples form.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.items():
>>>     print(item)
('name', 'Mark')
('age', 30)
('can_swim', False)

Second is 'x.values()' where we get only the values in the dictionary.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.values():
>>>     print(item)
Mark
30
False

Third is 'x.keys()' where we get only the keys in the dictionary. Works the same as iterating the dictionary without including a method.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.keys():
>>>     print(item)
name
age
can_swim

What if you want to print the items (key and values) in the dictionary separately? We can use tuple unpacking.

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for item in user.items():
>>>     key, value = item
>>>     print(key, value)
name Mark
age 30
can_swim False

(second way of unpacking)

>>> user = {
>>>     'name' : 'Mark',
>>>     'age' : 30,
>>>     'can_swim' : False
>>>   }

>>> for key, value in user.items():
>>>     print(key, value)
name Mark
age 30
can_swim False

Exercise2 (Done below)

Building a simple 'counter' to loop over a list and sum up the items in the list. The list is provided below.
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

>>> my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> sum = 0
>>> for i in my_list:
>>>     sum += i
>>> print (sum)
55

range() in loops

It returns an object that produces a sequence of integers from the start (which is inclusive) to stop (exclusive).

>>> print(range(100))
range(0, 100)

>>> print(range(0, 100))
range(0, 100)

We can iterate a range of numbers.

>>> for num in range(20)
>>>    print(num)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>>> for i in range(2, 15)
>>>    print(i)
2
3
4
5
6
7
8
9
10
11
12
13
14

>>> for i in range(10):
>>>    print('my name is')
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is

When one 'does not want to use' a variable name in the loop, the person can use an underscore _:

>>> for _ in range(20)
>>>    print(_)
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

>>> for _ in range(10):
>>>    print('my name is')
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is
my name is

(start: stop: stepover) in range()

>>> for _ in range(0, 10, 2)
>>>    print(_)
0
2
4
6
8

>>> for _ in range(0, 10, -1)
>>>    print(_)
#nothing will be printed out

>>> for _ in range(10, 0, -1)
>>>    print(_)
10
9
8
7
6
5
4
3
2
1

>>> for _ in range(10, 0, -2)
>>>    print(_)
10
8
6
4
2

>>> for _ in range(2)
>>>    print(list(range(10)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

enumerate()

It returns each item in the iterable with its index in tuple form.

>>> for i in enumerate('mark'):
>>>    print(i)
(0, 'm')
(1, 'a')
(2, 'r')
(3, 'k')

>>> for i, j in enumerate('mark'):
>>>    print(i, j)
0 m
1 a
2 r
3 k

>>> for i, char in enumerate(list(range(100))):
>>>     if char == 50:
>>>         print(f"The index of 50 is: {i}")
The index of 50 is: 50

>>> for i, j in enumerate('Mark'):
>>>     if j == 'r':
>>>         print(f"The index of r is: {i}")
The index of r is: 2

While Loops

In While loop, a command is run when a specific condition is met till the condition becomes false after constant looping.
eg:

>>> i = 0
>>> while 0 < 50:
>>>     print(i)
0
0
0
0
0
#will run infinitely for 0 will always be less than 50.

>>> i = 0
>>> while i < 50:
>>>     i += 5
>>>     print(i)
5
10
15
20
25
30
35
40
45
50

break command in while loop

When a break keyword is used in while loop, it breaks the loop after the first run.

>>> i = 0
>>> while 0 < 50:
>>>     print(i)
>>>     break
0

using else in while loop

>>> i = 0
>>> while i < 50:
>>>     i += 5
>>>     print(i)
>>> else:
>>>     print("Done with work")
5
10
15
20
25
30
35
40
45
50
Done with work

>>> i = 0
>>> while i > 50:
>>>     i += 5
>>>     print(i)
>>> else:
>>>     print("Done with work")
Done with work

The else block in while loop will only execute when there is no break statement in the while loop.

>>> i = 0
>>> while i < 50:
>>>     i += 5
>>>     print(i)
>>>     break
>>> else:
>>>     print("Done with work")
0

How for loops and while loops relates

>>> my_list = [1, 2, 3]
>>> for item in my_list:
>>>     print(item)
1
2
3
------------------------------------
>>> my_list = [1, 2, 3]
>>> i = 0
>>> while i < len(my_list):
>>>     print(my_list[i])
>>>     i += 1 
1
2
3

While loops are more flexible for we have a conditional statement but for loops are simpler. With the while loop, we have to remember to hope the loop in the course or use a break statement, to avoid getting an infinite loop.

>>> while True:
>>>     input("Say something: ")
>>>     break
Say something: _hi_

>>> while True:
>>>     response = input("Say something: ")
>>>     if (response == "bye"):
>>>         break
Say something: _hi_
Say something: _hi_
Say something: _bye_

break, continue, pass

The break keyword breaks out of the loop. The continue keyword continues the loop till the condition is met without running the indented line(s) below it. The pass keyword is used to pass to the next line. It is mainly used as a placeholder.

>>> my_list = [1, 2, 3]
>>> for item in my_list:
>>>    continue
>>>    print(item)
#nothing will be printed

>>> i = 0
>>> while i < len(my_list):
>>>    i += 1
>>>    continue
>>>    print(my_list[i])
#nothing will be printed

>>> my_list = [1, 2, 3]
>>> for item in my_list:
>>>    pass

>>> i = 0
>>> while i < len(my_list):
>>>    print(my_list[i])
>>>    i += 1
>>>    pass
1
2
3

Exercise3 (Done below)

Our First GUI Exercise 🥳 (Basic Version)

In this exercise, we are going to simulate what the computer does when we have a graphical user interface (GUI).

Assuming below are the pixels of an image (Christmas Tree in a nested list),;

picture = [
   [0, 0, 0, 1, 0, 0, 0],
   [0, 0, 1, 1, 1, 0, 0],
   [0, 1, 1, 1, 1, 1, 0],
   [1, 1, 1, 1, 1, 1, 1],
   [0, 0, 0, 1, 0, 0, 0],
   [0, 0, 0, 1, 0, 0, 0]
]

You gonna loop over the list(s) and the moment you encounter a zero(0), you will display on the screen 'an empty space' but when you encounter a one(1), you gonna simulate a pixel hence display a star(*).

For this challenge, we will include a new special print parameter(option) known as 'end ='.
By default, the print function ends with a newline (when we print anything, we get a new line for the next statement). Passing the whitespace to the end parameter (end=' ') indicates that the end character has to be identified by whitespace and not a newline which we will use, for in this case, we don't want a new line after printing each and every character.
end = - "String appended after the last value".

(Without using the 'end' parameter)

>>> picture = [
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0]
    ]

>>> for row in picture:
>>>    for pixel in row:
>>>       if pixel == 0:
>>>          print(" ")
>>>       else:
>>>          print("*")



*





*
*
*



*
*
*
*
*

*
*
*
*
*
*
*



*






*

(After using the end parameter to include a blank space 'empty string' after the end of the line)

>>> picture = [
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0]
    ]

>>> for row in picture:
>>>    for pixel in row:
>>>       if pixel == 0:
>>>          print(" ", end = ' ')
>>>       else:
>>>          print("*", end = ' ')

      *           * * *       * * * * *   * * * * * * *       *             *

(After each loop of the pixels, we also wanna include a blank space 'empty string' so that each single loop will be by default in each line):

>>> picture = [
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0]
    ]

>>> for row in picture:
>>>    for pixel in row:
>>>       if pixel == 0:
>>>          print(" ", end = ' ')
>>>       else:
>>>          print("*", end = ' ')
>>>    print(" ")

      *        
    * * *      
  * * * * *
* * * * * * *
      *
      *

Exercise4 (Done below)

(Finding Duplicates in a list using loops and conditional logic)
Note: No use of sets in this case.
After finding the duplicate values, the program should print the duplicate values.

>>> some_list = ['a', 'b', 'c', 'b', 'd', 'm', 'n', 'n']
>>> duplicates = []
>>> for value in some_list:
>>>    if some_list.count(value) > 1:
>>>        if value not in duplicates:
>>>            duplicates.append(value)
>>> print(duplicates)
['b', 'n']

Functions

Up until now, we've worked with python functions like print, list, input function and many more that allowed us to perform actions on our data types.
We can also create our own functions and use them on our program.
When creating functions in Python we use the def - 'define' keyword. We then give our function a name (defining the function) as we do with variables then we add the brackets () and a colon at the end.
For one to use a function one has to 'call it'.

>>> def say_hello(): #defining the function
>>>    print("Hellooo")
>>> say_hello() #calling the function
Hellooo

Functions are super useful because the work under the principle of 'DRY - Don't Repeat Yourself' because instead of the programmer re-typing the code each and every time, the programmer can just call the function as many times as possible to run a specific block of code.

Example: Using our Christmas tree example above, we can use the function to output it multiple of times.

>>> picture = [
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 1, 1, 1, 1, 1, 0],
       [1, 1, 1, 1, 1, 1, 1],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0]
    ]

>>> def show_tree():
>>>    for row in picture:
>>>        for pixel in row:
>>>            if pixel == 0:
>>>                print(" ", end = ' ')
>>>            else:
>>>                print("*", end = ' ')
>>>        print(" ")

>>> show_tree()
>>> show_tree()
>>> show_tree()

      *        
    * * *      
  * * * * *
* * * * * * *
      *
      *
      *
    * * *
  * * * * *
* * * * * * *
      *
      *
      *
    * * *
  * * * * *
* * * * * * *
      *
      *

The function is stored in a specific place in memory once created.

>>> def say_hello(): 
>>>    print("Hellooo")
>>> print(say_hello)
<function say_hello at 0x000002332BB33E20>

#The characters '0x000002332BB33E20' show the memory location where the function has been stored.

Arguments Vs Parameters(in functions)

The power of functions beyond it being able to be called multiple times, is the ability of the programmer to make it dynamic. In its brackets, one can pass parameters.
The values which are defined at the time of the function prototype or definition of the function are called as parameters.
When a function is 'called', the actual values that are passed during the 'call' are called as arguments.

>>> def say_hello(name, age): #name and age are parameters.
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Mark", 20) #"Mark" and 20 are arguments.
Hello Mark, You're 20 yrs

>>> def say_hello(name, age):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Mark", 20)
>>> say_hello("Emily", 19)
>>> say_hello("Dan", 17)
Hello Mark, You're 20 yrs
Hello Emily, You're 19 yrs
Hello Dan, You're 17 yrs

The above arguments are referred to as positional arguments because they are required to be in the proper position.

>>> def say_hello(name, age):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello(20, "Mark")
Hello 20, You're Mark yrs

Default Parameters and Keyword Arguments

Keyword arguments, as opposed to positional arguments, allow us to not worry about the position hence the arguments can be in any position.
However this makes the code more complicated and not a proper practice way.

>>> def say_hello(name, age):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello(age = 20, name = "Mark")
Hello Mark, You're 20 yrs

Default parameters allow us to give constant values as we define the function. Default parameters only work when no values have been passed as arguments to the function.

>>> def say_hello(name = "Emily", age = 17):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello()
Hello Emily, You're 17 yrs

>>> def say_hello(name = "Emily", age = 17):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Dan", 23)
>>> say_hello()
Hello Dan, You're 23 yrs
Hello Emily, You're 17 yrs

>>> def say_hello(name = "Emily", age = 17):
>>>    print(f"Hello {name}, You're {age} yrs")
>>> say_hello("Irene")
Hello Irene, You're 17 yrs

Return Statement

This is a keyword in python mostly used together with functions.
Functions always have to return something and when there is no return statement, the function will always return None.

>>> def sum(num1, num2):
>>>    num1 + num2
>>> print(sum(4, 5))
None

When the return statement is used;

>>> def sum(num1, num2):
>>>    return num1 + num2
>>> print(sum(4, 5))
9

A function should do one thing really well and/or should return something. This however doesn't mean that the code only has to be one line.

>>> def sum(num1, num2):
>>>    return num1 + num2
>>> total = sum(10, 5)
>>> print(sum(10, total))
25

>>> def sum(num1, num2):
>>>    return num1 + num2
>>> print(sum(10, sum(10, 5)))
25

>>> def sum(num1, num2):
>>>    def another_func(num1, num2):
>>>       return num1 + num2
>>> total = sum(10, 20)
>>> print(total)
None

def sum(num1, num2):
   def another_func(num1, num2):
      return num1 + num2
   return another_func
total = sum(10, 20)
print(total)
<function sum.<locals>.another_func at 0x000002387BF49B40>

>>> def sum(num1, num2):
>>>    def another_func(num1, num2):
>>>       return num1 + num2
>>>    return another_func
>>> total = sum(10, 20)
>>> print(total(10, 20))
30

>>> def sum(num1, num2):
>>>    def another_func(num1, num2):
>>>       return num1 + num2
>>>    return another_func(num1, num2)
>>> total = sum(10, 20)
>>> print(total)
30

To avoid confusion when working with more than one function (function in a function), it is advisable to use different names for the parameter.

>>> def sum(num1, num2):
>>>    def another_func(n1, n2):
>>>       return num1 + num2
>>>    return another_func(num1, num2)
>>> total = sum(10, 20)
>>> print(total)
30

Note: A return keyword automatically exits the function in that any code (to output) below the return statement is never run.

>>> def sum(num1, num2):
>>>    def another_func(n1, n2):
>>>       return num1 + num2
>>>    return another_func(num1, num2)
>>>    return 5
>>>    print("Hello")
>>> total = sum(10, 20)
>>> print(total)
30

Methods Vs Functions

Examples of inbuilt functions in python include : list(), print(), max(), min(), input(). We've also found out that we can use the keyword def to define our own functions.

When using methods, we use the dot(.) notation. Methods are owned by 'whatever is to the left of the dot(.)' be it strings, tuples, integers etc. Methods of the fundamental data types have been covered in the previous module where all the data types have been covered too.
Both Functions and Methods allow us to take actions on the data types.
None: Similar to functions, we can also build our own methods which will be explained in details in the next module as we discuss on 'classes and objects'.

Docstrings

This is using triple quotes ('''...''') to 'comment' multiple lines. It can also be used in functions to give more info about a function.

It works the same as the more info about a function provided by the developer environments when typing the inbuilt functions.

Help function

Used to give more info about a function. When a docstring is passed in a function, the help function returns the docstring.

>>> help(print)

print(...)
    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

    Prints the values to a stream, or to sys.stdout by default.
    Optional keyword arguments:
    file:  a file-like object (stream); defaults to the current sys.stdout.
    sep:   string inserted between values, default a space.
    end:   string appended after the last value, default a newline.
    flush: whether to forcibly flush the stream.

-----------------------------------------------------------------

>>> def test(a):
       '''
       Info: This is a function that prints the testing data.
       '''
       print(a)
>>> help(test)
test(a)
    Info: This is a function that prints the testing data.

We can also use the dunder method (Magic method) 'will get into it later in the course' to get more info on a function.

>>> def test(a):
       '''
       Info: This is a function that prints the testing data.
       '''
       print(a)
>>>print(test.__doc___)
Info: This is a function that prints the testing data.

Docstrings are really useful to add comments and definition to a function to enable other people understand what your function does without searching through your multiple files.

Writing clean code

>>> def is_even(num):
>>>    if num % 2 == 0:
>>>      return True
>>>    elif num % 2 != 0:
>>>      return False
>>> print(is_even(50))
True

>>> def is_even(num):
>>>    if num % 2 == 0:
>>>      return True
>>>    else:
>>>      return False
>>> print(is_even(50))
True

>>> def is_even(num):
>>>    if num % 2 == 0:
>>>      return True
>>>    return False
>>> print(is_even(50))
True

>>> def is_even(num):
>>>    return num % 2 == 0
>>> print(is_even(50))
True

*args and **kwargs

*args - arguments
**kwargs - Keyword arguments

In function we have special characters called *args and **kwargs.

>>> def super_func(num):
>>>    return sum(num)
>>> super_func(1, 2, 3, 4, 5)
#returns an error because the function should take just 1 positional argument but we gave 5.

_args (adding an asterisk at the start of the parameter) allows one to pass more than one positional argument.

>>> def super_func(*num):
>>>    print(*num)
>>>    return sum(num)
>>> super_func(1, 2, 3, 4, 5)
1 2 3 4 5

>>> def super_func(*num):
>>>    print(num)
>>>    return sum(num)
>>> super_func(1, 2, 3, 4, 5)
(1 2 3 4 5)

>>> def super_func(*num):
>>>    return sum(num)
>>> print(super_func(1, 2, 3, 4, 5))
15

__kwargs allows us to use keyword arguments. It returns a dictionary of the values.

>>> def super_func(*num, **kwargs):
>>>    print(kwargs)
>>> super_func(1, 2, 3, 4, 5, num1=10, num2=15)
{'num1': 10, 'num2': 15}

>>> def super_func(*num, **kwargs):
>>>    print(kwargs)
>>>    total = 0
>>>     for items in kwargs.values():
>>>        total += items
>>>     return sum(num) + total
>>> print(super_func(1, 2, 3, 4, 5, num1=10, num2=15))
{'num1': 10, 'num2': 15}
40

There's a rule of positioning when one is using parameters, default parameters, *args and **kwargs:

parameters, *args, default parameters, **kwargs

>>> def super_func(name, *num, greet="hi", **kwargs):
>>>    print(kwargs)
>>>    total = 0
>>>     for items in kwargs.values():
>>>        total += items
>>>     return sum(num) + total
>>> print(super_func("Andy", 1, 2, 3, 4, 5, num1=10, num2=15))
{'num1': 10, 'num2': 15}
40

Exercise5 (Done below)

Create a function called 'highest_even' that is passed a list of integers and returns the highest even integer.
The list is given below:
my_list = [10, 2, 3, 8, 4, 11]

>>> my_list = [10, 2, 3, 4, 8, 11]
>>> even_list = []
>>> def highest_even():
>>>    for i in my_list:
>>>       if i % 2 == 0:
>>>          even_list.append(i)
>>>          even_list.sort()
>>>          print(even_list)
>>>    print(even_list[-1])
>>> highest_even()
[10]
[2, 10]
[2, 4, 10]
[2, 4, 8, 10]
10

-------------------------------------------------------------

>>> my_list = [10, 2, 3, 4, 8, 11]
>>> even_list = []
>>> def highest_even():
>>>    for i in my_list:
>>>       if i % 2 == 0:
>>>          even_list.append(i)
>>>          even_list.sort()
>>>    print(even_list[-1])
>>> highest_even()
10

We can also use the max keyword to return the maximum even number:

>>> my_list = [10, 2, 3, 4, 8, 11]
>>> def highest_even():
>>>    even_list = []
>>>    for i in my_list:
>>>       if i % 2 == 0:
>>>          even_list.append(i)
>>>    return max(even_list)
>>> print(highest_even())
10

Walrus Operator (:=)

The walrus operator is a new feature in python 3.8.
It is explained in depths in the python documentation.
It is used to assign values to variables as part of a 'larger expression' eg. in if statements, in while loops etc.

>>> a = "Helloooooooooooooooo"
>>> if (len(a) > 10):
>>>     print(f"Too long, {len(a)} elements")
Too long, 20 elements

Using the walrus operator:

>>> a = "Helloooooooooooooooo"
>>> if ((n := len(a)) > 10):
>>>     print(f"Too long, {n} elements")
Too long, 20 elements

Walrus Operator (while loop)

>>> a = "Helloooooooooooooooo"
>>> while ((n := len(a)) > 1):
>>>     print(n)
>>>     a = a[:-1]
>>> print(a)
20
19
18
17
16
15
14
13
12
11
10
9
8
7
6
5
4
3
2
H

-----------------------------------------------------------------

>>> a = "Helloooooooooooooooo"
>>> while ((n := len(a)) > 1):
>>>     print(a)
>>>     a = a[:-1]
>>> print(a)
Helloooooooooooooooo
Hellooooooooooooooo
Helloooooooooooooo
Hellooooooooooooo
Helloooooooooooo
Hellooooooooooo
Helloooooooooo
Hellooooooooo
Helloooooooo
Hellooooooo
Helloooooo
Hellooooo
Helloooo
Hellooo
Helloo
Hello
Hell
Hel
He
H

Scope

"What variables do I have access to?"

>>> print(name)
#returns an error; NameError: name 'name' is not defined

Once a variable is not defined, one cannot have access to it.
A variable with a global scope is a variable that can be accessed by anybody in the file and can be used anywhere; in the conditional logic; in the while loop; in a function, etc.

>>> total = 100
>>> print(total)
100

#total has a global scope

A variable with a functional scope is a variable that can only be accessed in within the function.

>>> def some_func():
>>>    total = 100
>>> print(total)
#returns an error; NameError: name 'total' is not defined

>>> def some_func():
>>>    total = 100
>>>    print(total)
100

Scope Rules

"What would you expect the output of the code below to be?"

>>> a = 1
>>> def confusion():
>>>   a = 5
>>>   return a
>>> print(a)
>>> print(confusion())

The output will be 1 and 5. This is because the first print function, print(a), outputs the value stored in the a with the global scope while the second print function, print(confusion()), returns the value stored in the a variable in the function.
The a is not modified after the function because of scope.

Rules the interpreter follow in scope:

1. Local Scope - Scope within the functional scope.

>>> a = 1
>>> def confusion():
>>>   a = 5
>>>   return a
>>> print(confusion())
>>> print(a)
5
1

>>> a = 1
>>> def confusion():
>>>   return a
>>> print(confusion())
>>> print(a)
1
1

2. Parent Local scope - Works where there's a function within a function.

>>> a = 1
>>> def parent():
>>>   a = 10
>>>   def confusion():
>>>      return a
>>>   return confusion()
>>> print(parent())
>>> print(a)
10
1

3. Global scope

>>> a = 1
>>> def parent():
>>>   def confusion():
>>>      return a
>>>   return confusion()
>>> print(parent())
>>> print(a)
1
1

4. Built in python functions

>>> a = 1
>>> def parent():
>>>   def confusion():
>>>      return sum
>>>   return confusion()
>>> print(parent())
>>> print(a)
<built-in function sum>
1

Note: Parameters are part of the local scope:

>>> b = 10
>>> def confusion(b):
>>>    print(b)
>>> confusion(300)
300

>>> b = 10
>>> def confusion(b):
>>>    print(b)
>>> confusion(b)
10

Global keyword

"What if one wants to refer to a global variable while in the function without creating a new variable?"
Example:

>>> total = 0
>>> def count():
>>>    total += 1
>>>    return total
>>> print(count())
#returns an error; UnboundLocalError: local variable 'total' referenced before assignment

The error occurs because the function count does not recognize total. Hence, we have to add a variable total in the function:

>>> total = 0
>>> def count():
>>>    total = 0
>>>    total += 1
>>>    return total
>>> print(count())
1

To avoid recreating another variable in the function we can use the global keyword to tell the interpreter that we want to use the global scope on the variable in the function.

>>> total = 0
>>> def count():
>>>    global total
>>>    total += 1
>>>    return total
>>> print(count())
1

>>> total = 0
>>> def count():
>>>    global total
>>>    total += 1
>>>    return total
>>> count()
>>> count()
>>> print(count())
3

Dependency injection (A simplified version of global scope)

>>> total = 0
>>> def count(total):
>>>    total += 1
>>>    return total
>>> print(count(total))
1

>>> total = 0
>>> def count(total):
>>>    total += 1
>>>    return total
>>> print(count(count(count(total))))
3

Nonlocal Keyword

This is a new keyword(feature) in python 3 and its used to refer to the parent local scope.

>>> def outer():
>>>    x = "local"
>>>    def inner():
>>>       nonlocal x
>>>       x = "nonlocal"
>>>       print("inner:", x)
>>>    inner()
>>>    print("outer:", x)
>>> outer()
inner: nonlocal
outer: nonlocal

#Without the nonlocal keyword

>>> def outer():
>>>    x = "local"
>>>    def inner():
>>>       x = "nonlocal"
>>>       print("inner:", x)
>>>    inner()
>>>    print("outer:", x)
>>> outer()
inner: nonlocal
outer: local

Why do we need scope?

"Why not just have every variable with a global scope so that everything has access to everything?"
Machines don't have infinite power/memory hence we need to be cautious of the resources we use. Scope is a good demonstration of this.
Eg. When a function is run, we create one memory space hence when for instance we use nonlocal, we instead of creating another memory space, we use an existing one.

Hurraay!! 🥳
We come to the end of the second module. Hope you've learnt a lot and ready to implement the skills in different fields.
As we wrap up, here is a simple exercise for you to try before checking the answer done below:

>>> age = input("What is your age?: ")
>>> if int(age) < 18:
>>>     print("Sorry, you are too young to drive this car. Powering off!")
>>> elif int(age) > 18:
>>>     print("Powering On. Enjoy the ride!");
>>> else:
>>>     print("Congratulations on your first year of driving. Enjoy the ride!")

Given the code above, perform the actions below on the code:

Wrap the above code in a function called checkDriverAge() that whenever you call this function, you will get prompted for age.
Instead of using the input(), make the checkDriverAge() function accept an argument of age, so that if you enter eg. checkDriverAge(92), it returns "Powering On. Enjoy the ride!"
Make the default age set to 0 if no argument is given.

Answer:

>>> def checkDriverAge(age=0):
>>>    if int(age) < 18:
>>>        print("Sorry, you are too young to drive this car. Powering off")
>>>    elif int(age) > 18:
>>>        print("Powering On. Enjoy the ride!");
>>>    else:
>>>        print("Congratulations on your first year of driving. Enjoy the ride!")
>>> checkDriverAge(10)
Sorry, you are too young to drive this car. Powering off

What next? 🤔
Let's meet in the next module #Advanced Python1.

Till next time; bye bye.

Python from the word ...Go

Mark Gatere — Tue, 24 May 2022 14:40:43 +0000

Basics Part1

Introduction

What is programming?
In simple terms, programming is a way for us to give instructions to computers. "Giving it an instruction manual, and the computer follows".

Computers don't understand English or any other human language for that matter. Computers speak in 1s and 0s; On or Off (So is all the other electronic component).
But for humans, it would be gibberish or rather difficult to communicate in 1s or 0s. Humans have then developed programming languages that work in between human language and machine language (0s / 1s).
Some programming languages are low-level (closer to machine language) while others are high-level (closer to human language).
Examples of low-level programming languages include:

Assembly

Examples of high-level programming languages include:

Python
JavaScript

What then is a programming language?
A programming language is any set of rules that convert strings, or graphical program elements, to various kinds of machine code output (that is understandable to the computer).

Note: At the end of the day, all programming languages do the same thing, they tell the machine what to do. However, different languages have different modes of doing it.
The beauty is that "most languages have very similar principles."

The hardest part is only in learning the first language.

In between the programming language and the machine language, we need a 'translator' that understands both the programming language (source code) and machine language and hence can translate our code to machine language for the computers to understand.
*The translator ain't a person but rather another program that can either be an interpreter or a compiler.
Like a translator, an interpreter goes line by line throughout the code and executes the code on the machine. In contrast, a compiler takes the code and reads the entire file all at once and translates it to machine code. (Their other major differences are a little complicated and beyond the scope of the course)
Python usually uses an interpreter hence to use python you have to download the interpreter.

Note: To learn or understand more on any of the topics below, here is a link to the official Python Documentation.

Python interpreter

To download the python interpreter, we first visit python.org.

Under Downloads; Click on either Windows or Mac OS depending on one's operating system. (The system will automatically detect the specifications of your computer and either suggest 32bit or 64bit for they using Windows OS)

After downloading is complete, click to load the setup.
Note: While installing, don't forget to mark 'checked' for the option "Add Python to PATH" as shown below:

After clicking 'Install Now', the installation will commence immediately:

...and after a successful installation, the program will notify you:

After installing python, you can use the terminal, (or on Windows) use Command Prompt or PowerShell to confirm whether Python has successfully been added to PATH.
"Open either Command Prompt or PowerShell and type 'python' then click 'Enter' to run the command".
For a successful installation and adding to PATH, both Command Prompt(Image1) and PowerShell(Image2), after running 'python', should look like the image below:

...but by chance there probably was a problem in installation or adding to PATH, after running the 'python' command, it will return an error but one can re-install the interpreter and remember to check 'Add Python to PATH'.

First "Hello World" Program

After setting up the interpreter, we can use the terminal (Command Prompt, GIT Bash, PowerShell, Termux ...etc) to run a few of python commands.
Open the terminal and first run 'python' command. Secondly, use the python command "print" to display characters.

>>> print("I am using python")
I am using python

Setting up the environment (IDE Setup)

We have previously just run our first python program but in a profession, one cannot run the entire company's program on the terminal. It is mainly used for quick testing.
In most cases, we use code editors or IDEs to run python programs.

Why not write code in a word document or a text file?

In a word document, the code will be in form of text hence in case of a syntax error, no information will be returned. In addition, professional developers need some extra tools that code editors and IDEs provide that help them to be more efficient with their code.

What is a code editor and an IDE, and what is their difference?
Code editors are lightweight and give some features like auto-completion, while IDEs are full-fledged environments and provide a tone of extra features like debugging, auto-completion, code formatting, code snippets ...etc.
The most popular code editors and IDEs for Python include: Sublime Text, Visual Studio Code, PyCharm and Jupyter Notebooks.

To install, setup, customize and use Sublime Text: Link
To install, setup, customize and use Visual Studio Code: Link
To install, setup, customize and use PyCharm: Link
To install, setup, customize and use Jupyter Notebooks: Link

Python Basics

In order for any programmer to learn a language, there are 4 key things that they really need to master:

i). Terms of the language - Different words and definitions are used in the language eg. Variables, statements, and instantiation.
ii). Language Data Types - Integers, strings ...etc.
iii). Actions - Using memory and performing some actions.
iv). Best practices of writing a language.

1. Variables

Variables are memory locations that store information that can be used in a program.
They act like 'containers' that store/hold an item(s).
They can hold user(s) input, values ..etc.
eg.

>>> name = "Mark"
>>> print(name)
Mark

Hence, 'name' is a variable that stores the name, Mark.

>>> iq = 190
>>> print(iq)
190

Note: Assigning a value to a variable is known as binding.

Rules of declaring variables

snake_case

>>> user_iq = 190

start with lowercase or underscore

>>> _useriq = 190

letters, numbers, underscores

>>> us4er_iq = 190

Case sensitive

>>> user_iq = 190
>>> user_IQ = 200

>>> print(user_iq)
190

>>> print(user_IQ)
200

Don't overwrite python keywords - One cannot assign values to python keywords. To find the list of complete keywords in python, click the following link.

Variables can also be re-assigned.

>>> iq = 190
>>> user_age = iq/4
>>> print(user_age)
47.5

Constants - These are variables that are not meant to change.
They are written in uppercase.

>>> PI = 3.14

Dunder Variables - Preceded by a double underscore. (Will look at them later in the course)
Examples:

__debug__
__loader__
__import__

Assigning values to variables multiple times:

>>> a, b, c = 1, 2, 3
>>> print(a)
1
>>> print(b)
2
>>> print(c)
3

Note: Variables should be descriptive.

Expressions Vs Statements

>>> iq = 100
>>> user_age = iq / 5

Expression is a piece of code that produces a value. eg: iq / 5
Statement is the entire line of code that performs some sort of action.
eg: iq = 100, user_age = iq / 5
Augmented Assignment Operator

>>> some_value = 5
>>> some_value = some_value + 2
>>> print(some_value)
7

(Can also be written as)

>>> some_value = 5
>>> some_value += 2
>>> print(some_value)
7

>>> some_value = 5
>>> some_value -= 2
>>> print(some_value)
3

>>> some_value = 5
>>> some_value *= 2
>>> print(some_value)
10

2. Python Data Types

A data type is a classification of data which tells the compiler or interpreter how the programmer intends to use the data. It is a classification that specifies which type of value a variable has and what type of mathematical, relational or logical operations can be applied to it without causing an error.
In Python, data types include:

Fundamental Data Types

-Text Type:
str - string

-Numeric Types:
int - integer
float
complex

-Sequence Types:
list
tuple
range

-Mapping Type:
dict - dictionary

-Set Types:
set
frozenset

-Boolean Type:
bool - boolean

-Binary Types:
bytes
bytearray
memoryview

Custom Data Types - Created from classes
Specialized Data Types - Extensions from Modules
None Type - None

a.) int - Integer
An integer is a whole number with no decimal point; 1, 2, 3, 4, 456, -4643, -77.

>>> print(2 + 4)
6

>>> print(2 - 4)
-2

>>> print(2 * 4)
8

>>> print(type(2))
<class 'int'>

>>> print(type(-29))
<class 'int'>

>>> print(type(2 + 4))
<class 'int'>

>>> print(type(2 - 4))
<class 'int'>

b.) float
These are numbers with a decimal point; 5.7, 8.0, 3.5554, 0.00003, -0.543, -4.229.

>>> print(2 / 4)
0.5

>>> print(type(2.7))
<class 'float'>

>>> print(type(-27.554))
<class 'float'>

>>> print(type(2.8 + 4))
<class 'float'>

>>> print(type(2 / 4))
<class 'float'>

Note: - floats take up a lot of space in memory than integers.
This is because the number(s) need to be stored in memory in binary form. But when there's a decimal place eg. 10.56, it is difficult to represent that in a binary form(0s / 1s) because of the point '.' hence a floating-point number is stored in two different locations eg. one for 10 and the other for 56.

To learn more about floating-point numbers, here is a link to the python documentation on floating-point numbers.

Operations on integers and floats.

operators + , - , * , / , ** , // , %

+ ----- addition
- ----- subtraction
* ----- multiplication
/ ----- division

** ---- 'power of'
eg.

>>> print(2 ** 4)
16

>>> print(7 ** 9)
40,353,607

// ---- 'rounds down the quotient to the nearest whole number'
eg.

>>> print(2 // 4)
0

>>> print(3 // 4)
0

>>> print(4 // 4)
1

>>> print(5 // 4)
1

>>> print(7 // 4)
1

>>> print(9 // 4)
2

% ---- 'returns the remainder'
eg.

>>> print(5 % 4)
1

>>> print(5 % 2)
1

>>> print(5 % 3)
2

Math Functions (Actions performed on integers and floats).

i) round - rounds off the number to the nearest whole number.

>>> print(round(3.1))
3

>>> print(round(3.9))
4

ii) abs - returns the absolute value of the argument.

>>> print(abs(-20))
20

>>> print(abs(-354))
354

>>> print(abs(44))
44

iii) pow - used to calculate a number to its specific power.

>>> print(pow(2,3))
8

>>> print(pow(4,3))
64

iv) max - returns the highest number.

>>> print(max(2,3))
3

>>> print(max(2,-9))
2

v) min - returns the least number.

>>> print(min(3,8))
3

>>> print(min(2,-9))
-9

For most of the other mathematical functions to be used, they have to be 'imported' from the math module.
from math import *
The * symbol means 'everything' hence we import all the functions from the math module.

i) floor - rounds down the number.

>>> from math import *

>>> print(floor(3.7))
3

>>> print(floor(5.9))
5

ii) ceil - rounds up the number.

>>> from math import *

>>> print(ceil(3.2))
4

>>> print(ceil(5.9))
5

>>> print(ceil(5.3))
5

iii) sqrt - returns the square root of a number

>>> from math import *

>>> print(sqrt(4))
2.0

>>> print(sqrt(9))
3.0

>>> print(sqrt(121))
11.0

To get more mathematical functions used in python, click the following link.

Operator Precedence (BODMAS)

B - brackets
O - power off
D - division
M - multiplication
A - addition
S - subtraction

>>> print(20 - 3 * 4)
8

>>> print((20 - 3) * 4)
68

>>> print((20 - 3) + 2 ** 2)
21

Conversion to binary *optional

>>> print(bin(5))
0b101

>>> print(int('0b101', 2))
5

c.) str - String
A string is a piece of text. It can either be written with double or single quotation marks.

>>> greetings = "hi, hello there!"
>>> print(greetings)
hi, hello there!

>>> greetings = 'Welcome!'
>>> print(greetings)
Welcome!

>>> print(type("hi, hello there!"))
<class 'str'>

For long strings/sentences (strings that include a lot of lines) we use triple quotes:

>>> passage = ''' Mark Gatere is a student.
    He is currently at University pursuing his degree program.
    He wants to become a Data Scientist in future.'''
>>> print(passage)
Mark Gatere is a student.
He is currently at University pursuing his degree program.
He wants to become a Data Scientist in future.

Working with strings

String Concatenation
Concatenation is the action of linking things together in a series hence, string concatenation is joining multiple strings to one in series.

>>> first_name = "Mark"
>>> second_name = "Gatere"
>>> full_name = first_name + second_name
>>> print(full_name)
MarkGatere

>>> first_name = "Mark"
>>> second_name = "Gatere"
>>> full_name = first_name + ' ' + second_name
>>> print(full_name)
Mark Gatere

Type Conversion
This is converting a value from one data type to another.

>>> print(type(str(100)))
<class 'str'>

>>> a = str(100)
>>> b = int(a)
>>> a_type = type(a)
>>> b_type = type(b)
>>> print(a_type)
<class 'str'>
>>> print(b_type)
<class 'int'>

Escape Sequences
We use a backslash.

>>> weather = 'It\'s sunny'
>>> print(weather)
It's sunny

>>> weather = "It's \"kind of\" sunny"
>>> print(weather)
It's "kind of" sunny

>>> weather = 'It\\s sunny'
>>> print(weather)
It\s sunny

\t is used to add a tab to the output.

>>> weather = '\t It\'s sunny'
>>> print(weather)
    It's sunny

\n is used to take the part after it to a new line.

>>> weather = "It's sunny \n hope you have a good day."
>>> print(weather)
It's sunny
hope you have a good day

Formatted Strings (f-string)
An 'f' is added at the start of the expected output.

>>> name = "Johnny"
>>> age = 55
>>> print ("hi" + name + ". You are" + str(age) + "years old.")
hi Johnny. You are 55 years old.

(can also be written as)

>>> name = "Johnny"
>>> age = 55
>>> print (f"hi {name}. You are {age} years old.")
hi Johnny. You are 55 years old.

In python 2 (but also works in python 3):

>>> name = "Johnny"
>>> age = 55
>>> print ("hi {}. You are {} years old.".format(name, age))
hi Johnny. You are 55 years old.

>>> name = "Johnny"
>>> age = 55
>>> print ("hi {1}. You are {0} years old.".format(name, age))
hi 55. You are Johnny years old.

String Indexes
A string is stored in a memory as ordered pieces of characters.

my name is
0123456789

To access each character in a string, we use an index. Indexing starts from zero(0).

>>> sentence = "my name is Mark"
>>> print(sentence[3])
n

>>> sentence = "my name is Mark"
>>> print(sentence[8])
i

String Slicing
[start:stop] - We start from the stated index but stop at but not including the index given.

>>> number = '01234567'
>>> print(number[0:7])
0123456

>>> number = '01234567'
>>> print(number[0:8])
01234567

>>> sentence = "my name is Mark"
>>> print(sentence[1:10])
y name is

[start:stop:stepover]

>>> number = '01234567'
>>> print(number[0:8:2])
0246

>>> sentence = "my name is Mark"
>>> print(sentence[1:15:2])
ynm sMr

Extra ways to access the values using the indexes:

>>> number = '01234567'
>>> print(number[1:])
1234567

>>> number = '01234567'
>>> print(number[:5])
01234

>>> number = '01234567'
>>> print(number[::2])
0246

>>> number = '01234567'
>>> print(number[-1])
7

>>> number = '01234567'
>>> print(number[-2])
6

>>> number = '01234567'
>>> print(number[-3])
5

>>> number = '01234567'
>>> print(number[::-1])
76543210

>>> number = '01234567'
>>> print(number[::-2])
7531

Immutability
Strings in Python are immutable (they cannot be changed).

Built-in string Functions and methods
len() - used to find the number of characters in a string.

>>> greet = "Hello"
>>> print(len(greet))
5

x.upper() - capitalizes or changes the entire string to uppercase.

>>> greet = "Hello"
>>> print(greet.upper)
HELLO

x.lower() - changes the entire string to lowercase.

>>> greet = "HELLO"
>>> print(greet.lower)
hello

x.capitalize() - capitalizes the first character at the beginning of the string.

>>> greet = "hello"
>>> print(greet.capitalize)
Hello

x.isupper() - returns either True or False on whether the string is in uppercase.

x.islower() - returns either True or False on whether the string is in lowercase.

Using functions in combination with each other.

>>> phrase = "My name is Mark"
>>> print(phrase.upper().isupper())
True

x.find() - returns the index of the character(s) you're looking for in the string.

>>> quote = "to be or not to be"
>>> print(quote.find("be"))
3

x.replace() - used to replace character(s) in a string with new character(s).

>>> quote = "to be or not to be"
>>> print(quote.replace("be", "me"))
to me or not to me

>>> quote = "to be or not to be"
>>> print(quote.replace("t", "y"))
yo be or noy yo be

x.index - returns the index of a specific character or the index where the characters start.

>>> greet = "hello"
>>> print(greet.index("e"))
1

>>> greet = "hello"
>>> print(greet.index("l"))
2

>>> greet = "hello"
>>> print(greet.index("lo"))
3

To learn more on string methods, click the following link

d.) bool - booleans
This data type consists of either True or False.

>>> is_cool = True
>>> print(is_cool)
True

>>> is_tall = False
>>> print(is_tall)
False

>>> print(bool(1))
True

>>> print(bool(0))
False

>>> print(bool('True'))
True

>>> print(bool('False'))
True

>>> print(bool())
False

Note: A Boolean value is always True as far as there's a value. 0 or empty data will always return False as shown in the examples above.

An important concept to learn before getting to learn more data types is - Getting input from Users.
You've encountered a form that requires to be filled out.
The form is usually blank and requires specific details for each section including Name, Email address, and contact. An example is shown below:

In Python, we also create programs that require input from the users hence allowing users of the program to input information into the program. To create these programs, we use the keyword input which tells the interpreter that we require input from the user to continue with the other command.

Note: Every input from the user is stored by default as a string (including numbers) hence for any mathematical calculation, the input has to be converted to numerical, either integer or float.

>>> birth_year = input("What year were you born? ")
>>> age = 2022 - birth_year
>>> print(f"Your age is: {age} years old")
What year were you born? _2001_
#Will return an error as birth_year(string) cannot 
 be subtracted from 2022(integer).

>>> birth_year = input("What year were you born? ")
>>> age = 2022 - int(birth_year)
>>> print(f"Your age is: {age} years old")
What year were you born? _2001_
Your age is: 21 years old

Exercise 1 (Done Below)

Create a simple calculator that asks for two numbers from the user, finds their sum and outputs the sum.

(Note the two different programs)

>>> num1 = input("Enter a number: ")
>>> num2 = input("Enter a second number: ")
>>> sum = num1 + num2
>>> print(sum)
Enter a number: _12_
Enter a second number: _5.2_
125.2

# Correct Program
>>> num1 = input("Enter a number: ")
>>> num2 = input("Enter a second number: ")
>>> sum = int(num1) + int(num2)
>>> print(sum)
Enter a number: _12_
Enter a second number: _5.2_
17.2

Exercise 2 (Done Below)

Create a simple password checker that outputs the password in hidden format and outputs the number of characters in the password.

>>> user_name = input("Enter your username: ")
>>> password = input("Enter your Password: ")
>>> pass_length = len(password)
>>> pass_hidden = 'x' * pass_length
>>> print(f"Hello {user_name}, your password: {pass_hidden} is {pass_length} characters long.")
Enter your username: _gateremark_
Enter your Password: _swddbb243tbfbd_
Hello gateremark, your password: xxxxxxxxxxxxxx is 14 characters long.

Let's kick-off off our next data type:

e.) Lists
A list is an ordered sequence of objects of any type. It is denoted by square brackets [].
It can have a collection of items of different data types and can at times be referred to as an array though there's a slight difference between a list and an array. (Will cover this later in the course).

>>> li = [1, 2, 3, 4, 5]
>>> li2 = ['a', 'b', 'c', 'f']
>>> li3 = [1, 2, 'r', 'u', True]
>>> print(li)
>>> print(li2)
>>> print(li3)
[1, 2, 3, 4, 5]
['a', 'b', 'c', 'f']
[1, 2, 'r', 'u', True]

Lists are Data Structures.
A Data Structure is a data organization, management, and storage format that enables efficient access and modification.

Accessing individual items in a list (using index)

>>> li3 = [1, 2, 'r', 'u', True]
>>> print(li3[2])
>>> print(li3[4])
r
True

>>> amazon_cart = ["notebooks", "sunglasses", "earphones"]
>>> print(amazon_cart[2])
earphones

>>> amazon_cart = ["notebooks", "sunglasses", "earphones"]
>>> print(amazon_cart[3])
#Returns an error for the index is out range.

List Slicing

As we did in strings, we can use the index [start:stop] to access a specific range of items in a list.
Remember eg. [1:7] selects all items from index 1 to but not including the item in index 7 hence the last item is the item in index 6.

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> print(amazon_cart[0:4])
['notebooks', 'sunglasses', 'earphones', 'toys']

[start:stop:stepover]

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> print(amazon_cart[::2])
['notebooks', 'earphones', 'grapes']

Modifying elements in a list

Lists, unlike strings, are mutable hence one can modify elements in a list.

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> print(amazon_cart)
['Laptop', 'sunglasses', 'earphones', 'toys', 'grapes']

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> new_cart = amazon_cart[0:3]
>>> new_cart[1] = "gum"
>>> print(new_cart)
>>> print(amazon_cart)
['Laptop', 'gum', 'earphones']
['Laptop', 'sunglasses', 'earphones', 'toys', 'grapes']

Note: When you assign a list to a different variable, it points to the memory location of the original list hence modification of the list in the new variable leads to modification of the original list in the previous variable.
Example:

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> new_cart = amazon_cart
>>> new_cart[0] = "gum"
>>> print(new_cart)
>>> print(amazon_cart)
['gum', 'sunglasses', 'earphones', 'toys', 'grapes']
['gum', 'sunglasses', 'earphones', 'toys', 'grapes']

To avoid modification of the original list after one has modified the list assigned in the new variable, we use [:] after the list variable to copy the entire list and store it as a new list in a different variable.

>>> amazon_cart = ["notebooks", 
                   "sunglasses", 
                   "earphones",
                   "toys",
                   "grapes"]
>>> amazon_cart[0] = "Laptop"
>>> new_cart = amazon_cart[:]
>>> new_cart[0] = "gum"
>>> print(new_cart)
>>> print(amazon_cart)
['gum', 'sunglasses', 'earphones', 'toys', 'grapes']
['Laptop', 'sunglasses', 'earphones', 'toys', 'grapes']

Matrix (These are multi-dimensional lists/arrays)

>>> matrix = [
      [2, 4, 6],
      [9, 5, 7],
      [3, 8, 1]
    ]
>>> print(matrix)
[[2, 4, 6], [9, 5, 7], [3, 8, 1]]

Accessing elements in a multi-dimensional list/array.

>>> matrix = [
      [2, 4, 6],
      [9, 5, 7],
      [3, 8, 1]
    ]
>>> print(matrix[1][2])
>>> print(matrix[0][1])
7
4

>>> matrix = [
      [2, 4, 6],
      [9, 5, 7],
      [3, 8, 1]
    ]
>>> print(matrix[2][3])
#Returns an error for the index is out of range.

List Functions and Methods/Actions

len() - Find the length of a list (number of items in a list).

>>> basket = [1, 2, 3, 4, 5]
>>> print(len(basket))
5

x.append() - Used to add a value to an original list.
It modifies the list inplace hence does not create a copy of the original list.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.append(100)
>>> print(basket)
[1, 2, 3, 4, 5, 100]

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.append(100)
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100]
None

>>> basket = [1, 2, 3, 4, 5]
>>> basket.append(100)
>>> new_list = basket
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100]
[1, 2, 3, 4, 5, 100]

x.insert() - Used to insert a value anywhere in the list on a specific index.
It too modifies the list inplace hence does not create a copy of the original list.

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.insert(4, 100)
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 100, 5]
None

>>> basket = [1, 2, 3, 4, 5]
>>> basket.insert(4, 100)
>>> new_list = basket
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 100, 5]
[1, 2, 3, 4, 100, 5]

x.extend() - Used to append another list to the original list.
It too modifies the list inplace hence does not create a copy of the original list.

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.extend([100, 101, 107])
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100, 101, 107]
None

>>> basket = [1, 2, 3, 4, 5]
>>> basket.extend([100, 101, 107])
>>> new_list = basket
>>> print(basket)
>>> print(new_list)
[1, 2, 3, 4, 5, 100, 101, 107]
[1, 2, 3, 4, 5, 100, 101, 107]

numbers = [1, 2, 3, 4]
friends = ["Kelvin", "Karen", "Jim"]
friends.extend(numbers)
print(friends)
['Kelvin', 'Karen', 'Jim', 1, 2, 3, 4]

x.pop() - Automatically removes (pops off) the last element from the list or from the given index. It returns the element that has been popped off.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.pop()
>>> print(basket)
[1, 2, 3, 4]

>>> friends = ["Kelvin", "Karen", "Jim"]
>>> friends.pop()
>>> print(friends)
['Kelvin', 'Karen']

>>> basket = [1, 2, 3, 4, 5]
>>> basket.pop(0)
>>> print(basket)
[2, 3, 4, 5]

>>> basket = [1, 2, 3, 4, 5]
>>> basket.pop(2)
>>> print(basket)
[1, 2, 4, 5]

>>> basket = [1, 2, 3, 4, 5]
>>> new_list = basket.pop(4)
>>> print(new_list)
5

x.remove() - Removes an element/value from a list. Works 'inplace'.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.remove(4)
>>> print(basket)
[1, 2, 3, 5]

x.clear() - Clears the entire list. Works 'inplace'.

>>> basket = [1, 2, 3, 4, 5]
>>> basket.clear()
>>> print(basket)
[]

x.index() - Used to check the index of an element in the list.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print(basket.index('d'))
3

Checking from a specific index in the list.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print(basket.index('d', 0, 3)) #Checking from index 0 to index 3 (but not including index 3).
#returns an error as 'd' is in index 3 yet index 3 is not included in the range.

Finding whether an element is or is not in a list.

We use the keyword 'in' which returns whether True or False.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print('d' in basket)
True

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print('i' in basket)
False

>>> print('a' in 'My name is Mark')
True

>>> print('z' in 'What is the time?')
False

x.count() - Used to count the number of items an element appears in the list.

>>> basket = ['a', 'b', 'c', 'd', 'e']
>>> print(basket.count('d'))
1

>>> basket = [1, 2, 3, 4, 2, 5, 2]
>>> print(basket.count(2))
3

x.sort() - Used to sort the list in ascending order. If the list contains names, they are sorted in alphabetical order. Works 'inplace'.

>>> basket = [5, 2, 3, 4, 1, 3, 2]
>>> basket.sort()
>>> print(basket)
[1, 2, 2, 3, 3, 4, 5]

>>> friends = ["Karen", "Toby", "Elijah"]
>>> friends.sort()
>>> print(friends)
['Elijah', 'Karen', 'Toby']

sorted() - Used to sort the list in ascending order. If the list contains names, they are sorted in alphabetical order. Unlike the method x.sort(), sorted() is a function that produces a new array and hence does not work inplace.

>>> friends = ["Karen", "Toby", "Elijah"]
>>> print(sorted(friends))
['Elijah', 'Karen', 'Toby']

>>> basket = [5, 2, 3, 4, 1, 3, 2]
>>> print(sorted(basket))
[1, 2, 2, 3, 3, 4, 5]

x.copy() - Works the same as [:] by copying the entire list and creating a new one exactly like the original list.

>>> friends = ["Karen", "Toby", "Elijah"]
>>> new_friends = friends.copy()
>>> print(new_friends)
['Karen', 'Toby', 'Elijah']

x.reverse() - Used to reverse the elements in the list from the element in the last index to the element in the first index. Works 'inplace'.
(It does not follow the ascending or any order; It just swaps the elements).

>>> friends = ["Karen", "Toby", "Elijah"]
>>> friends.reverse()
>>> print(friends)
['Elijah', 'Toby', 'Karen']

>>> numbers = [1, 5, 3, 8, 7]
>>> numbers.reverse()
>>> print(numbers)
[7, 8, 3, 5, 1]

>>> numbers = [1, 5, 3, 8, 7]
>>> numbers.sort()
>>> numbers.reverse()
>>> print(numbers)
[8, 7, 5, 3, 1]

Common List Patterns

Reversing a list with list slicing
This creates a new list from the original, that is, it does not work inplace.

>>> numbers = [1, 5, 3, 8, 7]
>>> numbers.sort()
>>> numbers.reverse()
>>> print(numbers)
>>> print(numbers[::-1])
[8, 7, 5, 3, 1]
[1, 3, 5, 7, 8]

Note: You can reverse a list using list slicing (-1) or using the x.reverse() method as shown above.

range() - Generates a list of numbers from up to but not including the last number stated.

>>> print (list(range(1, 50)))
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
11, 12, 13, 14, 15, 16, 17, 18,
19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30, 31, 32, 33, 34,
35, 36, 37, 38, 39, 40, 41, 42,
43, 44, 45, 46, 47, 48, 49]

>>> print (list(range(50)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49]

>>> print (list(range(51)))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17,
18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33,
34, 35, 36, 37, 38, 39, 40, 41,
42, 43, 44, 45, 46, 47, 48, 49,
50]

Getting the length of a list - Number of items in a list.

>>> basket = [1, 2, 6, 8, 4, 0]
>>> print(len(basket))
6

>>> names = ["Mark", "Enoch", "Vivian", "Yvonne", "Mercy"]
>>> print(len(names))
5

.join
This is a string method used to join items in a list with the given 'character'. It creates a new item and hence does not work inplace.

>>> sentence = '!'
>>> new_sentence = sentence.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi!my!name!is!JOJO

>>> sentence = '.'
>>> new_sentence = sentence.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi.my.name.is.JOJO

>>> sentence = ' '
>>> sen2 = ['hello', 'welcome', 'to', 'the', 'city']
>>> new_sentence = sentence.join(sen2)
>>> print(new_sentence)
hello welcome to the city

>>> new_sentence = '!'.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi!my!name!is!JOJO

>>> new_sentence = ' '.join(['hi', 'my', 'name', 'is', 'JOJO'])
>>> print(new_sentence)
hi my name is JOJO

List Unpacking

This is assigning a variable to each item in a list. Works like multiple assigning of values in variables.

>>> a,b,c = [1, 2, 3]
>>> print(a)
>>> print(b)
>>> print(c)
1
2
3

In list unpacking, you can add more values, unpack the values assigned in the variables then store the remaining items in their own variable. You just add the * sign and the name of the variable.

>>> a,b,c *other = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(a)
>>> print(b)
>>> print(c)
>>> print(other)
1
2
3
[4, 5, 6, 7, 8, 9]

>>> a,b,c, *other, d = [1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> print(a)
>>> print(b)
>>> print(c)
>>> print(other)
>>> print(d)
1
2
3
[4, 5, 6, 7, 8]
9

f.) None type
This is a special data type that represents the absence of values.

>>> weapons = None
>>> print(weapons)
None

g.) Tuples
These are like lists but immutable data types. Data stored in tuples can never be changed eg. coordinates.

Can't add elements to it.
Can't erase elements from it.
Can't modify elements in it.

Tuples are also data structures.
They use the parenthesis '()' to store data and can store data of different data types in a single tuple.

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(my_tuple)
(1, 2, 4, 7, 5)

>>> my_tuple = (1, 2, 'a', True)
>>> print (my_tuple)
(1, 2, 'a', True)

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(my_tuple[3])
7

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(3 in my_tuple)
False

>>> my_tuple = (1, 2, 4, 7, 5)
>>> print(5 in my_tuple)
True

>>> my_tuple = (1, 2, 4, 7, 5)
>>> my_tuple[3] = 9
>>> print(my_tuple)
#returns an error as tuples cannot be modified

Tuples can be sliced (similar to list slicing)

>>> my_tuple = (1, 2, 3, 4, 5)
>>> new_tuple = my_tuple[1:4]
>>> print(new_tuple)
(2, 3, 4)

>>> my_tuple = (1, 2, 3, 4, 5)
>>> new_tuple = my_tuple[1:2]
>>> print(new_tuple)
(2,)

>>> x, y, z, *other = (1, 2, 3, 4, 5)
>>> print(x)
>>> print(y)
>>> print(z)
>>> print(other)
1
2
3
[4, 5]

Tuples have two main methods:

x.count()
x.index()

>>> my_tuple = (1, 5, 3, 4, 5)
>>> print(my_tuple.count(5))
2

>>> my_tuple = (1, 5, 3, 4, 5)
>>> print(my_tuple.index(4))
3

To get the length of a tuple:

>>> my_tuple = (1, 5, 3, 4, 5)
>>> print(len(my_tuple))
5

A list of tuples:

>>> coordinates = [(4, 5), (6, 7), (80, 34)]
>>> print(coordinates)
[(4, 5), (6, 7), (80, 34)]

>>> coordinates = [(4, 5), (6, 7), (80, 34)]
>>> print(coordinates[1])
(6, 7)

>>> coordinates = [(4, 5), (6, 7), (80, 34)]
>>> print(coordinates[1][1])
7

h.) Dictionaries
This is a special data structure that allows one to organize or store data in unordered key-value pairs. It uses curly braces '{}'.

dictionary = {
   'key' : value,
   'key' : value
   }

The key must always be unique (shouldn't be repeated).
To access the value, we use the key.

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict)
{'a': 1, 'b': 2, 'x': 3}

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict['b'])
2

>>> my_dict = {
      'a' : 1,
      'b' : 2
      'x' : 4
      }
>>> print(my_dict['c'])
#returns an error for the key is not defined.

Note: Elements in a dictionary are stored in different memory locations which are not necessarily in order:

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict)
{'a': 1, 'b': 2, 'x': 3}

At times the output may be as shown below.

>>> my_dict = {
      'a' : 1,
      'b' : 2,
      'x' : 4
      }
>>> print(my_dict)
{'x': 4, 'a': 1, 'b': 2}

Dictionary keys can store values of different data types (same as lists and tuples).

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict)
{'a': [1, 2, 3], 'b': 'hello', 'x': True, 't': 5}

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict['a'])
[1, 2, 3]

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict['a'][1])
2

>>> my_dict = {
      'a' : [1, 2, 3],
      'b' : "hello",
      'x' : True,
      't' : 5
      }
>>> print(my_dict['b'][4])
o

A dictionary in a list.

>>> my_list = [
       {
        'a' : [1, 2, 3],
        'b' : "hello",
        'x' : True,
        't' : 5
        },

       {
        'a' : [4, 5, 6],
        'b' : "welcome",
        'x' : False,
        't' : 5
       }
    ]
>>> print(my_list[0]['a'][2])
3

Dictionary Keys

Dictionary keys are immutable types and should be unique. This means that a string, a number, a tuple and a Boolean can be a key while a list cannot.
Note: When one re-assigns a key to another value, the original value in the key is overwritten.

>>> dictionary = {
         123 : [1, 2, 5, 6],
         True : 'hello',
         'a' : ('a', 't', 'u'),
         [100] : False
     }
>>> print (dictionary[100])
#returns an error as a list is mutable and hence cannot be used as a key.

>>> dictionary = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         '123' : ('a', 't', 'u')
     }
>>> print(dictionary['123'])
('a', 't', 'u')

Dictionary Methods

x.get() - A method used to check whether a key is present in a dictionary. At times it returns a default value given if a key is missing.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.get('age'))
None

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.get('age', 55))
55

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> print(user.get('age', 55))
20

A second way of creating a dictionary:

By using the keyword 'dict(key = value)'.
The key cannot be an expression, that is, it should be a variable when using 'dict'.

>>> user2 = dict(name = 'John')
>>> print(user2)
{'name': 'John'}

>>> user2 = dict(name = 'John', name2 = 'Mark')
>>> print(user2)
{'name': 'John', 'name2': 'Mark'}

'in' keyword can also be used in dictionaries.

It returns either True or False on whether a key is present or absent in a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('size' in user)
False

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('basket' in user)
True

x.keys() - Used to check whether a specific key is present in a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('123' in user.keys())
True

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('age' in user.keys())
False

x.values() - Used to check whether a specific value is present in a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print('hello' in user.values())
True

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(('a', 't', 'u') in user.values())
True

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print([1, 2, 6, 5] in user.values())
False

x.items() - Returns the entire items in a dictionary as tuples.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.items())
dict_items([('123', [1, 2, 5, 6]), (True, 'hello'), ('basket', ('a', 't', 'u'))])

x.clear() - clears the dictionary and returns an empty dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> print(user.clear())
None

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> user.clear()
>>> print(user)
{}

x.copy() - creates a copy of a dictionary.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u')
     }
>>> user2 = user.copy()
>>> print(user2)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u')}

x.pop() - Removes key with its value from the dictionary and returns the value.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.pop('age')
>>> print(user)
20
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u')}

x.popitem() - Removes a random pair of key-value.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.popitem()
>>> print(user)
('age', 20)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u')}

x.update() - Used to update the keys in the dictionary or by adding a new key and value.

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.update({'age' : 55})
>>> print(user)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u'), 'age': 55}

>>> user = {
         '123' : [1, 2, 5, 6],
         True : 'hello',
         'basket' : ('a', 't', 'u'),
         'age' : 20
     }
>>> user.update({'age2' : 55})
>>> print(user)
{'123': [1, 2, 5, 6], True: 'hello', 'basket': ('a', 't', 'u'), 'age': 20, 'age2': 55}

i.) Sets
These are an unordered collection of unique objects. It uses curly brackets and returns only the unique objects.

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> print(my_set)
{1, 2, 3, 4, 5}

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> my_set.add(2)
>>> my_set.add(100)
>>> print(my_set)
{1, 2, 3, 4, 5, 100}

>>> my_list = [1, 2, 2, 3, 5, 5]
>>> print(set(my_list))
{1, 2, 3, 5}

Objects in a set are not indexed and hence cannot be accessed using an index.

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> print(my_set[0])
#returns an error as items cannot be accessed using indexes in sets

>>> my_set = {1, 2, 3, 4, 5, 5}
>>> print(1 in my_set)
True

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> print(6 in my_set)
False

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> print(len(my_set))
6

Converting a set to a list.

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> print(list(my_set))
[1, 2, 3, 4, 5, 7]

x.copy - Copies a set.

>>> my_set = {1, 2, 3, 4, 5, 5, 7, 7}
>>> new_set = my_set.copy()
>>> my_set.clear()
>>> print(new_set)
>>> print(my_set)
{1, 2, 3, 4, 5, 7}
set()

Methods in sets

x.difference() - Finds the difference of two sets.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.difference(your_set))
{1, 2, 3}

x.discard() - Removes an element from a set if it is a member. Works inplace.

>>> my_set = {1, 2, 3, 4, 5}
>>> my_set.discard(5)
>>> print(my_set)
{1, 2, 3, 4}

x.difference_update() - Removes all elements of another set from the previous set.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.difference_update(your_set))
{1, 2, 3}

x.intersection() - Returns the common values in both sets.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.intersection(your_set))
{4, 5}

Note: You can also use the & symbol for intersection.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set & your_set)
{4, 5}

x.isdisjoint() - Returns either False or True if they have or don't have common values respectively.

>>> my_set = {1, 2, 3, 4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.isdisjoint(your_set))
False

>>> my_set = {1, 2, 3}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.isdisjoint(your_set))
True

x.union() - Returns the union of two sets and removes the duplicates.

>>> my_set = {1, 2, 3}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.union(your_set))
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Note: For union, you can also use the | symbol.

>>> my_set = {1, 2, 3}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set | your_set)
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

x.issubset() - Returns either True or False on whether a set is a subset of the other.

>>> my_set = {4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.issubset(your_set))
True

x.issuperset() - Returns either True of False on whether a set is a superset of the other.
Superset is the opposite of subset.

>>> my_set = {4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(my_set.issuperset(your_set))
False

>>> my_set = {4, 5}
>>> your_set = {4, 5, 6, 7, 8, 9, 10}
>>> print(your_set.issuperset(my_set))
True

Below are attached links to more resources on the topics discussed above:

Congratulations on completing the first milestone Python Basics Part1.
To recap, we have covered variables and data types in Python which includes a few data structures in Python.
Next, in Python Basics Pt2, we gonna be diving more into Python working with control structures, loops and many more...

See you Then!

The Ultimate Guide to Getting Started in Data Science.

Mark Gatere — Sat, 02 Apr 2022 00:07:49 +0000

"Whenever there's a buzzword and a 'complex' subject matter, it's usually good to start with the definition..."

What is Data Science?
The term Data Science, which was introduced around the 1980s remains confusing for many people even now.

"Data Science is not about making complicated models; it's not about making awesome visualizations; it's not about writing code..." - Joma Tech

Then what is it?

#it's up to you

if YouWant == True:
   YouCan
else:
   YouCan't

History of Data Science
Early in the days, before Data Science became the sexiest job of the 21st century, the popular term was Data Mining. In the article 'From Data Mining to Knowledge Discovery in Databases' in 1996, Usama Fayyad, Gregory Piatetsky-Shapiro and Padhraic Smyth referred to Data Mining as the overall process of discovering useful knowledge and patterns from data by use of specific algorithms.
In 2001, William S. Cleveland decided to combine Computer Science and Data Mining by making statistics a lot more technical believing that it would expand the possibilities of Data Mining and produce a powerful force of innovation.
Nowadays, you can take advantage of computing power for statistics which is now known as Data Science.
Data Science is an interdisciplinary field where its true foundations are in Statistics, Mathematics, Computer Science, and business too

"I wanna become a Data Scientist, where should I start?..."
Many would say statistics, others math, others programming...
Best answer? Let's find out.

Assuming Data Science is an Ocean...

Step 1 - Sail around the Sea of 𝗣𝗿𝗼𝗯𝗮𝗯𝗶𝗹𝗶𝘁𝘆 & 𝗦𝘁𝗮𝘁𝗶𝘀𝘁𝗶𝗰𝘀 📈

Someone once said, "A Data Scientist is just an overpaid Statistician". How true is that? Statistics is the science concerned with developing and studying methods for collecting, analyzing, interpreting and presenting empirical data. In both Data Science and Statistics, our main concern is Data. How we get insights from the data collected, the modes of collecting it, manipulating it... (Data Wrangling).
Hence, when equipped with the Probability and Statistics tools, one will find it easy working with the data, finding its correlation, and getting useful insights from it.

There are awesome free resources online and awesome platforms to learn Probability and Statistics including Probability and Statistics: To p or not to p? on Coursera, Statistical Learning on edX and an awesome book by Gareth James, Daniela Witten, Trevor Hastie and Rob Tibshirani, An Introduction to Statistical Learning.

Step 2 - Drift to the Bay of Computer Science 🖥️

Do you know how to code?

There are two main programming languages for Data Science (Python and R). Python unlike R is more popular and highly flexible, helping one transition to different domains like Web Development, Web Scraping, Embedded Systems etc.

There are several online free resources to start your Python Programming journey, which includes the most popular Python Programming tutorial on YouTube
Platforms like DataCamp and Coursera too have awesome courses to get you started in programming.

Ready to venture into deeper and stormier waters 🌊?

Step 3 - Machine Learning and Deep Learning

Recently, I published an article on Understanding Machine Learning and its Basic Workflow where I've gone deeper into explaining what Machine Learning is and its Complete Workflow in the Real-World.
In Machine Learning, you'll learn how to build models and use them for prediction, and also the math of what happens under the hood.
For more on Machine Learning and Deep Learning, I find Daniel Bourke's blog enriched with useful information which includes his Machine Learning Roadmap clip on YouTube.

Wooow!! We've just discussed everything in a nutshell;
Where can I find the rest?...

>Google has it all in store for you!!

In conclusion, 365 Data Science are offering a free "Starting A Career In Data Science:Ultimate Guide" to help you understand more concepts in the field of 'Data' including Data Engineers and Data Analyst and also explaining their roles in depths.