Mastering Python: A Beginner's Guide

Welcome to the Complete Python Master Recourse.

In this course, you're going to learn everything about Python from basics to more advanced

concepts.

So by the end of the course, you'll be able to confidently use Python for AI, machine learning,

web development and automation.

If you have been looking for a comprehensive, easy to follow, well-organized and practical

course that takes you from zero to hero, this is the right Python course for you.

You don't need any prior knowledge of Python to get started.

I will explain everything step-by-step in simple terms so you can build a solid foundation.

I'm Marsh Hamadani, a software engineer with over 20 years of experience, and I've taught

millions how to code and become professional software engineers through my YouTube channel

and online school called bitmash.com.

If you're new here, make sure to subscribe as I upload new videos all the time.

Now, let's jump in here, you'll start it.

In this course, you're going to learn everything you need to get started with Python.

Just be aware that I've designed this course for beginners.

So if you have some programming experience, check out my other Python course for developers.

You can see the link on the top-right corner of this video.

So, Python is the world fastest growing at most popular programming language,

not just amongst software developers, but also amongst mathematicians, data analysts, scientists,

accountants, network engineers, and even kids.

In fact, it's the ideal programming language to learn first.

But what makes Python so special?

Here are six reasons.

With Python, you can solve complex problems in less time with fewer lines of code than many other languages.

That's why huge companies like Google, Spotify, Dropbox, and Facebook

have embraced this beautiful and powerful language.

Here is an example.

Let's say we want to extract the first three characters of the text hello worth.

This is the code we would have to write in C-sharp.

This is how we would do this in JavaScript, and here's how we would do it in Python.

See how clean and simple the language is?

And that's just the beginning.

Python is a multipurpose language, and you can use it for a wide range of jobs,

such as data analysis, AI and machine learning,

writing automation scripts, building web, mobile, and desktop applications,

as well as software testing or even hacking.

So if you want a high paying, long-lasting career in any of these areas,

especially AI and machine learning, Python is the language to put those opportunities at your fingertips.

In fact, according to Indeed.com, the average salary of a Python developer in the US

was over $15,000 in March 2018.

And here are four more reasons that make Python the most desirable language.

Python is a high-level language, so you don't have to worry about complex tasks,

such as memory management as you do in C++.

It's cross-platform, which means you can build and run Python apps on Windows,

Mac, and Linux.

It has a huge community, so whenever you get stuck, there is someone out there to help.

And it has a large ecosystem of libraries, frameworks, and tools.

Whatever you want to do, it is likely that someone else has done it before,

because Python has been around for over 20 years.

There are two versions of Python out there, Python 2, which is the legacy version of Python,

and it's going to be supported until year 2020.

And Python 3, which is Python for the future.

In this course, you're going to learn Python 3.

Hi, my name is Mosh Hamadani, and I'm going to be your instructor in this course.

I'm a software engineer with 18 years of experience,

and I have taught way over a million people how to code,

or how to become top professional software engineers.

To learn more about me and my courses, head over to code with Mosh.com.

All right, now let's get started.

Alright, the first thing I want you to do is open your browser and head over to Python.org.

On this page, on their download, you can download the latest version of Python.

At the time of this video, the latest version is Python 3.13.

Chances are in the future, when you're watching this video,

there is a newer version of Python available.

Don't worry, what I'm going to show you in this tutorial,

will apply to future versions of Python as well.

So go ahead and download the latest version.

Now, if you're on Windows, before you click install,

make sure to check this little box here that says,

at Python to path.

This step is very important, and it will save you a lot of headaches later.

So check this box and follow the installation.

Now, to verify that Python is successfully installed,

click this magnifier, and here in this search bar, type terminal.

Now, here in the terminal, window, type Python,

dash dash version.

This verifies that we have successfully installed Python 3.13.

Now, if you're on Mac, press command and space to bring up the spotlight search.

Here type terminal.

Now, to verify that we have installed Python correctly,

on Mac, we should type Python 3,

space, dash, dash version.

So, as you can see, of successfully installed,

Python 3.13 on this machine.

So, this environment you see here is what we call Python interpreter,

which is basically a program that executes Python code.

We can type our Python code in a file and give it to this interpreter,

or we can type our code directly here in this interactive shell.

So here we can write an expression like 2 plus 2,

in programming, an expression is a piece of code that produces a value.

So here, when we add 2 plus 2, we get a value,

that is why we refer to this piece of code as an expression.

So enter, we get 4.

Let's try a different kind of expression.

Let's see if 2 is greater than 1.

We get true, which is an example of a Boolean value,

you're going to learn about these Boolean values in the next section.

Now, what if we type 2 is greater than 5?

Enter, we get false.

So in programming, we have true and false,

which are similar to yes and no in English.

Now, what if we type 2 is greater than,

what we don't add a second value here, just press enter,

we get a syntax error.

In programming, syntax means grammar.

So just like we have the concept of grammar in the languages that we speak,

we have the exact same concept in programming.

If we write a sentence, that is not grammatically correct,

chances are some people may not understand that sentence.

So in this example, we have this expression, which is incomplete.

It doesn't have the right grammar or syntax.

That is why Python interpreter is complaining by returning an error.

So this interactive shell is a great way to quickly experiment with a bit of Python code.

But that's not how we build real-world applications.

To do that, we need a code editor.

And that's what I'm going to show you in the next lecture.

When it comes to typing Python code, you have two options.

You can use a code editor or an IDE, which is short for integrated development environment.

An IDE is basically a code editor with some fancy features like auto-completion,

which means as you type code, this feature helps you complete your code.

So you don't have to type every character by hand.

It's a productivity boosting feature.

It also gives you additional features like debugging, which means finding and fixing bugs in your programs, testing and so on.

For both code editors and IDE's, there's so many options out there.

The most popular code editors are VS Code, Adam, and Subline.

You can use the code editor that you prefer.

In terms of the IDE's, again, there's so many options out there.

The most popular one is Python.

In this course, I'm going to use VS Code or Visual Studio Code, because that's my favorite code editor.

Later, in the course, I will show you how to install a plugin or an extension that will convert VS Code to a powerful IDE.

So, before going any further, head over to code.visualstudio.com and download the latest version of VS Code.

Now, with VS Code open, on the top, from the file menu, go to Open and somewhere on your disk create a new folder.

Let's call this folder, hello world.

And then open it, beautiful.

Now, click this icon on the top.

This opens up the Explorer panel.

In this panel, you can see all the files and folders in your project.

So, let's add a new file and call that app.py.

So, all our Python files should have thepy extension.

Presenter.

Now, let's close this and type a bit of Python code.

In this lecture, we're going to use one of the built-in functions in Python called Print.

So, in Python, we have a lot of built-in functions for performing various kinds of tasks.

For example, as a metaphor, think of the remote control of your TV.

On this remote control, you have a bunch of functions.

Like, turn on, turn off, change the channel, change the volume and so on.

These are the built-in functions and your TV.

We have the same concept in Python and many other programming languages.

So, one of these built-in functions that comes with Python is Print.

And we can use this to print something on the screen.

Now, whenever you want to use a function, you should open and close parenthesis.

In programming, we say, we're calling the print function.

Calling a function means executing it.

Now, let's display the Hello World Message on the screen.

Whenever you want to work with text, you should put your text in between quotes.

Either double quotes or single quotes.

Now, I'm going to go with double quotes and add Hello World.

And then put a happy Persian cat here.

Beautiful.

Save the changes with command and S on Mac or control and S on Windows.

Now, to execute this code, we need to go back to command prompt on Windows or terminal on Mac.

But the good news is that we don't have to switch programs.

Here in VS Code, we have an integrated terminal.

So press, control and back tick.

That is the key before number one on your keyboard.

That is just below the Scape button.

So, this is our integrated terminal.

Now, you're from Windows type Python.

If you're on Mac or Linux type Python 3,

and next to that, add the name of our file.

That is app of Python.

And here's our Hello World Message in the terminal.

Beautiful.

Now, let's take this to the next level.

I'm making it a little bit more interesting.

Let's close this terminal window by pressing control and back tick.

And add a second line of code.

So one more time, print.

This time, let's add quotes with a star in between them.

Now, let's say we want to repeat this star 10 times.

So here, we can multiply this by 10.

Save the changes.

Open up the terminal and run our program.

And you can see this star is repeated 10 times.

So, as you see, the instructions on our program are executed

from top to bottom in order.

In the next lecture, I'm going to show you how to convert this VSCode

to a powerful IDE for building Python applications.

In this lecture, I'm going to show you how to convert VSCode

to a powerful IDE by using an extension called Python.

With this extension or plugin, we get a number of features,

such as linting, which basically means analyzing our code

for potential errors.

We also get debugging, which involves finding and fixing errors.

We'll look at this later in the course.

We also get auto-completion, which basically helps us write code faster,

so we don't have to type every character.

We get code formatting, which is all about making our code clean and readable,

just like how we format our articles, newspapers, books to make them clean and readable.

