Python Programming

A 7-Day Crash Course to Learn Python

Language for the Absolute Beginner,
Including Practical Exercises, Tips & Tricks
to Quickly Getting Started with Computer
Programming

John Russel
© Copyright 2019 by John Russel- All rights reserved.

This content is provided with the sole purpose of providing relevant information
on a specific topic for which every reasonable effort has been made to ensure
that it is both accurate and reasonable. Nevertheless, by purchasing this content
you consent to the fact that the author, as well as the publisher, are in no way
experts on the topics contained herein, regardless of any claims as such that
may be made within. As such, any suggestions or recommendations that are
made within are done so purely for entertainment value. It is recommended that
you always consult a professional prior to undertaking any of the advice or
techniques discussed within.

This is a legally binding declaration that is considered both valid and fair by both
the Committee of Publishers Association and the American Bar Association and
should be considered as legally binding within the United States.

The reproduction, transmission, and duplication of any of the content found

herein, including any specific or extended information will be done as an illegal
act regardless of the end form the information ultimately takes. This includes
copied versions of the work both physical, digital and audio unless express
consent of the Publisher is provided beforehand. Any additional rights reserved.

Furthermore, the information that can be found within the pages described
forthwith shall be considered both accurate and truthful when it comes to the
recounting of facts. As such, any use, correct or incorrect, of the provided
information will render the Publisher free of responsibility as to the actions taken
outside of their direct purview. Regardless, there are zero scenarios where the
original author or the Publisher can be deemed liable in any fashion for any
damages or hardships that may result from any of the information discussed
herein.

Additionally, the information in the following pages is intended only for

informational purposes and should thus be thought of as universal. As befitting
its nature, it is presented without assurance regarding its prolonged validity or
interim quality. Trademarks that are mentioned are done without written consent
and can in no way be considered an endorsement from the trademark holder.
Table of Content

Introduction
Day 1: The Basics

What is Python
Your Choices in Python Versions
The Benefits of Python
How to Install Python On Your Computer
Day 2: The Variables and the Operators

Python and Its Keywords

The Comments
The Statements
Strings and Numbers
How to Name the Variables
The Importance of the Functions
The Python Operators
The Basics of the Python Class
Day 3: Understanding How Functions Work in Python
How to Define and Call Functions
Returning a Value of the Function
The Arguments in Our Functions
Some Tips to Get Started

Day 4: The Data Types

What are the Python Variables?
 The Different Types of Data in Python
Day 5: Files in Python

Creating a New Python File

The Binary Files
How to Open Up Your Files
Seeking Out Your File
Day 6: Data Structures

The Dictionary
Lists
How to Create a Class
The Class Objects
Inheritances
Encapsulation
Polymorphism
Day 7: Getting Started; Python Tips and Tricks
Conclusion
Introduction
Congratulations on purchasing Python Programming and
thank you for doing so.

The following chapters will discuss everything that you need

to know in order to get started with Python programming. If
you have never spent time working on coding at all, you will
find that this is the best option for you to choose, because
Python is easy, with lots of power, and you can catch on
pretty quickly. And with this guidebook, we are going to
provide you with all of the basics that you are looking for,
and teach you how to code in just seven days!

For our first day, we are going to start out nice and
easy and learn a bit about the Python language. We are
going to learn what some of the benefits are, a bit
about the different versions that come with this
language, and why you would want to choose to work
with this language compared to some of the other
options out there. We will also take a brief time to look
at some of the steps that you need to take in order to
download this language onto any operating system
that you want, ensuring that you can jump right into
coding when you are ready.
On the second day, we are going to look at some of the
basics that you need to know when it is time to start
coding. We will spend time looking at strings, numbers,
how to handle variables, statements, classes,
comments and more. And then on day 3, we will move
on to looking a bit at the Python functions and how we
are able to make these work for our needs. These
functions are important to many of the codes that you
want to write, and we will spend our time looking at
how to define them, and how to make some of our own
as well.

On day 4 we are going to move into some of the

information about data in Python. Data is going to be
so important when you are working in Python, and we
will definitely explore this one a bit later on. But for this
chapter, we are going to take a look at some of the
different types of data, what types of numbers are
recognized, and more all inside.

On Day 5, we will move on to looking at the files in

Python and what these are all about. These files are
important because they are where we are going to
write out some of our codes in this language, and being
able to start a new one, find your file, overwrite parts,
and save them properly can all be important to some
of the coding that we will spend our time on in this
chapter and on this day.
 When we are done with all of the neat things that we
are able to do with the files in Python, it is time to
move on to some more about data, and in specific, we
are going to focus on data structures in Python. This
chapter is going to dive into more of the different data
structures that we are able to focus on including the
dictionary, how to create a class and access members
of the class, what objects are about along with the
ideas of inheritances, encapsulation, and
polymorphism all wrapped up in one.

Then on day seven or last and final day, we are going

to take a look at some of the tips and tricks to make all
of the information that we have used in the other days
and put it to use. We will look at things like web
scraping and how to do it, how to debug your program,
and some of the other steps that you can take in order
to get the most out of some of the coding that you will
do in Python.

And that is all that it takes! Even if you have never worked
with a coding language in the past, and this is the very first
time that you have even worked with it at all, you will find
that this guidebook has some of the tips and tricks that you
need to get this done. It only takes seven days for you to
get started with a new coding language, especially one as
simple as Python, and soon you will be able to write out
some of your own codes and see some great results in the
process.

You don’t have to be scared or worried that coding is going

to be too hard to learn. This is often the biggest issue that
will prevent new programmers from getting into the game
and learning how to do some of their own coding for their
own projects or applications. It only takes seven days to
work wit and learn how the Python language works, and in
that time, you can master one of the most popular and
widely used coding languages out there.

Learning a new coding language can be a great thing for

many different reasons, and figuring out how to get all of
the different parts to line up and do the work that you want
is sometimes a challenge. When you are ready to learn how
to work with the Python coding language, no matter what
project or application you plan to use it with, and you want
to learn how to use this language quickly and efficiently,
then make sure to take the time to read through this
guidebook and learn how to master the basics of the Python
language in just one week.

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 it!
Day 1: The Basics

There are many things that you are going to love about
working with the Python language. Many people may be
wary of starting on a new coding language because they
may think it is too hard for them to focus on or learn. They
may not think they have the time to learn. Or they may
worry that each time they want to create a new project,
they will have to go through and start from scratch.

In addition to the benefits that you get simply because the

Python code is an OOP language, you will also enjoy that
Python is open-sourced. This means that there are a ton of
codes that you are able to use with Python that is free and
available for you. You could even choose a few and just
tweak them to fit your needs.

This open-source of Python is great because it allows you to

get ahold of codes and encourages more advanced
programmers to get into the game and make the needed
changes and adjustments to the program as time goes on.
Some people can have their own copyrights on specific
third-party libraries or IDLE’s or more, but the basics of the
Python code are open-sourced to make it easier for you to
use as needed.

There are a lot of good coding languages out there that we

are able to work with, and learning how to make this work
can be a challenge, as can choosing which one is the best
for our needs. This is why we are going to spend some of
our time exploring the Python language and all that this
kind of language is able to do for our needs. When you are
ready to get started, let’s dive right in!
What is Python
Python is going to be a programming language that is
known as interpreted, general-purpose, high-level, and
multiparadigm. Python is going to allow the programmers
who use it some different styles of programming in order to
create simple or even some complex programs, get quicker
results than before, and write out code almost as if they are
speaking in a human language, rather than like they are
talking to a computer.

This language is so popular that you will find a lot of major

companies that are already using it for their systems,
including Google App Engine, Google Search, YouTube,
iRobot machines and more. And as the knowledge about this
language continues to increase, it is likely that we are going
to see even more of the applications and sites that we rely
on each day working with this language as well.

The initial development of Python was started by Guido van

Rossum in the late 1980s. Today, it is going to be developed
and run by the Python Software Foundation. Because of the
features behind this language, programmers of Python can
accomplish their tasks with many different styles of
programming. Python can be used for a variety of things as
well including serial port access, game development,
numeric programming, and web development to name a
few.

There are going to be a few different attributes that we can

look at that show us why the development time that we see
in Python is going to be faster and more efficient than what
we are seeing with some of the other programming
languages out there. These will include:
 1. Python is an interpreted language. This means that
there is no need for us to compile the code before we
try to execute the program because Python will not
need this compilation in the background. It is also
going to be a more high-level language that will
abstract many sophisticated details from the
programming code. Much of this abstraction is going to
be focused so that the code could be understood even
by those who are just getting started with coding.

2. Python codes are often going to be shorter than similar

codes in other languages. Although it does offer some
fast times for development, keep in mind that the
execution time is going to lag a little bit. Compared to
some of the other languages, such as fully compiling
options like C and C++< Python is going to execute at
a slower rate. Of course, with the processing speeds
that we see in most computers today, the differences
in the speed are not really going to be noticed by the
people who are using the system.

There are a lot of different things that we are able to do

when it comes to the Python language, and we are going to
spend some time looking at how we can do some of the
different parts as well. From some of the basics that we are
able to do with the help of Python all the way to some of the
more complex things that we are able to do with data
science and machine learning that we can talk about a little
later.

And all of this can be done with the ease of the Python
language. You will find that when we spend some time
focusing on this language and some of the basics that we
are able to do will help to prepare us for some of the more
complicated things that we are able to do with this code as
well.
Your Choices in Python Versions
As a type of interpreted language, Python does have a lot of
advantages over the other programming languages. One of
these advantages is that it has the ability to grow and make
changes as your computing needs change. Like your
desktop applications, the fact that Python is continually
developed will allow for new features to be added to the
language, and you will see a lot of refinements added to
Python to make it easier to use.

Throughout the years, there have been various versions of

the Python language released, each one providing different
features and benefits compared to the one before. Some of
the different options you can choose when it comes to
working with Python include:

The first version of Python that we need to take a look at

here is going to be Python 2. This was the version of Python
that was released in 2000, but there have been a few
versions of this that were released over time. The latest
version of this one, Python 2.7 was released in 2010 and is
likely to be the last of the Python 2 family that developers
are going to work on since focus has moved over to working
with Python 3.

While most programmers are going to work with Python 3

because it is the newer version out of the two, you will find
that if this version is already on your computer, you will be
able to complete a lot of the coding that you want. And it is
an easy version to work with, providing us with many of the
features that we need to complete Python coding, without
all of the extras that seem neat, but tend to slow down the
system

There are also times when the programming requirements

for your company, such as ones that maybe have a little bit
older technology, will benefit more from the Python 2
version that is available. For example, if you are working on
a company that has some policies in place that discourage
or ban the installation of unapproved software from other
sources, then you may find that Python 2 will fit the bill a bit
better. This is because the Python 2 version is pre-installed
on many computers ahead of time, so you won’t have to
worry about doing this yourself.

In addition, there are many third-party libraries and

packages that are used to help extend what capabilities the
2.X version can handle, and some of them are not present in
the newer 3.X version. If you want to work with a specific
library for your application, you may find that it is only
available in the 2.X version. You would need to download
this version to get it to work for you.

If you do decide that this version is the best one, you should
still take a look at the 3.X version. There are some
differences in the best programming practices of each and
you may even be able to make slight modifications to your
code on the 2.X version and get it to work on the newer
version.

