Learn Python Programming

Master Programming in Python

Language and Work in Data Science
(From Beginner to Intermediate to
Advanced)

Paul Jamsey
 Table of Contents

Introduction
Chapter 1: What Is the Python Language?
The Benefits of Working with Python
Chapter 2: How to Download and Install the Python Language
Downloading Python On a Mac Computer
Downloading Python On the Windows System
Downloading Python On Linux
Chapter 3: Some Simple Parts of the Python Code
The Keywords In Python
How to Name Your Identifiers
The Python Control Flow
The Python Statements
The Comments
The Importance of the Variables
Adding In Some Operators
Chapter 4: Working with Python Classes
How to Create a New Class
The Class Definition
The Special Attributes
How to Access a Member of a Class
Chapter 5: The Python Files
Creating Your Own Python Files
How to Create a Binary File
How to Open Up a Python File
Seeking Out the File
Chapter 6: A Look At the Python Functions
Taking a Look At the Python Functions
Chapter 7: Creating Our Own Loops to Shorten Our Programs
Working on the While Loop
The For Loop
The Nested Loop
Chapter 8: The Python Operators
The Arithmetic Operators
The Comparison Operators
The Logical Operators
The Assignment Operators
Chapter 9: Learning How to Handle Python Inheritances
Understanding How to Override Our Base Class
Chapter 10: Recognizing and Raising Your Own Exceptions
How to Raise An Exception
How to Define Your Own Exception
Chapter 11: The Decision Control Statements
An Introduction to the If Statement
The If Else Statements
The Elif Statement
Chapter 12: How to Work with Regular Expressions
Basic Patterns to Look For in Regular Expressions
The Search Method
The Match Method
The Findall Method
Chapter 13: How Can I Troubleshoot My Python Code?
Get Used to Printing Things Out
Run the Code After Changes
Pay Attention to the Error Messages
Comment Out Parts of the Code
Try the Binary Search
Take a Break From the Code
How to Ask for Help When You Need It
Chapter 14: A Look at Data Science
Why Do We Need Data Science?
What Is Data Science?
Data Science Vs. Business Intelligence
The Data Life Cycle
Chapter 15: How Python Can Work with Data Science
Python Can Help Us Analyze the Data
All the Python Libraries Work Well With Data Science
The Community of Python Makes It Easy to Get Help
Conclusion
 Introduction

Congratulations on purchasing Learning Python Programming, and thank

you for doing so.

The following chapters will discuss all of the different parts that we need to
know in order to take a look at learning Python programming. There are a
lot of good coding languages out there that you can work with. Some of
these languages are going to be great options to work with to help with
writing programs for websites. Some are best for certain types of
programming. And then there is the Python program, which is one of the
best to help us see some great results as a beginner, while still providing us
with all of the power that we need to get our codes all done.

At the beginning of this guidebook, we are going to get a nice introduction

to what the Python language is all about. We are going to explore some of
the basics of the Python language and why so many programmers are taking
the time to learn how to work with this coding language. We will then learn
how to download the Python library, all of the necessary files onto your
computer no matter what operating system you are using, and some of the
basic parts of the code to help us get more familiar with this language.

From there, we are going to dive into some of the different coding examples
that you are able to do with the help of Python. We will look at how to work
with conditional statements, how to raise exceptions, handling the loops,
working with Python files, and even how to handle some of the classes in
Python. As a beginner, these topics are going to be so important to ensure
that we can actually see some results with the coding that we are doing.

The end of this guidebook is going to focus more on Python and how it can
work with the world of data science. Many companies are exploring data
science, and how a gathering and analyzing of data can ensure that the
company can really find the best insights and learn the best predictions that
will help them beat out the competition. We will explore in this part how
Python is able to get on with this system and will help businesses to see a
lot of great benefits with data science.

Python is one of the best coding languages that we can work on, whether
we are a beginner to coding or have been working with this for a long time.
When you are ready to finally learn how to work with the Python language
and all that it has to offer, make sure to check out this guidebook to see how
it can help you to become an expert Python coder in no time.

There are plenty of books on this subject on the market, thanks again for
choosing this one! Every effort was made to ensure it is full of as much
useful information as possible; please enjoy!
 Chapter 1: What Is the Python Language?
There are a lot of different coding languages out there that you can work
with. If you do any kind of search with the Python language, you will find
that there is a large list, and each of these coding languages will be able to
help with many of your needs. Often, the hardest part that comes with this
is figuring out how you will pick the right one for what you need. Some
work the best with one operating system over another. Some will do a lot of
work with websites and other online work. And others are more
multipurpose as well.

With all of these choices, it is sometimes hard to figure out which kind of
coding language you would like to work with. Even with all of these
choices, though, the best option that is going to benefit beginners and more
advanced coders alike is the Python coding language. There are a lot of
benefits that come with this kind of language, and it won’t take long before
you fall in love with Python coding as well.

Python is considered an object-oriented programming language or OOP.

This is something that we will explore a bit later when we get to our
discussion of classes in this guidebook, but it basically makes a life for a
programmer easier when they work on their code. These languages are
often seen as much easier to work with compared to some of the older or
more traditional coding languages, and they still bring in the power that we
need. If you are a beginner working with Python or another OOP language,
you will appreciate some of the ease that this feature can offer to you.

Of course, this is not the only benefit that you will be able to enjoy when it
comes to using the Python language. This is a popular programming
language, and it can bring in a lot of the power and ease that you need to go
from beginner to more advance in your coding in no time. And this
guidebook will not only show you some of the benefits that come with
coding in Python, but also some of the best tips, example codes, and more
to make it all happen.

Many programmers like to work with Python for a variety of reasons. They
like this coding language and have a lot of power, but it is still an easy
program to learn how to use and read. It also works with many different
operating systems based on your own needs and can work on a variety of
networks, as well. This is definitely one of the best coding languages out
there, no matter what project you want to use, or how much coding
experience you have at the time.
The Benefits of Working with Python
To help us to understand some more about the Python language, we need to
take a look at some of the benefits that come with the Python language.
Some of the best benefits that come with this coding language and have
been driving people to this language for their coding needs include:

Python comes with a lot of support libraries. One of the best features that
programmers are going to enjoy when it comes to working with the Python
language is that it is able to work together with a ton of different extensions
and libraries. The traditional library that comes with Python has a lot of
power, and it will be able to handle a lot of the tasks that we try to do
throughout this guidebook. But there may be times when you want to add in
a few more extensions and libraries to the language to get more
functionality in your own codes.

There are a lot of libraries and extensions that we can add when we want to
work with the Python language. We will see that there are extensions for
Python in many different library forms on science, mathematics, machine
learning, data science, and so much more!

It comes with some good integration features. When it comes to working

with various integration features and Python, you will find that this is one
of the best. Python is able to integrate with a process known as the
Enterprise Application Integration. This is going to help out with many of
the factors that we want to do with Python and can ensure that this language
is able to work with other coding languages you want to use with Python,
and even the various operating systems as well.

This language can add in some more productivity for the programmer.
Because the Python library is easier to work with, we will find that it can
add to the amount of productivity that you get to enjoy on a regular basis.
The designs that come with this language are considered object-oriented,
and they will support many different libraries based on what you would like
to accomplish with your own coding.
Because of the various resources that come with Python, and how easy this
programming language is to work with, programmers are going to find that
Python programmers are easily able to increase their productivity. This kind
of language will be able to help improve the amount of productivity that the
programmer will see with some of the other coding languages out there.

It is easy to learn how to work with the Python language. The Python
language was one that developers worked on to ensure it was easy to use
and that programmers will be able to adapt easily. This translates into it
being easy, even for a beginner to use. This guidebook is going to spend
some time looking at the basics that can happen with Python, and when we
are all done with this, you will find that you have the ability to write out
some codes that are strong and powerful, and you will be able to do some of
your own projects.

It is even easy to read the Python language. In addition to the language

being easy to learn, it is also really easy to read through. As we work
through this guidebook, and even before you learn how to work with these
codes, you can go through and see some words and phrases that actually
make sense. The Python language is designed with the beginner in mind
and is based on the English language, which makes it perfect for
understanding the codes that you want to write out.

Many programmers are amazed at how much power comes with this coding
language, even with the ease of use. Many of those who want to work with
Python will be impressed because it does come with a ton of power in the
process. Even though there are many out there who consider this more of a
beginner's language, you can really adapt this language to use with many
applications. If you work with the right libraries, it is even possible to
expand out Python to do tasks of data science and machine learning. There
is a lot of power that comes with the Python language, and it is definitely
one that many programmers find worth their time to learn.

There are a lot of other programmers who use this language, which means
that beginners get the advantage of working with a large community any
time they have trouble or need some assistance. The fact that Python comes
with all of these great benefits and that it is so much easier to work with
compared to some of the other coding languages, so many programmers
throughout the world are willing to work with Python to get some great
results with their coding.

This is good news for those beginner programmers who are just getting
started with the Python language. This provides us with a big community of
programmers we can follow, a community that provides us with advice,
tutorials, help, codes, and more that we can use any time that we need a bit
of help with the Python code.

The Python language is an open-sourced language. This is good news for

someone who is brand new to coding because it means that you are able to
get ahold of the original files that come with Python, for free. Anyone who
wants to add this to their computer and who wants to use it will be able to
access it without any extra part and without having to add to the costs.

One thing to keep in mind here though, is that some companies and some
individuals have taken the code and created their own third party extensions
that go along with Python. These companies may choose to sell their
extensions to those programmers who would like to use them. Just because
the cost doesn’t mean that they are not legitimate. But you can easily work
with the Python language without having to pay for these extensions, and it
can be completely free from the very beginning.

As we can see through this chapter, there are a lot of benefits and things to
enjoy when you decide to code with the Python language. And these are the
main reasons why so many people decide to spend some time learning how
to work with Python. This is true whether the programmer is going to be
learning their very first coding language, or if they have done some coding
in the past, and want to improve their portfolio and their computer
knowledge. And now that we know a bit more about the Python language
and what it all entails, it is time to actually dive in and learn a bit of the
coding that is necessary to get the most out of Python.
 Chapter 2: How to Download and Install the
Python Language

Now that we know a bit about some of the benefits that come with Python,
it is time to take a look at the important steps that are needed to help us
download the Python product and to make sure that Python is going to be
on our computer and working the way that we want. Before you can even
think about some of the codes that you would like to write, we need to
install the interpreter and some of the other folders that come with this
coding language. And downloading this program is simple and easy to
accomplish.

Python is going to work with any of the operating systems that you would
like. So, no matter which operating system is found on your computer, we
will be able to download and install Python on it and see some good results,
In addition, we are going to work with downloading python from the
website of www.python.org. This one is going to allow us to download
Python, and all of the programs that we need, for free. There are other
options that you can work with if you would like, and some of them may
have some nice features that you want for your coding. But for the most
part, working with www.python.org is the best option for helping us see
some great results. With that in mind, let’s take a look at some of the steps
that you need to take to install Python.
Downloading Python on a Mac Computer
The first system that we are going to take a look at downloading on is the
Mac Operating System. If you are working with a computer that has the
Mac operating system, then you will find that it comes with Python 2
already preinstalled on it. The exact version of this is going to depend on
how new or old your computer is and what system is found on the
computer. If you would like to tell which version of Python is on your
computer, simply open up the terminal app and then use the prompt below
to help:

python – V

This is going to show you the version you get, so a number will come up.
You can also choose to install Python 3 on this system if you would like,
and it isn’t required to uninstall the 2.X version on the computer. To check
for the 3.X installation, you just need to open up the terminal app and then
type in the following prompt:

Python3 – V

The default when it comes to the OS X computer is that we won’t see

Python 3 installed on it at all. If you do want to upgrade to work with the
Python 3 version, we are able to use a few of the installers that are found on
www.python.org to help us install this version. This is one of the best places
to install it from, as we talked about earlier because it ensures that we are
going to have all of the parts that we need with Python in order to code, and
it offers all of these files for free. The Python language needs to have a few
different files in place in order to work properly, including the IDLE, the
shell, and the interpreter, and having them all available in one place can
make things easier.

Being able to get the IDLE to run well, and having the Python shell present
is going to be dependent on the version of Python that you choose to go
with, and sometimes the one that you pick will be based on your own
personal preferences with coding. You are able to work with the commands
that are below to start the IDLE and shell applications:

For Python 2.X just type in “Idle”

For Python 3.X, just type in “idle3”

As we mentioned before, when you download and install Python 3, you are
going to install IDLE as a standard application in the Applications folder. In
order to start this program from your desktop, you simply need to open up
that folder and then double click on the IDLE application.
Downloading Python on the Windows System
Another option that we have for using Python is that it can work on a
Windows computer and operating system. We do need to go through a few
more steps to make this happen, simply because Microsoft does have its
own programming language. This means that Python is not going to be
included in the standard installation of Windows.

This doesn’t mean that Python won’t work on a Windows computer. It just
means that we need to take some extra steps to make sure that we get
Python on the computer and ready to work. We can’t assume that the
program is already there. By default, the installer of Python for Windows is
not going to provide us with the necessary environment variables to run any
of the commands for this language from the command prompts. So, going
from www.python.org, we need to use the following steps to ensure that we
can get the Python coding language to work with our Windows operating
system:

1. To start with this process, we need to go and visit the