We get unit testing, which involves writing a bunch of tests for our code.

We can run these tests in an automated fashion to make sure our code is behaving correctly.

And finally, we get code snippets, which are reusable code blocks

and we can quickly generate, so we don't have to type them all by hand.

But don't worry about memorizing any of these.

As we go through the course, you're going to learn about these features.

So back to VSCode, on the left side, click this icon.

This opens the extensions panel, where we can install additional extensions

to enhance VSCode.

Up here in the search bar, search for Python.

Alright, look, we have an official extension for Python from Microsoft.

So go ahead and install this.

Now you might see a box here saying reload.

If you see that, make sure to click it to reload VSCode.

Now with this extension installed, we have a ton of new functionality VSCode for writing Python code.

The first one I'm going to show you in this lesson is the ability to run our code.

So back to app.py, look with this extension installed.

Now we have this play icon on the top for running our code.

So if we click it, we can see the output of our program in the terminal window.

In this lecture, I'm going to show you a linting and action.

So let's start by writing some invalid code like this.

Print, space with no parentheses, and then hello world.

Earlier I told you that print is a built in function,

and whenever you want to use or call a function, you should always use parentheses.

Now to be more precise, this is actually valid Python 2 code,

but because we're using Python 3 here, this is invalid code from Python 3's point of view.

So now when I saved the changes, you can see this read on the line here.

Let's hover our mouse over this underlying.

You can see this tool tip.

It's coming from pilot, and here's the error message, missing parentheses in call to print.

Did you mean print with parentheses?

So this is the benefit of linting.

As you're writing code, you can see potential problems in your code.

You don't have to wait to run your program to see these errors.

So now, if we put parentheses here and save the changes, you can see that read on the line is gone.

Let's look at another error.

Let's type 2 plus and then save the changes.

Earlier, we ran this code and Python interpreters interactive shell.

There, we got a syntax or grammar error.

So if you hover your mouse here one more time, you can see,

Pylints is telling us that this is invalid syntax or invalid grammar.

It's like an incomplete sentence.

So this is linting an action.

Now let me show you a couple useful shortcuts here.

On the top, look at the view menu.

Here we have this problem's menu.

Look at the shortcut.

On Mac, it's Shift, Command, and M.

On Windows, it's probably Shift, Control, M.

So as you're working with VS code, try to memorize these shortcuts

because they really help you write code faster.

Now let's take a look at this problem's panel.

So this problem's panel lists all the issues in your code in one place.

So if you have an application with multiple files, this is really useful

because some of those files may not currently be open.

So this linter, Pylint, will analyze all your files.

And if it finds any issues, it will list them here in the problem's panel.

Now you can also put this on the right side of the screen.

So let's put it here.

So as you write code, these problems will appear here.

Now let's fix this issue.

Now I'm going to add three here, save the changes, and you can see the problem disappear.

And one last thing before we finish this lecture.

Once again, on the top, let's go to the view menu.

The first item is Command Palat.

This is a very important feature in VS code.

Once again, look at the shortcut that is Shift, Command, and P on Mac,

or Shift, Control, P on Windows.

With this Command Palat, you can execute various commands in VS code.

If you type Lint here, you can see all commands related to Linting.

As you can see, all these commands are prefix with Python,

because these commands come with a Python extension that we installed earlier.

So these are additional features available to us in VS code.

The first command here is Select Linter.

In this list, you can see various Linter's available for Pylint.

So as you're reading tutorials or talking to other people,

you will hear about Linters such as Flake 8, My Pie, Pep 8, and so on.

Different developers prefer different Linters.

I personally prefer Pylint.

That is the most popular one, and that is the default Linter set in the Python extension of VS code.

If you're adventurous, you can try using other Linters on your own.

The difference between these Linters is in how they find and report errors.

Some error messages are more meaningful or more friendly.

The others are more ambiguous.

So that's all about Linting.

In the next lecture, we'll talk about formatting code.

In Python community, we have a bunch of documents called Python enhancement proposals or peps.

Here on Google, if you search for Python peps,

you can see the list of all these peps under python.org slash dev slash peps.

Let's have a quick look here.

So here are the peps.

We can see each pep has a number and a title.

The one that is very popular amongst Python developers is Pep 8,

which is a style guide for Python code.

A style guide is basically a document that defines a bunch of rules for formatting and styling our code.

If you follow these conventions, the code that you write will end up being consistent with other people's code.

Now, if you have time, you can go ahead and read this pep 8 documentation.

But if not, don't worry, because throughout the scores, I'm going to explain the key things in pep 8.

In this lecture, I'm going to show you a tool that helps you automatically format your code according to pep 8.

So back in VS code, let's write some Python code.

X equals one. Here I'm declaring a variable and setting it to one.

If you're not familiar with variables, don't worry. The next section you're going to learn about them.

So according to pep 8, this code is considered ugly.

Because by convention, we should add a space around this equal sign or the assignment operator.

Now, since you're starting out with Python, you probably don't know these rules.

So let me show you a tool that helps you automatically format your code.

Let's revert this back to its original state.

Now we need to go back to the command palette.

Remember, so it's right here under view and the shortcut is Shift, command, and P.

Here if you search for format, you can see this command format document.

The first time you execute this command, you're going to see this message here.

For matter, auto pep 8 is not installed.

So there are a bunch of tools for formatting Python code.

The most popular one is auto pep 8.

And this is the tool that this Python extension will install uses to format our code.

Now if you don't see this, you can install auto pep 8 using the extensions panel.

So once again on the left side, click the icon and search for auto pep 8.

There it is. Let's install it.

Good.

So let's go ahead and install this.

Good.

Now one more time, let's open up the command palette and execute format document.

See, this tool automatically formats our code.

Beautiful. Let's take a look at another example.

I'm going to declare another variable, y and set it to two, and it's variable with a long name.

Like unit on the line price, I'm set this to three.

Now some developers have this habit of formatting their variable declarations like this.

So they put all these equal signs in the same column.

According to pep 8, this is considered ugly.

So once again, let's format our code.

That is better. Beautiful.

Now let me show you a trick.

Opening of this command palette and searching for format document every time is a little bit time consuming.

So I want to show you how to have your file automatically format it as soon as you save the changes.

On the top, let's go to the code menu, preferences, and settings.

Here in the search box, search for format on save.

So we have this option editor format on save.

Take this.

Now back to app.py.

I'm going to change the formatting of these lines.

Make them really ugly.

Now as soon as I save the changes, you can see, my code is reformatted.

Beautiful.

Alright, that lets talk about a few different ways to run Python code.

As I told you before, one way to run Python code is by opening the terminal window.

If you're on Windows type Python, if you're on Mac type Python 3, followed by the name of the file.

This approach is useful in situations where you don't have access to a code editor.

Okay. Now with the Python extension in VS code, there is a simpler way to run Python code.

We get this play button on the top.

When we click it, we see the output in the terminal.

But clicking this button every time we change our code is a little bit tedious.

So let me show you how to associate a shortcut to this button.

First, we close this.

Next, we bring up the command palette.

The shortcut on Mac is shift command and p.

On Windows is shift control p.

Here we search for open keyboard shortcuts.

Look, we have this command up here.

Now on this window, we can see all the commands in VS code

and the shortcuts associated with them.

Here in the search bar, search for run Python file.

Okay. So this is the command that is associated with the play button.

As you can see, we don't currently have any key bindings or shortcuts here.

So double click in this column.

Now here you can press any key combination for creating a shortcut.

I'm going to press Ctrl and R.

Okay. Now we press Enter.

With this in place, we can go back to app.py and press Ctrl R.

And here we see the output beautiful.

Let me talk about Python.

We mean two separate things that are closely related.

Python language and a particular implementation.

Python as language is just a specification that defines a sort of rules and grammar for writing Python code.

A Python implementation is basically a program that understands those rules and can execute Python code.

Earlier in the course, with downloaded Python from Python.org,

this is the default implementation of Python called C Python.

It's a program written in C. That's why it's called C Python.

So here in terminal, when we run Python, we get this C Python.

This is the default implementation of Python.

There are a few other implementations out there, such as Python, written in Java,

Iron Python, written in C sharp, and Python written in a subset of Python itself.

As new features are added to the Python language,

they are first supported by C Python because it's the default implementation.

And then they will gradually come to the other implementations.

In theory, if it gives some Python code to any of these implementations,

we should get the same result.

But in practice, that's not always the case.

Certain features may be available in one implementation, but not another,

or they may just behave a little bit differently in a particular implementation.

Now you might ask, what is the point of this?

Why do we have several implementations of Python?

Wouldn't C Python be enough?

Well, it's for the same reason that we have multiple operating systems,

or multiple browsers, or multiple programming languages.

After all these years, in programmers haven't agreed on a single programming language.

And that's the same story with Python implementations.

However, there is one technical reason behind these implementations that you should be aware of.

Since JSON is implemented in Java, it allows you to reuse some existing Java code in a Python program.

So if you're a Java developer, and you want to import some Java code into a Python program,