Then you have the option of working with the Python 3

library. Many people who decide to work with Python are
going to take some time to look at how they can work with
Python 3 because it is the newest and the one that the
Python developers are working on right now. This is the
version that was originally released in 2008. There are
several versions that have come out since that time so you
are able to pick the one that works the best for you.

Since Python 3 is the most current version of this language,

most of the examples and the codes that we are going to
talk about in this guidebook will be based on this version.
You will find that there are many benefits that work with
Python 3 because it has a lot of add-ons that we need, has
the latest libraries, and since it is the version that
developers are working on right now, it will get the latest in
features, developments, and updates as time goes on.
The Benefits of Python

It will not take long for you to work with the Python
language before you are able to see some of the benefits
that are available when it comes to working with this kind of
language. In fact, you may already know some of the
benefits that are present, and you may already have a list of
your own reasons as to why you would like to choose this
language as the one that you choose to work with. Some of
the different benefits that come with working on the Python
language will include:

Python is one of the best languages for beginners to learn

about. If you have ever wanted to get into coding and
learning how to write some of your own programs then the
Python language is one of the best to help you get this
done. You will quickly find that this is a language that is
simple to learn how to use, even though it does come with a
lot of power along the way. For those who might have been
afraid in the past to try something new, it won’t take long to
see the benefits that come with Python, and why it is such a
good coding language to get you started.

You are able to use and make modifications to the Python

program for free because it is open-sourced. This is great
news because it means that you will be able to go to the
Python website and download the version of Python that you
want, for whatever operating system you would like as well,
without having to pay anything. Python is open-sourced so
you will be able to write some of the codes that you want,
and get it all taken care of, without a lot of hassle along the
way either.

There are a lot of resources out there that will help you to
take charge of your programs. This is due to the fact that
there is a large community of programmers out there who
are willing to answer your questions, show you new ways to
do some of the codings, and so much more. Because Python
has so many benefits and is such a good coding language to
work with, there are a ton of developers out there who know
how to use this language, and they are found all throughout
the world.

As a beginner, it is likely that you are going to run into some

trouble with the coding on occasion, or have some
questions. And the fact that there are so many other
programmers and coders who know how to use Python and
who are active online is going to be good news for you.
These individuals will be able to help you with any of the
programming problems that you have, making it easier for
you to get the results in no time.

It is easy to read this language and it is likely that without

even starting, you will have a good idea of what is found in
some of the codes in this guidebook already. Take a look at
some of the codes that are further down in this guidebook
and see if you are able to read through and understand
some of them for your own needs. Python was designed to
be easy not only to use but also to read as well. This makes
it possible for us to really work on some of the codes that
we would like and will ensure that we are going to see some
of the best results with this in no time.

Python is also going to work well with some of the other

coding languages that are out there. This can be good news
when you want to work with some of the more complicated
parts of coding along the way. when you are able to work
with this language and combine it with some of the other
options that are out there, especially during machine
learning and data analysis, you are going to get some
amazing results in the process as well.

There is a lot of power that is available with the Python

language. We have spent some time talking about the
Python language and how it is designed to help out with
some of the different parts that you would like as a
beginner. But this doesn’t mean that you are going to have
to sacrifice the power and the functionality of this language,
just because it works well for those who are just starting out
with the coding.
There is actually some good power behind this language,
which is going to make it the perfect option to use for those
who are just beginning on this process. You will find that this
language is able to handle a lot of the more complex parts
of coding that you would like to focus on, and it works well
no matter what kind of coding you would like to focus your
attention on at the time. Don’t be fooled by hearing that this
is a language for beginners. The Python language works well
whether you are a beginner or you are more advanced in
coding, and it can definitely help you to get your work done
in no time.

The standard library that comes with Python will help you to
get a ton of things done no matter what your level of coding
may be. When you download the Python language like we
will talk about later, you will find that it has a lot of the
capabilities that you need to get some coding done. We will
take a look at some of the different coding things that we
are able to do when it comes to working with Python, but
there is so much more than the Python language is able to
do to help us see results.

There are also a lot of extensions and other libraries that

come with the Python language that can increase the
capabilities of what you are able to do with this language.
This is a great option for you to work with when it is time to
handle a few different parts of things like machine learning,
data analysis, and more. These are hot topics when it comes
to working with the Python language, and many businesses
want to be able to use these for their own needs as well.
The Python language allows you to work with some of these
ideas without having to worry about how complicated they
are, or whether or not the coding is going to be too difficult
overall.

As we can see here, there are a ton of benefits that are

going to be yours when it is time to work with the Python
language. Knowing how to work with this language, and
some of the different parts that come with it are critical to
making sure that you get what you want out of coding.
Whether you would like to add in another language to your
skills after already knowing some coding in other languages,
or you are starting out with this one as your very first
language, the Python coding is the best one to use.

How to Install Python On Your Computer

The good news here is that the Python language is going to
work no matter what operating system you plan to use. This
makes it really easy for you to go through and use it on your
system no matter which one you have, and you will not
have to go through and change up a lot of things along the
way. This can be a great thing for programmers who are just
getting started and who do not want to work with a new
coding language and a new operating system at the same
time.

Downloading Python is going to be a simple process to use.

We are going to keep it basic, but you can just visit the
www.python.org website and look for the version that you
would like to work with. This website is going to come with a
lot of the options that you will want to use when it comes to
Python, and you can choose from which operating system
you would like to use, and which version of Python as well.

You simply need to go through and click on the version, and

the operating system, that you would like to focus your
attention on, and then follow the instructions that come with
it. Be aware that working with the Windows system is going
to take a bit longer than working with the Mac or Linux
systems. This is because Windows already has its own
operating system found on it, so we will have to go through
and add this on, and there are a few more steps.
Another thing to note while we are here is that the Python
language is going to be available on many different
platforms and third-party options. The reason that we get it
off of www.python.org for our purposes is that this is the
original website that will offer Python for free. And it will
make sure that all of the files and shell and other parts that
you need with Python are going to be present in the
download that you do.

When you download from other sites, you may be able to

get some really cool features and more that come with it,
but sometimes they only download the IDE, and only
download the shell and not some of the other features you
need. And sometimes they even charge for the use of that
product. Getting it off the website above will ensure that the
program is going to work for your needs.

As we can see here, there are a lot of parts that come with
the Python language and being able to use this properly and
getting them to work the way that we want, and there is just
so much that we are able to do with this language. Now that
we have some of the basics down of what works with
Python, let’s explore a little bit more about some of the
different things that we are able to do with this language to
make it work the best for us.
Day 2: The Variables and the
Operators

The next topic that we need to spend time on is some of the

basics that come with the Python language. Knowing these
basics will ensure that you are able to write not just simple
codes that come with Python, but also some of the more
complex codes that you will reach when it comes to data
science, machine learning, math, and science as well.

Of course, for right now those are in the future, and we are
going to spend our time looking at some of the basics that
come with coding. Still, some of the topics that we are going
to spend our time on in this chapter will be things that you
can see in all sorts of programs that you work with and can
be reused over and over again. These include things like the
Python keywords, the comments, functions, operators, and
more. Let’s dive into some of these topics and see what
they are all about so we can learn how to make them work
for some of our needs as well.
Python and Its Keywords
The first thing that we are going to take a look at when it
comes to doing some of the codings that we want to
complete in Python is to take a look at some of the
keywords that come with this language. These keywords are
so important because they are going to help us to really
give the right commands to the compiler. When these
keywords are used in the proper manner, you will find that
they are going to provide you with the right execution when
it is all said and done.

You have to make sure that you are using the keywords in
the right spots of your code. If you use them outside of the
prescribed areas, you will end up confusing the compiler
that you are using because it will not know what you would
like to have done. Make sure that you are learning what
some of these keywords are all about, and where to put
them properly in your code, to ensure that they are going to
do the right work for you.
The Comments
Another part of the code that is pretty simple to work with,
but can make a world of difference in some of the parts of
coding that you do here will be the comments. Sometimes,
you may go through the code and need to leave a little note
or an explanation about what is going on inside of the code.
But you don’t want to have the compiler read these at all
and ruin the program. This is where you will need to bring in
the comments.

Writing these comments in Python is going to be pretty easy

to work with. You simply need to add in the # sign before
the comment that you want to write out, and then the
compiler will know that you would like to have that part of
the code skipped over for now. You can add in a lot of these
comments to your code, as long as you have that symbol
showing up before it.

If you forget the comment symbol before one of the

comments that you want to write, this will end up confusing
the compiler you are working with and can cause some
problems along the way. it is likely that the compiler is going
to send up an error message with this, and that could cause
a lot of issues and the code will not keep working. Make sure
that the # symbol is before the comment that you want to
make, and then keep the comments down to just the ones
that you really need in the code, and you will find that the
code will work the way that you want in no time.
The Statements
We can also take a look at the statements in Python. These
are pretty basic. If you would like to have the compiler put a
sentence, or even a paragraph, on the screen at some point
of the code, then you will be working with a statement.
These are going to show up quite a bit in the code that we
have written, and you will find that they can be as short or
as long as you would like them to be overall. You get to be in
control of this one, and you will find that they are pretty
prevalent in some of the work that you do with this one.

Strings and Numbers

In this section, we need to take a look at a few of the
different parts that are going to come with the strings and
numbers. First, we will take a look at how the strings are
going to work in this kind of programming language. The
string, to keep things simple for now, is going to be just a
series of text characters that are going to show up in the
code that you are trying to write.

There are going to be a few different operators that you are

able to use when it is time to focus on these Python strings.
An operator for this case (we will discuss more of them in a
moment), is going to just be a symbol that is meant to work
with a specific operation inside the code that you are
writing. In this scenario, the operation that we are working
with is any of those that can be performed on the string that
you have.
The good news with this one is that there are quite a few
operators that we are able to work with that relate directly
to the strings that we are focusing on. Some of these string
specific operators that we can work with will include:

Concatenation operator: This is the operator that you

would want to use when it is time to concatenate
strings.

Repetition operator: This is the operator that you will

use in order to create many copies of a string. You can
choose how many times you would like to repeat the
string.

Slice operator: This is the operator that is going to look

through your string and then retrieve the specific
character that you want from there. Any time that you
use this one, you would need to remember that zero is
going to be the first character of the string.

Range slice operator: This is the operator that is going

to retrieve a range of characters from your index,
rather than just one character. If you just want to
showcase one word or one part of your string, you
would use this kind of operator.
 In operator: This operator is going to search for a
specified character in a target string. If the character is
present somewhere in the string, then you will get an
answer of True returned to you. If that character is not
inside the string, then you will get an answer of False
returned to you.

No in operator: This is the operator that will work in the

opposite manner as the in operator. It is going to
search for a specified character in your string. But if
the operator is not able to find that character in the
string, then you will get the True answer returned. If
that character is found in the string, then it is going to
return False.

We can also work with some of the numbers that show up in

Python. We are able to work with a number in a similar
manner as what we would od with some of the other
applications. You can have integers and floating numbers in
your code, and often they are going to be used in some of
the mathematical methods that you will want to focus on.
This again is going to bring up the use of the operators as
well and can help us to do a variety of mathematical
equations in Python as well when we would like.
How to Name the Variables
While we are here, we need to spend some time looking at
the importance of the variables in Python, and how we are
able to handle these, as well as name them. There are a lot
of times when we will need to focus on these variables, and
they are going to show up in a lot of the different codes that
we are working with as well because the variables are there
to help us bring out the values that we would like to use.