www.python.org download page and grab the installer for
Windows. You can choose to go with the latest version that
Python 3 comes in or go with one of the other options that are
available.
a. One thing to note is that by default, the installer that
you are provided with will include the version of
Python that is 32 bit. You do have the option to choose
the 64-bit if you would like, but you need to go in and
manually switch around the option that you are using.
2. From here, you can click on the installer and make sure to click
on the button that says, “Run as Administrator”. As you click on
this, you will find that the program gives you two different
options to choose from. Your choice should be “Customize
Installation.”
3. When you move on to the next screen, we need to make sure all
of the boxes that are available under Optional Features are
clicked. Then you can click on Next.
4. While you are still under the tab for Advanced Options, you will
need to carefully select the location where you would like to
install Python. Click on Install and then wait a few minutes for
the installer to finish with its task. When the installer is done,
you can close out of this part.
5. At this part, we are going to set the PATH variable for the system
so that it is going to include with it all of the directories that you
need. These will include the packages and some of the other
components that you may need to pull out later. The steps that
we need to work with this part will include:
a. First, we need to open up the Control Panel. Do this by
clicking on the task part and then typing into the
Control Panel. Click on the icon.
b. Inside this Control Panel that we opened, we want to
do a search for the Environment. Then we can click on
Edit the System Environment Variables. At this point,
you can click on the button that lists out Environment
Variables.
c. From here we need to go to the section that is listed
out for User Variables. When you are in here you can
choose to edit the PATH variable that the program
already offers to you, or you can create a new one.
d. If you look in at this part and see that there isn’t a
variable for PATH on the system, then you get to
create one of your own! This can be done by clicking
on the button for New in here. Make the name for the
PATH variable that you would like, and make sure that
the right directories are going to show up in this part.
Click on Close All to get out of the dialog box of the
Control Panel and then move on.
6. When we get here, we are able to open up the command prompt.
You can open up the command prompt by clicking on the Start
Menu Then click on Windows System, and then on the
Command Prompt. You can then type in the “python”. This will
make sure that we get the interpreter for Python fired up and
ready to go.
At this point, the program is going to be all set up and we can use it on our
Windows computer. You will then be able to choose whether you would
like to open up the interpreter and any of the other files that you want with
Python before writing out a few lines of code or working with some of the
other programs that we will write out in this guidebook.
Downloading Python on Linux
Another option that we can work with when it comes to downloading
Python on an operating system is the Linux system. The Linux system may
not be as widely used as what we see with the Windows systems and Mac
OS X, but it has a big following of programmers and others who like all of
the features and the ease of use compared to some other options. Because of
this, we need to take some time to explore how we can download Python,
and all of its files, on computers that rely on the Linux operating system.

The first thing to do here is to see if there is a version of Python 3 already

on your system. You can open up the command prompt on Linux and then
run the following code:

$ python3 - - version

If you are on Ubuntu 16.10 or newer, then it is a simple process to install

Python 3.6. You just need to use the following commands:

$ Sudo apt-get update

$ sudo apt-get install Python3.6

If you are relying on an older version of Ubuntu or another version, then

you may want to work with the deadsnakes PPA, or another tool, to help
you download the Python 3.6 version. The code that you need to do this
includes:

$ Sudo apt-get install software-properties-common

$ sudo add-apt repository ppa:deadsnakes/PPA
# Sudo apt-get update
$ Sudo apt-get install python3.6

The good news here is that if you are working with other distributions of
Linux, it is likely that you already have Python 3 installed on the system. If
not, you can use the distribution’s package manager. And if the package of
Python 3 is not recent enough, or not the right one for you, you can go
through and use these same steps to help install a more recent version of
Python on your computer as needed.

And this is all that we need to do to get started with some Python
programming. If you have downloaded this system from www.python.og,
then all of the files that you need to work with will be present. Once you
have followed the steps above for downloading these files for Python on
your chosen operating system, we will be able to open up the interpreter
and start writing some of our very own codes in no time.
Chapter 3: Some Simple Parts of the Python Code

One of the first things that we need to take a look at when we start coding in
the Python language is some of the basic parts that come in the code. There
are a lot of different topics that we are going to explore as we start to write
out our own codes, and this can really add a lot to what we want to do with
Python and even data science as a whole. But even with this in mind, we
need to make sure that we understand some of the basic parts that help put
the Python code together and will ensure that our programs run the way that
we would like.

These basics are going to be found in even some of the more complicated
codes that we try to write out. You can take these basics and add more to
them, change them up, and more, but the basics will ensure that we gain a
bit of familiarity with the codes that we are writing and that we gain a better
understanding of what is going on in the process. Some of the basics that
you should know before you try to write out any codes in Python include:
The Keywords in Python
While there are a lot of basic parts that come with the Python code, the first
place we are going to start is with the keywords. These are going to be the
reserved words in our code that are there to tell the compiler what you
would like it to accomplish. It is important to not allow these keywords to
show up in any other part of the code that you write, and we must make
sure that we are using them in the proper manner.

If we ever try to use some of these keywords in the wrong place of our
code, it is going to result in us getting an error. These keywords are special
because they provide the compiler with the commands that are needed so
that it knows the best way to reach inside the code. And because of this, we
need to make sure that we use them at the best time and the best place to
make the code run smoothly. You will see a lot of these keywords as you
work through your Python code and in a lot of the codes that we write out
later, so make sure to be on the lookout for these. Some of the most
common keywords that we can use with the Python language will include:

Except
Else
If
Yield
Assert
Elif
From
Try
While
Lambda
For
Continue
None
False
Class
Finally
Is
Return
Pass
Or
Not
With
How to Name Your Identifiers
The next thing that we can look at when it comes to our Python code is
going to be the identifier and how we are able to name them. These
identifiers are going to be important in Python and there are actually a few
different types that fit into this category. There are even different names
depending on what they will do inside of the code. Some of the most
common names that come with these identifiers will include classes,
entities, functions, and variables, and we will take some time to explore
some of these more as we go through this guidebook.

Naming the identifiers is an important step to ensure that the code will work
the way that you want, and that there won’t be any issues as you try to find
them later. The good news with this is that the process of naming your
identifiers is going to be the same no matter what kind of identifier you are
using, so this can save a lot of time and hassle in the process.

The first rule to remember is when you name these identifiers. You have
many options when you are naming your identifiers. For example, you can
rely on both uppercase and lowercase letters with naming, as well as any
number and the underscore symbol. You can also combine any of these
together. One thing to remember here is that you can’t start the name with a
number and there shouldn’t be any spaces between the words that you write
out. So, you can’t write out 3words as a name, but you can write out words3
or three words. Make sure that you don’t use one of the keywords that we
discussed above, or you will end up with an error.

When you pick out the identifier name, you can follow the rules above, and
try to pick out a name that you can remember. Later on, when writing the
code, you will need to pull it back up, and if you give it a name that is
difficult to remember, you could run into problems or raise errors because
things aren’t showing up the way that you want. Outside of these rules, you
will be fine naming the identifiers anything that you want.
The Python Control Flow
Next on the list to explore is the control flow of the Python language. This
control flow needs to be explored to make sure that we have written out the
code in a proper manner. There are some strings of code that you may
decide to write out in a manner so that the compiler can read through them
the proper manner. But if you do not follow the right rules and you write the
string out in the wrong manner, you will end up with errors in your system.

The good news is that the control flow is pretty easy to work with, and we
are going to take a look at many of the codes you can write with Python in
this guidebook. You will be able to follow some of the rules that come with
it so you will be able to catch on to how the control flow of Python works.
This helps us to write out any codes that we would like and ensures that the
compiler is going to show the results that we want as well.
The Python Statements
We need to take a few moments to look at the Python statements. These are
simple parts of the Python code and are just going to be the strings of code
that you write out want the compiler to list out that string When you spend
the time to tell the compiler what instructions it needs to follow, you will
find that those instructions are going to be considered the statements in the
code as well. As long as the programmer takes some time to write out the
statements at the right times, and in the right way in your code, then you
can have the statement be as short or long as possible.
The Comments
Any time that you are writing out code, whether it is in the Python language
or with another coding language you may find that you run into a place
where you would like to leave a little note in the code or name a part of the
code. This is something that you can do and will ensure that other
programmers are able to see it, but these notes will not affect anything that
happens in the code. The compiler knows that these comments should be
ignored, and any time that you have a comment added in, it is going to just
jump right over it and not pay any attention to it.

In order to add in one of these comments to your code you simply need to
use the # symbol. When the compiler sees this symbol, it knows that you
are writing out the comment and that you don’t want this to show up in any
of the code that you are writing. You can technically have as many of these
comments in place in the code that you are writing, but it is best if you can
keep the number down to the minimum only make the number of comments
that your code really needs, and leave it there so the code doesn’t get as
messy.
The Importance of the Variables

Variables are another part of the code that you will need to know about
because they are so common in your code. The variables are there to help
store some of the values that you place in the code, helping them to stay
organized and nice. You can easily add in some of the values to the right
variable simply by using the equal sign. It is even possible for you to take
two values and add them to the same variables if you want and you will see
this occur in a few of the codes that we discuss through this guidebook.
Variables are very common, and you will easily see them throughout the
examples that we show.
Adding In Some Operators

The final part of the Python code that we are going to pay attention to are
the operators. These are a simple thing to add to the code, but we still need
to spend a bit of time exploring them and how they can help us see some
great results in the process. There are actually a few options and types when
it comes to using operators, and learning about all of them can be important
as well.

For example, there are arithmetic functions that are going to help us to do a
variety of mathematical functions that we want with our code. Then there
are the assignment operators that are there to assign a specific value back to
one of our variables so that the compiler knows how to handle all of them.
There can be comparison operators as well which can step in and view more
than one piece of the code, and then determine whether these parts are
similar and then does a reaction based on the conditions you set with it.

All of these operators are important, and while they only take a few seconds
to set up and get to work inside your code, you will find that they add in a
lot of power and capabilities to the code that you want to write. Learning
the different operators and the best way to work with them can be critical to
seeing your code behave the way that you would like.

As this chapter is able to show to us, there are a lot of different basic parts
that come with operators, and you can add a lot of these to your code to see
some results these basic parts may seem too easy to learn and like they are
not going to help you out, but even these can be found in some of the more
complicated parts of the code that you want to write. As we work on a few
of the other codes that are needed in this guidebook, you will start to
recognize a few of these parts and will start using them for your own needs
as well.
 Chapter 4: Working with Python Classes

One of the most important topics that we can understand when we work
with Python is the idea of classes. This is a great topic to look at when
exploring object-oriented languages. Python is considered an object-
oriented programming language, which means that the different objects that
we work with will actually match up with some of the real-life objects that
we find in the world. This is a great thing for us because it ensures that we
are going to be able to find the objects and get them to show up exactly
where we would like them to within our coding.

The lack of classes and the lack of being an object-oriented language was a
big issue in some of the past coding languages that were used. Things
would move around, it was hard to find the items of the code that you
needed, and it was just more difficult for most beginners to get into all of
this. But with object-oriented programming languages like Python, this
problem is not long such a big deal to work with.

Classes and objects are going to be really important parts when it comes to
writing out your own codes in Python This is because both of these are able
to ensure that all of the parts of your code will stay in the spot that you
expect, and they won’t be able to move into a different spot when you
execute your code. The objects are going to be there in order to define parts
of the code to make them easier overall to understand, but the classes can be
thought of as the container that is going to contain the objects.

This may sound a bit confusing, and maybe a bit hard to understand when
we are first getting started. So, to make this easier, let’s dive right in and
learn a bit more about what we can do with the classes in Python and how
they can work to make your code amazing.
There is so much that we are able to do when it comes to working with
classes in the Python language. And the fact that these classes are even
present inside of the codes that we want to write can open up a lot of doors
in Python. In fact, the idea that we have classes is one of the main reasons
that Python is considered an object-oriented programming language, and
can help to keep things organized, and will ensure that when the code is
done, it will make a lot of sense and work the way that we want.

These classes are basically going to be containers that hold onto the objects
and other parts of the code. You need to name these classes the proper way
and put them in the proper spots to get them to work the right way. And you
need to store the right objects in your class.

You can store anything that you want inside a class that you design, but you
must ensure that things that are similar end up in the same class. The items
don’t have to be identical to each other, but when someone takes a look at
the class that you worked on, they need to be able to see that those objects
belong together and make sense to be together.

For example, you don’t have to just put cars into the same class, but you
could have different vehicles in the same class. You could have items that
are considered food. You can even have items that are all the same color.
You get some freedom when creating the classes and storing objects in
those classes, but when another programmer looks at the code, they should
be able to figure out what the objects inside that class are about, and those
objects should share something in common.

Classes are very important when it comes to writing out your code. These
are going to hold onto the various objects that you write in the code and can
ensure that everything is stored properly. They will also make it easier for
you to call out the different parts of your code when you need them for
execution.
How to Create a New Class
The first thing that we need to take a look at here when we are working
with a class is how to create one of these on our own. We need to be able to
create a class before we are able to do anything with them and to ensure that
our code stays organized with nothing that gets lost in the process. To begin
to create one of these classes, though, we need to start out with using the
right keywords to name the class. You do get some freedom to name the
class as you would like, just make sure that the name is going to show up
right after the keyword that you need to use for the compiler, and that the
name is going to be something easier for you to remember.

After we name the class, it is time for us to go through and name the
subclass that we are using. This is the part that will fall into the parenthesis
when we write out the code. We need to make sure that at the end of the
first line, whenever you start to create a class, you add in a semicolon to it.
This is seen as proper coding etiquette, so it is worth your time to add this
in when you are done with these two parts.

At this point, it may seem like writing out a brand new class is going to be
pretty complicated to work with. But it is not that bad, and taking a look at
an example of how this is going to work, and how you can create your own
class in Python is going to show us how easy it can be. Let’s take a look at
an example of creating a new class in Python below, and then we can
discuss all of the different parts that come with that code, so we understand
what is going on a bit better as well.

class Vehicle(object):
#constructor
def_init_(self, steering, wheels, clutch, breaks, gears):
self._steering = steering
self._wheels = wheels
self._clutch = clutch
self._breaks =breaks
self._gears = gears
#destructor
def_del_(self):
 print(“This is destructor….”)

#member functions or methods

def Display_Vehicle(self):
print(‘Steering:’ , self._steering)
print(‘Wheels:’, self._wheels)
print(‘Clutch:’, self._clutch)
print(‘Breaks:’, self._breaks)
print(‘Gears:’, self._gears)
#instantiate a vehicle option
myGenericVehicle = Vehicle(‘Power Steering’, 4, ‘Super Clutch’, ‘Disk
Breaks’, 5)