you should use Python instead of C Python.

Similarly, Iron Python is written in C-sharp.

So if you're a C-sharp developer, and want to bring some C-sharp code into a Python program,

you will have to use Iron Python.

Next we will look at how exactly C Python executes Python code.

The programming languages we use, like C, C-sharp, Java, Python,

these are all simple text-based languages that we humans understand.

Computers don't understand them, they only understand machine code.

So if you have some code written in C, we should convert it to machine code.

And that's the job of a C compiler.

So a C compiler is a program that knows how to convert or compile C code into machine code.

However, this machine code is specific to the type of CPU of a computer.

So if you compile a C program on a Windows machine, we can't execute it on a Mac.

Because Windows and Mac have different machine code, just like how people from different countries speak different languages.

Java came to solve this problem.

Java compiler doesn't compile Java code into machine code.

Instead, it compiles it into a portable language called Java byte code,

which is not specific to a hardware platform like Windows or Mac.

Now, we still need to convert Java byte code to machine code.

So Java also comes with a program called Java virtual machine or JVM for doing this.

When we run a Java program, JVM kicks in, it loads our Java byte code,

and then at runtime, it will convert each instruction to machine code.

With this model, we can run Java byte code on any platforms that have a JVM.

We have JVM implementations for Windows, Mac, and so on.

So the JVM implementation on Windows knows how to convert Java byte code into machine code that a Windows machine can understand.

C Sharp and Python have also taken the same route, so they are platform independent.

When we run a Python program using C Python, first it will compile our Python code into Python byte code.

Then it will pass that byte code to Python virtual machine,

which will in turn convert it into machine code and execute it.

This is how C Python works.

In the last lecture we talked about various Python implementations.

I told you that if you want to reuse some Java code in a Python program, you should use Jithon.

Now, let's see how Jithon makes this possible.

When you use Jithon to run a Python program,

instead of compiling your Python code into Python byte code,

it will compile it to Java byte code.

Now we can take this Java byte code and run it using Java virtual machine.

And that's why you can import some Java code into a Python program when using Jithon.

Because the end result is Java byte code, which will eventually be executed by Java virtual machine.

So I've got a few questions for you because I want to see if you have been really paying attention to this video or not.

The better half. So here's the first question.

For each question, I want you to pause the video,

think about the answer for a few seconds when you're ready to continue watching.

So here's the first question. What is an expression?

An expression is a piece of code that produces a value.

Here's an example of an expression.

What do you think is the value of this expression?

Well, here we have this string.

We're multiplying this by three.

So the result will be a string of three asterisk like this.

Here's another question. What is a syntax error?

A syntax error is a kind of error that is due to bad syntax or bad grammar in the code.

And finally, the last question. What does a linter do?

A linter is a tool that checks our code for potential errors,

mostly in the category of syntactical errors.

So if you have grammatical issues in our code,

the linter will tell us before running our program.

Okay, that's it for now.

If you like more quizzes and programming exercises,

look at the link below this video.

And if you have enjoyed this video, I hope you have.

Please support me by giving a thumbs up.

Please like this video and share it with others.

In the next section, we're going to look at the fundamentals of Python.

Hey guys, I just wanted to let you know that this tutorial is actually the first two hours of my complete Python mastery course.

If you're finding this helpful and want to dive even deeper,

the full course covers everything from beginner basics to advanced concepts like machine learning,

web development and automation.

You also get hands on projects to build your skills step by step.

I put the link in the description box if you're ready to take your Python knowledge to the next level.

Now let's continue.

Let's start this section by discussion of variables,

which are one of the core concepts in programming.

We use variables to store data in computer's memory.

Here are a few examples.

I'm going to define a variable called students on the line count

and setting it to 1000.

When we run this program, Python interpreter will allocate some memory and store this number

thousand in that memory space.

Then it will have this variable reference that memory location.

So this variable is just like a label for that memory location.

We can use this variable or this label anywhere in our program to get access to that memory location

and the data stored there.

So now if we print students count and run our program will get the number thousand.

So this is the basic of variables.

Now what kind of data can we store in computer's memory?

Well, we have several different kinds of data.

In this section we're going to look at the built in primitive types in Python.

Primitive types can be numbers, bullions and strings.

Let me show you.

So here we have a whole number.

We refer to this as an integer in programming.

We can also have numbers with a decimal point.

Let's take a look.

So rating we set this to 4.99.

This is what we call a float or a floating point number.

And this terminology is not specific to Python.

In the future, when you learn a new programming language,

you're going to hear this terms again.

Now let's take a look at an example of a Boolean.

Is published with set this to true or false?

These are examples of Boolean values in programming.

So Boolean values can either be true or false.

And these are exactly like yes and no in English.

Later in the course, you will learn that we'll use this Boolean values

to make decisions in our programs.

For example, if the user is an admin user,

perhaps we want to give them extra permissions.

So these are the Boolean values.

Now take into account that Python is a case sensitive language,

which means lowercase and uppercase characters have different meanings.

So Boolean values should always start with a capital letter like what you see here.

If we type false or false, these are not accepted Boolean values in Python.

Only what you see here is a valid Boolean value.

The false or true.

And finally let's take a look at an example of a string.

So of course, on the line name, we set this to a string like Python programming.

So a string, as I told you before, is like text.

Whenever you want to work with text in your programs,

you need to surround your text with quotes.

So these are the basics of variables.

So these are the variables from the last lecture.

Now I've got a question for you.

There are four things that have consistently used in this program.

Can you spot them?

If you want, you can pause the video.

Think about this for a few seconds and then continue watching.

So here are those four things.

The first thing is that all my variable names are descriptive and meaningful.

So students count represents the number of students for a course.

Or course name, cleared explains that this variable holds the name of a course.

One of the issues that I see a lot amongst beginner programmers is that they use mystical names for their variables.

Something like this.

CN, as in short for course name.

When someone else reads this code, they have no idea what CN stands for.

Or they use variable names like C1.

When I look at that code, I wonder, where is C2?

And what is the difference between C1 and C2?

So these variable names are very mystical.

That's a bad practice.

Make sure your variable names are always descriptive and meaningful because this makes your code more maintainable.

Now there are times that you can use short variable names like x, y, z.

If you're dealing with things like coordinates.

So that's an exception.

Now the second thing that I have consistently used in this code is that I have used lowercase letters to name my variables.

So here we don't have course name, all in capital or in title case.

All letters are lowercase, right?

Let's delete this.

The third thing that I've consistently used here is that I have used an underscore to separate multiple words.

And I've done this to make my variable names more readable.

Because in Python, we cannot have a space in variable names.

So we cannot have course name.

And if you put these two words together, it's a little bit hard to read.

That's why we use an underscore.

And the fourth thing that I have used consistently here is that I have put a space around this equal sign.

Again, that's one of the issues I see a lot amongst beginners.

They write code like this.

This is a little bit ugly.

This is what we call dirty code.

Dirty, stinky, smelly.

You should write code that is clean and beautiful.

So other people can read it like a story, like a newspaper article.

You should be formatted properly.

And that's why we have Pepe 8 in Python.

Now the good thing is if you forget these rules when you save the changes,

Auto Pepe 8 kicks in, I did automatically reformat your code.

But that aside, you should always give yourself the habit of writing clean code without relying too much on the tooling.

So these are all the best practices about naming your variables.

Next, we're going to look at strings in more detail.

So here we have this course variable set to Python programming.

As I told you before, whenever you work with text, you should surround your text with quotes.

You can either use double quotes or single quotes.

That's more of a personal preference, but quite often we use double quotes.

We also have triple quotes and we use them to format a long string.

For example, if you have, let's say, a variable message,

that is the message we want to include in the body of an email.

You can use triple quotes to format it like this.

Hi, John. This is Marsh from code with marsh.com, blah, blah, blah.

So that's when we use triple quotes.

Now we don't need this and this lecture, so delete.

Let me show you a few useful things you can do with strings.

First of all, we have this built-in function in Python for getting the length of strings.

What is a function?

A function is basically a reusable piece of code that carries out a task.

As a metaphor, think of the remote control of your TV.

On this remote control, you have buttons for different functions,

like turn on, turn off, change the channel and so on.

These are the built-in functions in your TV.

In Python and many other programming languages, we have the exact same concept.

So we have functions that are built into the language on the platform.

We can reuse these functions to perform various tasks.

So here we can use the built-in length function to get the length of a string,

which means the number of characters in that string.

Now, whenever you want to use a function, you should use parentheses.

Now we say we're calling this function, which basically means we're using this function.

Now some functions take additional data, which we refer to as arguments.

These arguments are inputs for these functions.

So this length function takes an input on an argument.

Here we pass our course variable, and this will return the number of characters in this string.

So let's print that and see what we get.

Run the program.

We get 18, because we have 18 characters here.

Let's look at another example.

If you want to get access to a specific character in this string, you use the square bracket notation.

So here we add course, square brackets, to get the first character, you use the index zero.