To start with, we need to know that these variables are

basically going to be anything that is able to hold onto a
value, and that can also change in the process A variable is
just going to be a box that reserves some space on the
memory of your computer and that can hold onto things for
the code. These are going to be important for us to learn
about because they will ensure that the value you need can
be attached to a variable and then pulled out at the time
that we want.

As a programmer who is learning more about Python, you

will find that these variables are going to be really good for
us to learn because they are the parts that store information
in the memory of our computer for the code. Then the
compiler is able to pull out these values when it is time to
execute them. The variables that you will create will be
found in a certain location, based on where the computer
would like to store it, and then we can find them later during
the execution of the code. Depending on the kind of data
that you are using, the variable is going to be there to tell
the compiler where it should save this information to use
later.
One of the most important things that we are able to do
with these variables is to assign one or more values over to
it. If we do not complete this step, then we are going to end
up with an empty space in the memory of our computer,
and it is hard to pull this out later when it is needed. If the
variable has a value that is assigned to it, and sometimes
we may see that it has two or more values assigned to it
then it is set up in a manner that it will react how you want
inside of the code.

As you write some programs and start to work with these

variables, you will find that the Python code is going to
provide us with three good options that we are able to pick
from. It is often going to depend on what you would like to
do with your code, and what values you are assigning to the
variables to help you figure out how to handle things here.
The variables that we are able to pick from for this will
include:

Float: this would include numbers like 3.14 and so on.

String: this is going to be like a statement where you

could write out something like “Thank you for visiting
my page!” or another similar phrase.

Whole number: this would be any of the other numbers

that you would use that do not have a decimal point.
When you are working with variables in your code, you need
to remember that you don’t need to take the time to make a
declaration to save up this spot in the memory. This is
automatically going to happen once you assign a value over
to the variable using the equal sign. If you want to check
that this is going to happen, just look to see that you added
that equal sign in, and everything is going to work.

Assigning a value over to your variable is pretty easy. Some

examples of how you can do this in your code would include
the following:

x = 12 #this is an example of an integer assignment

pi = 3.14#this is an example of a floating-point assignment
customer name = John Doe #this is an example of a
string assignment

Another option that you can do here, and that we have

mentioned a little bit in this chapter already, has a variable
assigned to two or more values. There are some instances
when you are writing code and you will need to take two
values and place them with the same variable.

To do this, you simply need to use the same procedure that

we talked about above. Just make sure that you add in an
equal sign to each part to help the compiler know that these
are all associated with the same variable. So, you would
want to write out something like a = b = c = 1 to show the
compiler that each of these variables equals one. Or you
could have 1 = b = 2 to show that there are two values to a
variable.

As you work with these variables, you will need to always

remember that the best way to get these to work the way
that you want is to assign a value over to the variable in the
code. These variables on their own are not able to do much
except reserve a bit of space in the memory of your
computer that can be pulled out later on. But when we
combine them together with a value, and sometimes more
than one value, then you will find that the variable will be
able to bring out this value when the variable is called.
The Importance of the Functions

The next basic on our lists that we need to spend some time
on here is the importance of functions and how we can use
these to our advantage as well. These functions are
basically just going to be sets of expressions, which we can
also call statements in some cases. They are going to fall as
some of the first-class objects that show up in the code,
which helps to take off some of the restrictions and other
issues that can come upon how you will work with these.

The nice thing here is that you are able to use these
functions in a manner that is similar to some of the other
values out there, including strings or numbers. Plus, they
are going to have some nice attributes that we are able to
bring out, simply with the use of the dir function.
It will not take long for us to work with these functions
before we notice that they are really diverse. Plus they
come with a lot of attributes that the programmer is able to
use when they would like to create these functions. Some of
the different attributes and types of functions that we are
able to work with here 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.

There are different things that you can do with your

functions, such as passing it as an argument over to one of
your other functions if you need it. Any function that is able
to take on a new one as the argument will be considered the
higher-order function in the code. These are good to learn
because they are important to your code as you move.
The Python Operators

While we are here, we want to look at the topic of the

Python operators and what these are able to do for some of
our codings. As we go through some of the codings that
need to be done as a beginner throughout this guidebook,
you will find that these operators are pretty common and we
are going to use them on a regular basis. There are actually
a number of operators, but we are able to split them up into
a few different types based on our needs. Some of the
different operators that we are able to work with will
include:
1. The arithmetic operators. These are the ones that will
allow you to complete some mathematical equations
inside of your code, such as addition or subtraction.
You can simply add together two operands in the code,
or two parts of the code together, subtract them,
multiply them, and divide them and work from there.
These can be used in many of the different codes that
you would want to write along the way. Some of the
options that you will be able to use when it comes to
the arithmetic operators will include:

a. (+): this is the addition operator and it is

responsible for adding together both of your
values.

b. (-): this is the subtraction operator and it is going

to be responsible for taking the right operand and
subtracting it from the left.

c. (*): this is the multiplication operator and it is

used to multiply two or more values in the
equation.

d. (/): 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.
2. Comparison operators: We are also able to work with
the comparison operators. These are going to be a
good option when we would like to take two or more
parts of the code, such as the statements or the
values, and then compare them with one another. This
one is going to rely on the Boolean expressions to help
us get things done because it will allow us to look at
true or false answers along the way. so, the statements
that you are comparing will either be true or they will
be false based on how they compare.

a. (>=): this one means to check if the left-hand

operand is greater than or equal to the value of
the one on the right.

b. (<=): this one means to check if the value of the

left-hand operand is less than or equal to the one
on the right.

c. (>): this one means to check whether the values

of the left side are greater than the value on the
right side of the code.

d. (<): this one means to check whether the values

of the left side are less than the values that are on
the right side.

e. (!=): this is not equal to operator.

 f. (==): this one is equal to operator.

3. The logical operators: The next option is going to be

the logical operators. These ones are often not used
until we get to some of the more advanced codes that
you may write later. These types of operators are going
to be the ones that we will need to use to evaluate the
input that a user is able to give to you with any of the
conditions that you decide to set in the code, and there
are three of them that can be used to help us with this
goal.

a. 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.

b. 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.

c. 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.

4. Assignment operators: And finally, we are going to take

a look at the assignment operators. These are going to
 be ones that are used all of the time, and we have
actually already seen them in some coding in this
chapter. The assignment operator is simply going to be
an equal sign because it takes a value and assigns it
over to one of your variables. You can use any variable
or value that you want here, and do the assigning s
much as you would like, just make sure that the equal
sign is in the right place.

These operators are going to be important to the codes that

you write for many reasons, and it often depends on what
you are hoping to accomplish out of some of the codes that
you are writing along the way. Take some time to look these
over and learn a bit more about these operators and how
you are able to use them in some of your own codings along
the way for the best results.
The Basics of the Python Class
While we will dive into the classes with Python a bit more as
we progress through this guidebook, we are going to do a
little glance at these right now to see what they are all
about. The Python class is going to be a unique feature that
comes with OOP languages like Python, and it helps to keep
everything organized and easy to find at execution,
especially when it is compared to some of the older
programming languages.

Python classes are basically just little boxes in the program

that are able to hold onto the objects that you work with.
These objects are going to be based on real-world items, so
we can really understand what they are and how we are
using them within the code. But if we did not organize these
objects and put them in the right place it is likely they would
just bounce around and get lost and your code would not
work the way that you want.

On the other hand, we can work with the classes to help

keep all of these objects organized and easy to work with
along the way. You can easily create a class in Python and
then add in any of the objects that you choose. As long as
the objects that are in the same class make sense to go with
one another, your code is going to work the way that you
would like.
As we can see here, there are a lot of different parts that
come together when we are working with the Python
language and all of the different parts that come with it.

Learning some of these basics and what we are able to do

with this language is a great start to ensuring that we are
going to get some of the results that we want in no time.
And once we get some of the basics down, we will find that
it is much easier to work with some of the more complex
and hard codings later on.
Day 3: Understanding How
Functions Work in Python

We spent a bit of time earlier in this guidebook looking at

the functions and what these are all about, and now it is
time for us to take a look at how these functions are
supposed to work in more depth. There are many times
when we will want to focus on these functions, and being
able to use them in the proper manner will ensure that we
are going to get the results that we want in no time. With
this in mind, let’s dive into what these functions are and
what they mean to some of the codes that we are writing.

The function is going to be used in the Python language in

order to utilize the code in more than one place in our
program, and sometimes it is going to be known as the
procedure or the method. Python is going to be a nice
language to work with because it will come with many
inbuilt functions that we have. But it also provides us with
some of the freedom that we need in order to create our
own functions in the process.
How to Define and Call Functions
To start, we need to take a look at how we are able to define
our own functions in this language. The function in Python is
going to be defined when we use the statement of “def” and
then follow it with a function name and some parentheses in
place as well. This lets the compiler know that you are
defining a function, and which function you would like to
define at this time as well. There are going to be a few rules
in place when it comes to defining one of these functions
though, and it is important to do these in the proper manner
to ensure your code acts in the way that you would like.
Some of the Python rules that we need to follow for defining
these functions will include:

1. Any of the arguments or input parameters that you

would like to use have to be placed within the
parentheses so that the compiler knows what is going
on.

2. The function first statement is something that can be

an optional statement something like a documentation
string that goes with your function if needed.
 3. The code that is found within all of the functions that
we are working with needs to start out with a colon,
and then we need to indent it as well.

4. The statement return that we get, or the expression,

will need to exit a function at this time. We can then
have the option of passing back a value to the caller. A
return statement that doesn’t have an argument with it
is going to give us the same return as None.

Before we get too familiar with some of the work that can be
done with these Python functions, we need to take some
time to understand the rules of indentation when we are
declaring these functions in Python. The same kinds of rules
are going to be applicable to some of the other elements of
Python as well, such as declaring conditions, variables, and
loops, so learning how this work can be important here.

You will find that Python is going to follow a particular style

when it comes to indentation to help define the code
because the functions in this language are not going to have
any explicit begin or end like the curly braces in order
languages to help indicate the start and the stop for that
function. This is why we are going to rely on the indentation
instead. When we work with the proper kind of indentation
here, we are able to really see some good results and
ensures that the compiler is going to know when the
function is being used.
Returning a Value of the Function
The next thing that we need to take a look at here is how to
return a command in Python. This is important because it is
going to specify what value we are able to give back to the
caller of our function. We are going to take some time to
look at an example to see how we can return the value of
our function and get it to perform in the manner that we
want.

The first step is that we are going to see when a function is

going to not be “return”. In this example, we are going to
get the square of 4, which is going to give us an answer, if it
is working properly, of 16, when we execute the code. This
is what we are going to get when we simply use the code of
“print x*x” in the code, but when you call the function,
“print square” you may find that the output that you are
getting is going to be “None”.

The reason that this is happening is that when you call up

the function, the recursion is not happening right now, and
it is going to end up falling off at the end of the function that
we are working with. Because of this falling off at the end of
our function that is going on here, the Python compiler is
going to return to us the answer of “none” for right now.