myGenericVehicle.Display_Vehicle()
The Class Definition
Before we dive into this, let’s go through and open up your compiler and
then type in the code that we had before. This will help us to notice a few of
the topics that were discussed earlier on in this guidebook, and we can get
used to how to type out some code as we go in. Then we can dive into the
code and see what the different parts are all about.

First, we need to spend some time exploring the class definition of the code
below. This class definition is going to be the place where a programmer
needs to instantiate the object, and then they will have the definition of the
class. This is important because it ensures that we keep up with the proper
syntax in the code. During this part, we must pay attention because this is
the part that will be responsible for telling the compiler what needs to
happen, and it will highlight the best commands that have to be the most
important for this part.
The Special Attributes
The second thing that we need to take a look at the inside of this code will
be the special attributes that show up. These special attributes are important
because they will help to provide a programmer, especially a beginner
programmer, with a bit of peace of mind. This comes from the idea that
these special attributes will work in the proper manner, and that the code
won’t end up with a mess.

In the code that we wrote above, there were actually a few of these special
attributes that are present, which can show us how this works. But we need
to remember that these are not all the possible special attributes that are out
there, and another code you write may need to use some of the others. Some
of the other special attributes that are commonly used in Python coding will
include the following:

__bases__: this is considered a tuple that contains any of the superclasses

__module__: this is where you are going to find the name of the module
and it will also hold your classes.
__name__: this will hold on to the class name.
__doc__: this is where you are going to find the reference string inside the
document for your class.
__dict__: this is going to be the variable for the dict. inside the class name.
How to Access a Member of a Class
With some of the information that we talked about above in mind, it is time
for us to move on to another thing that we are able to do when working on a
class In this part of this chapter, we want to take a different approach to
classes, and instead learn how we are able to access several of the members
of any class that we plan to create.

During this part, we want to make sure that the editor and the compiler are
set up in a way that they can recognize some of the classes that are created.
This is important because it helps the compiler and text editor to execute the
code in the proper manner. To help us accomplish this goal, we need the
code to be set up in the proper manner in the first place.

There are going to be a few different methods that a programmer is able to

choose from to make all of this work, and all of them will show you a level
of success when executing the code. However, for now, we are going to
focus on what is known as the accessor method. This one is used because it
is a favorite between a lot of programmers, and it is pretty easy for us to
work with. To help us understand how to go through this process and how
to access the various members of a class, we need to take a look at the
following code:

class Cat(object)
itsAge = None
itsWeight = None
itsName = None
#set accessor function use to assign values to the fields or member
vars
def setItsAge(self, itsAge):
self.itsAge = itsAge

def setItsWeight(self, itsWeight):

self.itsWeight = itsWeight

def setItsName(self, itsName):

 self.itsName =itsName

#get accessor function use to return the values from a field

def getItsAge(self):
return self.itsAge
def getItsWeight(self):
return self.itsWeight

def getItsName(self):
return self.itsName

objFrisky = Cat()
objFrisky.setItsAge(5)
objFrisky.setItsWeight(10)
objFrisky.setItsName(“Frisky”)
print(“Cats Name is:”, objFrisky.getItsname())
print(“Its age is:”, objFrisky.getItsAge())
print(“Its weight is:”, objFrisky.getItsName())

Now, before we spend some time discussing what this code above has to
tell us, open up the Python compiler and then type this code inside to see
what shows up. If you go through and run the compiler with this code, you
will find that there are a few results that will show up with this right from
the start. The results that we see will include the name of the cat (in this
case, the cat’s name is Frisky, but you can name the cat anything that you
would like), the age of the cat, and the weight.

This is the information that we added into the code above, and so the
compiler is commanded to have these show up with the right result. As the
programmer, you have the freedom to go through and change up these
responses and put anything into the code as you would like.

Classes are not meant to be a difficult part of coding for you to work with.
Instead, they are supposed to be helpful to ensure that we are able to take
care of any information that we have, and we want to be able to set them up
in a manner that will allow us to really find the items and objects that we
need in the code, and to ensure that it all stays nice and organized at the
same time.
 Chapter 5: The Python Files

The next topic that we need to spend some time on is the files in Python,
and how to handle the input and the output with these files. When you are
writing out a few of your own codes with the Python coding language, there
are going to be times when you would like to store the data. This makes it
easier to find the data that you want and will ensure that the code will show
up when it should. You can choose to save the data on the computer to
make sure that it will show up at the right time in your code.

When we save this data, it is going to get saved as a regular file on a disk,
or you can choose to reuse parts of the code over and over again, similar to
what you would do with an inheritance, as long as you are working with the
proper steps along the way. This chapter will help us take a look at how we
should properly handle these files to ensure that they are saved and that the
data is ready to use when you want it.

Now, there are going to be a few different tasks that you can work with
when it comes to the files that you handle in Python. To make it easier to
understand what we are talking about with this process, think about the
Python files like a file that you would create in Word. You can write and
manage and do a lot of different things with your Word file. But there will
be some point when you need to stop and save the document from getting to
later on. The Python file is going to work in a similar manner. Instead of
saving these pages, though, you are saving up the code that you have
written out.

The neat thing that you will see with the Python files is that there are a few
tasks and operations that you can throw into the mix to help handle them.
Some of the tasks that work well with these files will include:
1. Opening up a file that you already created and then write out a
new code inside of it.
2. Seeking, or working to move one of your files into a brand new
location.
3. Creating a new file that you want to use.
4. Closing up one of the files when you are done.
Creating Your Own Python Files
The first task that we are going to look at the Python files is how to create a
file. This will help us to start writing out some of the code that you want to
create here. If you would like to make one of your own files, and then write
some code on it, you first need to open up the file inside of the IDLE. You
must also choose the mode that you want to work with to write out the
code.

There are three main modes that you can choose from based on what you
would like to see happen when creating your own Python file. You can pick
out the one that works best for your needs. These three modes are going to
include things like append(a), write(w), and mode(x).

Any time that you are opening up one of your current files and you would
like to make a few changes inside of that file, you will want to work with
the write option, or (w). This one needs to be used when it is time to open
up the file and write out a new string of work in that file. This will give us a
binary file, and the write() method will help to get it done. This works
because it comes in and ensures that you will get the right kinds of
characters to show up in the end.

Despite how it may sound in the beginning, the write() function is actually
an easy one to work with and can help the programmer to change up any of
the files that they would like. You can use this method to help write in new
information to a file, or to make some changes to one of the files that you
would like to open up. If this is something that you want to complete with
your Python file, then work with the following syntax to see results:

#file handling operations

#writing to a new file hello.txt
f = open(‘hello.txt’, ‘w’, encoding = ‘utf-8’)
f.write(“Hello Python Developers!”)
f.write(“Welcome to Python World”)
f.flush()
f.close()
Before we move on, make sure to open up your compiler and write out this
code. This code is basically helping you to create a file and get all the
information into the right directory. The default directory is known as the
current directory. It is possible to switch out which directory where you
want to store the information, but make sure that you go through and
change that ahead of time, or you may have trouble finding it later on.

Pay attention to the directory that you are in at the time. The current
directory where you are located right now is the one where you will need to
head on back to when it is time to search for your file. If you don’t like the
current directory, and you want to move the file to a new location, then we
need to make sure that we move over to this before we try to save anything.

With the option above, when you head on over to the right directory and
then open up the file, you are going to get a message. Based on what we
wrote out in the beginning, this message is going to be, “Hello Python
Developers! Welcome to Python World!”

When we get to this point, we already have a program that is written out,
and there may be some times when we need to take a previously written on
code and overwrite all of it, or at least a part of it, so that we can get a brand
new statement to show up, even though the file is already created. This is
something that Python does allow for, as long as we take the right steps to
make this happen. The syntax that you are able to use to see this work out
includes:

#file handling operations

#writing to a new file hello.txt
f = open(‘hello.txt’, ‘w’, encoding = ‘utf-8’)
f.write(“Hello Python Developers!”)
f.write(“Welcome to Python World”)
mylist = [“Apple”, “Orange”, “Banana”]
#writelines() is used to write multiple lines into the file
f.write(mylist)
f.flush()
f.close()

The example above is a good one to use when you want to make a few
changes to a file that you worked on before because you just need to add in
one new line. This example wouldn’t need to use that third line because it
just has some simple words, but you can add in anything that you want to
the program, just use the syntax above and change it up for what you need.
How to Create a Binary File
The next topic that we want to work with when it comes to Python files is
how to create a binary file. This may sound like a complicated thing to
work with, but it is actually something that is simple to do in the Python
language. It simply involves taking whatever data that you have right now
and changing it over to either a sound file or an image file, rather than
writing it out as a text file.

You can change any of the other text files that you have or that you write
out in Python over to a binary file, regardless of if it were a picture file, a
sound file, or a text file. The most important thing to consider here is that
you have to be able to supply the data inside of the object so that it is easier
to expose the file the way that you want at a later time. If you would like to
create your own binary file from a regular Python file, the following syntax
will help to make this happen:

# write binary data to a file

# writing the file hello.dat write binary mode
F = open(‘hello.dat’, ‘wb’)
# writing as byte strings
f.write(b” I am writing data in binary file!/n”)
f.write(b” Let’s write another list/n”)
f.close()
How to Open Up a Python File
In the work that we did with the examples above, we spent some time
talking about how we can create a file and write in the words that we want,
and even how to turn those files into a binary function so that it is easier to
bring it up later. Now it is time to move on to another step and practice the
coding that is necessary to open that file up. Once you can open that file, it
is easier to use it again, add some more words or code to it, or even just
read it. Opening up the file again is pretty easy, and you just need to use the
following syntax to help get it all done:

# read binary data to a file

#writing the file hello.dat write append binary mode

with open(“hello.dat”, ‘rb’) as f:

data = f.read()
text = data.decode(‘utf-8’(
print(text)

the output that you would get form putting this into the system would be
like the following:

Hello, world!
This is a demo using
This file contains three lines
Hello world
This is a demo using

This file contains three lines.

Seeking Out the File
The last thing that we are going to take a look at when it comes to the
Python files is how to seek the file out. This is when we want to take the
file and move it to a new place, making it easier to find what we need. For
example, if you have started to work on a file, and you find that things are
not matching up the way that they should, such as you spelled the name of
the identifier the wrong way, or you find that it was saved in the wrong
directory, you may want to use what is known as the seek option in order to
help you find the file and make the changes that are needed.

With Python, you do get the benefit of going through and changing up
where you have saved the file, helping to ensure that it gets saved in the
proper directory at the right time and making it easier for you as a
programmer to find that file later on. You just need to write out the code in
a way to tell it where you would like to find the file, and then make the
necessary changes to have this happen.

As we can see here, working with the various files that you create in the
Python language is going to be helpful when it comes to getting things in
order in the Python code when you want to make some changes to what you
can write in the file, and so much more in the process. Make sure to take
some time to try out and experiment with a few of the codes that are in this
guidebook, and see just how easy these Python codes can be, how they can
help you to create a new file, make the necessary changes, and how you can
get the files to work in the proper way for your code.
 Chapter 6: A Look at the Python Functions

One topic that we are going to take a quick look at when it comes to Python
is the idea of the functions. This is a quick discussion that we need to take a
look at in order to see what it is all about and how we are going to benefit
from it in order to make some of the codes that we have in Python so much
better than before. So, with that in mind, let’s take a look at some of the
functions in Python and how these are meant to work.
Taking a Look at the Python Functions
The topic that we are going to take a look at when it comes to Python
functions in our code. These functions are often going to be known for
being sets of expression, which we will also call statements depending on
how we are going to use them in our codes. You will get the choice of either
giving these functions a name that can make them easier to pull out and
read later on, or you can choose to keep the functions as anonymous based
on what is going to work the best for your own code.

As you are writing out the code that you would like for a program, you will
find that the best way to work with a function is to have it be the first-class
object inside of that code. This is a great thing for you because it is going to
mean we don’t need to concentrate on lots of restrictions on the use of the
various functions. Functions can be used in a manner that is similar to what
we see with some of the other values in your code, such as the strings and
the numbers and they are going to have some attributes that we are able to
bring out to make sure they work the proper way inside of our codes.

Now, we will find that these functions are going to be really diversified, and
we are able to add in a ton of attributes to them any time that we first want
to create the functions, and then bring them up. Some of the choices that we
are going to have when we use these functions will include:

__doc__: This is going to return the docstring of the function

that you are requesting.
Func_default: This one is going to return a tuple of the values of
your default argument.
Func_globals: This one will return a reference that points to the
dictionary holding the global variables for that function.
Func_dict: This one is responsible for returning the namespace
that will support the attributes for all your arbitrary functions.
Func_closure: This will return to you a tuple of all the cells that
hold the bindings for the free variables inside of the function.

As with some of the other topics that we have been able to discuss in this
guidebook, we will find that there are going to be a lot o different things
that we are able to do with a function. Some of these tasks are going to
include passing it as an argument over to another function as needed. Any
function that is able to take on a new one and use that as its argument is
going to be considered the function that is higher-order inside the code.
There are a lot of times when these functions are going to show up in some
of the codes that we are writing, so understanding how they work and what
you can do with them is going to be really important along the way.
 Chapter 7: Creating Our Own Loops to Shorten
Our Programs

Another thing that we need to spend some time on when it comes to writing
our Python codes are the loops. Loops are going to be an ice addition
because they can add in a low of power in just a few lines of code, and they
get the code to look nice and clean. This takes away some of the mess, and
they are simple to write even with all of the different things you can put in
them.

A good example of how this works is when you would like your particular
code to write out a list of numbers, or you would like to create a
multiplication table. When you type it out in the traditional manner, you
will write out a ton of code, and it often repeats itself. But we can write out
a loop and get this information in just a few lines of code instead.

There is a lot of information that we are able to bring out in the loop, but
they are still going to be easy for us to work with, despite all of that. These
loops are going to come in and tell our compiler that it needs to continue
reading through the same line of the code until the conditions you set are
met. If you ask the compiler to do the task of writing out the numbers going
from one to ten, then the loop gets to help with this and will run through
that line of code until it gets to ten. This is a great way to simplify the code
that you are writing, and you can get all of the work done in less time.

Any time that we try to work on these loops, it is important to set up the
right conditions for this, the ones that you would like to have met before
you ever try to write one of these programs. If you just write out the loop
without making sure the condition is present for it, then the loop is going to
continue running through the line, with no idea on when it should stop. It
will just read the loop over and over again, which effectively freezes your
computer. So, before you try to run one of your programs that has a loop,
double-check that you have added in these conditions.

As you are working to create some of your own codes in Python, you will
find that there will be a few types of loops that you can work with. While
we can pick from a variety of loops based on what we would like to see
happen with the code, we are going to focus on the three most common
types, the ones that you are most likely to use overall as a beginner in
writing code.
Working on the While Loop
The first loop that we are going to take a moment to look at here is the
while loop. This is one of the loops that you would want to choose any time
your code has a specific number of cycles that it needs to go through for the
loop to work correctly. You would use this kind of loop to help you write a
program that can count to ten, for example. This one must have a condition
that is added to the end to make sure that it does stop at the right point, and
that you don’t end up with something that continues on forever.

We will also find that for programming, this is one that is a good option if
you would like to make sure that the loop goes through itself at least one
time before it decides that it is time to move on to the next part of the code.
If you would like to see an example of how this code works, and how we
would use the while loop, we need to take a look at the following code:

#calculation of simple interest. Ask the user to input the principal, rate of
interest, number of years.

counter = 1
while(counter <= 3):
principal = int(input(“Enter the principal amount:”))
numberofyeras = int(input(“Enter the number of years:”))
rateofinterest = float(input(“Enter the rate of interest:”))
simpleinterest = principal * numberofyears * rateofinterest/100
print(“Simple interest = %.2f” %simpleinterest)
#increase the counter by 1
counter = counter + 1
print(“You have calculated simple interest for 3 time!”)

In the example that we just did, you will find that it will allow a user to go
through and add in any of the information they want that pertains to them
into this program. The code will then go through and compute the interest
rate, based on the numbers that the user put into the system.

For this one to work the proper way, we set up the while loop (which is
done right at the beginning of the code), and then we told it to only go
through this loop three times, and no more. You are in charge here and can
increase or decrease the number of times that you would like the loop to go
through things and get results the way that your code needs.
The For Loop
The next type of loop that we are able to work within addition to the while
loop is the for loop. When you want to work with this for loop, there are
going to be a few key differences compared to the while loop, but it is still
something useful to consider. In fact, many programmers of Python are
going to consider the for loop the traditional type to work with when you
want to create a few loops. This one can even replace the while loop if you
would like to, so it is definitely something that we want to focus on a little
bit here.

When you bring out one of these for loops, you will have things set up in a
way that the user is not going to provide any information to the code before
the loop starts for you. Rather, with this for loop, Python is going to be set
up to make its way through an iteration in the order that we have set it in the
code, up on your screen. There isn’t going to be any need for some input
from the user because it will just continue through the iteration until the end
shows up. An example of a code that shows how this for loop is going to
work inside of Python will be the following:

# Measure some strings:

words = [‘apple’, ‘mango’, ‘banana’, ‘orange’]
for w in words:
print(w, len(w))

Write this code into your compiler and then execute it. The for loop is going
to make sure that all the words in the line above it are shown up on the
screen, exactly how you wrote them out. If you want them in a different
order, you need to do that as you work on the code, not later on. You can
add in any words or other information that you want to show up in this kind
of loop, just make sure that you have it in the right order from the
beginning.
The Nested Loop
And now, we are going to spend some time looking at the third type of loop
that we can work with, known as the nested loop. Any time that a
programmer would like to create their own nested loop, it means that we are
taking one of the other loops from above, either the for loop or the while
loop, and then placing it inside another loop. So, we are going to end up
with two loops that are working together and running at the same time here.

Both of the loops that you run here will go at the same time, and the nested
loop will continue until they are both complete. There are actually quite a
few times in your coding when you would want to work with the nested
loop to ensure that your code is done the way that you want. For example, if
you want to create something like a multiplication table in your code, then
the nested loop is the perfect solution to getting this under control. A good
example of the syntax that you will want to write out in order to create your
own multiplication table in Python with a nested loop will include the
following:

#write a multiplication table from 1 to 10

For x in xrange(1, 11):
For y in xrange(1, 11):
Print ‘%d = %d’ % (x, y, x*x)

When you got the output of this program, it is going to look similar to this:

1*1 = 1
1*2 = 2
1*3 = 3
1*4 = 4
All the way up to 1*10 = 2
Then it would move on to do the table by twos such as this:
2*1 =2
2*2 = 4

And so on until you end up with 10*10 = 100 as your final spot in the
sequence
Any time that you are writing a code where you need to have one loop run
inside of another loop, the nested loop is going to be the tool that you need
to use to make all of this happen. You are able to combine together the for
loops, the while loops, or a combination of each based on what needs to
happen inside of the code you are writing. No matter how you decide to use
the nested loop can help you to get it all done. The multiplication table that
we wrote above took only a few lines of code overall and one of those was
a comment, and you were able to get a whole table done in no time.

The nested loop, the while loop, and the for loop is the most common
options when it comes to working with loops in the Python language and
can help you get your coding done in no time. You can use these codes to
help get a ton of work done in your chosen program, without having to
spend as much time writing out the codes, or rewriting the lines again and
again. You can just set up the code with a loop, and it will handle all of this
on its own. This ensures that a beginner is able to write out some more
complex parts of the coding, without as much work in the process.
 Chapter 8: The Python Operators

The next topic that we need to talk about when it comes to writing codes in
Python are the operators. These are going to be pretty simple to work with,
but you will find that they add a lot of versatility and power to some of the
codes that you are trying to write in Python, so they are definitely worth our
time as well. In fact, quite a few of the codes that we have already been
writing I this guidebook are going to rely on these operators to make them
work, so that can show us exactly how great these operators are going to be.

There are a lot of different types of operators that we are able to work with,
and they are going to be there to help our code compare a few different
things, do some mathematical equations in the code, and figure out so much
more. These are even the parts that will assign a value to the variable that
you are working with. There are really so many different types of operators
that we are able to work with, but each of them is important because they
will work slightly different from one another, so let’s stop now and explore
how each one of these is meant to work.
The Arithmetic Operators
The first of these operator types that we are going to spend some time
exploring is the arithmetic operator. If you take some time and think back to
a math class that you took in school, then you will already be able to
recognize a lot of the arithmetic operators that we are going to talk about in
this section. These are basically the kind of symbols that we will use to
make sure that our code can complete a mathematical equation.

Sometimes, these operators are going to keep things as simple are adding
two of the operands in the code together, or even subtracting two or three
numbers from one another. There are a few options that you can make when
working with the arithmetic operators, but some of the most common
options for this category will include:
(+): this is the addition operator and it is responsible for adding
together both of your values.
(-): this is the subtraction operator and it is going to be
responsible for taking the right operand and subtracting it from
the left.
(*): this is the multiplication operator and it is used to multiply
two or more values in the equation.
(/): this is the division operator and it is going to divide the value
of the left operand from that on the right and gives you the
answer.

As you write out your code, remember that there are times when you will
want to use just one arithmetic operator at a time, and then there may be
situations when you want to use more than one of these at a time. You can
even use more than one of the operators, such as an addition and a
multiplication in the same line of code. Just remember the order of
operations before you start doing this and how that is going to affect the
way that the code works.
The Comparison Operators
Now that we have had a chance to look at the arithmetic operators, it is time
to move on to the second type of operator that we are going to focus on,
including the comparison operator. This one is going to be a helpful option
to work with because it will allow us to take two, and sometimes, even
more, values and statements that show up in our code, and then we will try
to compare them to each other for a true or false value.

The comparison operator is going to make its way out to the code any time
that we want to work with our Boolean expressions. This means that the
two statements are going to match up with one another and be true, or they
will not match up with one another and be false. This is just one example of
what we are going to see with this though, and some of the other
comparison operators that we are able to work with will include:

(>=): this one means to check if the left-hand operand is greater

than or equal to the value of the one on the right.
(<=): this one means to check if the value of the left-hand
operand is less than or equal to the one on the right.
(>): this one means to check whether the values of the left side
are greater than the value on the right side of the code.
(<): this one means to check whether the values of the left side
are less than the values that are on the right side.
(!=): this is not equal to the operator.
(==): this one is equal to the operator.
The Logical Operators
The third type of operator that we are going to take a look at in this
guidebook is the logical operators. These are a type that we may not use as
much as some of the others, but we still need to spend a bit of time looking
them over and seeing how we can benefit from adding these into some of
the codes that we want to write in Python.

These logical operators are going to be the best ones to work with when it is
time to evaluate the input that the user gives to you with any of the
conditions that you decide to set into the code you wrote. There are three
main types of logical operators that you can add to a Python code, and these
three logical operators will include:

Or: with this one, the compiler is going to evaluate x and if it is

false, it will then go over and evaluate y. If x ends up being true,
the compiler is going to return the evaluation of x.
And: if x ends up being the one that is false, the compiler is
going to evaluate it. If x ends up being true, it will move on and
evaluate y.
Not: it ends up being false, the compiler is going to return True.
But if x ends up being true, the program will return false.
The Assignment Operators
And the fourth and last type of operator that we are going to take a look at
here will be the assignment operators. This one is going to show up very
often in the codes that we do with this guidebook because we simply need
to use the equal sign to make sure that we get the right value, and
sometimes the right values, assigned over to our variable within the code.

So, if you want to assign the value of 100 over to the variable of “a,” then
we would just need to have these two points and add in the equal sign
between the two, and the compiler will know that it is supposed to put the
two of these together. This is done with a ton of the values and the variables
that are going to be in your code, so by this time, with all of the codes that
we have written out in this guidebook so far, we should have a pretty good
idea of how to make this work.

It is also possible for us to take this a bit further and we can take on several
values and assign them back over to the same variable if we choose. As
long as we have an equal sign in place from the beginning, it is possible for
a programmer to add in as many values to one variable as they would like.
And with that equal sign in place, the compiler will know exactly how to
handle it all for you.

As we can see, these operators and working with them can be a simple
process, but they are going to really help us to get a lot of different tasks
done in no time. You can add together some of the variables that you want
to work with, compare the various parts of your code with one another, and
even handle some of the mathematical operators as well. All of this can
make a big difference in the kind of code that we are trying to write out so
learning how to work with these operators is going to be very important to
the amount of success that you will see.
 Chapter 9: Learning How to Handle Python
Inheritances

Another topic that we are going to spend some time on within this chapter
is the idea of a Python inheritance. These inheritances are a great way for us
to work on enhancing the codes that we want to be able to create with the
help of Python. In the long run, you will find that these inheritances are
going to save us a lot of time and are going to be one of the best ways to
make the code we have look cleaner and nicer as we go along. The
inheritances are going to help you to reuse parts of a previous code over and
over again, without us having to rewrite the same code all of the time.
While these are a unique part of the code that comes with Object-Oriented
Programming Languages, it is definitely a perk to what we are able to do
with the help of Python.

Basically, to help us understand how this process works, when we are

developing an inheritance, you will need to take the original code that you
have, which is often called the base code or the parent code, and then
change up parts of it before reusing it as the derived code. You can work to
make the code stronger, or you can reuse it for some other purpose inside
your code, based on what you would like to see happen as we go through all
of this.

Even as someone who is just beginning on their journey with Python

coding, you will enjoy some of the power that comes with Python
inheritances. These inheritances and the parts that come with them are
going to help us to work with a strong piece of code that we already
developed and then use it over and over again, without needing to go
through and rewrite the code over each time that we need it.

With this in mind, during the inheritance, you are going to take the original
parent code and then copy it over to another part of our program, usually at
some point later on in the process. The new part of the code, the one that
you copied down, is going to be known as the child code, one that we can
copy over and then make any of the changes that we need to keep it strong.
And when we make these changes, they are going to have no effect on the
parent code at all.

Depending on the kind of code that we are trying to write out, sometimes
we need to copy this all down one time, and other times we need to
complete it many times. But no matter how many times we copy the child
code down from the parent code, the process is going to be exactly the
same.

To help us to better understand how the inheritances work, what they are
about, and how we are going to be able to benefit for using these inside any
of the codes that we have (while saving time and making the code as neat
and tidy as possible), let’s take a look at how one of these inheritances will
look inside our code.

#Example of inheritance
#base class
class Student(object):
def__init__(self, name, rollno):
self.name = name
self.rollno = rollno
#Graduate class inherits or derived from Student class
class GraduateStudent(Student):
def__init__(self, name, rollno, graduate):
Student__init__(self, name, rollno)
self.graduate = graduate

def DisplayGraduateStudent(self):
print”Student Name:”, self.name)
print(“Student Rollno:”, self.rollno)
print(“Study Group:”, self.graduate)

#Post Graduate class inherits from Student class

class PostGraduate(Student):
def__init__(self, name, rollno, postgrad):
 Student__init__(self, name, rollno)
self.postgrad = postgrad

def DisplayPostGraduateStudent(self):
print(“Student Name:”, self.name)
print(“Student Rollno:”, self.rollno)
print(“Study Group:”, self.postgrad)

#instantiate from Graduate and PostGraduate classes

objGradStudent = GraduateStudent(“Mainu”, 1, “MS-
Mathematics”)
objPostGradStudent = PostGraduate(“Shainu”, 2, “MS-CS”)
objPostGradStudent.DisplayPostGraduateStudent()

When you type this into your interpreter, you are going to get the results:

(‘Student Name:’, ‘Menu’)

(‘Student Rollno:’, 1)
(‘Student Group:’, ‘MSC-Mathematics’)
(‘Student Name:’, ‘Shaun’)
(‘Student Rollno:’, 2)
(‘Student Group:’, ‘MSC-CS’)
Understanding How to Override Our Base Class
Now that we know a bit more about what these inheritances are all about
and why they may be useful for some of the codings that we want to do, it
is time for us to take a step back and look at another process that we can do,
known as overriding one of the base classes. Remember that the base class
is going to be the same as the parent class that we talked about before.

There are going to be times when you will work on one of the derived
classes, and you will find that it will be useful to go into the code and
override some of the things that you add put into the base class. To make
sure that things stay as simple as possible, we need to go into the base class
and make some simple changes to make sure that this base class is going to
work along with the new derived class that we want to create. The child
class is then going to be able to use any of the new behaviors to get its job
done in the right manner.

Yes, this is probably sounding really complicated and hard to do at this

point, but it actually is fairly simple, and it will be nice since you get some
say in the parental features that your program will have inside of the
derived class, which parental features you are hoping to keep around, and
which ones you would like to ditch and not use any longer. This is
definitely a process to focus on because it makes it easier to follow through
with some of the changes that you have in a new class, while still keeping
around the parts from the original that we need from the base class to help
you out.

The number of times that we want to go through and make the new children
classes, and how much you decide to override in each part of the code, will
really be depending on what you would like your code to accomplish for
you in the process. It can be just as simple as the code that we wrote above,
or it could add in some more complication and could include a lot more
steps along the way. no matter what method you choose to use with these
inheritances, they are going to be helpful because they get the code to work
better without as much clutter being involved in the first place.
Inheritances are definitely a part of your code that you will enjoy using on a
regular basis. This is because they add in a level that allows you to keep on
using a pat of the code, a part that you already went through and created,
and then use it to create new parts of the code later on, without having to
rewrite them again and again. This saves us a lot of time, makes coding
easier, and can be just what you need to get things done without having
such a mess within your original code.
 Chapter 10: Recognizing and Raising Your Own
Exceptions

The next thing that we need to take a look at when writing codes in Python
is how to recognize and raise some of your own exceptions. As you are
writing some of your own codes, there may be times when the program will
raise up an exception for you, or when you would like to make sure that a
new exception is created and ready to go in the program. These exceptions
can be more complicated compared to some of the other coding topics that
we have talked about. But it is important for us to learn how to work with
these exceptions to make sure that the code acts in a way that you would
like.

There are many different situations where you are able to raise the
exception, and at times, they are going to show up on your screen just like
what we see with an error message, and recognizing these can make a
difference in the coding that we do. Make sure that when one shows up, you
really take the time to read through it and then follow some of the code that
we have in the rest of this chapter to make sure you can handle all of the
exceptions that show up. They are not something that you need to run and
hide from, but the more that you know about them, the easier it is to handle
them when they show up, or when you specifically need to use them.

Now, as you take a look through the library that is found with Python, you
will notice that there are already a few of these exceptions found in there. If
you try to write out some code that has these in them, or a user tries to
complete an action that the program doesn’t like, then you will see that the
compiler gets to work raising up an exception about this.

That is the most common type of exception, but then there are going to be
some cases where you need to write out some of your own exceptions. In
this case, we will find that we need to write out a good program where we
need some extra exceptions, and you will need to raise up some of your
own to make it all work well.

One of the exceptions that we need to take a look at that the compiler is
going to always raise is when the user, making their way through your
program, decides to divide something by zero. In this case, the compiler is
going to see that this is an action that cant be done, and will choose to raise
up an alert when they kind of exception does show up In addition, if you try
to call up a function that you created, but you misspell the name at some
point, either when you originally saved that function, or later when you are
trying to call it back up, the exception is going to happen as well.

As we mentioned a bit before, there are going to be a few exceptions that

are set up to go off automatically in the Python program. As a new
programmer, it is a good idea for us to take some time to look through all of
these, and then recognize them as we work on our code. There are a number
of these that you can work with, but some of the most common exceptions
that we can focus on and worry about will include:

Finally—this is the action that you will want to use to perform

cleanup actions, whether the exceptions occur or not.
Assert—this condition is going to trigger the exception inside of
the code
Raise—the raise command is going to trigger an exception
manually inside of the code.
Try/except—this is when you want to try out a block of code and
then it is recovered thanks to the exceptions that either you or the
Python code raised.
How to Raise an Exception
Now that we have had some time to learn more about what these exceptions
are about, and how we can use them, it is now time for us to figure out the
best way to use these. We are going to focus on writing out one of these
exceptions and will see what steps you should take if one does show up in
another code you are writing. If you are working on a code, and you notice
in there that a potential issue can come up, then be prepared for an
exception. The good thing here is that the exception is usually going to be
something simple to fix, but then there are also times when it is going to be
more complicated. Let’s take a look at raising this kind of an exception to
see how it works:

x = 10
y = 10
result = x/y #trying to divide by zero
print(result)

The output that you are going to get when you try to get the interpreter to
go through this code would be:

>>>
Traceback (most recent call last):
File “D: \Python34\tt.py”, line 3, in <module>
result = x/y
ZeroDivisionError: division by zero
>>>

When we take a look at the example above, we see that the program is
going to raise an exception simply because you have tried to divide a
number by zero. Remember from before that the code in Python is not
going to allow you to do this. If you go through and run the program with
this in there, you will end up with an error message on the screen at this
point. The code is going to tell the user what the problem is, but we will
find that there is going to be another issue as well. How this code is written
out, the error message will come up with a bunch of letters and numbers
that make no sense to someone who isn’t well-versed in writing code at all.
We can make some changes to this though to ensure the user can read the
error message, and that they actually understand what is going on.

We are able to go through here though and make some changes to the
example that we have above to ensure that the message is more user-
friendly when we are done. To do this, we will write out a message that will
help the user to see what is going on and what steps they need to take to fix
it. This is easier to read through, and you can add in any kind of code that
you would like to see the results. An example of the code that you can write
to make this happen in your code includes:

x = 10
y=0
result = 0
try:
result = x/y
print(result)
except ZeroDivisionError:
print(“You are trying to divide by zero.”)

Take a look at the two codes above. The one that we just did looks a little
bit similar to the one above it, but this one has a message inside. This
message is going to show up when the user raises this particular exception.
You won’t get the string of letters and numbers that don’t make sense, and
with this one, the user will know exactly what has gone wrong and can fix
that error.
How to Define Your Own Exception
The next thing that we need to take a look at when working on exceptions is
how to raise some of our own. So far, we have taken a look at how we can
handle an exception that is already present in the library of Python. But
there are going to be times when you work on a code and you want to raise
one of your own exceptions in it. For example, if you are working on a code
that only will let certain numbers show up, you could set up an exception to
raise when the user picks out the wrong number. This is something that may
show up in games that are created. You could, for example, set up the
program so that it is only going to allow the user three guesses during the
game, or when they are trying to pick out the right number to continue.

With these kinds of exceptions, we have to go through a few steps to raise

them, because the compiler is not going to recognize them or that there is
anything wrong with the answers that the user is giving. Technically, even
though you don’t want it to be a part of your code, the user isn’t doing
anything that is wrong according to the compiler. But we need to teach the
code how to react in the manner that we want when these situations happen.

Keep in mind here that these exceptions that we are going to write here are
completely unique to the code that we are writing right now. The compiler
wouldn’t recognize them on its own, and you would have to re-write them if
you ever wanted to use them again in another code later on. You can add in
any of the exceptions that you would like, and you can even add in a
message to help explain it as we did with some of the codings that we did
before. If you would like to write some of your own exceptions into your
code, you can use the syntax below to help you out:

class CustomException(Exception):
def_init_(self, value):
self.parameter = value
def_str_(self):
return repr(self.parameter)

try:
raise CustomException(“This is a CustomError!”)
except CustomException as ex:
print(“Caught:”, ex.parameter)

In this code, you have been successful in setting up your own exceptions
and whenever the user raises one of these exceptions, the message of
“Caught: This is a CustomError!” is going to come up on the screen. This is
the best way to show your users that you have added in a customer
exception into the program, especially if this is just one that you personally
created for this part of the code, and not one that the compiler is going to
recognize on its own.

Just like with the other examples that we went through, we worked with
some generic wording just to show how exceptions are able to work. You
can easily go through and change this up so that you get a message that is
unique for the code that you are writing and will explain to the user what is
going on when they get the error message to show up.

Exception handling is going to be something that we bring out more often

as the codes we create in Python get more advanced over time. there are
many times when you will need to create an exception that is recognized by
the program or you will want to bring up your own exception to work with
your particular code. Working with some of the syntax and codes that we
talked about in this chapter can help you to deal with these exceptions, and
will ensure that you can make them look good and organized to your user.
Make sure to take the time to try out a few of these codes in your compiler
to gain some practice and to get a better idea of how these exceptions are
meant to work.
 Chapter 11: The Decision Control Statements

The next topic we are going to explore when it comes to the Python
language is the conditional statements. These conditional statements can be
important for having the program react, without the programmer being there
to tell it how to behave. With the right conditions set up, the program can
look at the input that the user gives, and then gives the right output based on
this. There are a few options of conditional statements that we are able to
work with, and we will explore some of this in the following pages.

The conditional statements, or the decision control statements, are going to

help our program respond to any answer that a user provides to the
machine. It is pretty much impossible for us to sit down ahead of time and
guess what answers or input the user will provide to the computer, so
working with these conditional statements can make it easier to get the
program to run properly, no matter what information the user provides in
the first place.

This may sound confusing, but this kind of coding is going to be pretty easy
to do, despite how much power is behind it. We will find that these
conditional statements will work on a variety of programs that you are
trying to write. These are simple, but we have many options to add with
them, giving them more power and ensuring our program the power we
want in the process. The three main conditional statements that we are
going to focus on in this chapter will include the basic if statement, the if
else statement, and the elif statement. Let’s take a look at these now!
An Introduction to the If Statement
The first conditional statement we are going to take some time working
with is known as the if statement. This statement is the most basic of the
three and can be a good place to start when we look at the idea of the
conditional statements and how they actually work. The if the statement is
set up so that it only allows the program to proceed forward to the next step
if the user provides us with the right answer, based on the conditions that
you set up.

There isn’t going to be the option of two answers or more. If the user puts
in the answer of their choice, and then the program, looking at the condition
that you add in, determines that the answer is wrong, then nothing is going
to happen with this program. But if the user adds in an answer that your
program recognizes as correct based on those conditions, then it will show
up the statement that you wrote in the beginning, or complete another
process that you coded in.

At this point, we can already see a few potential issues that will show up
with this kind of conditional statement. But it is still an important
conditional statement that we should learn above. A good syntax example
that we can focus on to work with the if the statement includes:

age = int(input(“Enter your age:”))

if (age <=18):
print(“You are not eligible for voting, try next election!”)
print(“Program ends”)

There are a few things that will show up with this code. If you have a user
go to the program and state that their age is under 18, then the program will
work and display the message that is listed there. The user can read this
message and then end the program right there.

But, things can go wrong if the user puts in that their age is above 18. This
is true for the user, but because it doesn’t meet the conditions that you wrote
out, the program will see it as false. As the code is written right now,
nothing is going to happen because it isn’t set up to handle this. The user
will just see a blank screen any time they enter an age that is over 18.
The If-Else Statements
Now that we have had a chance to look at the if conditional statement and
how this can work, we can see that there are potentially a few problems that
can come up with that kind of coding. We want to make sure that our
program is not just stopping, even if the answer the user provides to us is
not the exact one that we want to see show up. This can be a confusing way
to end your code and doesn’t really explain to the user what is going on.
Because of this, we want to move on to see how the if else statements work,
and how these conditional statements can help to solve this major coding
problem.

The if statements are often a good place for us to start in order to get a bit of
practice with coding. But as you can imagine here, there are not going to be
that many times in the program when we will actually want to see just this
kind of statement. With the example above, we want to make sure that some
kind of answer or response shows up on the screen, whether the user puts in
their age under 18 or not. And that is where you will need to bring in the if-
else statement to fix things up.

The if-else statement is a great option to work with because it helps to

provide the user with the output they need, regardless of what age they add
in as the input. If we stick with the example that we did with the if
statement the user may get the previous message any time they add their
age under 18. But we want to also make sure that the user is able to get a
response if they put in an answer like 32 for their age.

With the if-else statement, we are still going to get a response with the
answer, whether the person puts in their age as above or under 18. Sticking
with the voting example that we talked about above, we are able to
implement the code below to help us see exactly how the if else statement
will work, and how it is different than the if statement.

age = int(input(“Enter your age:”))

if (age <=18):
print(“You are not eligible for voting, try next election!”)
else
 print(“Congratulations! You are eligible to vote. Check out your local
polling station to find out more information!)
print(“Program ends”)

With this option, you are adding in the else statement, which will cover
every age that doesn’t fall under 18. This way, if the user does list that as
their age, something will still pull up on the screen for them. This can
provide you with more freedom when working on your code and you can
even add in a few more layers to this. If you want to divide it up so that you
get four or five age groups and each one gets a different response, you
simply need to add in more if statements to make it happen. The else
statement is at the end to catch everything else.

For example, let’s say that you are working with the code that is above, and
you want to ask the user to pick out their favorite color. You could start this
out with the if else statement and cover a few of the basic colors, maybe
picking out five or six and adding in a nice statement to go along with each
one. Then we can make sure to add in the else statement at the end to pick
up any of the other colors that your user could decide to go with. Since it is
impossible to list out all of the colors that someone could pick, and would
take too long to accomplish, it is much better to use the if else statement to
help us see some good results.
The Elif Statement
Now that we have taken some time to look at the if statement and the if else
statement, it is time for us to move on to the third type of conditional
statement, the elif statement. This elif statement is going to work in a
manner that is similar to what we see with the other two conditional
statements, but it can take it to the next level. Don’t worry though, this is
still an easy conditional code for us to work with.

The nice thing about the elif statement is that you are able to add in as many
of the different parts of these into the code that you are writing as you
would like, and it also has that else statement form before to catch anything
else, or the other decisions, that the user is able to pick from in the code. A
good way to think about the elif statement is like a game that relies on a
menu of choices for the user to make. When we execute the elif statement,
this is going to be what the whole thing will look like.

With the elif statement, we are given the freedom to have as few or as many
different options as we would like. You can choose to have just two or three
in the mix, or you can expand this so that you end up with twenty or more
options. Keep in mind with this thought that the fewer options that are listed
out, the easier it is for you to write on the code, and the less time it will
take. To see how the elif statement is going to work, and the different parts
that come with it, take a look at the following:

Print(“Let’s enjoy a Pizza! Ok, let’s go inside Pizzahut!”)

print(“Waiter, Please select Pizza of your choice from the menu”)
pizzachoice = int(input(“Please enter your choice of Pizza:”))
if pizzachoice == 1:
print(‘I want to enjoy a pizza Napoletana’)
elif pizzachoice == 2:
print(‘I want to enjoy a pizza Rustica’)
elif pizzachoice == 3:
print(‘I want to enjoy a pizza capricciosa’)
else:
print(“Sorry, I do not want any of the listed pizza’s, please bring a
Coca Cola for me.”)
With this option, the user is able to choose the type of pizza they want to
enjoy, but you can use the same syntax for anything you need in your code.
If the user pushes the number 2 in the code, they are going to get a pizza
Rustica. If they don’t like any of the options, then they are telling the
program that they just want to have something to drink, in this case, a Coca
Cola.

This is a simple way to use the elif statements to give the user a set of
choices. In the other options, the user could add in any choice that they
wanted, but in the elif statement, they can either pick that they want one of
the choices that you provide, or they will have to go with the default option
at the end. This can work well for many games that you may want to pick,
for some tests online, and other programs where you want to limit the
choices that the user gets to pick from in the code.

And this is all we need to know when it comes to using the conditional
statements. Each of the three options will be slightly different, but that helps
us to create the code the exact way that we would like. These help us to get
the computer to respond to any of the inputs that the user provides, even
without being able to guess what they are ahead of time. However, we will
find that the computer is able to make a decision and give the best results
based on the conditions that you set in the first place.

The nice thing about these conditional statements is that you are able to
create them and manipulate them to make a program behave the way that
works the best for you. You can set it up in a manner that there will just be
one right answer that the user can go with. You can make it so that the user
is going to see some kind of response no matter what input they choose, and
you can even set it up so that a menu of choices is presented to the user has
to pick from one of those. No matter how you use these conditional
statements, this is one of the methods that can allow for the program and the
user to have a lot of interaction with one another and with the program.
Chapter 12: How to Work with Regular
Expressions
One thing that a lot of beginners are going to appreciate when it comes to
working with the Python language is the large library that is present. When
you decide to use this kind of library in your coding, you will be able to pull
out a ton of regular expressions. These regular expressions are going to be
great because they are responsible for handling any task that you need,
without any glitches inside, and which can even handle some of the
different searches that you would like to complete.

In addition to some of the benefits that we talked about above, these regular
expressions are going to be good for use in the Python language to help us
go through various types of text, including things like text strings, and you
can even use some of these expressions to see if several strings or parts of
text in your code are going to match up with one another.

These regular expressions are going to be nice to work with, and when you
do decide that part of your code needs these expressions, you can stick with
the exact type of syntax for those expressions, even if you add in another
coding language to work at the same time as Python. So, if you are working
on some coding with Python, and then need to implement another coding
language at the same time, including C++ and Jave, you will still be able to
stick with the Python syntax the whole time. For someone who is just
getting started with Python and with coding in the first place, you will enjoy
that you can just work with one language the whole time.

Now that we have had some time to talk about some of the regular
expressions, you may be a bit curious about what these are all about and
how you would really be able to use them in your own code. One method
that we are able to use to help us explore some of these regular expressions
is to do a search for any word that is in your code, but that you may have
spelled in a different manner when writing in the text editor.
For example, you may have been working on your code in one place and
wrote out the word “blue” and then when you tried to bring it up at another
time, you wrote out the word “bleu” instead. You may need to go through at
some point and change up one or the other of these to ensure that they align
in the proper manner, and working with the process of regular expression
will make this possible.

Any time that one of your codes needs to use the regular expression, you
have to enter into the library of Python and then import the specific
expression that you want to use. Make sure to look at the library and all of
the options that are available, and pick out the one that is the best for your
program, or the code that you are writing at the time. Think about all of the
functions and expressions that you will want to write, and all of the libraries
that you might need to use, and then import them from the beginning to
make things easier.

There will actually be a few regular expressions that you can use and ones
that will be really useful to work with any time that you want to write out
code in Python. This is going to show up near the statements in the code,
and we have to make sure that these expressions show up in the right spot to
see them actually work in your code.

To help you to make sure that all of the statements are going to work, we
first need to understand the way that these expressions work as well. If you
bring out the wrong expression in the code, then the interpreter is going to
struggle to understand the command that you want. With this in mind, let’s
dive in a bit more and look a little more at the different types of regular
expressions that are available, and how to use them.
Basic Patterns to Look For in Regular Expressions

One thing that we need to pay attention to, and will notice pretty quickly
when we work with these expressions, is that their only job is not to just
specify out a fixed number of characters that you want to use in a specific
code. In some situations where you bring this out, they can also help you to
specify the patterns that could show up in the code. Some of the patterns
that you may need to use in your statements, as well as with some of the
other parts of your code in Python will include the following:

1. Ordinary characters. These are characters that will match

themselves exactly. Be careful with using some of these because
they do have special meanings inside of Python. The characters
that you will need to watch out for include [], *, ^, $
2. The period—this is going to match any single except the new
line symbol of ‘\n’
3. 3. \w—this is the lowercase w that is going to match the “word”
character. This can be a letter, a digit, or an underbar. Keep in
mind that this is the mnemonic and that it is going to match a
single word character rather than the whole word.
4. \b—This is the boundary between a non-word and a word
5. \s—this is going to match a single white space character
including the form, form, tab, return, newline, and even space. If
you do \S, you are talking about any character that is not a white
space.
6. ^ = start, $ = end—these are going to match to the end or the
start of your string.
7. \t, \n, \r—these are going to stand for tab, newline, and return
8. \d—this is the decimal digit for all numbers between 0 and 9.
Some of the older regex utilities will not support this so be
careful when using it
9. \ --this is going to inhibit how special the character is. If you use
this if you are uncertain about whether the character has some
special meaning or not to ensure that it is treated just like another
character.
Take some time here to look through all of these and learn what they are all
about. This will make it easier for you to use them and bring them out at
any time that you need.
The Search Method
There are three main queries that you are able to work with when it comes
to regular expressions. These are going to include the search function, the
match function, and the findall function or method. Each of these will work
in a slightly different manner, so we are going to take a moment to talk
about all of them, and how they can work in the code that you are writing.

The first option that we will take a look at between these three is the search
function. This is the one that you will want to use any time that you are
looking through your code, and you want to match up your search with any
of the parts of the string, no matter where it is located. If the program is
able to find a match anywhere in the string of text, then you will get a result
back. So, let’s take a look at the syntax that you can use to get started with
this regular expression in your coding:

import re
string = ‘apple, orange, mango, orange’
match = re.search(r’orange’, string)
print(match.group(0))

When you try this one out, you are going to get an output of orange. While
you can see above that there are two oranges present, the search function is
just there to tell us whether or not orange shows up in the code at all. Since
it does, the function will just tell us the one time, and nothing more. It
found the match and then stopped right there, so it doesn’t have any idea
whether there is another match in the process or not. This is a good one to
use if we just want to figure out whether there is some kind of match in our
code for a term or some words that we want to use.
The Match Method
Now that we have a better idea of how the search method works, it is time
for us to move on to the match method for a bit. You will find that this one
can be inserted into the code, simply by replacing “search” with “match”,
but it will give you a different result than what we got with the first
example that we did before. With the match function, our goal is to figure
out if the term or the words we are looking for are right at the beginning of
the string.

We can work with the same example that we did in the last section. When
we take a look at that example, the match method will not provide us with
any output at all. Look at the string of text that is there. This one has the
word apple first. Since the match is looking to see whether the word orange
is the first word in the string or not, the result is that there is not a match.
You will get nothing to show up when you do this one.

You do have the option to turn things around if you would like. If we
rewrote the code that we have above and made orange the first word of the
string, then the match function would find it and would give that as the
output for us as well. It all depends on what is the first part of that string or
not. If the search that you are doing matches up with the beginning of the
string, then the match function will give you an output in the process.
The Findall Method
Another command that is pretty unique with the Python code is the findall
method. If you would like to look at a string and get the statement to release
all the possibilities for one word out of the string, then this is the method
that you will need to use. So, if you would like to see how many instances
of orange are on your code, you would want to use the findall() method
rather than one of the other options.

So, to basically get this to happen, you would just need to take the formula
we had above and put re.findall() inside rather than the re.search(). Then
you would get the results of “orange” “orange” showing that you have two
of them inside your statement. You are able to do this no matter how many
are in the pattern. For example, if your code went on to have ten “orange”
inside, you would have these listed out ten times when using the findall
functions.

As you can see, all of these are going to work in different ways to help you
work on your codes. Each of these methods will make it easier to find the
information that you need, helps you to find out if there is a pattern inside
of the statements, and more. Give them a try and practice some of your
coding using these new parts and see what each of them is able to do.

Each of these functions and regular expressions is going to work in a

slightly different manner, but they can come together to provide us with
some good insights into what is in our code. Whether you want to make
sure that a certain part shows up when the user puts in input, or you are
trying to make sure that certain parts are where they should, the regular
expressions will make sure that you can get all of this done in no time.
 Chapter 13: How Can I Troubleshoot My Python
Code?

The next topic that we need to take a look at is how to troubleshoot some of
the programs that you are writing when it comes to Python. There are a lot
of great coding things that we are able to do with Python, but then there are
times when the code is not going to do what we want. The real world of
coding, no matter how much we discuss in this guidebook, is going to be
messy, and there are times when things will turn out more difficult for us.
Learning how to troubleshoot some of the bugs that may show up in the
code can be important to ensure that the program behaves the way that you
want and to cut out some of the frustration that you may feel when the code
doesn’t work.

There are a number of things that can happen to your code that won’t end
up the way that you would like. There are a number of steps that we are
able to take in order to handle any codes that are not behaving the way that
we want, and some of the steps that you can take in order to avoid some of
the issues as well. So, let’s get started!
Get Used to Printing Things Out
The first tip that we are going to take a look at is how to print out things as
you work on the code. As you look through the code that you are writing,
you should have it set up in such a way that you can look at each line, and
have a good sense of what values belong to each variable. This ensures that
we are writing the code the proper way. if there is ever a time when you
look at the code and you are not sure what is going on, stop what you are
doing and then print out that line of code.

When you print this part out that part of the code, and it is running, you will
be able to see what comes up on the console and how the values have
changed. If everything went where you thought it should, then there will be
no problems here. If something is mismatched or you did not assign a value
to one of your variables, then this is where you will catch the mistake.

You may find that at some points in your coding, it is helpful to print a fixed
string right before you try to get that variable printed out. The point of
doing this is because it helps make sure that all of the print statements you
add will run at the same time, and you will still tell what is being printed
from which part. The more you can do this process and check that the code
is working the way that you want, the better and stronger your code will
become.
Run the Code after Changes
One thing that is really tempting for a beginner to try and do with coding is
that they get excited and sit down at their computer ready to go. They open
up a new file that is blank and ready to go, and just spend the next few
hours coding and filling up that document. While this enthusiasm is nice, if
you do all of this work, and then find out that the code is not working, or
you have an error message, think of how hard it will be for you to figure out
which part of the code is to blame? You may even end up with a ton of error
messages showing up on the screen, and now you have to spend another
few hours checking out the code and fixing everything.

Instead of going through this process of torturing yourself and hoping that it
will all work out, why not check the code very few lines and make sure it is
all working. If you do a loop, check the code when the loop is done. If you
do an exception or a conditional statement or something else like that, make
sure that you check the code when that is all done. Every few lines of code,
you should run the program and see what happens.

If you have been coding well, then you can do this process and the code
will work exactly how you expect it to. But sometimes, especially when
you are first starting out in the world of coding, you will find that you add
in a bit of code, and then an error message pops up when you try to run the
code. The good news here though is you know exactly where the error is
and can go right in and fix it. Just start looking exactly where the code
behaved last time, and move on down until you spot the error.

It is a lot easier to catch and error when you have only written a few lines of
code, rather than trying to search through all of the errors when you have
pages of code done. Plus, this is a great way to learn to code better as you
go along. You can catch where an error is right when you make the mistake,
and then you get the benefit of fixing it up right then and there.
Pay Attention to the Error Messages
As a beginner in the world of Python, it is important to know that there are
going to be some error messages that show up at some point. This is just
part of the learning process with coding, and as time goes on, and you use
the codes more often, they will become fewer and farther between.
However, when an error message does come up, it is important that we
actually take a look at what it is telling us. Many times the error message is
going to be pretty descriptive to work with. And when you actually read
through it all, you will be able to learn something and fix the mistake so
much easier.

There could be some times when you see the message pop up and it is a
series of numbers and letters that don’t make a lot of sense. But often the
information in the error message is set up so that you are able to figure out
exactly what went wrong, and sometimes it even lists out were I the code
the error happened. This can help us to figure out what to fix and will make
the process of coding that much easier.

For the most part though, if you read through the message that comes with
the error, or your head back into the code and look for where the error was
sent from, you will easily be able to tell where the error is from and how
you can fix it all up. But there are times when even with this information, it
is still difficult to know what the error message is trying to say, and you
don’t know what you need to fix up to make it work.

If this is something that is happening to you while you work on your code,
another option that is available for you here is to copy and then paste the
last line of that error message into a search engine like Google. If you are
experiencing this message then it is likely that there are other programmers
who have run into it as well, and some of them have likely asked questions
about it as well. This is a great place to start looking to figure out what the
error message is about, and how others were able to solve the issue when
they encountered it.
Comment Out Parts of the Code
The next thing that we are going to take a look at when troubleshooting
some of your own code is commenting out certain parts of that code until
you figure out what is wrong. Remember how we talked a bit earlier about
how each of the various programming languages out there are going to
provide us with the use of comments This makes it easier for us to leave a
message or have something in the code that won’t actually affect the code
and how it is set up to function with the compiler at all.

This is going to be really beneficial to programmers who are still trying to

troubleshoot some of their code. You can use this in order to comment out a
part of your code, telling the compiler to not run that part right now. You
can comment on a few parts and see whether the code still works properly
with the rest there. If you comment out a piece of the code and then the
code is able to work without an error, then you know the part that is
commented out is the part that you need to fix.

If you are working with a longer script, you can work to comment out a few
parts of the code that are not really related to the changes you are working
on at the time. This method is sometimes going to help the code run faster,
and it helps to make it easier to search the rest of the code to find what you
need. We do need to use some caution with this method though because it
won’t help you out much if you comment out the parts that are responsible
for setting the needed variables because the program won’t run without
some of those.

Of course, once you have been able to finish up with the testing through this
method, and everything is organized and in the place that you want, you
need to go back through and remove a few of the comment characters to get
the code back up and running. You can then run the code one more time to
make sure that it works the way that you expect.
Try the Binary Search
The more code that you try to run for a single program the more potential
there is for some kind of error, and the more places the programmer needs
to search through and check for an error. This is even truer if you have a
project that is more advanced and rushes through a few of the simple tasks
that we described in this book, simply because these tasks often make it
harder to figure out where the errors are happening.

As you work through all of this though, you will find that the error
message, as well as the stack trace, are going to be some great options to
helping you figure out the exact place where the code went wrong. Even
with these tools though, there are still some times when both the error
message and the stack trace are not going to provide you with the answers
that you need.

If neither the error message nor the stack trace shows you the information
you need, you need to go through a binary search to help hone in on the part
of your code that is causing the issue.

At a high level, this kind of search is going to involve splitting something in

half and then taking a look at each half to see what is going wrong. Once
you decide which half of the code the error is in, you can then repeat this
process by breaking the code in half again. You keep going through this
until you find where the error is. When the other options are not helping
you out, this can be one of the fastest ways to hone in on where something
is, especially in a large code with lots of instructions.

To get started with this option, take the first half of the code, commenting
out the second half. Print out the results of the first half and see if it works
the proper way. If there doesn’t seem to be an issue, then you know the
problem occurs in the second half and you can start to look through that
part of the code to find the issue.
Take a Break from the Code
Sometimes, the best thing that you can do to handle any issues that show up
in the code, and to ensure that you don’t add frustration to the mix, is to just
walk away. This is easier said than done when you have spent a lot of time
working on the code, and it still isn’t performing the task that you would
like. But, sometimes, the fix is something really simple, and we are never
going to recognize it or find it when we have spent too much time focusing
on the code without getting a break.

We’ve all had those times. We get so frustrated with something that we end
up walking around in circles, trying things over and over again, and
basically making a big mess out of all the work we have already done. In
the end, we actually make the process worse, and that just adds to the
frustration. This is going to make the whole situation so much worse, and
can really cut into some of the hard work you have done.

But there is something about us that makes it almost impossible to quit

before we get to this point. We know that we are just making it worse, but
we have invested so much time and energy into fixing the code at that time,
and the frustration is just so high, that it is hard to walk away and realize
that we need a break. And often that is all that we need to make the
situation so much better.

Often, when we take a break from the code, at a minimum for a few hours
but often longer is better, we can come back to it with new eyes. We get a
nice break, we can take a breather, and maybe even get some sleep. Then,
when we come back, the frustration is gone and we can actually see what
the problem is. Often, the solution was so simple that we almost laugh that
we missed it before. So, if you ever find that you are running in circles
when it comes to any troubleshooting that we are doing, just take a step
away from the code and come back to it at another time.
How to Ask for Help When You Need It
If you have taken some time to work through the other tips and suggestions
that we have given in this guidebook, and maybe even tried a few of your
own ideas, to troubleshoot your Python program and there is still an error
message in the system, then it is time to ask another programmer or
someone else for some help. There are many programmers out there and
you just need to find the one who is willing to give up some of their time to
work with you on this coding project to get it right.

Before you go through the process of asking someone to step in and help
you, we need to make sure that all of the right parts are in place so that the
other programmer knows what is going on with the code, what you have
tried already, and then they can figure out what they can do to make things
easier for you. Some of the things that you should do when you ask
someone else to help with your code includes:

1. Explain what you want the program to do for you and where the
error is occurring.
2. Show the other person the code that is sending you an error so
they can see it for themselves.
3. Show the other person the stack trace, all of it, including the
message you got stating the error.
4. Explain everything that you have already tried on the error. This
helps the other person have a good idea of what you have tried
and what they should try to get the code to work.

You may find that the process of thinking through these items in your mind
and then getting them written down on paper can help make a brand new
solution obvious. If that doesn’t work, try to find someone who may be able
to look through the code and tell you what is going wrong and what you can
do to fix the error.

As someone who is just getting into the world of coding, you may feel a bit
nervous about having to go through the code and troubleshoot or debug
things all of the time. But this isn’t going to be as hard to handle as you may
think. You have the ability to figure out what the error message is all about,
and how you can make the program behave the way that you would like.
And even if none of the steps above seems to be the solution, then you can
always ask someone to come and help you out!
 Chapter 14: A Look at Data Science

The next topic that we need to take a look at here is the basics of data
science. Many times Python will be able to help us to complete some of the
work that businesses want to do with data science, and even with some of
the most basic parts of Python that we have been able to explore in this
guidebook, you will be able to add in a few data science libraries that are
compatible with Python and work on this process that has helped so many
businesses.

Let’s go back a little bit here. Data science is the process of gathering,
cleaning and organizing, analyzing, and visualizing the data that we have
available in order to gain some good predictions and insights out of that
data in the first place. Companies have been collecting this data for a long
time but then they need to take it a bit further and learn the exact steps that
they can take in order to learn something out of this data.

Without a good analysis of the data that has been collected, it is going to be
almost impossible to understand what is in all of that information. But with
the help of Python, and some of the other parts that come with a good data
science process, it is easier for us to understand what is in that data, and this
can help to benefit a business in so many ways. Let’s take a look at data
science a bit more and see what we are able to do with this amazing
addition to any business and any industry.
Why Do We Need Data Science?
The first thing that we need to take a look at is why data science is so
important. Traditionally the information and data that a business would
collect would be structured, and be pretty small in size, which could be
analyzed by using some of the basic tools of business intelligence. Unlike
data that is found in these traditional systems, most of the data that we are
able to collect in the modern business world is going to be unstructured, and
at best, semi-structured. This is going to make a big difference in how we
are able to work with it, and what kind of insights we are able to focus on.

Because the data is unstructured and harder to read through, and there is a
lot of data coming in, much more than ever before. This means that some of
the older and more basic tools that businesses used in the past to sort
through and understand this data, just are not going to cut it anymore.

The data that we see now is often going to be generated from a lot of
different sources, such as from social media, sensors, multimedia forms,
text files, and financial logs. Simple tools form BI are not going to be able
to process all of the variety and the huge volume of data. This is why many
businesses are looking towards more advanced analytical tools and different
algorithms to help them handle this information, whether it is processing
the data, analyzing the data, and drawing meaningful insights out of all of
this.

Of course, this is not the only reason why we are seeing such an increase in
why data science is becoming so popular. What if your business could
understand the precise requirements of your customers from the data that
you already have, including their age, their income, their purchase history,
and even past browsing history. No doubt that your business has been able
to collect this data in the past, but now we are able to take that data and
train some great models more effectively, and then recommend the products
that your customers will like with more precision. This can ensure that we
are going to make it easier for your business to really make more sales and
see a rise in customer satisfaction.
We can also take a look at another example of how data science is going to
benefit a business in making a decision. What if it were possible to have a
car that was smart enough to drive you all the way home, without you being
in control of it at all and having to do the driving? These self-driving cars
are going to collect a lot of information, including data from lasers,
cameras, radars, and sensors, to help create a map of all the things that are
around it.

Based on all of the different types of data that the sensors are able to collect,
and a large amount of data as well, the car will be able to make some great
decisions on when to speed up or go slower, when it should overtake
another car, when it should make a turn, and more, thanks to some more
advanced algorithms from machine learning.

We can also use the ideas of data science when it comes to predictive
analytics. For example, we can work with weather forecasting. Data from
things like radars, aircrafts ships, and satellites can be collected and then
analyzed in order to build up some models to use later. These models are
not only there to forecast the weather, but will also help in predicting the
occurrence of any natural calamities that may show up. It will make sure
that we are able to take the right measures ahead of time, and then save a lot
of lives in the process.
What Is Data Science?
When it comes to the world of business, the word data science is becoming
even more popular than ever before. But before we try to use this term and
the processes that come with it, we need to have a better idea of what data
science actually means for us? What kinds of skills are necessary to handle
all of that data and to become a data scientist? What is the difference
between data science and another similar term known as business
intelligence? How are we able to make predictions and decisions with the
help of data science? These are going to be some of the questions that a
business may have when they are working with data science for the first
time.

The first thing that we can look at is what data science is all about. Data
science is going to be a blend of various principles of machine learning,
tools, and different algorithms that come together with the main goal of
taking some raw data and finding the hidden patterns that are inside of it.
But, is this really that much different from what we have seen statisticians
doing for years now? The difference between these two fields will be found
in the difference between predicting and explaining.

A data analyst is usually going to help us explain what is going on in a

certain process by looking through the history that is present with the data.
But the data scientist is able to take this a bit further. This professional is
not going to just focus on the exploratory analysis of the data to discover
some new insights from that information. They will also work with a
variety of algorithms from machine learning that are more advanced to help
identify the occurrence of a particular event and whether it is likely to
happen in the future. They will take a look at the raw data that they are
presented with form many angles, and sometimes these angles are brand
new and ones we did not know about before.

So, to keep this simple, data science is going to be used in order to help us
to make predictions and decisions. And this is going to be done with the
help of a few different processes including machine learning, prescriptive
analytics, and predictive causal analytics. Let’s explore what each one of
these is about and how they will work with data science overall.
First on the list is the predictive causal analytics. If you would like to create
a new model that is able to predict the possibilities of whether an event is
going to happen in the future or not, you need to work with the predictive
causal analytics. A good example of this is if you are providing money on
credit, then you would use this model to figure out the probability of a
customer making their payments on time.

Since this is very important to determine whether you will loan out the
money that the other person is asking for or not, you would use a variety of
features and information in order to build up a model. This model is going
to perform our own predictive analytics on the history of payment of the
customer to help predict whether they will make those payments in the
future and if they will actually make payments on time or not.

Then we can move on to the prescriptive analytics. If you would like to

work with a model that is smart enough to make some of its own decisions,
and one that has the capability of modifying some of the dynamic
parameters that you want to use, then you should use a prescriptive analysis
for this.

Prescriptive analytics is relatively new, but it is designed to provide

businesses with lots of advice. It is not only able to predict things but can
suggest to a business or another system a range of prescribed actions that
they could take, along with some of the outcomes that are most likely for
those actions. And all of this is done based on the data that you used to train
that model.

For example, we are able to see this happen with the use of the self-driving
car that Google developed. The data that is gathered by the vehicles can be
used to help train these cars to drive on their own. The programmers are
then able to run algorithms on this data, adding in some intelligence to the
car and enables it to make decisions. When the car has enough experience
behind it, then the machine will be able to make decisions on when to speed
up or slow down, when to turn, and even which path it needs to take to get
to the next location.
And finally, we have machine learning to help make some predictions. If
you are a financial company who would like to handle some data on
transactions, or you need to build up a new model to help figure out a trend
that is likely to happen in the future, then the algorithms that come with
machine learning are the best ones to help you out. The topics that we
talked about above would actually fit under the category of supervised
learning.

The reason it fits in this category is that you are going to have the data that
you can use to train the machine. For example, you would be able to create
a model for fraud detection by using some of the historical records the bank
or financial institution holds onto about purchases that were fraudulent in
the past for them.
Data Science vs. Business Intelligence
The next question that we need to take a look at is the idea of how data
science and business intelligence, or BI, are different. BI is basically going
to take any of the previous data that you have and analyze it in order to find
the insight and the hindsight that will make it easier to see and describe the
trends that are happening in your business.

Many times, BI is going to enable you to take data from internal and
external sources, prepare that information, run queries on it, and then create
a dashboard in order to answer a variety of questions to help the business
out. Often, this data can help us to look at common business problems and
even do an analysis of the quarterly revenue. BI can come in and help us to
evaluate the impact that certain events will have on our industry, or even
just on our own business, in the near future.

Data science is going to be a bit different, though. This approach is going to

spend some more time looking towards the future and asks us to work more
on the exploration of the future, rather than concentrating on what may have
happened in the past. We are able to focus on analyzing the past, and
sometimes the current, data that we have.

With this analysis, though, we are able to make some predictions about the
future outcomes that we may experience, starting out with the aim of
making decisions that are more informed for our business. It is going to
answer some of the more open-ended questions that we may have about our
industry and our business, such as how and what events occur.
The Data Life Cycle

The final thing that we need to take a look at here when exploring data
science is the lifecycle of data science. This is an important process to know
about and learn more about because it can help us to really understand the
steps we have to take to not only gather up a lot of information, but sort it
out, clean it up, and analyze it to see what information and insights are in
that data. This is a process that takes some time. But for the companies who
are able to do this the right way, you will find that this is a great way to
learn more about your customers, about your competition, and about how
you can really help your business to grow.

The first phase of the data life cycle is the phase of discovery. Before you
begin working on any project with data, you need to stop and plan a few
things out. You need to have an understanding of the various priorities,
specifications, and requirements for the project. And you need a good idea
of what budget you are working with. Without these things, you will just
randomly sort through a lot of information and have no idea what you are
able to do.

Another thing that needs to be present in the discovery phase is that we

must have the ability to ask the right questions at the very beginning. Here,
you will need to assess whether or not you have the right resources to even
begin in terms of the data, the time, the people, and the technology to
support this project. This is also the phase where you will frame the
problem in the business that you want to solve, and then formulate the
initial hypotheses that you would like to test during the project.

The second phase of this lifecycle is the preparation of the data. IN this
phase, you are going to need to use what is known as an analytic sandbox.
This is a place where you are able to perform analytics for the entire
duration of the project, trying things out, seeing what will make certain
changes, and learning what will work based on the business problem you
would like to see solved. During this phase, we need to be able to explore,
preprocess, and condition the data before we try to model it.
While we are in this step, we also want to perform something that is known
as the ETLT. This stands for extract, transform, load, and transform. This
ensures that we are able to get all of our data over to the sandbox. The
statistical analysis that we are trying to work on here will come in four
steps, including the ones that are below:

1. We prepare the data to work with the analytics sandbox that we

talked about above.
2. Perform the ETLT.
3. Conditioning the data
4. Survey and visualize

When we are working on the process of cleaning, transforming, and

visualizing our data, we can use the R programming language, though
Python is often the one that is preferred. This is a great way for the data
scientist to spot any of the outliers that are found in the data and can make it
easier to see whether there are any relationships between the variables you
have. Once you have been able to clean and prepare the data, we can move
on to performing exploratory analytics on that. Some of the steps that we
will talk about next will show us how we can make this happen.

Then we can move on to the third phase of this lifecycle. This is the model
planning phase. During this phase, we are going to determine which
techniques and which models we would like to use in order to draw up
those potential relationships between the variables in the data. These
relationships are important because they are going to be the base, or the
foundation, for all the algorithms that we want to implement in the coming
phases.

During this part of the process, you will need to apply what is known as
EDA, or Exploratory Data Analytics, to get things done. The EDA is
applied with a variety of visualization tools and statistical formulas. There
are a few different model planning tools that we can work with to see this
happen and some of the best ones include:

1. R: This has a complete set of capabilities for modeling and can

provide programmers with a great environment for building up
 your own interpretive models.
2. SQL Analysis services: These are helpful because they can
perform some analytics in the database, often with the help of
common functions for data mining, and some basic models for
predictions.
3. SAS and ACCESS: These two methods can be used in order to
help a programmer access data from places like Hadoop and is
going to be used when we want to create a model flow diagram
that is reusable and repeatable.

Although there are a lot of tools that are open on the market, the R
programming language and the Python programming language will be the
two most common tools that we can use. Now that we have gone through
the right process in order to come up with some insights into the nature of
our data, and we have an idea of which algorithms we want to use on the
data, we are going to take this a bit further in the next stage. In this phase, it
is time to apply the chosen algorithm and then build up the model to help us
see the insights and the predictions found in that information.

Now we can move on to the fourth phase of the process, the one that is
reserved for model building. When we are in this phase, we are going to
focus on building up some sets of data that we can use for training, and a
separate set of data that we can use for testing purposes. During this part,
we have to consider whether the tools that we already possess are enough to
run these models in, or if we need to add in some new things, such as an
environment that is more robust, including extensions in it like parallel
processing and processing that is faster.

The tools that we need for our model or the process that we are doing with
the data will depend on the business issue we are trying to solve, and what
we are hoping to find out. At the same time, we also need to analyze a
variety of learning techniques to see which ones will help us to build our
model. There are a variety of options available for this, but some of the best
learning techniques that work well for data science will include clustering,
association, and classification.
The fifth phase that we are going to take a look at here is known as the
operationalize phase. When we enter into this phase, we will be near the
end of our process. During this one, we are delivering the final reports, the
briefings the code, and any of the technical documents that are needed to
show what we did, and how we arrived at our conclusions and our insights
based on that data.

In addition to some of the information that we explore in the other phases of

the process, it is possible that the business will decide to implement a pilot
project in the real-time production environment to see how everything will
work. This is helpful because it allows us to have a clearer picture of the
performance and other related constraints on just one area, and on a small
scale before a company risks all that time and money on doing a full
deployment. If things go well, then they will scale the pilot project up. If it
goes badly, they can scrap it without wasting as much money and time in
the process.

And the final phase that we need to take a look at is to communicate the
results. It is important that we go through and evaluate whether or not we
have been able to achieve the goal that we planned out earlier in this cycle.
So, in this last phase, we are going to identify all of the findings that we
worked on, communicate this information to the stakeholders, and then
determine if the results of the process are either a failure or a success based
on the criteria that we developed in the first phase.

There are a few different ways that we can do this. Often there is so much
data and it is so complex that we can’t just sit down and talk about it all,
without a lot of back and forth and some confusion along the way. The best
way for data scientists to look at this information and share it with others is
through data visualization.

Data scientists are able to pick from a variety of visualizations to work

with, based on the kind of data they need to show off. You can work with
pie charts, line graphs, and more to help show some of the complex
relationships that are hidden inside of your data.
There are so many benefits that can come with using data science in your
business. If you have already been collecting all of this data in order to help
your business grow, it is now time to take the field of data science a bit
further, and learn how to analyze and then visualize the information and
insights that are found in the data. Once you are able to do this, you will be
able to make predictions about your business, learn how to cut down on the
waste and the expenses, and improve customer service all from the data that
you have been able to collect.
 Chapter 15: How Python Can Work with Data
Science

We have just spent some time taking a look at data science and all of the
different parts that come with it. We know that data science is very
important to help a company not only collect the pertinent information but
also to help the company glean important insights out of that information.
This helps them to learn more about their customers, about the industry they
are in, which products they should release, how to beat out the competition,
and so much more.

With all of the benefits that come with using data science, the next question
that we need to ask here is how we can use data science along with the
Python language. There are other languages that can work with data
science, and depending on what your preferences are and what results you
are able to get from other coding languages, you may wonder why Python
is often considered one of the best coding languages to go with.

With this in mind, we are going to take a look at some of the reasons why
the Python coding language works so well with data science, and why you
need to have this coding language to really learn about and analyze any data
your business has gathered.
Python Can Help Us Analyze the Data
To start with, we need to remember that Python is seen as a multi-paradigm
programming language, which means that it is like the Swiss Army knife
when it comes to the world of coding. It is going to support a lot of different
things, including functional programming, structured programming, and
object-oriented programming, to suit the needs of your project. Python, in
general, is going to be one of the best languages to use for almost
everything.

The creator of Python thought that this language, even though it has some
power and more behind it, should be fun to use. For this reason, and for
many others, Python is a language that many programmers love to use. Data
scientists who come from backgrounds of science and engineering may feel
like they are out of place, but the readability and the simplicity that comes
with this language really is helpful. These help us to pick up the language
quickly.

And when we can see all of the dedicated analytical libraries that are
available to use with this language, we can see why data scientists, no
matter which sector or industry they are in, will find a package that is
already designed and tailored for their needs. These libraries are often open-
sourced and free to use, making them even more valuable in the world of
data science.

Because of the Python language’s extensibility and the general-purpose

nature, it was inevitable that the popularity of this coding language would
explode, and that people would start to use it to help out with a variety of
projects for data analytics. It may not have started out with the intention of
working with statistics and other things that data science needed. But the
adaptations that come with it have ensured that many people in this field
have seen the result and have started to use Python, along with its data
science and machine learning libraries, for this purpose.
All the Python Libraries Work Well With Data Science
Another benefit of working with the Python language with data science is
all of the great libraries that are available with it as well. As is the case with
a lot of the other coding languages out there, it’s some of the libraries that
are available with Python that leads to its success. With Python designed in
order to have a lightweight and stripped down the core, the standard library
that comes with it has been built up with a ton of tools for all of the
different programming tasks that you want to do. It comes with a
philosophy of “batteries included” which is going to allow users of the
language a way to quickly get down to some of the nuts and bolts of solving
problems, without them having to sift through and make a choice between
competing libraries out there.

Remember here that Python is a software that is open-sourced and free to

use. This means that it is possible for any programmer who would like to
write out a package to extend the amount of functionality that comes with
Python. Data science is one of the best, and the earliest, beneficiaries of
these extensions. And while there are many Python libraries that work well
with data science, Pandas is often seen as one of the best.

Pandas, which is known as the Python Data Analysis Library, is one of the
best for us to use with data science because it is going to have the
capabilities to handle many tasks form importing data from a spreadsheet
all the way to processing sets for an analysis of a time series. Pandas are
able to put pretty much all of the common tools for data munging at your
fingertips. This means that some of the advanced manipulations that you
need, and the basic cleanup, can be performed with the powerful data
frames of Pandas.

One thing to keep in mind here is that the Pandas library is going to be built
on top of NumPy, which is one of the earliest libraries to come on the scene
and help Python be successful with data science. NumPy functions are
going to be exposed to the Pandas library to help with a more advanced
numeric analysis.
In addition to all of this, if you would like to work with a library or another
task that is more specific in data science, with the help of Python, then it is
likely that there is a library of Python out there to help out. Some of the
options that we have when it comes to picking out a library includes:

1. SciPy: This is considered one of the scientific equivalents to

NumPy, offering the right tools and techniques that are needed
for analyzing any scientific data.
2. Statsmodels: This library is going to focus on providing us with
some of the tools that we need to complete statistical analysis.
3. PyBrain and Scikit-Learn: These are great libraries to help out
with machine learning. They will provide us with some modules
that are needed to help with building any neural networks and
with data preprocessing as we talked about before.
4. SymPy: This is used for statistical applications
5. PyMC, PyLearn2, Shogun: These three are great libraries to use
with machine learning.
The Community of Python Makes It Easy to Get Help
Another thing that programmers and data scientists are going to love when
it comes to working with Python for all your data science needs is that it
comes with a very broad and diverse base. There are millions of users all
around the world, many of whom are happy to offer up some suggestions
and advice any time that you may get stuck. It is likely that if you are
struggling with a Python data science issue, then there is someone else out
there who has struggled with the same issue as well.

Communities for open-sourced software like Python are known for some of
their open discussion policies though there are a few of them that have a
reputation for not suffering newcomers lightly. But Python is going to be an
exception to this. Both the local and the online meetup groups are going to
contain experts of Python who are happy to help you out as you work your
way through learning a brand new language, even when it comes to data
science.

Python is actually a very prevalent coding language when it comes to

working in the world of data science. Because of this, there are a lot of
resources that you can use out there that are specific to using Python in the
field of data science. You are sure to find exactly the help that you need to
handle any of your data science needs and questions, even when it comes to
using the Python library.

And for someone who is brand new to data science, to Python or to both of
these topics combined, this is going to be a really great thing to learn about.
It is scary to think about getting into a new field or a new coding language
and worrying that you have to figure everything out on your own. But with
the Python coding language, you will be able to find just the community
you need, no matter your skill level, or whether you are struggling with
Python, data science, or a combination of both.

Python is one of the best coding languages out there to work with when you
want to handle anything in data science. While there are some other options
that you can choose to go with at times, you will find that when it comes to
seeing success with data science and making things as easy as possible,
while adding in the power that you need, then Python is one of the best
choices out there. and this chapter, along with some of the other topics that
we have discussed throughout this guidebook, can show us exactly why
Python is so good for any of your data science projects.
 Conclusion

Thank you for making it through to the end of Learning Python

Programming. Let’s hope it was informative and able to provide you with
all of the tools you need to achieve your goals whatever they may be.

The next step is to start practicing some of the topics that we have discussed
in this guidebook and learn some of the basics of the Python coding
language. We already spent a good deal of time talking about some of the
benefits that come with the Python coding language, understanding what
these are all about, and how you can benefit from them can make a world of
difference in how well you can learn how to code.

This guidebook went from the basics to the more complex when it comes to
coding in Python. Whether you have done some coding in the past or this is
the first time you have been able to jump into the world of coding, Python
is the right language for you. And the point of this guidebook was to walk
you through some of the basic parts that come with code writing in Python,
so you can go from beginner to advance in no time at all.

In this guidebook, we took a look at many of the different types of coding

that you can do and how to handle a variety of situations inside any code
that you write. We looked at the basic parts of the code, how to download
the Python code into your computer, how to work with the conditional
statements, inheritances, functions, and classes to name a few. These are all
important parts that come with coding in Python, and it won’t be long until
you can write some of your own codes in Python, and add this with data
science to see the best results for your business.

When you are ready to go from beginner to more advance when it comes to
learning how to program with the Python coding language, make sure to
check out this guidebook to help you get started!
Finally, if you found this book useful in any way, a review on Amazon is
always appreciated!
 Description

Have you always wanted to learn how to work with a coding language, but
you were worried that it would be too difficult to get started? Are you
interested in being able to write some of your own codes and algorithms for
data science, but you worry that any language that could handle it would
take years to learn and master? Do you feel like you are falling behind and
you want to be able to code with the best of them, no matter what your
coding needs are all about?

This is where the Python coding language can come into play and solve all
of your problems. Python comes with a lot of different benefits, from being
easy for a beginner to learn to have a large community of support, and even
a ton of power to help you accomplish some of the more complex tasks that
are needed for data science, machine learning, and even tasks with artificial
intelligence.

If you are interested in learning more about machine learning and what you
are able to do with this coding language, then this is the guidebook for you.
We are going to explore from the very basics to the more complex of what
we can do when we start coding with Python.

Some of the topics that we are going to explore when it comes to seeing
success with the Python coding language, even as a beginner, will include:

What the Python language is all about and some of the benefits
of getting started.
How to download the Python language and many of its libraries
onto your computer so you can get started.
The basic parts of a Python code that you should know before
getting started.
Easy coding examples and explanations for how to work with
classes, conditional statements, inheritances, loops, and more.
 A bit about data science and why it is such a great option to help
businesses succeed.
How to use the Python coding language to help complete the
process of data science for your needs.

There are many programmers who have learned how to love working with
the Python language and how it can help them to complete many different
coding tasks, from the very basic up to complex tasks of data science,
artificial intelligence, and data science. When you are ready to go from
beginner to advance with the Python language, make sure to check out this
guidebook to help you get started.