So in Python, like many other languages, strings are zero index, which means the index of the first character or the first element is zero.

So now when we print this, we'll get p, okay?

Now you can also use a negative index, like minus one.

What does that mean? Well, if zero represents the first character here, what do you think negative one represents?

That takes us back to the end of the string.

So that returns the first character from the end of the string.

Let's do on this program, you will see we'll get g.

There you go.

Using a similar syntax, you can slice strings. Let me show you.

So I'm going to duplicate this line and remove negative one.

Now let's say we want to extract the first three characters in this string.

So here we need two indexes.

The start index, colon, the end index.

So this will return a new string that contains the first three characters in this course variable.

That will be p, y, and t.

So the index of these characters are zero, one, and two.

So that means the character at the end index is not included, okay?

Let's run the program and make sure we get the right result.

There you go, p, y, t.

Now what if we don't include the end index?

What do you think we're going to get?

It's common sense.

We start from index zero and go all the way to the end of the string.

So this will return a new string that is exactly the same as the original string.

Let's take a look.

So we get Python programming.

Now what if we don't include the start index, but include the end index?

What do you think we're going to get?

Once again, it's common sense.

So by default, Python will put zero here, so it will start from the beginning of the string.

So when I run this program, we should get p, y, t, one more time.

There you go.

And finally, as the last example, if we don't include the start and the end index,

this will return a copy of the original string.

Let's look at this.

So we get Python programming.

Now you don't have to memorize any of these.

Just remember, we use the length function to get the length of a string.

We use bracket notation to get access to a specific element or a specific character.

And we use this notation to slice a string.

So we have this string here, Python programming.

Now let's say we want to put a double code in the middle of this string.

There is a problem here.

Python interpreter sees this second string as the end of the string.

So the rest of the code is meaningless and invalid.

How do we solve this problem?

Well, there are two ways.

One way is to use single codes for our string.

And then we can use a double code in the middle of the string.

But what if for whatever reason, perhaps for being consistent in our code?

We decided to use double codes.

How can we add another double code in the middle of this string?

Well, we can prefix this with a backslash.

Backslash in Python strings is a special character.

We have a jargon for that called escape character.

We use it to escape the character after.

Let me show you what I mean.

So let's print this course and run this program.

What's going on here?

We don't have the backslash because we use that to escape this double code

and basically displayed here.

So backslash is on escape character.

And backslash double code is on escape sequence.

In Python strings we have a few other escape sequences that you should be aware of.

Let me show you.

So in Python we use a high sign to indicate a comment.

A comment is like additional note that we add to our program.

It's not executed by Python interpreter.

So here are the escape sequences.

You have seen backslash double code.

We also have backslash single code.

So we can use that to add a single code here.

Let's run the program.

Here it is beautiful.

We also have double backslash.

So if you want to include a backslash in your strings,

you should prefix it with another backslash.

Let me show you.

So when we run this we get Python 1 backslash for programming.

And finally we have backslash n, which is short for new line.

So now if I add a backslash n here, see what we get.

We get a new line after Python, so programming will end up on the second line.

So these are the escape sequences in Python.

Here we have two variables first and last.

Let's say we want to print my full name on the console.

So we can define another variable full set it to first,

then concatenate it with a space.

And one more time concatenated with last.

Now when we print full, we get my full name on the console.

Beautiful.

Now this approach are using concatenation to build a string is okay,

but there is a better and newer approach.

We can use formatted strings.

So here we can set full to this string and prefix it with an F,

which can be lower case or upper case.

This formatted string doesn't have a constant value like these two strings here.

It's actually an expression that will be evaluated at runtime.

So here we want to add our first name.

We use curly braces to print the value of the first variable.

After that we add a space and then we add curly braces one more time

to print the last name.

So at runtime this expression will be evaluated.

What we have in between curly braces will be replaced at runtime.

Now let's run this program one more time.

We get the exact same result.

Just be aware that you can put any valid expressions in between curly braces.

So earlier you learned about the built in land function.

We can call land here to get the lengths of this string.

Let's run this program one more time.

So we get four.

We can also replace last with an expression like this two plus two.

Let's run this program we get four and four.

So when using formatted strings you can put any valid expressions in between curly braces.

In this lecture we're going to look at a few useful functions available to work with strings.

So earlier you learned about this built in land function.

This function is general purpose so it's not limited to strings.

Later I will show you how to use this function with other kind of objects.

But in Python we have quite a few functions that are specific to strings.

Let me show you.

So here if we type course dot see all these are functions available on strings.

Now in precise terms we refer to these functions as methods.

This is a term in object-oriented programming that you will learn about later in the course.

For now what I want you to take away is that everything in Python is an object and objects have functions.

We call methods that we can access using the dot notation.

So here course is an object.

We use the dot notation to access its functions or more accurately methods.

Let's take a look at a few of these methods.

We have upper to convert a string to upper case.

Now let's print this and run the program.

Here is what we get beautiful.

Now note that the methods that you call here return a new string.

So the original string is not affected.

Let me show you.

So print course run the program one more time.

Look this is our original string right?

So course dot upper returns a new string a new value.

We can store it in a variable like course on the light capital like this.

Now to keep this demo simple and consistent I'm going to revert this back and use a print statement.

We also have the lower method to convert a string to lower case.

We also have title which will capitalize the first letter of every word.

So if our string was like this.

When we call the title method we get Python programming as you see here.

Okay.

Another useful method is strip and we use it to trim any white space at the beginning or end of a string.

This is particularly useful when we receive input from the user.

Let me show you.

So let's imagine the user entered a couple of white spaces at the beginning of the string.

When we call course dot strip those white spaces will be removed.

Take a look.

So note that in the first three examples we have those white spaces but in the last one it is removed.

So strip remove the white space from both the beginning and end of a string.

We also have L strip which is short for left strip and R strip which is short for right strip.

So it will remove the white space from the end of a string.

If you want to get the index of a character or a sequence of characters in your string,

you should use the find method and we'll show you.

So of course that find.

So as an argument here we pass another string.

We can pass a character or a series of characters.

Let's find the index of pro.

Round the program.

So the index of pro is 9.

So if you start from zero here all the way to 9 this is the index of pro.

Okay.

Now as I told you before python is a case sensitive language.

So if I pass a capital P here obviously we don't have these exact characters in our string.

So let's see what we get.

We get negative one.

That means this string was not found in the original string.

Another useful method is replace.

So we call replace.

With this we can replace a character or a sequence of characters with something else.

So let's say we want to replace all lowercase piece with j.

With this we get jth on geogramming.

Whatever that means.

And finally if you want to check for the existence of a character or a sequence of characters in your string,

you can use the in operator.

Let me show you.

So this is an expression.

Realize an expression like this.

Pro in course.

So this is an expression as I told you before.

An expression is a piece of code that produces a value.

So this expression checks to see if we have pro in course.

The difference between this expression and calling the fine method is that the fine method returns the index of these characters in our string.

But as this expression returns a Boolean.

So it's a true or false.

Let me show you.

So we run the program.

We get the Boolean true.

And finally we have the not operator.

And we use that to see if our string does not contain a character or a sequence of characters.

So let's change this to Swift.

Not in course.

When this expression is evaluated, what do you think we're going to get?

Well, we don't have Swift in this string.

So not in will return true.

Let's take a look.

There you go.

So these are the useful string methods.

Next we'll look at numbers.

In Python, we have three types of numbers.

Two of these we have already seen before.

They are integers and floats.

We also have complex numbers.

So complex numbers in math are in the form A plus B i.

Where i is the imaginary number?

If you're not familiar with this concept,

or this is something that it uses a lot in mathematics and electrical engineering.

If you want to use Python to build web applications,

you're never going to use complex numbers.

But let me quickly show you the syntax for representing complex numbers.

Instead of i, we use j.

So here is an example.

1 plus 2 j.

So x now is a complex number.

And by the way, as I told you before,

this is just a comment or an additional note in our program.

When we run this program, anything after this high sign will be ignored.

So these are the three types of numbers we have in Python.

For all these types of numbers,

we have the standard arithmetic operations that we have in math.

Let me show you.

So we have addition,

subtraction,

multiplication,

division.

But we actually have two different types of divisions.

Let me show you.

First, let's run this program.

So with this division operator,

which is a slash,

we get a floating point number.

If you want an integer,

you use double slashes.

Let me show you.

So double slash,

run the program.

We get three.

Okay?

We also have modules,

which is the remainder of a division.

And finally,

exponent,

which is left to the power of right.

So 10 to the power of three will be a thousand.

These are the standard arithmetic operators.

Now for all these operators,

we have a special operator called augmented assignment operator.

Let me show you.

So let's imagine we have X set to 10.

We want to increment X by,

let's say, three.

We can write an expression like this.

X equals X plus three.

Or we can use an augmented assignment operator.

That is a little bit shorter.

So we write X plus equal three.

These two statements are exactly the same.

Now here I'm using addition as an example.

You can use any of these operators here.

Next, I'm going to show you some useful functions

to work with numbers.