To make sure that this is a little bit clearer, we need to go

through and replace the print command that we had above
with a command for an assignment. When we runt the
command of “print square (4)” it is going to actually return
to us a value of that object that we inserted. This is because
we don’t end up having any specific function to run over
here that caused the original issue in the first place.

Then we can take this a little bit further as well. Here we are
going to see how we are able to retrieve the output with the
use of the “return” command. When you work with this
function, and then execute out the code that we are going
to have, and we used the command of “print square (4) “
from above, our output is going to be 16.

And finally, the functions in Python are going to be objects

on their own. And all of the objects need to have some kind
of value. This is where we are going to really see how we
are supposed to treat an object in the Python language.
When you go through and run the command of the print
square, it is going to help us out because it returns the
value of the object. At this point, we have not passed any
argument over yet, which means that we are not going to
end up with a specific function to run over here and it is
going to return to us a default value, which is going to
reveal to us the location of the object.

One thing to note here is that while we are explaining what

all of this means and why it is important, in most of the
programming that you are going to do with Python, you will
not need to work with this so it is not a big deal.
The Arguments in Our Functions
We mentioned the importance of those arguments earlier
when it comes to our functions, so now it is time for us to
take a look at them again. The argument is going to be a
value that we can pass to the function when we call it up. In
other words, when we find ourselves on the calling side, it is
going to be an argument and when we are on the function
side instead, it is going to be our parameter. Let’s take a
look at how these arguments are going to work when it
comes to these functions.

First, the arguments are going to be declared in the function

definition. While calling the function, you are able to pass
the values for that argument as you would like. Then it is
time to declare our default value of an argument while also
assigning a value to it. We can work with the following code
to help us get an idea of how this is going to work:

def multiply(z, y=0):

When we look at the example above, we will find that the x

we are working with is not going to have any kind of default
value to work with. Then the default that we will see with y
is going to be 0. When we supply only one of the arguments
when we call up the multiply function, Python is going to
assign the supplied value to x while keeping the value of y
= 0 This is why we are going to end up with the multiply of
*y=0.

This time we are going to change things around and we

want to find out what is going to happen when we have the
value of y be 2 instead of the default of 0 that we had
before. In this one, we are going to get the output of (4 X 2)
= 8.

You are also able to go through and change up the order

that you are using when it is time to pass the argument over
in Python. Here, we are working with the order of the value
x and y to x = 4 and y = 2. Multiple arguments are also
something that is possible in this kind of coding, and we are
able to pass them as long as we work with an array. Here,
we can work with the multiple arguments of (1, 2, 3, 4, 5) by
calling out the (*args) function that we have. for example,
we went through and declared the multiple arguments as
number (1, 2, 3, 4, 5), when we call the (*args) function.
When this is called up, we are going to get an output that
says (1, 2, 3, 4, 5).
Some Tips to Get Started
Before we end this chapter, we need to look at a few of the
important things that you have to remember when working
with this kind of code. In some of the previous versions of
Python, including Python 2.7, the function overloading is not
going to be supported with Python. Function overloading is
when the code has the ability to create more than one
method that has the same name but gives them different
implementations. This process may not be possible in some
of the older versions of Python, but it is possible and
supported in Python 3.

In addition, there can sometimes be confusion between

functions and methods. These are similar, but there are
some important differences that we need to know. For
example, methods are going to be associated with instances
of objects like functions that are not. When Python has
called up a method, it is going to bind the first parameter of
that call to the right object reference. To keep this simple, a
standalone function in Python is going to be known as a
function while the function that goes with classes or
instances will be a method.

To summarize this chapter, we will find that a function is

going to be a piece of code that we can reuse and can help
us to perform a single related action. We took some time to
look at how to define these functions in your code, and how
to handle some of the different parts of the functions to
make things easier overall. Learning how to work with these
functions and how you can explore using them in your own
codes can be an important part of the whole process and
helping you to see some good results in the process as well.
Day 4: The Data Types

Right now Python is one of the most sought after languages

for programming today. Many developers want to make sure
that they are focusing on the implementation part rather
than spending time writing complex programs. This is a
place where we are going to see Python be able to deliver,
with the ease of access and readability that we are. The
fundamental concepts that come with this are going to be
the foundation of Python, as well as some of the
programming language and hence we are going to spend
some time on this day looking at the concepts of data types
and variables and how they work with Python. Let’s dive in
and see what we are able to do with these data types.
What are the Python Variables?
The first thing that we need to take a look at is the variables
in Python. Variables and data types in Python are going to
be the values that are able to vary. In a programming
language, a variable is going to be a location on the
memory of your computer where you store a value with it.
The value that you have been able to store with this
variable can change in the future based on what your
specifications are all about.

A variable in this language is going to be created once you

have assigned a value over to it. It does not need you to go
through and add in additional commands in order to declare
this variable. There are going to be certain kinds of
regulations and rules that we need to follow when we are
writing these variables. But to help us get started with this
is to look at how to define and declare the variable so that
we can really see how these work in our language.

To start, Python is not going to provide us with any

additional commands to use to declare these variables. As
soon as you have gone through and assigned a value to the
variable, it has been declared. There are a few rules though
that we should remember when we go through this process
of declaring a variable. These rules are going to include:

1. The variable name is not able to start out with a

number. It can only start out with either an underscore
or a character.
 2. Variables that show up in Python are going to be case
sensitive.

3. These names can only have characters that are

alphanumeric and underscores.

4. You are not allowed to work with any special characters

when you are doing these names.

With this in mind, we can remember that there are several

types of data that show up in Python. We need to spend
some time looking at these to figure out how to use them,
and how we are able to work with the variables to work with
this. Data types are basically going to be the classes, and
then the variables are going to be the instances of these
classes
The Different Types of Data in Python

There are actually a few different types of data that we are

able to work with when it comes to assigning these values
over to your variables. According to the kind of properties
that these are going to possess, we are able to see six types
of data that show up in this language. Although there is
going to be one more data type range that is also used
when it is time to make loops in Python, we are going to
focus mainly on these six. We will find that we have
numbers, strings, lists, tuples, sets dictionary, and range.
We can go into these in a little more depth to figure out
what is going on with them. We will start out with the
numerical types of data. These are the types of data that
are going to hold onto a numerical value. In this kind of
data, we are going to find four subtypes that we need to
focus on including complex numbers, float, integers, and
Boolean. Let’s explore what all of these are going to be all
about:

1. Integers: These are the types of data that we are able

to work with that can represent whole number values.
If you would like to check out the type of any of these,
we are able to work with the function of type(). This is
then going to return to us the type of the mentioned
variable data type that we need to focus on.

2. Float: This is going to be a type of data that is used in

order to represent decimal point values.

3. Complex: These are going to be the numbers that we

are able to use in order to represent imaginary values.
These values are going to be the ones that are denoted
with a “j” at the end of the number to help us know
that we are working with these or not.

4. Boolean: This is going to be the type that we can use

for some output that is categorical because it will show
us whether the output is true or false.
We can then move on to working with the type of data that
is known as strings. These strings are going to be helpful in
Python because they are going to help us to represent the
Unicode character values. Python is not going to have a
data type that is just a character, so you can find that even
one single character is going to be considered as a strong
here. We are going to denote or declare the string values
inside of either a double quote or a single quote based on
what we would like to accomplish. To help us access the
values that are in the string, we would just need to work
with square brackets and indexes.

Another thing that we need to remember with this one is

that these strings are going to be immutable. This means
that when you make one of the strings that you want to use
in your coding, you will not be able to change it at all. If you
would like to replace one, you would need to work with the
list to help make this happen.

Then we are able to work with the list. The list is going to be
one of the four collection data types that we have in Python.
When we are working with a collection type and picking out
which one we want to work with, it is important for us to
understand the limitations as well as the functionality of the
collection. Dictionaries, sets, and tuples are going to be
some of the other collection data types that come with
Python. A list is ordered and changeable, unlike the string.
We are then going to be able to add some duplicate values
to this as well. And we can do the declaration of these with
some square brackets as well.

The nice thing about these lists is that you are able to work
with this process and then make some changes to the items
that are on the list. Some of the different methods that we
need to know about when it comes to working with these
lists include:

1. Clear(): This is going to be the one that can help us to

remove all of the elements that are on the list.

2. Copy(): This is going to help return a copy of our list to

us.

3. Extend(): This is going to help add on some elements

to your list but will make sure that these are added to
the very end of our current list.

4. Count(): This is going to help return the number of

elements that meet with a specified value.

5. Index(): This is going to return the index of our element

.

6. Pop(): This is the one that we are going to use when we

would like to take an element that is in one specific
 space in the list and then remove it.

7. Remove(): This is going to be the one that is able to

remove the item that has a specified value.

8. Sort(): This one is going to help us to sort our list.

9. Reverse(): This is the one that is going to provide us

with a reversed list in the process.

The list that we are working with is going to be helpful

because it will store any type of data as an item. This is true
whether you are working with strings, numbers, or some
other kind of data in the process.

Once we have a good understanding of what these lists are

able to do, it is time to work with the tuples. The tuple is
going to be a collection that is not changeable, and also
immutable in the process it is going to be ordered, and we
are able to access the values when we are using the index
values. In addition, you will find that we are able to have
some duplicate values out there as well. To help us declare
these tuples, we need to use the round brackets.

Since we will find that the tuple is unchangeable once we

have had a chance to declare it, there are not going to be a
ton of operations or actions that we are able to perform on
these. But the good news is that there are some benefits
that come with using a tuple. This bright side is that you are
able to store the values in a tuple when you do not wish for
these values to be changed during the project. Although you
can still have the access that you need to these values, you
will not be able to go through and make any changes to
them at all.

Next on the list is going to be a set. This is going to be

another example of a collection that we are able to work
with, but this collection is not going to be ordered. It is also
not going to come with any indexes attached to it either. To
help us to declare one of these sets in Python, we are going
to work with the curly brackets.

A set is not going to come with any duplicate values even

though it is not going to show us the errors when we declare
the set. Instead, the output that you get is only going to
have distinct values instead to access some of the values
that come with a set, we have a few options. We can either
loop our way through this set. Or we can work with a
membership operator to help us find the value that we
need. With this in mind, some of the codings that we need
to work with to access the parts and the values of a class
will include:

for x in myset:
print(x)
#this will get all the values.
20 in myset
#this will return true if the value is in the set.
#to add value in a set
myset.add('edureka')
#to add multiple values in a list
myset.update([ 10, 20, 30, 40, 50])
#to remove an item from a set
myset.remove('edureka')
#we can use the discard or pop method to remove an item
from a set as well.
myset = {10, 20, 30}
myset1 = {10,30,50}
myset.issubset(myset1)
#this will return false
myset.union(myset1)
#this will return a set with the union of the two sets.

The methods that we talked about earlier will be the same

for what we see with the sets, but there are a few
differences that we are able to focus on as well. Some of the
other method names that we are able to explore in this part
about sets will include:

1. Clear(): This one is going to help you clear out some of

the items from a set.

2. Copy(): This one is going to help us to return a copy of

the set that we are working with.
 3. Difference(): This one is going to return to us a set with
the difference between the two sets that you want to
work with.

4. Isdisjoint(): This is going to help us see whether or not

the set we see have an intersection somewhere.

5. Issubset(): This one is going to return our set if it is

considered a subset of some sort.

6. Symmetricdifference(): This one is going to return to us

a set with the symmetric difference that is found.

7. Update(): This is going to be helpful because it helps

update the sets that we have with the union that we
get out of that set.

Now we need to move on to some of the information that we

will need to know about a dictionary. We will explore this in
a bit more detail later on, but we can still add it in here. A
dictionary is going to be similar to any of the other
collection arrays that we find in Python. But the big
difference that we are going to see that this one is going to
come with a key value pair that you need to use to get the
values to show up.
A dictionary is going to be unordered and you can change it
up. This is why we are going to work with the keys to access
the items out of the dictionary. And any time that you are
working on a code where you need to declare a dictionary,
we are going to declare one of these dictionaries, we are
going to need to use the curly braces as well.

Since we are working with the keys to help access the items
that are there, we have to remember that we can’t duplicate
them at all. If we do, then the compiler is going to get
confused about the key value pairs that you want to use,
and it just makes a mess. The values can have duplicate
items though. Some of the other operations that are needed
when we are working with this dictionary is going to include
some of the following:

1. Copy(): This is going to return to us a copy of the

dictionary.
 2. Clear(): This one is going to help us to clear off the
dictionary.

3. Items(): This one is going to help us return a list that

contains a tuple of key-value pairs that you would like
to work with.

4. Keys(): this one is going to help us out because it

returns a list that contains all of the keys.

5. Update(): This one is going to update the dictionary

with the help of all the pairs of key values that you
want to work with.

6. Values(): This one is going to return to us a list of all

the values that we are able to find inside of a
dictionary.

7. Setdefault(): This one is going to help us to return the

value of a specified key.

The range is important when we are on this topic as well.

The range is going to be a type of data that is going to be
used when it is time to handle a loop. These can really help
us to go through the code in the manner that we would like
and will ensure that we are going to get the loop to work the
way that we want. It is not used as often as some of the
others that we have, but when we come to working on
loops, it is more likely that we are going to see these
ranges.

Now that we have had some time to look at the variety of

data types that are found in Python, there is another topic
that is pretty important to our code, and this is going to be
known as typecasting. This is going to be a helpful process
when we would like to change from one type of data over to
another. This may sound confusing, but we need to take a
look at it a bit closer to figure out what is going on with this
to see how to work through some of our codings.

Typecasting is going to be the simple idea of changing one

type of data that we have into another type of data. We will
be able to work with some constructors for each of these in
Python and switching them over is easier to handle than it
may seem. We are able to do some of this typecasting with
the help of data types including lists, sets tuples,
dictionaries, strings, integers, and floating.

We are able to just use these kinds of constructors on a

specified type of data, or we are able to change a type of
data over to another with the help of these constructors.
Using these can really help us to use the various types of
data with the functionality of the other. Suppose that we
declare the list as a tuple in our program. What this does is
turn that list into something that is immutable for that part
of the code at least. We can always work with other kinds of
constructors as well.

There are a lot of different types of functions that we are

able to use based on what we are hoping to get out of the
program we are working with. This takes some time to
handle, and learning all of the different types is not always
as easy as it may seem. But when we are able to put it all
together, and we know how to work with the different data
types in this language, it can add in so much power to some
of the work that we are doing.
Day 5: Files in Python

Now it is time for us to take a look at how to handle some of

the files that show up in the Python language. There are
many times when we will want to open up a new file in
Python and start writing our codes, but we may also want to
go through and make changes on the file, delete a file, open
up an older file, and more. We are able to do so much with
these files, similar to what we would think of when opening
a Word document but instead we are going to need to type
in codes to make this happen in Python.
In this chapter, we are going to spend some time looking at
how to create some of these files in Python, and even how
to create a new file, work on writing some code into a file
that was already created, how to close up a file, and how to
move or seek one of our files so that it ends up in the
location that we want, such as when we saved it to the
wrong directory. Let’s get started on seeing how all of this
will work.
Creating a New Python File

The first thing that we are going to take a look at here when
we get started with files in Python is how to create a brand
new one to work for our needs. Any time that you would like
to make a few changes to the file that is already opened on
your computer though, we would work with the function of
write(w) to help get this done because it is the easiest and
can allow us time to start writing right away.

Any time that you would like to open up a new file though
and then write out a brand new string inside of there, we
will work with a binary file, which we will discuss a bit more
in a moment, and then work with the write() method again.
This is going to work out well for us because it will make it
easier to get all of the characters that you want to be
returned to you right away.
The write() function is really easy to use and allows you to
make as many changes to the file as you would like. You can
add some new information to the file or you can make some
changes to one that you opened up. If you are interested in
doing the writing in the code, you can use this example to
make things easier:

#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.

One thing that we need to be able to keep in mind when we

are working here is that whichever directory you find
yourself in when you get started, this is going to be the one
you will need to move back to when you want to search or
that file. If you want to put the file into a different directory,
that can happen, but you need to move over to that one
before you start saving. With the option that we have above,
you will need to go to the directory that was your current
one at the time, and then you can open up the code and get
it to execute in the proper manner.

When we reach this part of the process, we have been able

to write out a program. But maybe something isn’t working
right or you would like to make some changes and overwrite
what is there. Maybe you simply want to change up the
statement that is on a file that was created in the past. This
is possible to do, we just need to work with the syntax below
to make it happen:

#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.
The Binary Files
While we are on this topic, we need to spend some time
taking a look at what is known as binary files in this
language. This is a simple process to work with because to
accomplish it, we just have to take whatever data that we
have ahold of and then change it so that it saves as a sound
or image file rather than the text file. This is going to make
it easier to save and will ensure that the code is going to
execute the way that you would like.

Before you jump on this one, the number one thing that we
need to consider here is that we have to be able to supply
the data inside of our object. This will make it easier for us
to expose the byte that is there when we execute the code.
The syntax that we are able to use to make this happen will
include:

# 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()

This will help you to get the data changed over to a binary
file simply by turning it over to the image or sound file.
How to Open Up Your Files

Now that we know how to create and save one of our files, it
is time to move on and take a look at the steps that you
would need to take in order to open up one of your files.
Once you open up that file, you are then able to overwrite
what is on it, or just write things on it for the first time. the
good news with this one is that opening up the files that you
would like to use through Python is going to be relatively
easy to accomplish. Some of the codes that we are able to
use to make this happen to include the following:

# 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 from 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 Your File

You will find that when it comes to some of the Python codes
that you want to write, working with these files will be a
great option to choose from. We already took some time to
look at how to write out a new file, how to overwrite some of
the data that we were able to write into the file, and we
even looked at how to open up the files. Now we are going
to take a look at how to move your file from one directory to
a new directory.

Maybe you are working on a file and you then find out that
things are not matching up in the manner that you would
like, such as misspelling the name of your identifier the
wrong way, or you ended up placing it into the wrong
directory. When this happens, you would like to use the seek
option in order to help you find that file, move it where you
want or change the name of the file you are working with.

You will be able to go through on this and change up where

the file is located, ensuring that it is going to be in the right
spot, or even move it so that this becomes a lot easier for it
to find. You can then just tell the code where it should move
things, and work from there.

These files may seem like a simple thing to work within

Python, but you will find that they are going to be there to
help you out a lot when it is time to order and organize
things inside of your code.

It can help you to write out the code, make some changes to
what you wrote in the first place, and more. Try out some of
the different codes that we talked about above and you will
find that you can do anything you would like with some of
your Python codes.
Day 6: Data Structures

There is so much that we are able to do when it comes to

some of the options of coding in Python, and in this chapter,
we are going to explore some of the most important parts.
Data is a critical component when it comes to writing out
many of the Python codes that you want to handle, and we
are going to explore how to handle these, the codes that
you can use to make this happen, and so much more. Let’s
dive in and learn about the different structures of data, how
to create our own classes, and so much more today!
The Dictionary
There are many times when we are going to work with the
Python dictionary. The dictionary that comes in Python is
going to basically be an unordered collection of value of our
data, that is going to be used to store values of data like a
map. Unlike some of the other types of data that are able to
just hold onto one single value as their element, the
dictionary is going to be able to hold onto a key value pair.
This key value pair is going to be something that the
dictionary is able to provide to us to make sure that it is
optimized.

When we are looking at each key value pair in the

dictionary, we will notice that they are going to be
separated out with a colon. But then each of the keys is
going to be separated out with a comma. The dictionary in
Python is going to be pretty similar to how we see a
dictionary in the real world. Keys of the dictionary have to
be unique and their own, while being an immutable type of
data including tuples, integers, and strings. However, you
will find that the key values are repeatable and can be of
any type that you want.

One thing to note here is that the keys in your dictionary

can’t have any polymorphism in them. This is something
that we are going to explore in a little more detail as we
move through this guidebook, but it is still not something
that we are able to work with for these keys in the
dictionary.

We will also find that in the Python language, a dictionary

can be created when we place a sequence of elements
inside of curly braces, and it will be separated out by a
comma. The dictionary is going to hold onto a value pair for
us, with one of these being the key and the other
corresponding being the key value here. Values in the
dictionary can really be any type of data and you can
duplicate it, while the keys are things that we are not able
to repeat and we have to set them up to be immutable
along the way.

We are able to create a dictionary with the function that is

already built into this library called dict(). An empty
dictionary is something that we are able to create though,
we just need to make sure that we place it inside of the
curly braces. Another thing to remember here is that the
keys that come with these dictionaries are going to be
sensitive. This means that you will be able to use the same
name, but if you put it into a different case the key is going
to be treated in a different manner.

With this in mind, we need to take a look at some of the

code that we are able to do with this dictionary. A good way
to create our own dictionary in the Python language will be
below:
# Creating an empty Dictionary
Dict = {}
print("Empty Dictionary: ")
print(Dict)

# Creating a Dictionary
# with Integer Keys
Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print("\nDictionary with the use of Integer Keys: ")
print(Dict)

# Creating a Dictionary
# with Mixed keys
Dict = {'Name': 'Geeks', 1: [1, 2, 3, 4]}
print("\nDictionary with the use of Mixed Keys: ")
print(Dict)

# Creating a Dictionary
# with dict() method
Dict = dict({1: 'Geeks', 2: 'For', 3:'Geeks'})
print("\nDictionary with the use of dict(): ")
print(Dict)

# Creating a Dictionary
# with each item as a Pair
Dict = dict([(1, 'Geeks'), (2, 'For')])
print("\nDictionary with each item as a pair: ")
print(Dict)

We are also able to go through this process and add some

elements to our dictionary to make it work the way that we
would like. There are a few methods that we are able to use
for this one though. One value at a time can be added to the
dictionary by defining the value along with the key that we
want to work with. For example, if you would like to go
through and update one of the existing values inside of the
dictionary can be done by using the method of update() that
is already built into the Python library. The nested key
values can be added to the dictionary that is already out
there.

Note, while we are working on adding one of these values if

there is already a key value in existence that we want to
create, the value is just going to be updated. Otherwise, you
are going to end up creating and adding in a new key with
the corresponding value with it. The code that you would be
able to use to make this happen for your needs will include:

# Creating an empty Dictionary