In this lecture,

we're going to look at a few useful functions to work with numbers.

So we have this built-in function round for rounding a number.

So if we pass 2.9 here and print the result,

we'll get three.

We have another useful built-in function called ABS,

which returns the absolute value of a number.

So if you pass negative 2.9 here, we'll get positive 2.9.

That's technically we have only a handful of built-in functions

to work with numbers.

If you want to write a program that involves complex mathematical calculations,

you need to use the math module.

And module is like a separate file with some Python code.

So in Python, we have this math module,

which includes lots of mathematical functions for working with numbers.

But we need to import this module so we can use it.

On the top, with type, import, math.

Now math in this program is an object.

So we can use the dot notation to see all the functions

or more accurately, all the methods available in this object.

As an example, we have math.seal for getting the ceiling of a number.

So if you pass 2.2 here and run this program, we get three.

Now in this math module, we have lots of functions.

Let me show you how to find the completeness.

Here on Google, search for Python 3,

make sure to add the version number, math module.

On this page, you can see all the functions in the math module.

So in this lecture, we looked at math.seal.

We also have math.copySign, Fabs, and so on.

As an exercise, I encourage you to play with a couple of functions in this module.

Alright, now let's take a look at another useful built-in function in Python.

We use the input function to get input from the user.

As an argument, we pass a string.

This will be a label that will be displayed in the terminal.

You will see that in a second.

So let's add x colon.

Now this function returns a string.

So we can store it in this variable.

Now let's imagine that y should be x plus 1.

Save the changes.

Now don't run this program using the code runner extension

because code runner by default runs your program in the output window,

which is read only.

So you won't be able to enter a value.

So open up the terminal using control and backspace.

Once again, if you're on Windows, type Python,

if you're on Mac or Linux, type Python 3, and then app.py.

So here's our label.

Let's enter a value like 1.

We got an error, type error.

What is going on here?

Well, when we receive input from the user,

this input always comes as a string.

So this expression at runtime will look like this.

String 1 plus 1.

Note that the number 1 is different from string 1 because these are two different types.

Now when Python sees this expression, it doesn't know what to do.

Because two objects can be concatenated if there are of the same type.

So here we need to convert this string 1 to a number.

In Python, we have a few built-in functions for type conversion.

We have int for converting a number to an integer.

We have float, we have bull and stir or string.

Now in this case, we don't need to convert x to a string

because x is already a string.

If you don't believe me, let me show you.

So I'm going to comment out these few lines.

Now let's print type of x.

So type is another built-in function.

We pass an object as an argument and it returns its type.

Also, I'm going to comment out this line,

because that's the bad boy.

We don't want to execute this.

Save the changes.

Back in the terminal,

let's run this program one more time.

Enter one.

Look.

This is what the type function returns.

Now don't worry about the class.

We'll talk about classes later in the course.

So the type of x is a stir or string.

So let's delete this line.

To fix this problem, we need to convert x to an integer.

And then we can print both x and y using a formatted string.

Remember?

So we add an f, close.

Now here we add a label like x.

Then we'll add a field.

So here we want to print the value of x variable.

After that, we add some more text.

And finally, we want to print the value of y.

Let's run this program one more time.

So here in the terminal,

let's enter one.

And here's the result.

x is one and y is two.

Beautiful.

Now all these built-in functions are self-explanatory.

The only tricky one is bull.

Because in Python,

we have this concept of truthy and falsy values.

These are values that are not exactly a Boolean true or false,

but they can be interpreted as a Boolean true or false.

So here are the falsy values in Python.

M2 strings are considered falsy,

so they're interpreted as a Boolean false.

Number zero is also falsy.

We have an object called non,

which represents the absence of a value.

We'll look at this later in the course.

So whenever we use these values in a Boolean context,

we'll get false.

Anything else will be true.

Let me show you a few examples.

So in this interactive shell in Python,

let's convert number zero to bull.

That's falsy, so we get false.

What about bull of one?

We get true.

If we pass a negative number,

we'll also get true.

If we pass a number larger than one,

like five, we still get true.

So we only get false.

Let me try to convert zero to a Boolean.

Now with strings,

I told you that an empty string is falsy.

So here we'll get false.

Anything else is true.

So even if I have a string that is false,

we'll get true.

Because this is not an empty string.

It's a string with a few characters.

That's why it's a value-it-a-stru.

All right. Once again,

it's time for another quiz.

Let's see if you've been really paying attention to this tutorial.

So here's the first question.

What are the built-in primitive types in Python?

We have strings, numbers, and Boolean ads.

Numbers can be integers, floats, or complex numbers.

Here's the second question.

You have this variable, fruit, set to apple.

What do you think we will see on the terminal

when we print fruit of one?

Well, using screw brackets,

we can access individual characters.

The index of the first character is zero.

So this expression returns the second character, which is p.

What if we add a colon and negative one here?

Well, using the same text, we can slice a string.

Our start index is one,

and our end index is negative one,

which refers to the first character from the end of the string.

Now, when slicing a string,

the character at the end index, or negative one,

is not included.

So with this expression,

we'll get all the characters starting from the second character,

which is p, all the way until we get to e.

So the result of this expression is ppl.

Here's another question.

What is the result of this expression?

Well, this is what we call the modulus operator,

and it returns the remainder of a division,

which is in this case one.

And finally, the last question.

What do you think we will see when we print

bull of false?

Well, earlier I told you about false values in Python.

So number zero, an empty string,

and the non-object is our all-false values.

Anything that is not false is considered true C.

Here we have a string that has five characters.

It doesn't matter what those characters are.

This is not an empty string.

So it's not false C.

It's true C.

So when we convert it using the bull function,

we'll get the bullion true.

And this brings us to the end of the section.

In the next section, you're going to learn

the fundamentals of computer programming.

I hope you have enjoyed this section,

and thank you for watching.

We're going to start this section by exploring

comparison operators.

We use comparison operators to compare values.

Here are a few examples.

So 10 is greater than 3.

We get true.

So what we have here is a bullion expression.

Because when this expression is evaluated,

we'll get a bullion value that is true or false.

Here is another example.

10 is greater than or equal to 3.

Once again, we get true.

We also have less than, so 10 is less than 20.

We have less than or equal to.

Here's the equality operator.

So 10 is equal to 10.

What about this expression?

What do you think we're going to get?

We get false.

Because these values have different types,

and they're stored differently in the computer's memory.

And finally, we have the not equal operator.

So now with this expression, we should get true.

Beautiful.

We can also use these comparison operators with strings.

Let me show you.

So we can check to see if bag is greater than apple.

We get true because when we sort these two words,

bag comes after, so it's considered greater.

Now what about this one?

Bag equals capital bag.

We get false.

Here's the reason.

Every character you see here has a numeric representation in programming.

Let me show you.

So we have this built-in function called Ord.

Don't worry about memorizing this,

because you probably never going to use this in the future.

But let me show you the numeric representation of the letter B.

So that is 98.

In contrast, capital B is represented as 66.

That is the reason these two strings are not equal.

So these are the comparison operators in Python.

Next, we'll look at conditional statements.

In almost every program, there are times you need to make decisions.

And that's when you use an if statement.

Here's an example.

Let's say we have a variable called temperature.

We studied to 35.

Now if temperature is greater than 30,

perhaps we want to display a message to the user.

So we use an if statement.

If after if we add a condition,

which is basically a Boolean expression,

an expression that produces a Boolean value.

So if temperature is greater than 30,

here we have a Boolean expression.

If this expression evaluates to true,

the following statements will be executed.

Let me show you.

Now here's the important part that a lot of beginners miss.

When you use an if statement,

you should always terminate your statement with a colon.

Now let's see what happens when I press enter.

Our cursor is indented.

So here we have two white spaces.

This is very important because using these indentations,

Python interpreter will know what statements should be executed

if this condition is true.

Here we want to print a message like it's warm.

We can print another message as well.

Drink water.

So we can have as many statements as we want here.

As long as they are indented,

they belong to this if block.

Now when we finish here,

we should remove indentation to indicate the end of this if block.

So here we can add a print statement with a message like done.

This statement will always be executed,

whether this condition is true or not.

Now note that when I save the changes,

this indentation you see here is going to be doubled up.

Take a look.

Save.

There you go.

So when we save the changes,

auto-pepp eight reformats are code

and uses four white spaces for indentation.

So one, two, three, four.

It uses four white spaces because that's what pep eight recommends.

All right.

Now let's run this program.

So because temperature is greater than 13,

we see the first two messages

and we see the done message regardless.

So if I change the temperature to let's say 15

and run the program one more time,

look, this done message is executed

whether our condition is true or not.

So pay great attention to these indentations.

That's one of the issues I see in beginners code.

Let's say they want both these print statements

to be executed if the condition is true.

Accidentally, they remove the indentation

on the fourth line.

And that's why their program doesn't work as they expect.

So be careful about this.

Now what if you want to have multiple conditions?

We use an L if statement.

So L if that is short for L's if.