Dict = {}
print("Empty Dictionary: ")
print(Dict)

# Creating a Dictionary
# with Integer Keys
Dict = {1: 'Geeks', 2: 'For', 3: 'Geeks'}
print("\nDictionary with the use of Integer Keys: ")
print(Dict)

# Creating a Dictionary
# with Mixed keys
Dict = {'Name': 'Geeks', 1: [1, 2, 3, 4]}
print("\nDictionary with the use of Mixed Keys: ")
print(Dict)

# Creating a Dictionary
# with dict() method
Dict = dict({1: 'Geeks', 2: 'For', 3:'Geeks'})
print("\nDictionary with the use of dict(): ")
print(Dict)

# Creating a Dictionary
# with each item as a Pair
Dict = dict([(1, 'Geeks'), (2, 'For')])
print("\nDictionary with each item as a pair: ")
print(Dict)

While there are other things that we are able to do when it

is time to work with the dictionaries in Python, we are going
to take a look at one more thing, which is the process of
removing some elements out of your dictionary. The Python
library allows us to delete some of the keys if we would like,
we just need to work with the keyword of “del”.
Using this keyword, along with some of the specific values
from the dictionary as well as the whole dictionary can be
deleted as well. There are also other options that are there
that will help us to get this done, such as the functions of
popitem() and pop() in order to help delete wither the
arbitrary or specific values that are found in our whole set.

You are also able to take this a bit further and delete all of
the items that are in your dictionary at once. You just need
to use the clear() function. Items that show up in a nested
dictionary can also be deleted using that del keyword that
we had before, as long as we make sure to provide the
specific nested key and a particular key to be deleted from
that nested dictionary.

One thing that we need to remember with this one is that if

we type in the command of “del Dict” we are going to end
up the entire dictionary. If you do this and then try to print
off the dictionary, you are going to end up with an error
message, so be careful when we are working with this one.
Some of the codes that we need to work with here in order
to remove the items from the dictionary that we no longer
want, or even to delete the whole dictionary, will include
some of the following:

# Initial Dictionary
Dict = { 5 : 'Welcome', 6 : 'To', 7 : 'Geeks',
 'A' : {1 : 'Geeks', 2 : 'For', 3 : 'Geeks'},
'B' : {1 : 'Geeks', 2 : 'Life'}}
print("Initial Dictionary: ")
print(Dict)

# Deleting a Key value

del Dict[6]
print("\nDeleting a specific key: ")
print(Dict)

# Deleting a Key from

# Nested Dictionary
del Dict['A'][2]
print("\nDeleting a key from Nested Dictionary: ")
print(Dict)

# Deleting a Key
# using pop()
Dict.pop(5)
print("\nPopping specific element: ")
print(Dict)

# Deleting an arbitrary Key-value pair

# using popitem()
Dict.popitem()
print("\nPops an arbitrary key-value pair: ")
print(Dict)
# Deleting entire Dictionary
Dict.clear()
print("\nDeleting Entire Dictionary: ")
print(Dict)

Lists
We can also take some time to look at what the Python lists
are all about. There are going to be four types of collection
data in the Python language. We already talked about one of
them with dictionaries. But let’s spend some time looking at
all four of them below:

1. List: This is going to be a collection that will be ordered

and changeable. This will ensure that you are able to
move the information in the list any time that you
would like. And it is going to allow for some duplicate
members as well.

2. Tuple: This is another option that is going to seem

similar to the list, but there are some differences. For
example, while the tuple is also ordered, it is not
something that we can change. This one will allow for
some duplicate numbers though as well.

3. Set: This is going to be a collection like the other

options, but the collection is not going to be ordered,
and it is not going to be indexed. You are also not able
to add in duplicate members as well.
 4. Dictionary: this is going to be a collection that is not
ordered, it is changeable, and it can be indexed. You
are not able to add in duplicate members to this one
either.

When you are choosing which type of collection you would

like to work with, it is going to be important that we are able
to spend some time understanding the properties of that
type. Making sure that you choose the right type of data for
your goals could mean retention of meaning, and it could
help to increase efficiency and security.

So to keep it simple, you will find that the list is going to be

a collection that is ordered and can be changed. Some of
the other options are going to look very similar, but they are
not going to let you change up the items that are there, and
some of them are not going to be ordered. You will be able
to write out the lists in Python with the help of the square
brackets.
How to Create a Class

One thing that you will quickly find is really important when
it comes to working on your Python code is that the classes
are going to have a big place. In fact, this is one of the
things that is going to make your codes so strong and easy
to use in Python. These classes are meant to help you get
the most out of what you are doing in this process, and will
ensure that you are able to really organize things and get
them to show up at the right times for you.

Classes and objects will prove themselves to be really

important when you are writing out codes in Python because
they will ensure that all of the parts that you write in your
codes are going to stay in the right spot, and they won’t be
able to move at all while the code is going through
execution. The objects are important because they are there
to help define some of the parts of the code so that it is
easier to understand. But the classes are there to help store
some of the objects and keep things in place.

Now that we have some of that out of the way, we need to

take a few minutes to look at some of the steps that we can
take in order to create one of our own classes. To make one
of these classes though, we have to start out with the right
keywords ahead of naming the class. You can name one of
these classes anything that you would like, but we have to
make sure that we are working with the right keywords to
tell the compiler what to do, and we need to pick out a
name that is easy for us to remember at a later time.

After naming the class, it is time to name a subclass, which

will be placed inside parenthesis to stick with proper
programming rules. Make sure that at the end of that first
line, whenever you create a class, that you add in a
semicolon. While this isn’t technically needed with most
newer versions of Python and the code is going to work
even if you forget this part, it is still considered part of
coding etiquette to do this so make sure that you put it in.

Writing a class sounds more complicated than it really is, so

let’s stop here and look at an example of how you would
write this out in Python. Then we can discuss what the parts
mean and why they are important. A good example of
creating a class with Python includes the following:

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()

Keeping track of all of this is hard, and figuring out whether

it actually works or not is going to be a challenge as well.
This means that we need to get some practice with our code
writing skills and open our text editors so we can type in the
code above. As you work on typing this option out, you may
notice that there are already a few of the basics, and a few
of the other topics, that we talked about earlier in this
guidebook showing up in this code, which can really help to
boost some of our confidence while coding.

There is so much that we are able to discuss when it comes

to these classes and objects, but we are going to keep it to
the basics for now. This means that it is time for us to move
on to how we can access the members of our class when it
is time. During this step, we want to make sure that we
have a text editor and a compiler that are able to recognize
all of the classes that we are trying to create. This is going
to help them to execute the code in the proper manner.

To make all of this happen, we, of course, have to ensure

that the code is set up in the proper manner. The good news
here is that there are a few methods that we are able to use
to make all of this work, and all of them are going to be able
to provide us with some good results. However, our choice
here is to work with the accessor method because it is
simple to use, it is the one that most coders are going to
rely on, and it has a lot of efficiency behind it as well.

To understand the process of accessing members of your

created class better, first 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())

Before we move on, type this into your compiler. If you have
your compiler run this, you are going to get some results
that show up on the screen right away. This will include that
the cat’s name is Frisky (or you can change the name to
something else if you want), that the age is 5 and that the
weight is 10. This is the information that was put into the
code, so the compiler is going to pull them up to give you
the results that you want. You can take some time to add
different options into the code and see how it changes over
time.
Working with these classes can be a great way to see some
of the different things that the Python language is able to do
overall, and it is likely that with any code you would like to
write, you will need to create a few of these to get the best
results. With that said, we need to see that these classes
are not really all that difficult to work with and they can be
just the thing that you need to organize your code and keep
everything in place. Take some time to explore the codes
that we have above to ensure that you are able to create
some of your own Python classes in no time.
The Class Objects
Now that we have explored a bit about the classes above,
we also need to take some time to look at the objects of
these classes. A good way to think about this is that the
class is going to be like a container that is able to hold onto
the objects. The objects will be real-life items that we add to
the code, and they need to be stored somewhere so that the
code is able to find them at the right time. This is where
they will fit into the classes that you plan to create.

With this in mind, there are a few rules that we need to use
to make sure that the objects work with the classes that we
create along the way. You are able to place as many objects
as you would like into a class, and you can have any type of
class that you would like. But when you or another person
takes a look into one of the classes that you created and
you look at some of the objects, it needs to make sense why
those objects are together in the same class.
This doesn’t mean that the objects have to be identical to
one another. It simply means that we can’t just throw
random objects into the same class and hope it works out
for us. You could have a class that is about vehicles or fruits
for example, but putting things like a horse, the color blue,
peas, and pepper into the same class would not make sense
and should not be done.
Inheritances
Another cool option that we are able to work with when it
comes to the Python language is the idea of inheritances.
This is something that is pretty unique when it comes to
OOP languages like Python and when you learn how to use
them properly, you will find that it is a great way to save
time by reusing parts of your code, and can make the codes
look nicer and cleaner in the long run. These are going to
help us to reuse parts of code that we have used in the past
on our program, without having to go through the process of
rewriting all of that same code again and again.

Basically, when we are working with one of these

inheritances, we are going to take what is considered the
parental or base code, and then change up some of the
parts, either taking some away or adding to it, before we
reuse as the derived code. You can do this in order to save
yourself some time or to make the code you are writing
even stronger than before. Even as someone who is a
beginner in all of this, you will be able to work with these
inheritances, bringing the same parts back many times,
without having to do so much rewriting of the code in the
process.

During this process of the inheritances, you will take the

original parent code and then work to copy it over to some
other part of the program. This new part is going to be
known as the child code because you are able to make any
changes to it without any effect happening to the original
part of the code in your program. And you can definitely go
through and create multiple inheritances in the code that
you are writing, following the same steps more than once if
you would like.

To help make more sense out of these inheritances, how

they work, and how they can help to keep your code clean
and tidy and save you time, let’s take a look at an example
of how they look in your 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:’, ‘Mainu’)
(‘Student Rollno:’, 1)
(‘Student Group:’, ‘MSC-Mathematics’)
(‘Student Name:’, ‘Shainu’)
(‘Student Rollno:’, 2)
(‘Student Group:’, ‘MSC-CS’)

As we can see here, writing out some of these inheritances

does require a bit of code in order to get it done, but that
doesn’t mean that things have to be impossible to work
with, and you are actually able to get quite a bit done in this
process. Taking the time to write this into your compiler and
then testing it out can show us just how much we are able
to get done in a short amount of coding with this, and can
really help us to see how powerful these inheritances can be
for our needs.
Encapsulation
Encapsulation is going to be one of the fundamental
concepts that come with Object-Oriented programming.
When there is going to be a requirement in part of the
coding to group the data in one place, while hiding some of
the complex details that we see from the user, we are going
to work with the process of encapsulation to get it all done.

Encapsulation can help us out here because it will make

sure that we are restricting the access methods and
variables in the right manner along the way. Depending on
the kind of code that we are trying to write, this can help us
out because it prevents any accidental modification of the
data. And it is achieved when we work with the non-public
variable and variable methods.

There are going to be a few advantages that we are able to

enjoy when it comes to using this process in Python. First,
encapsulation is going to help us establish a better flow of
data, and it can help us to protect the data that we have in
the code already from some outside forces. The concept and
the use of this encapsulation are going to ensure that the
code is self-sufficient on its own as well.

Another benefit is that when we use it, the process will

provide us a great deal of help at the implementation level
as it is going to primarily focus on the questions of “how” in
our code while leaving some of the complexities of the when
and where questions behind. Hiding the data into a unit can
help to make the encapsulation process easier while also
securing some of the data that we have.

This brings us to the point of why we would need this

encapsulation in the first place in the Python code. Below
we are going to take a look at some of the reasons why
developers are going to find encapsulation to be a good
thing and why they would decide to use it in some of their
own programs:
1. There is already a need for interaction that is well-
defined in every application and the process of
encapsulation is going to make sure that we are able to
get this done.

2. The concept of OOP languages in Python has a focus

on making codes that can be reusable, and the
encapsulation can help.

3. The application maintenance is going to be easier and

here is security ensured.

4. Clarity on the procedures of coding as developers are

going to be concerned at the objective of the class, and
we can take care of complex issues in a more
systematic manner.

5. When you have the right organization of your codes, it

is going to help with some of the flexibility of the code
and can make some of the Unit Testing easier.

6. Users are going to find that it is easier to use the

system in this kind of process because it will help them
to stay hidden away from the complex design that is
involved at the back end of this.

7. Having all of your data that are similar in one place,

and having it encapsulated, is going to increase the
 cohesion inside of the module.

8. This can help to improve how readable the codes are,

and can ensure that changes that happen in one part
of the code will not end up causing harm to the other
parts.

9. Encapsulation is great because it is going to prevent

the part of the code that you want to protect from
being accessed on accident.
Polymorphism
And finally, while we are on this topic, we need to spend a
few minutes looking at the idea of polymorphism. In an OOP
language, this is going to be the characteristic of being able
to assign a different usage or meaning to something based
on the context that it is using. In specific, we will find that
this allows an entity, such as an object, function, or variable
to have more than one form at a time. In Python there are
going to be a few types of polymorphism that we are able to
work with including:

A variable that has a given name can sometimes have

different forms and the program can then determine which
variable form it would like to use when it is time to execute
the code.

For example, you could name a variable as USERID, and it

could be capable of being a whole number or a string of
characters based on what kind of user ID that input is. By
giving the program the way to distinguish which form it is
handling in each case, this will not be a big issue for the
program to handle.

In addition, a named function can also vary based on the

kinds of parameters that you decide to give to it. For
example, if given a variable that is an integer, the function
chosen would then be able to seek a match against lit of
numbers fr the employees. But if the variable was a string,
then it is going to seek out a match with a list of names
instead. In either of these cases, both of the functions will
have the same name for the program to work with.
Sometimes we are going to call this process overloading
instead.

Another version of polymorphism is going to mean

something else when we are working with machine learning.
It could be a type of data of “any” such that when specified
for a list, a list containing any type of data can be processed
by the function that you are working with. In this one, if you
have a function that can simply determine how long the list
is, it won’t really matter what types of data show up in that
list at all.

And finally, we can look at a polymorphism in PHP. With this

one, we will see that B is going to be a descendant of A, and
then a function is able to accept A as the parameter that it
needs to follow. But this function is also able to accept B for
this job as well.
Day 7: Getting Started; Python
Tips and Tricks

We have spent the last few days of this guidebook looking

at some of the different parts of the Python language that
we are able to work with. These are meant to help us get
going with some of our own coding in Python and will ensure
that we are able to write some of your codes in no time.
With some of this information in mind, we are able to work
on some of the final skills that we need to focus on before
we are done. We are going to look at some of the tips and
tricks that will help you to get started with Python, along
with how we can work with web scraping and debugging
some of our programs as well. Let’s get started with this one
in order to help us get started and finalize how good our
codes can be.
Web Scraping
Imagine for a moment that we are going to pull up a large
amount of data from many websites, and we want to be
able to do this at a very fast rate. How would we be able to
go through this without having to manually go through each
of the websites that we have and gathering the data in this
manner? This is where the process of web scraping is going
to come into play.

Web scraping is going to be used by companies in order to

collect a large amount of information form websites. But
why does someone want to go through and collect all of this
data, in such large amounts, from these websites in the first
place? There are a lot of reasons for this, and some of them
are going to include the following:

1. Price comparison: Some of the different services that

are out there, such as ParseHub, will work with this
process in order to collect data from websites for online
shopping and then can use this in order to compare
prices of similar products.

2. Email address gathering: We can use the process of

web scraping in order to help with marketing. This can
help us to collect the email IDs that come with
 customers and then send out bulk emails to these
individuals as well.

3. Social media scraping: Web scraping is going to be

used to collect data from social media sites and then
figure out what is trending.

4. Research and development: Web scraping is going to

be used to help a company collect a lot of data from
websites. We can then analyze this and use it to finish
our surveys and to help out with research and
development.

5. Job listing: Details regarding openings of jobs,

interviews, and more can be collected from a variety of
websites and then we can list them in one place in
order to make them easier for the user to access

Web scraping is going to be more of an automated method

that we can use in order to get a huge amount of data from
any website that we choose. The data that we are able to
get out of these websites will be unstructured. And this web
scraping helps a company to collect all of this data and then
will ensure that they are able to store it in a structured for.
There are a variety of methods that we are able to use in
order to scrape these websites that we want, including
online Services, writing out some of your own codes, and
APIs.
Talking about whether or not scraping of this kind if seen as
legal or not, it can depend on what the website says. Some
websites are fine with this and some are not. You can check
with each website to figure out whether they are fine with it,
and if they are, you are able to continue on with your web
scraping tools and gather up the information that you need.

Since we are talking about Python here, we are going to

take some time to see how we are able to use Python to
help out with web scraping. But this brings up the reasons
why we would want to work with Python to help out with this
process rather than working with some of the other coding
languages that are out there. some of the features that
come with Python and can make it more suitable for web
scraping will include:

1. It is easy to use: The code that you are able to use

along with Python is going to be simple. This ensures
that any of the codes that you want to use for web
scraping will not be as messy to work with and can be
easy to use.

2. A large library collection: There are a lot of libraries

that work with data science and web scraping that are
also compatible with what the Python language is able
to do. These include options like Pandas, Matplotlib,
and NumPy. This is why you will find that the Python
 language is going to be suitable for web scraping and
even for some of the other manipulations that you
want to do with the extracted data.

3. Dynamically typed: This is something in Python where

you will not need to go through and define all of the
types of data that you are using with our variables.
Instead, you are able to just use these variables
wherever you would like. This is going to save a lot of
time when it comes to working on the codes and can
make your job faster than ever.

4. The syntax of Python is going to be easy to understand

the syntax that we are able to see with Python is easy
to understand, mainly because the statements that
come with this are going to be written in English. It is
going to be expressive and easy to read, and the
indentations will make it easier for us to figure out
between the different parts of the code.

5. A small code is able to handle some large tasks. Web

scraping is a process that we are going to use in order
to save some time. And with Python, you are able to
write out a small amount of code in order to get some
of the big tasks that you would like to accomplish done.
This is going to save you time not only when it comes
to figuring out the important data that comes in that
 website, but can also help you to save time when you
would like to write out the codes.

6. Community: At times, when you are a beginner, you

are going to find that there are parts of the code that
are hard to work with and are not going to go as
smoothly as you had hoped in the process. This is
where you will find the Python language to be healthy.
If you get stuck while writing out some of your code,
you will like that the Python community is going to help
you to answer your questions and get things done on
the code in no time.

Now that we know some of the benefits that come with

Python, especially the ones that are going to help us to
handle some of the web scrapings that we want to do, it is
time for us to take things to the next step and look at how
the process of web scraping is going to work. When you run
out the code that you want to work within web scraping, you
will find that there is a request that is sent out to the URL
that you mentioned. Then there is going to be a response
sent back from that request, and then the server is able to
send the data and allows you a chance to read the page,
whether it is XML or HTML at the time.

The code is then able to go through and parse the XML or

HTML page, find the data, and takes it out. The location
where you are going to find this data when it is extracted
will depend on what you told the code to do. Often it is
going to be moved over to a database so that you are able
to search through it later and learn more from it as well.

To help us go through the process of extracting the data

with the help of web scraping in Python, there are going to
be a few simple steps that you are able to take to make this
happen. The steps that will help you to use Python to help
with web scraping ill include:

1. Find the URL that you would like to scrape in the first
place.

2. Inspect the page that you are planning on using.

 3. Find the data that is on the page that you would like to
extract.

4. Write out the code that you would like to use with the
help of Python in order to complete this process.

5. Run the code that you just wrote and then extract out
the data that you would like to use.

6. Store the data in the format that would be the most

helpful for you in the process.

There are also a few options that you are able to use when it
is time to work on the process of web scraping. As we know,
Python is already able to be used for a lot of different types
of applications, and there are going to be a ton of libraries
with Python that is going to be used for different purposes.
There are a few libraries that work the best when it comes
to working with the process of data web scraping will
include:

1. Selenium: This is going to be a web testing library. It is

going to be used to help automate some of the
activities that are found on your browser.

2. BeautifulSoup: This is going to be one of those

packages that you are able to use with Python to help
us to parse HTML and XML documents. It is also able to
 create parse trees that can help us to extract the data
in an easy manner.

3. Pandas: This is one of the best libraries to rely on when

it is time to handle any kind of work that you would like
in data analysis and data science. Pandas are often
going to be used to help out with any of the data
analysis and the data manipulation that you would like.
When it comes to web scraping, you will find that
Pandas is going to be used in order to extract the data
and then get it stored in the right format in the way
that you would like along the way.

There are many times when a company is going to try and

gather up data from other websites and from many other
sources. This is one of the first steps that is going to be
found when we are working with data analysis and using
that information to improve a business through their
customers, the industry, or from the other competition out
there.

But going through and gathering all of that data in a manual

manner is going to take too long, and can be really hard to
work with as well. And with the large amounts of data that
are being used and generated on a daily basis, it is no
wonder that so many companies are working with processes
like web scraping to handle all of the work in a timely
manner as well.
When we work with web scraping and do some of the
codings that are necessary with the help of Python, we will
find that we are able to get through the information in a fast
manner and get it stored in the right place for our needs,
without having to do all of the work manually. This can make
the process of data analysis much easier overall and will
ensure that we are able to see some of the results that we
want with this as well. And with some of the right Python
algorithms and codes, we can get data scraping done in no
time.
Debugging

The next thing that we need to work on here when it comes

to the Python program is how to debug some of the
programs that you are working on. This is something that
you may spend quite a bit of your time working with, simply
because you are a beginner and learning how to handle all
of this work. As you get more practice with the Python code
and you learn how to work with it a bit more, you will find
that you may not need to debug much anymore.

No matter how much experience you have with any coding

language though, we need to spend some time looking at
some of the basics that are there with debugging our code.
This ensures that we learn about the coding a little bit more
and that we are able to change things up and get them
fixed when something doesn’t seem to be going the way
that we would like.

When we are talking about the process of software

development, we will find that debugging is going to be the
process of looking for, and then resolving, any issues that
are going to prevent the software from running in the proper
manner. We all hope that the codes that we are going to
write will work the way that we want, but this is not always
something that happens. Being prepared, and knowing how
to fix these problems, will be a big bonus when we work on
the debugging process.