Here we can add another condition.

Another expression.

So temperature is greater than 20 once again.

Column.

Enter.

Now by default here,

VS code is using two white spaces.

So don't worry about this.

As soon as you save the changes,

those two white spaces will be converted to four white spaces.

So let's print a different message.

It's nice.

Save the changes.

Now look, all these lines are indented consistently.

You can have as many L if statements as you want.

And optionally, you can also have an L statement.

So if none of the previous conditions are true,

then what you have in the L's block will be executed.

Once again, we add the colon,

annotation, print.

Here we can add a message like it's called.

Save the changes.

In this case, temperature is 15.

So none of these two conditions will be true.

And we will see it's called.

Let's run the program.

There you go.

In this lecture, I'm going to show you a technique for writing clean our code.

So let's say we're building an application for university.

And if you want to check to see if the person who's applying for this university program is eligible or not.

So we start by defining a variable called age.

Set it to 22.

Now, if age is greater than or equal to 18,

colon, print, eligible.

Remove the indentation, else, colon, print, not eligible.

Let's run the program.

Make sure it works beautiful.

Now, there is nothing wrong in this piece of code,

but I want to show you a cleaner way to achieve the same result.

Instead of having a print statement here,

we can define a variable like message

and set it to this string.

That is the first step.

So message equals this string.

And then we will print this message.

Now, when you have an if L statement with this structure,

where you're basically assigning a value to a variable,

you can rewrite this in a simpler way.

So, this is how it works.

All we want to do over this field lines is to assign a value to this message variable, right?

So we start with message.

We set it to eligible if age is greater than or equal to 18,

else we set it to not eligible.

This statement is almost like plain English.

So what we have online seven is exactly equivalent

to these four lines of code.

Delete, save the changes, run the program.

You can see this person is eligible.

If I change the age to 12 and run the program,

we get not eligible.

So what we have here is called turnery operator.

In Python, we have three logical operators

and we use these operators to model more complex conditions.

So these operators are and or and not.

Let's see a real word example of using these operators.

So imagine we're building an application for processing loans.

So we need to variables high income.

We can set this to true and good online credit with set it to true.

Now here's the condition we want to implement.

If the applicant has high income and good credit square,

then there are eligible for the loan.

So if high income and good credit,

we had the colon and print eligible.

Now note that here I have not compared the value of this variable with true.

That is one of the issues I see in a lot of beginners code.

This is redundant and unprofessional because high income is a Boolean.

So it's either true or false.

We don't need to compare true with true.

So if this condition is true and this second condition is true,

then we will print eligible in the terminal.

So save the changes and run the program.

Obviously this person is eligible.

However, if one of these conditions is false,

we will not see eligible in the terminal.

So let's add an L statement here and print not eligible.

Run the program.

We see not eligible.

So this is how the and operator works.

With and operator, if both conditions are true,

the result will be true.

In contrast with the or operator,

as long as at least one of the conditions is true,

the result will be true.

So if I replace and with or here,

we should see eligible in the terminal.

Let's run it one more time.

There you go.

So these are the and or operators.

Now let's take a look at an example of the not operator.

So I'm going to define another variable student.

Set it to true.

Tape it early.

I'm going to remove this expression and simplify it.

We'll come back to this later.

So let's say if the person is eligible,

if they are not a student.

The not operator basically inverses the value of a Boolean.

So in this case, student is true.

When we apply the not operator, the result will be false.

So in this case, our condition will be false.

And that's why this print statement will not be executed.

Let me show you.

So save run the program.

They're not eligible.

If student was false.

When we apply the not operator will get true.

So our condition will be true and we'll see it eligible.

Let's run it one more time.

There you go.

With these operators, we can model even more complex conditions.

Here is an example.

A person can be eligible if they have either high income or good credit.

And they should not be still that.

Let me show you how to implement this condition.

So if high income or good credit,

we won't at least one of these conditions to be true.

So we put these in parenthesis.

We want to separate these from the other condition, which is not a student.

Now the result of this should be true, which means at least one of these conditions should be true.

After that, we'll add and not student.

And finally call.

So with these operators, you can model all kinds of real words scenarios.

So here's the example from the last lecture.

A person is eligible for a loan if they have high income and good credit.

And they are not still that.

Now one thing you need to know about these Boolean operators is that they are short circuit.

What do they mean by that?

Well, when Python interpreter wants to evaluate this expression,

it starts from the first argument.

If this is true, it continues the evaluation to see if the second argument is also true.

So it continues the evaluation all the way to the end of this expression.

However, as soon as one of these arguments is false, the evaluation stops.

Let me show you what I mean.

So if I change high income to false, when Python interpreter sees this expression,

it starts here.

It knows that high income is false,

so it doesn't matter what comes after the result of this entire expression will always be false

because at least one of the arguments or one of the operands is false.

This is what we call short circuiting.

Just like the short circuit concept we have in electronics.

So the evaluation stops as soon as one of these arguments,

the evaluates to false.

We have the same concept with the OR operator.

So if I change these and operators to OR, let's see what happens.

With the OR operator, we know that at least one of the arguments should be true.

So the evaluation stops as soon as we find an argument that evaluates to true.

In this case, when Python interpreter evaluates to this expression,

it sees that high income is false, so it continues the evaluation

hoping that the next argument will be true.

Here, good credit is true, so evaluation stops,

and the result of this entire expression will be true.

So in Python, logical operators are short circuit.

In this lecture, I'm going to show you how to chain comparison operators.

This is a very powerful technique for writing clean code.

Here is an example.

Let's say we want to implement a rule that says age should be between 18 and 65.

Here's how we can implement it.

So we define a variable like age set it to 22.

Now, if age is greater than or equal to 18,

and age is less than 65, then we print eligible.

Now, here's a question for you.

How do we write this rule in math?

We can write it like this.

Well, more accurately, we should have an equal sign here.

So age should be between 18 and 65.

This is how we write this rule in math.

Now, I've got some good news for you.

We can write the exact same expression in Python.

So I'm going to move this up, put an if statement here.

Line 4 and line 3 are exactly equivalent.

But as you can see, line 4 is cleaner and easier to read.

So let's get rid of line 3.

This is what we call chaining comparison operators.

Alright, here's a little quiz for you.

I want you to pause the video and think about this quiz for 10 to 20 seconds.

What do you think we'll see on the terminal when we run this program?

So pause the video, figure out the answer when you're ready.

Come back continue watching.

Alright, let's see what happens when we run this program.

First, we get this if statement.

In this case, we're comparing two different objects for equality.

And these objects have different types.

We have a number compared with this string.

So number 10 and string 10 are not equal.

That is why A will not be printed on the terminal.

So the control moves to the elephant part.

Here we have two Boolean expressions.

Here's the first one. Here's the second one.

And they are combined using the logical end.

So if both these expressions are evaluated to true,

then this entire expression will be true and we will see beyond the terminal.

Let's see if both these expressions are evaluated to true.

Here's the first part.

Back is greater than apple.

That is true because when we sort this word,

back comes after apple.

But look at the second part.

This expression is evaluated to false because back is not greater than cat.

So when we apply the logical end between true and false,

the result will be false.

That is why this statement will not be executed.

So to control moves to the else part.

And when we run this program,

the letter C will be printed on the terminal.

There are times that we may want to repeat a task a number of times.

For example, let's say we send a message to a user.

If the message cannot be delivered,

perhaps we want to retry three times.

Now for simplicity, let's imagine this print statement

is equivalent to sending a message.

In a real world program,

to send a message to a user,

we have to write five to ten lines of code.

Now if you want to retry three times,

we don't want to repeat all that code.

That is ugly.

That's when we use a loop.

We use loops to create repetition.

So here is how it works.

We start with four,

number in.

We have a built-in function called range.

Now how many times we want to repeat this task?

Let's say three times.

So we call range and pass three as an argument.

Now similar to our if statements,

we need to terminate this line with a colon.

Enter, we get indentation.

So in this block,

we can write all the statements that should be repeated three times.

Let's do a print a message like attempt.

Save the changes.

Run the program.

So we have attempt printed three times beautiful.

Now what is this number?

Let's take a look.

It's a variable of type integer.

So let's pass it as the second argument to the print function.

Number.

Run the program.

This is what we get.

012.

So here we have a four loop.

This four loop is executed three times.

In each iteration, number will have a different value.

Initially it will be zero.

In the second iteration it will be one.

And finally in the last iteration it will be two.

Now here we can do something fun.

We can add.

Want to this.

Run the program.

I now the messages that the print are kind of more meaningful or more user-friendly.

Like attempting number one, attempting number two and so on.

We can take this to the next level.

So we can pass another argument.

Here I'm going to add an expression.

One more time.

Number plus one.

So we'll get one to three.

Now I want to put this expression in parentheses.

So let's select this.

Put it in parentheses.

And then multiply it by a dot.

So here we have a string that is multiplied by a number.

The result will be that string repeated that number of times.

Let's take a look.

So run the program.

See?

That's pretty cool, isn't it?