The Python debugger is a great option to go with because it

is going to provide us with a good environment for
debugging that works for all of our Python programs. It is
going to be there to support some of our conditional
breakpoints hat we want to set, stepping through the source
code one line at a time, stack inspection, and so much
more.

The first thing that we need to take a look at here though is

how to work interactively with the Python debugger to learn
how to work with it. This kind of debugger is going to come
as part of the Python distribution that is standard, and the
module that we are talking about here is going to be the
pdb. The debugger is also going to be extensible, and we
are able to define it as the class of pdb. You are able to go
and read through some of the official documentation of this
if that helps out as well.

We are going to begin this with a short program that will

come in with two global variables, a function that is going to
create for us a nested loop, and then the if __name__ ==
‘__main__’: construction that is something we will need to
call up to give us the function for the nested_loop(). An
example of how to work with all of this and the code that we
are able to use here will include the following:

num_list = [500, 600, 700]

alpha_list = [‘x’, ‘y’, ‘z’]

def nested_loop():
for number in num_list:
print(number)
for letter in alpha_list:
print(letter)

if __name__ == ‘__main__’:
nested_loop()

we are then able to go through and run the program

through the debugger that we are working with using the
following command:
$ python -m pdb looping.py.

The -m command flag is going to help us out here because it

is responsible for importing any of the modules of Python for
us that we need and then running it as a script. In this case,
for what we want to get done using the debugger, we are
going to import and then run the module of pdb, which is
what we are then able to pass into the command as we
showed a bit earlier.

Take a moment to type in the code that we wrote above to

see what the output is going to be. When we look at the
output, the first line that we see is going to tell us the
current name of the module with the directory path. And
then we are going to find that the printed line number is
going to follow this. In this situation, we are going to have
the number 1, but if we find that there is a common, or
some other kind of line that is not executable, then this
could end up being a higher number.

Then we are able to move onto the second line. this one is
going to show us the current line of a source code that is
going to be executed here, as a pdb, and will provide us
with an interactive console that is going to help us to do the
debugging that we want. You are able to work with the help
command to help us to learn the commands that are here,
and then the help command to help us out with the specific
command that we want. Note that the console for pdb is
different than what we will find with the interactive shell in
Python.

In addition, we are going to find that the Python debugger is

automatically going to start over when it reaches the end of
the program that you are writing. Whenever you want to be
able to leave this console though you are able to type in the
command of exit or quit. If you would like the choice to
explicitly restart a program at any place within the program,
rather than always restarting from the beginning, then you
are able to do this with the command of the run.

One more thing that we need to figure out when it comes to

working on the debugger in Python is how to use this in
order to move through a program. When we are working
with some of the programs of the debugger, we are going to
work with a variety of commands like next, list, and step to
help us get through the code in the manner that we will like.

Within the Python shell that we are working with, we are

able to type in the command of the list to help us get some
of the contexts that is around the line we are currently in.
from the first line of the program, that we did above, we are
going to see that it is going to look like the following:

num_list = [500, 600, 700]

alpha_list = [‘x’, ‘y’, ‘z’]
def nested_loop():
for number in num_list:
print(number)
for letter in alpha_list:
print(letter)

if __name__ == ‘__main__’:
nested_loop()

The current line is going to be seen with the ->, which in our
case is going to be the first line of the file that we are
working with, but it can definitely be found in some of the
other parts as well.

Since we are working with a program that is pretty short

here, we are going to basically receive most of the program
back when we do the list command. This is not going to be
true when we work with some of the longer ones, but it
works for some of the codes that we are trying to work with
right now. Without going through and providing the exact
argument that you want to work with, the list command is
going to provide us with 11 lines around the current line.

It is also possible for us to go through and specify which

lines we would like to be able to include in the process.
Some of the codes that we are able to do in order to make
this work for our needs, and to not get the whole code to
show up at once will include the following:

(Pdb) list 3, 7
3
4
5 def nested_loop():
6 for number in num_list:
7 print(number)
(Pdb)

Now we need to take a quick look at the step and the next
function. The step is going to stop within a called function.
But then the next one is going to execute all of the called
functions, and it is only going to stop at the next line of the
current function. We are going to see the difference of this
when we work with the functions, even though it may seem
like it is not telling us much right now.

The step command that we are talking about is going to

iterate through a few loops once it is able to get to the
running of the function, and it will be able to show us
exactly what loop it is doing, as it will first print a number
with print(number). Then it is able to go through and print
out the letters that you have with the function of
print(letter) to return the number and more.
There is some coding that we are able to use to make this
happen. Some of the coding that we are going to use to help
make sure that we are able to see the best results with
some of the coding, and to show us how the step command
is going to work for us will include:

(Pdb) step
> /Users/sammy/looping.py(5)<module>()
-> def nested_loop():
(Pdb) step
> /Users/sammy/looping.py(11)<module>()
-> if __name__ == ‘__main__’:
(Pdb) step
> /Users/sammy/looping.py(12)<module>()
-> nested_loop()
(Pdb) step
--Call--
> /Users/sammy/looping.py(5)nested_loop()
-> def nested_loop():
(Pdb) step
> /Users/sammy/looping.py(6)nested_loop()
-> for number in num_list:
(Pdb) step
> /Users/sammy/looping.py(7)nested_loop()
-> print(number)
(Pdb) step
500
> /Users/sammy/looping.py(8)nested_loop()
-> for letter in alpha_list:
(Pdb) step
> /Users/sammy/looping.py(9)nested_loop()
-> print(letter)
(Pdb) step
x
> /Users/sammy/looping.py(8)nested_loop()
-> for letter in alpha_list:
(Pdb) step
> /Users/sammy/looping.py(9)nested_loop()
-> print(letter)
(Pdb) step
y
> /Users/sammy/looping.py(8)nested_loop()
-> for letter in alpha_list:
(Pdb)

On the other hand, the next command is able to go through

and execute the entire function, without having to show us
each of the steps that we are able to do in the process. In
order to help us to get this finished up and to quit the
current session that we are in, we are able to use the exit
command to help finish off.

There are so many things that we are able to do with the

debugger that we are using, and making sure that we are
using it in the proper manner, and understand all of the
things that it is able to do to help us out, can ensure that we
are able to handle some of the work that we are going to
see in our codes.

As a beginner, it is likely that we are going to need to work

with some of the debugger tools that are there on a regular
basis. This will ensure that we are going to see some of the
best results with the code and that it is going to help us to
really see some codes that will work as strongly as we would
like, rather than ones that aren’t going to work at all. It may
seem like it takes a lot of our time and is kind of a hassle,
but it can save us a lot of issues later on because we know
that the programs are going to work for us.

Now, sometimes the debugger that you are working with is

not going to provide you with some of the results that you
are looking for, or it will not solve the problem.

And maybe you have gone through and tried out a few other
options and they are not working out for you either. This can
be frustrating when you are a beginner, but sometimes the
best thing that we are able to do for this is to ask someone
who has some more experience with coding to help us out.
If you have gone through all of these steps trying to
troubleshoot your program and you still can’t seem to find
the error or you worry that you are just making things
worse, then it is fine to ask someone else for help. But
before you ask someone to help you go through the code
and figure out what is wrong, you need to make sure that
you have all of the following parts in place to help them
understand what is going on, what you have tried, and what
they can do to help you out.

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.

Another thing that we need to spend some time on is

remembering that you should go through and run your code
after each small bit or block of code that you are working
with, rather than handling a huge amount at once. Do not
start out with a blank file, sit down, and spend an hour
coding before you even try out the code for the first time.
You will just make the work harder for yourself and when
there are a whole bunch of little errors that pop up, you
won’t know where to start. It can take forever to go through
it all and fix whatever is going wrong.

Instead, every few minutes, you should run the updates and
test the code to see if something comes up. That way, when
a bug does show up in the code, you only have a few lines
or so of the code to check for the issue rather than a whole
bunch of code. It really isn’t possible for you to test out your
code too often so do it as much as you can.

Always remember that the more code that you write before
you test it again, the more places where errors can occur
and the more code that you will need to go search through
again. And each time that you do go through and run the
code, you will get some more feedback on your work so you
can learn as you go.

Along the same lines, you may find that printing out a lot of
the things that you work with can help you to really see
what is going on as well.
As you look through your code, you should be able to look at
each line and have a sense of what values are associated
with each variable. If you are unsure, then stop and print
them out. Then, when it is time to run that program, you
can look at the console and see how the values are going to
change or how they get changed to null values in a way that
you wouldn’t expect.

You may find at times that it is helpful to print a fixed string

right before you print out a variable. This ensures that all of
your print statements won't run together, and then you can
tell what is being printed from where. There may even be
some times when you aren’t sure whether or not the code is
being run in the first place. A simple print “got here” can
often be enough to help you see whether you have a
mistake in your loops or in your if statements.

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 a beginner, you may be worried that you won’t be able to

do any debugging or troubleshooting with your own code.
But this just isn’t true. You have the ability to look through
the error messages that the compiler sends to you, you can
look up solutions, and you can make sure to test out the
code every few minutes or so to ensure that you are getting
the results that you want for your code without any of the
errors. And if nothing seems to be working for you, it may
be best to work with someone who has a bit more
experience to help you find the solutions that you need.
Conclusion
Thank you for making it through to the end of 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 set up one week where you would like to
start learning Python and go through each day of this
guidebook to help you get that done. Many people are
worried about starting out with a new coding language
because it may seem complicated and like something that
they would never be able to catch up on. But with the help
of this guidebook, you will be able to master some of the
basics, and even some of the more advanced, parts that
come with the Python language.

In this guidebook, we have set it up so that you can go from

a beginner to a pro in no time with the Python language.
Each day of the week is divided up to help you to really
learn some of the parts that you need to know, to ensure
that you are going to be able to learn about the Python
language and even write out some of your own codes along
the way.
We spend some time learning how to install the language on
your own computer system, how to work with the basics of
the code that will show up later the importance of the
different types of data and how each of them is going to
work in your own code, and even some of the work with
classes, inheritances, files, and more. We will also end with
some information on how you can go through and debug
one of your own programs in no time, ensuring that you will
get things done, and will not end up with a code that can’t
be used.

When you are ready to learn how to master some of the

basics of Python so you can do some of your own programs,
you don’t want to spend months, and even years getting it
all down. This is where you will find this guidebook to be
healthy. When you are ready to get started on the Python
language and you are ready to see how working with this
language is simple and easy enough to learn how to use and
write out in just one week, make sure to check out this
guidebook today!

Finally, if you found this book useful in any way, a review on

Amazon is always appreciated!
Other Books You May Also
Like...

Python Programming: The Ultimate Advanced

Guide to Python Coding Language, Machine Learning,
and Data Analysis, Become an Expert with Hands-On
Projects and Step-by-Step Exercises

Click Here to See More Details About this Book

Python Programming: The Ultimate Beginner's
Guide to Python Language Fundamentals, a Crash
Course with Step-by-Step Exercises, Tips, and Tricks
to Learn Programming in a Short Time

Click Here to See More Details About this Book

Python for Data Science: The Ultimate Beginner's

Guide to Learn Data Science, Analysis, and Machine
Learning from Scratch with Step-by-Step Exercises
Click Here to See More Details About this Book