Now let me show you one more thing before we finish this lecture.

As you saw, this range function generates numbers.

Starting from zero all the way up to this number here.

But it doesn't include this number.

Here we can pass another argument.

Say start from one and finish before four.

With this change, we don't need to add one to number every time.

Because in the first iteration, this number variable will be set to one.

So we can simplify our code and make it cleaner.

Let's run it one more time.

We get the exact same result.

We can also pass a third argument as a step.

So I'm going to change the second argument to 10 and pass two as a step.

Look at the result.

These are the numbers we get.

One, three, five and so on.

So pretty useful.

You're going to use this function a lot in real-world applications.

Continuing with the example from the last lecture.

Let's imagine the scenario where after the first attempt,

we can successfully send the message.

In that case, we want to jump out of this loop.

We don't want to repeat this task of sending a message three times.

Let me show you how to implement this.

So in this demo, I'm going to simulate the scenario where we can successfully send a message.

So we define a variable, successful, and set it to true.

Now here, after this print statement, we'll have an if statement.

If successful, colon, then perhaps we can print successful.

Now here we want to jump out of this loop.

For that, we use the break statement.

Let's try this program and see what happens.

So there you go.

After the first attempt, we're successful and there are no more attempts.

So once again, I want you to take great attention to the indentation here,

because that's one of the common issues amongst beginners.

So here's our four loop.

These two lines are indented with four spaces, and they belong to our four loop.

In every iteration, these two lines will be executed.

Now, when we get to line four, if this condition is true, then these two lines will be executed.

Because both these lines are indented below this if statement.

Now let's take this program to the next level.

What if we attempt three times?

I still cannot send an email.

Perhaps we want to display a different message to the user.

We say, hey, we try three times why it didn't work.

So I'm going to change successful to false.

Now, at the end, here we can add an L statement.

This is what we call a four L statement.

What we put under this L statement will only be executed if this loop completes without an early termination.

So if we never break out of this loop, then the L statement will be executed.

So here we can print a message like attempt at three times and failed.

So run the program.

See what we get?

Three attempts followed by this message attempt at three times and failed.

In contrast, if we change successful to true,

because we terminate this loop using this break statement, what we have in the L's block will not be executed.

Take a look.

Run the program.

We have one attempt successful done.

In programming, we have this concept called nested loops.

So we can put one loop inside of another loop.

And with this, we can get some interesting results.

Let me show you.

So I'm going to start with this loop for X in range five colon.

Now inside of this loop, I'm going to add another loop.

So for Y in range three colon.

And then in our second loop, I'm going to add a print statement.

Here we can use formatted strings to display coordinates.

Remember formatted strings, so we have F followed by quotes.

Now here we add parenthesis for our coordinates.

First, we want to display X and then comma followed by Y.

Let's run this program and see what happens.

There you go.

Pretty cool, isn't it?

So we get zero and zero, zero and one, zero and two.

Then we get one and zero, one and one, one and two and so on.

Now let me explain how exactly Python interpreter executes this code.

So here we have two loops.

This is what we call the outer loop and this is the inner loop.

So the execution of our program starts here.

In the first iteration of this loop, X is zero.

Now we get to this statement, which is a child of this four statement,

because it's indented four times.

This statement itself is a loop.

So what we have inside of this loop will be executed three times.

In the first iteration, X is zero because we are still in the first iteration of the outer loop.

And Y is also zero because we are in the first iteration of the inner loop.

That is why we get zero and zero.

Now we go to the second iteration of this inner loop.

In this iteration, Y will be one, whereas X is still zero.

That is why we get zero and one.

And similar in the third iteration of our inner loop will get zero and two in the terminal.

Now we are done with the execution of the inner loop.

So the control moves back to our outer loop.

Here we will be in the second iteration.

So X will be one.

And then we start here again.

So we have to execute this inner loop three times.

In the first iteration, Y will be zero, and X is one.

So here we have one and zero.

Then we will get one and one and one and two, you got the point.

So this is all about nested loops.

So you have learned how to use four loops to repeat one or more statements in your programs.

Now let's dive deeper and see what this range function returns.

So earlier you learn about the built-in type function.

With this function we can get the type of an object.

So if I pass five here and run this program, this is what we get.

So the type of this number or this object is int or integer.

Now let's look at the type of the value that we get from the range function.

So as an argument we pass, range of a number.

Let's run this program.

So this range function returns an object of type range.

So in Python we have primitive types like numbers, strings, and Boolean,

but we also have complex types.

Grange is an example of one of those complex types.

Throughout this course, we're going to learn about a lot of other complex types.

Now what is interesting about this range object is that it's iterable,

which means we can iterate over it or use it in a four loop.

That is why we can write code like this.

So this range function returns a range object which is iterable,

which means we can iterate over it.

In each iteration, X will have a different value.

Now range objects are not the only iterable objects in Python.

The strings are also iterable.

So here we can add a string like Python.

Now in each iteration, X will hold one character in this string.

Let me show you the print x.

And I'm going to delete these two lines here.

Let's run this program.

So in each iteration we'll get one character and print it.

We have another complex type called list, which we use to store a list of objects.

So we add square brackets, this indicates a list.

Now we can add a list of numbers or a list of strings, like a list of names.

You will learn about lists later in the course.

So let's run this one more time.

As we can see, we can iterate over lists.

In each iteration, we'll get one object in this list.

Now later in the course, I will show you how to create your own custom objects that are iterable.

For example, you will learn how to write code like this.

For item in shopping, cart, print, item.

So shopping cart is going to be a custom object that you will create.

It's not going to be an integer or string or Boolean.

It's a custom object.

It has a different structure.

You'll make it iterable so we can use it in a for loop and in each iteration, we can get one item in the shopping cart and print it on a terminal.

So you have learned that we use for loops to iterate over itrable objects.

In Python, we have another kind of loop that is a while loop.

And we use that to repeat something as long as a condition is true.

Here is an example.

So let's define a variable number and set it to a hundred.

Now we use while and here we add a condition.

As long as number is greater than zero, we add a colon.

Once again, we have a notation so we can repeat one or more statements.

We can print this number and then we can divide it by half.

So number equals number.

Use the integer division to divide it by two.

Or we can use the augmented assignment operator to shorten this code.

Like this.

Now let's run this program.

So here is what we get.

Initially our number is a hundred.

We divide it by half.

We get 50.

Then 25.

And so on.

So as you can see, in this example, we are not iterating over an iterable,

like a range object or a string or a list.

We are evaluating a condition and repeating a task.

Let me show you a real word example of a while loop.

In this interactive shell, Python is waiting for an input.

We can type something like 2 plus 2.

It will evaluate it and ask for the next input.

We can add another expression like 10 is greater than 2.

So these steps will continue until we press control D.

So behind the scene, we have a while loop that continues execution until we press control D.

That is the condition that causes the while loop to terminate.

Let me show you how to build something like this in Python.

So let's define a variable.

Command and set it to an empty string.

Now here we need a while loop.

We want this while loop to execute as long as command does not equal to quit.

So command does not equal to quit.

Column.

In this loop, we want to continuously get input from the user.

So we use the built-in input function.

We add a label like this.

Get the result and store it in the command variable.

This point Python interactive shell will evaluate this command.

We are not going to do that in this lecture because that's way too complex.

For simplicity, we can just echo back what the user entered.

So print, echo and as the second argument, we pass this command.

So this is our while loop.

It will execute until we type quit.

Now as I told you before, don't run this program using the code runner extension.

Because by default, it will run your program in the output window, which is read only.

So open up the terminal using control and backtake.

And run Python or Python 3 and that pie.

So here's our command prompt.

Let's type 2 plus 2.

It echoes back.

Let's type 3 times 2.

There you go.

If we type quit, our program terminates.

Now let's try it one more time.

What if we type quit and uppercase?

The program doesn't terminate.

Because as you learn before, lowercase and uppercase characters have different numeric representations.

So quit in lowercase is different from quit and uppercase.

Now to solve this problem, an amateur programmer may do something like this.

And command does not equal to capital quit.

So while command does not equal quit in lowercase and quit in uppercase,

continue getting input from the user.

Let's run this program in terminal and see what happens.

So one more time, Python after pie.

We type quit, beautiful, it works.

We type quit in uppercase that would work too.

But what if I type quit with an uppercase queue and lowercase UIT?

Our program doesn't terminate.

So this is a poor way of checking for the quit command.

What is the better way? Let me show you.

So we don't need this and operator here.

Instead, because command is a string, we can call the lower method.

So whatever the user types in, first will convert it to lowercase

and then compare it with quit in lowercase.

With this change, it doesn't matter how the user types the word quit.

We'll always terminate the program.

Now the last thing I want to discuss in this section is the concept of infinite loops.

An infinite loop is a loop that runs forever.

So if I change this condition to true,

because true is always true, this while loop will run forever.

So to jump out of this, we need a break statement.

So after we get the input from the user,

we can get the command, convert it to lowercase

and see if it equals to quit.

If that's the case, we want to break.

Now with this change, we no longer need to initialize command

to an empty string.

Previously, we needed this because we had a wild statement like this.

While command does not equal quit,

so we had to define this command variable,

and that's why we have set it to an empty string.

Without the line, when Python interpreter tries to execute this code,

it doesn't know what command is.

So now that we have an infinite loop,

we no longer need to define command and set it to an empty string.

So in terms of functionality, this program is exactly the same as the program we wrote in the last lecture.

Just be aware of this infinite loops,

because they run forever, you should always have a way to jump out of them,

otherwise your program will run forever.

And this can sometimes cause issues,

because if you're executing operations that consume memory,

at some point your program may run out of memory and crash.

All right, time for an exercise.

I want you to write a program to display the even numbers between 1 to 10.

So when you run this program, we should see 2, 4, 6 and 8.

And after these, I want you to print this message.

We have four even numbers.

Now here's a quick hint before you get started.

You should call the range function with 1 and 10.

Do not use the third argument, which is called step.

So basically, I want you to iterate over all the numbers between 1 to 10,

check if each number is an even number and then printed on the terminal.

So pause the video, spend 2 minutes on this exercise when you're done,

come back, continue watching.

So we started with a four loop for number in range 1 to 10,

colon.

We check to see if the remainder of division of this number by 2 equals 0.

So if number module is 2 equals 0, then,

reprint this number.

Now let's run this program.

So we get 2, 4, 6, 8, beautiful.

Now to count the even numbers, we need a separate variable.

So let's call that count.

Initially, we set it to 0.

Now in this if block, every time we find an even number,

we need to increment count.

So we set count plus equals 1.

And finally, after our four loop, we can print a formatted string.

We have count even numbers.

Let's run the program and here's the result.

So that brings us to the end of this section.

In the next section, you're going to learn how to create your own functions.

I hope you enjoyed this section and thank you for watching.

So far, you have learned how to use some of the built-in functions in Python,

such as print, round, and so on.

In this section, you're going to learn how to write your own functions.

Now you might ask, but why do we even need to write our own functions?

Well, when you build a real program, that program is going to consist

hundreds or thousands of lines of code.

You shouldn't write all that code in one file like we have done so far.

You should break that code into smaller, more maintainable,

and potentially more reusable chunks.

You refer to this chunks as functions.

So let me show you how to create your own custom functions.

We start with the Deaf keyword, which is short for define.

Next, we need to give our function a name.

So let's call this grid.

All the best practices you learn about naming your variables,

also apply to naming your functions.

So make sure your function names are meaningful, descriptive,

use lowercase letters to name your functions,

and an underscore to separate multiple words.

Now, after the name we need to add parentheses,

you will see why shortly, and then we'll add a colon.

Now, what is going to happen?

You know it.

We're going to get indentation, which means the following statements

will belong to this function.

So here, I'm going to add two statements.

Hi there, and welcome aboard.

Both designs belong to this function because they're indented.

Now, we are done with this function.

We need to call it.

So, we remove the indentation,

and we add two line breaks after this function.

This is what Pep8 recommends to keep our code clean and maintainable.

Now, if you forget to add two line breaks, don't worry.

As soon as you save the changes,

Auto Pep8 will automatically add these line breaks for you.

Let me show you.

So I'm going to remove these line breaks,

and call this function, create with parentheses.

Just like how we call the built-in functions.

Now, save the changes.

There you go.

So, we get two line breaks after our function.

Now, let's run this program.

So, we get these two messages on the terminal.

Now, here's a question for you.

What is the difference between the grid and print functions?

The difference is that this print function

takes an input, whereas our grid function doesn't take any inputs.

So, let me show you how to pass inputs like first name

and last name to this function.

When defining a function, in between parentheses

will list our parameters.

So, here we add two parameters like first,

on the line name, and last on the line name.

Now, with calling this function,

we need to supply two values for those parameters.

We refer to them as arguments.

So, mash, hamadani.

These are the arguments to the grid function.

That's one of the terms that a lot of developers

out there don't know.

They don't know the difference between parameters and arguments.

A parameter is the input that you define for your function,

whereas an argument is the actual value for a given parameter.

Now, let's change line two,

and instead of saying hi there,

we can greet a person by their full name.

So, we can convert this to a formatted string,

and pass two fields here.

First name as well as last name.

Save the changes, run the program,

and this is what we get in terminal.

Now, this function is more useful.

We can reuse it and call it with different arguments.

So, let's greet John Smith as well.

Run the program.

So, we get hi, mash, hamadani, and hi, John Smith.

Now, note that by default,

all the parameters that you define for a function are required.

So, here our grid function takes two parameters.

If I exclude one of these arguments and save the changes,

we can see we have this red underline.

So, pilot is complaining,

and saying there is no value for argument last name.

Also, if we run the program,

we get this type error,

greet missing one required positional argument.

So, let's put this back.

Now, later, I will show you how to define optional parameters.

So, this is the simplified version of this grid function

we created earlier.

Now, in programming, we have two types of functions.

Functions that perform a task

and functions that calculate and return a value.

Here are some examples.

Both the print and grid functions are examples of type 1.

The performing task, which is printing something on the terminal.

In contrast, the brown function is an example of a function

that calculates and returns a value.

So, the functions that you create fall into these two categories.

Now, let me show you how to rewrite this grid function,

but in the second form.

So, instead of printing this string on the terminal,

we simply return it.

Let me show you.

So, I'm going to delete all this code,

define a new function,

but call it get underlying greeting.

We add the name parameter,

simply return this form at a string high name.

Let's all we have to do.

So, we use the return statement to return a value from this function.

Now, we can call this function,

get underlying greeting, pass a name,

like mosh,

because it returns a value, we can store that value

and separate variable like message.

Now, you might be curious,

which form of this greeting function is better.

Well, with this first implementation,

we are locked to printing something in the terminal.

In the future, if you want to write that message in a file

or send it in an email,

we have to create another function.

So, we cannot reuse this grid function in other scenarios.

In contrast,

this second form is not tied to printing something on the terminal.

It simply returns a value.

Now, we get this value,

and we can do whatever we want with it.

We can print it on the terminal,

or we can use the built-in open function

to write this message to a file.

So, we can create a file like content.txt,

open it for writing.

This returns a file object,

and then we can call file.write message.

Now, don't worry about these two lines.

Later in the course, I'm going to talk about working with files.

But what I want you to take away here

is that we have this message variable,

and we can do whatever we want with it.

We can print it on the terminal, write it to a file,

send it in an email and so on.

And one more thing before we finish this lecture.

So, here's our grid function,

and as you can see, we're simply printing a string.

Now, if we call,

create, give it a name,

run the program,

we get this message,

hi-mosh.

But what if we put this inside of a call

to the print function?

Let's see what we get.

We get hi-mosh,

followed by none.

What is this?

None is the return value of the grid function.

So, in Python,

all functions by default,

return the non-value,

none is an object that represents

the absence of a value.

Later in the course, you're going to learn more about none.

What matters now is that all functions

return none by default,

unless you specifically return a value.

So, here, if we return some string,

none will no longer be returned.

Now, I just want to clarify something.

Earlier, I told you that we have two types

of functions in programming,

functions that carry out a task,

or functions that calculate and return a value.

So, back to the code we previously had,

so even though this function returns

non-by default,

it is still classified as a function

that carries out a task.

Let's create another function.

We call it increment.

We want to use this function

to increment a number by a given value.

So, here, we simply return number plus by.

Now, we can call this function like this,

increment two and one.

This returns a value, so we can store it

in a variable, like result,

and then print it on the terminal.

Let's run the program.

We get three.

Beautiful.

Now, we can simplify this code.

We have used this result variable

only in a single place.

That is line six.

So, we don't really need it.

So, on line six,

we can replace result with a call

to increment function.

Like this.

So, when Python interpreter executes this code,

first it will call the increment function,

it will get the result,

and temporary stored in a variable for us.

We don't see that variable.

And then it will pass that variable

as an argument to the print function.

Now, if we run this program,

we get the exact same result.

Beautiful.

Now, we can make this code more readable.

If someone else looks at line five,

they may not know exactly what these arguments are for.

We can use a keyword argument to make this code more readable.

So, this one here is the value of this by parameter.

We can prefix it with a name of the parameter like this.

Now, we can read this code almost like plain English.

So, if you're calling a function with multiple arguments,

and it's not quite clear what these arguments are for,

you can make your code more readable by using keyword arguments.

So, here, by equals one is a keyword argument.

Earlier, I told you that all the parameters that you define for a function

are required by default.

In this lecture, I'm going to show you

how to make the by parameter optional.

So, let's say we don't want to explicitly pass by equals one every time

we want to call this increment function.

We want to use this function to increment a value by one.

So, we remove the second argument.

Now, we need to give this parameter a default value.

So, we set it to one.

Now, if we call this function,

and don't supply the second argument,

this default value will be used.

Otherwise, the value that we specify here will be used.

Let me show you.