This video teaches you programming

thinking.

People say you don't need to write code

anymore. You have AI.

I actually agree with that. But if

somebody say you don't need programming

thinking because of AI, I couldn't

disagree more. To say programming

thinking doesn't matter is like saying

basic knowledge and common sense don't

matter. We still went to school to learn

the fundamental of math, science,

economics because it helps us to think

and ask better question.

In the age of agentic engineering or

vibe coding, programming thinking is a

new common sense that help you to

maximize your use of AI. It's no

surprise to see the value created by

pure vibe coder just plateaus over time.

Whereas it's a people with programming

thinking can harness the true potential

of AI and create impactful project.

Throughout this video, we use a Python

language to learn about programming

thinking.

Starting from variable,

control statement, Python list, for

loop, loop with range, nested loop,

function,

value versus reference, dictionary,

and recursion.

Your attention is all I need. If you

invest your next 60 minutes in the

video, you'll transcend from a pure vibe

coder to the enlightened programming

thinker.

The first time when we saw equal sign,

it probably dates back in grade school.

1 + 1 = 2. The equal sign here feels

like a noun because it is statically

describing a math expression. And this

interpretation is buried deep within our

subconscious. Yet, in programming, the

equal sign means a complete different

thing. It's a verb. It's action which

you perform as a programmer. Using the

equal sign, we store a data into a

variable.

For example, hey, the variable whose

name is A, now you store the number

five. And if we print A, it's going to

print five. And we can use a variable A

as you were directly using a number

itself. So, A + 1 is basically 5 + 1, so

forth, A * 3, A to the power of 2.

We can also store a string to variable.

The variable whose name is B, now stores

a string Bob. If we print B, it prints

Bob. So, hello plus B is hello Bob. And

likewise, my name is plus B, B plus B

plus B.

Question. So, the variable thingy you

said here, what kind of data type? Is it

a number or is it a string?

Well, neither. The best way to think

about the nature of a variable is that

it is something that can store any data

type, but itself is not intrinsically a

data type. So, I know sometimes a

variable really looks like a string, but

it's not because it does not have the

quotes. For example, this is a variable

and the name of this variable is season.

But this season here is a string.

After you store a data to a variable,

which is action we call assignment

statement, you can use a variable later

as you were directly using a data stored

within.

Just knowing this fact, variable is

already a powerful tool. Potato was

using Python to calculate the surface

area and volume of a sphere. But now,

suppose the radius of a sphere is no

longer eight, but seven. He needs to

manually update all occurrences of eight

into the number seven and execute this

code again.

That's really not so efficient, right?

The more clever move here is to use a

variable. So, we first create a variable

on top. The variable's name is R. It

stores the number seven. And in our

formula, rather than multiplying with a

specific radius, we'll multiply that

with variable R, which we know now it is

seven.

And execute again. Great, this works.

From now, potato can just easily modify

the variable on top and you'll just

compute the answers for that particular

radius R.

At this point, some of you are like,

"Come on, potato. Don't be lazy. You are

only manually changing the number three

times. You don't need variables in your

life." But our potato could be more

ambitious. He's also interesting using

Python to compute the surface area and

volume of all the Platonic solid in this

world of the same edge length. They are

tetrahedron,

hexahedron,

octahedron, dodecahedron, icosahedron.

All the different type of hedron have

different formulas for surface area and

volume. But with the use of variable,

one modification here, every line of

computation below changes accordingly.

However, if you do want to replace all

occurrences of edge length manually,

it's very tiring. You get my point.

Let me interject with a few words about

terminology. With such an assignment

statement, variable A stores the number

five. Another 100% equivalent statement

is to say the value of A is five. I just

want to let you know that the two

description here means the exact same

thing. I would also use them

interchangeably.

Cool. Variables can store data. Variable

has value. Why don't we just call them

data container or value with a name?

Because a variable can store different

data throughout the execution of the

program. After your initial assignment

statement, you can change it again and

again. It can store the data of whatever

you want and changes whenever you want.

As a matter of fact, understanding how a

variable changes is a critical part of

programming. Hence, we need to be solid

on this topic.

So, I'm going to ask you to do the

following six quizzes.

I know your reaction. Wait a second. I'm

here to learn about Python variables.

Why are you already testing me?

Although this feel a little unfair at

the moment, I actually think it's a very

good idea to have you using your own

intuition to speculate how variable

behaves in Python and see where your

expectation misalign with outcome. This

is actually much better way of learning

and retain information.

Somewhere along the middle, you might

feel things start to get pretty boring,

but the mastery of variable is very

important. So, please stay with me

through the end.

I'll remind you one important fact.

Python program executes from top to the

bottom line by line.

Let's begin with a warm-up question

first. You can pause the video and

contemplate on what would this Python

program print out at the end.

Okay.

Hopefully, you have got your answer.

As the program executes from the top to

the bottom, the variables A, B, C, D

each stores its respective data.

On line number five, we have a string

concatenation, which begins with

variable A. We know that A is a string

Bob adding with has earned the string of

B * C * D, which is 5 * 8 * 20, 800, and

join again with this week. So, the final

output is Bob has earned $800 this week.

Quiz number one. You can go ahead to

pause and ponder on this Python program.

The answer here is pretty

straightforward. The variable is

initially assigned with a string that

says water

and then reassigned to the result of 2 +

1, which is 3, reassigned again to the

string fish, and then reassigned to the

number 500. But, what's the lesson here?

It is that a Python variable can change

between data types. The variable called

thing is initially storing a string, but

later it stores a number. Although this

may seem somewhat trivial at the moment,

yet in many other programming language

like C or Java, once a variable is

initially created to store number, it

can never be used to store a string

later on. Therefore, Python variable is

very flexible.

Number two.

The variable A stores seven, but in the

second line we create a variable B and

assign variable A to it. This is the

first time that a variable appears on

the right-hand side of the equal sign.

So, what exactly happens here? What does

B store?

The answer is B is going to store

whatever A stores.

A very common misunderstanding is that

people tend to have this mental image,

in which case we believe variable B is

storing the symbol of A, rather than the

value of A. That's incorrect.

When any variable is on the right-hand

side of the equal sign, we just treat it

as its value. Variable B stores the

value of A.

In line number four, variable B is

assigned as A plus 100. Since A is on

the right side of the equal sign, we

treat variable A as if we're treating

its value directly, which at the moment

the value is seven. So, B is a

reassigned as seven plus 100, 107.

In line six, C is assigned with B. So, C

is going to store the value of B.

In line number seven, D is assigned with

C. So, D also store 107.

So, the lesson here is all about

assignment of one variable by another

variable.

Number three.

Line one, variable n stores number 10.

Line two, the variable n appears on both

side of the expression, n equal to n

plus one. To be honest, this is

something strange to even look at. Then,

what's going on here?

Remember our principle that whenever a

variable appears on the right-hand side

of the equal sign, we treat it as if

we're directly treating its value. At

this point, n is 10. So, line number two

is basically saying n equal to 10 plus

one.

Line four, the variable n once again

appears on both sides of the expression.

But, we know we just need to treat it as

its value. At this moment, n is 11. So,

this line is saying n equal to 11 plus

one.

In line number six, n equal to n times

two, which is saying n equals to 12

times two. So, n is 24 now.

Whenever I see an assignment statement

looking like this, my brain

automatically translate this to plus one

to whatever its current value is.

And you might also see another way which

we can write this, and that is n plus

equal one. And those two statement you

see here, they are the exact same thing.

It's just a matter of personal

preference to choose either one of them

to use. So, the lesson of quiz three is

that a variable can update itself based

on its current value.

Number four.

The goal here is to once again test your

understanding of variable assignment. A

common misunderstanding would sound like

this.

In line number two, variable k is

storing the variable f. Therefore, if I

change k to zero, that means f is also

changed to zero.

But, that is incorrect.

I know that you know in line number two,

k equal to f is saying k stores a value

of f, which is 3,000. In line number

three, we change the value of k to zero.

But, that really had no business to do

with the original variable f. So, later

again, if we print F, it's still going

to be 3,000.

Number five.

So, what is the problem with this code

here?

Line number one and two executes

normally.

In line number three, we set area equals

to pi times radius squared.

What is the value of variable pi?

Oh, it's 3.14. It said that on the next

line.

But, remember Python program executes

from top to the bottom line by line. So,

at precisely the timing of line three's

execution, our computer has no idea the

value of pi.

So, there is actually going to be a

error. The lesson here, always define a

variable before using it.

Number six.

The last one we have here is a classic,

swapping two variables value. But, did

this code actually swap though? Nope.

The end goal here, after swapping, we

should see A is 99 and B is one. In line

four, A is assigned with value of B,

which is 99. So, the value of A is 99

now. In the following line, B is

assigned with value of A, which is also

99.

So, in the end, the value of the two

variables did not swap. They just both

became the value of B.

What code can we add so that in the end,

their values actually swap?

Perhaps you remember, after line number

four, when we reassign A with the value

of B,

the original data which A hold, the

number of one, is completely lost in the

environment of this program. Which

means, to fix this problem, we actually

need to create an additional variable

here, a variable called original A to

store A's original value

before A changes.

And later, rather than assigning B with

A, we assign B with a value of original

A.

And indeed, they're swapped. The lesson

here, when we want to swap two variables

in this manner, we need to be cautious

and we need to create an additional

variable for help.

Although I presented them as six small

quizzes, they in fact were six mini

lessons to go over the fundamental of

Python variable and assignment statement

while having you to use your own

intuition to speculate its behavior.

Did I spend too much time on the

details?

Absolutely not. Variable is such an

important concept. Many years down the

road, after you have written 1,000 lines

of code, you will have an unceremonious

realization that

wait, is programming just the art of

creating and updating variables?

And alas, let's finish with two remarks

about variable naming.

When coding, we really have freedom in

naming the variable we create. Yet, the

number one rule to follow is that

variable names should be meaningful.

Remember our warm-up question here? It

would make much more sense if I had to

use a more explicit variable naming.

See how the one down here feels like

this program is telling you exactly what

it is doing and it flows like an article

with high readability.

However, there is a few restriction on

variable naming. One is that we cannot

have any empty space within the

variable's name.

To fix that, we just replace the empty

space with an underscore symbol.

Another one is the first character of a

variable cannot be an integer, but we

could put integer anywhere afterwards.

At the moment, everything doesn't need

to be perfect. We're all beginners here.

If we make a mistake, the clever Python

interpreter is going to tell us where

the mistake happens.

We just need to go and fix it.

Today, we are going to learn about if,

else, and Boolean values. With their

help, our program gains ability to make

decisions, obtaining intelligence in

some way. As human, we really make

decision in a very subjective way, and

often times, we couldn't even precisely

explain our decision. We make decision

based on our mood, how tired we feel,

how hungry we feel, our friend's opinion

on certain matter.

Unlike humans, computer programs make

decision in the most objective way. It

evaluates the current condition. Is it

true?

Or is it false?

And nothing else. We call those two the

Boolean values.

You might wonder, Boolean, what a weird

name. So, they're actually named after a

famous logician, George Boole, who

believes true and false are the only two

values that's sufficient to describe all

the logic in this world.

The Boolean value is a new data type,

which can be stored by a variable.

If I print A, it prints true.

If I print B, it prints false.

Notice, true, false, they're both

capitalize.

Combined with if else, the Boolean

allows our program to make decision. I

think a demo is the best way to explain

this.

The behavior here is pretty

straightforward. Python still executes

from top to bottom.

In line number four, the if statement is

checking whether happy mood is true. And

now, it is.

When the if condition is true, our

program would execute the indented code

block under the if statement,

and will deactivate or completely ignore

the indented code block under else.

>> On the other hand, suppose happy mood is

false.

The if statement is facing a false

condition, and therefore, it would

deactivate the following indented code

block and go ahead to execute the else

part.

In short, using if else, our program can

take different actions based on

different conditions.

In the demo we just saw, there were a

piece of syntax we never seen.

Whenever we use if statement to check

for a condition, this line must

terminate with a colon, and the

following line must be indented.

Together, they're pretty much saying,

"This indented code block only belongs

to the statement here."

The indentation is a must, and there are

two ways you can do it. You can either

indent with one tap

or you can indent with four spaces.

Tap versus space, just who cares?

Surprisingly, many, many people. There

have been a long bloody war among the

programming community fighting over

which method is superior to indent your

code.

Linus Torvalds and Chris Latner are

perhaps two of humanity's most important

software engineer. One uses tap, the

other uses spaces. Personally, I'm

really in no position to imply which one

is better, so you pick your side from

here.

The values true, false, are two

intrinsic Boolean values,

but we can also have expressions that is

equivalent to true

or equivalent to false.

For example, the value of K is 1. K + 1

less than 5. This expression is

obviously correct.

If I print this, it actually prints

true.

If I change expression to K + 1 greater

than 5, then it prints false.

Those two symbols are what we call the

comparison operator because they

literally compare the left and

right-hand side, and the result is

comparison is always a Boolean value.

There are a few more of them.

We use this one to check for less than

or equal to.

This one for greater than or equal to.

The double equal sign to check for

equality.

The exclamation equal to check for

inequality.

1 + 1 is equal to 2. This expression is

true.

1 + 1 is equal to 3. This expression is

false.

The string of three is equal to the

number three.

False. And therefore, it is true to say

they are not equal.

The value of A is a string that says

protein.

If A is equal to the string fat, then we

print they're equal.

Else, we print not equal.

You might wonder, it's pretty weird to

write two equal sign next to each other.

Why can't we just use the one equal sign

to check for equality?

Remember, we have already reserved the

single equal sign exclusively for

variable assignment. Therefore, we must

use something different for actually

checking equality.

In the video game The Legend of Zelda,

the currency is called rupee.

Suppose our main character has

absolutely no money now. So, we set the

variable money to zero.

But, he finds a chest box. If the item

in the box is actually a green rupee,

which has a value of one in this

currency system,

our character has money now, and we

increase his money by one.

But, oftentimes the item is something

else, such as food,

weapon, minerals.

In those cases, the main character need

to sell the item in exchange for rupee.

Perfect. This code uses if else to

express the logic we have.

If I change the item to sword, then our

character has zero money.

Mhm, there is one issue. In this game,

there are also rupees of other colors, a

red rupee worth 20,

or if you get super lucky, there is the

gold rupee, which worth 300.

So, suppose you are the game developer,

how do you change this program to

include more conditions?

One easy way is to use the elif

statement, which stands for else if.

You can think of elif as an additional

checking of condition in between if and

else.

In our case, if the item is not a green

rupee, rather than directly skipping to

the else part, we can use the elif to

check if the item is a red rupee.

And after that, another elif to check if

the item is a gold rupee.

In summary, the elif statement give us

more condition to evaluate in the

process of decision-making.

In this game, we can also eat things to

restore health.

But, whenever we're trying to eat

things, the gaming system is first going

to check if the thing is actually

edible.

So, please take a moment to consider

this code right here.

As ST meat skewer is edible.

An ancient gear is not.

So a simple if else will check for this

logic.

But actually even if our item is edible,

it doesn't mean we can consume it right

now. There is one more condition to be

met, which is our character cannot be

full health.

If the character's maximum health is

four, then his current health must be

less than four in order to eat food.

So how can we encode this logic into our

program?

Our attempt is to add another pair of if

else within the first if condition.

So notice this line is actually indented

twice.

You can think of this logic here is

saying something like this.

If the item is edible, then it still

needs to go through this entire

evaluation procedure again.

If our food is not edible, then it just

skip to the else part.

Wait. Line seven, the condition here is

clearly true. Our current health is 2.5

and the maximum health is four. So why

is line number eight not executing?

Very good question. The key property of

if statement inside another if statement

is that whenever you want to check for

an inner condition, the outer condition

must be true first. If the outer

condition is false, it doesn't matter

how true the inside is because the

program will just never go in there.

So if I change the food back to zesty

meat skewer, then the character can eat

it.

But if I change the current health to

four, then he cannot.

Whenever we have if inside another if,

this is called a nested if statement.

Honestly, when I first learned a Python,

nested structure was pretty hard for me

to comprehend. The only way out is

just doing some coding exercise.

And I'll take a moment here to compare

and contrast between elif versus nested

if.

Initially today, the only thing we know

about is if else.

The use of elif is much like adding a

new path in between them.

When the condition for if is false, elif

give another condition to evaluate

before jumping straight to the path of

else.

The use of nested if is much more like

extending an additional path from the

existing one.

Suppose we want to get here, the only

way is for the outer condition to be

true.

And after that, the inner condition is

also true.

Often times, certain action can only be

taken if two conditions are true at the

same time. In the game, even a simple

action such as shooting an arrow

requires two conditions to be true.

One, we need to have a bow. Two, we need

to have at least one arrow.

This is where logical operators comes in

handy. The logical operator and allows

us to create a Boolean expression that

is only true when both condition on each

side are true.

If either condition is false, then the

overall expression evaluates to false.

This expression would evaluate to false.

Four is equal to four. True.

Zero is greater than zero. False.

True and false would evaluate to false.

Therefore, we can use the and operator

to encode our logic for shooting arrow.

If has bow is true and arrow counts is

greater than zero, then we shoot arrow.

Else, we cannot.

Changing the variable has bow to false,

the program outputs cannot shoot arrow."

If we're really being serious, we should

also decrease the main character's arrow

counts by one because he just shot it.

In contrast to and, there is the or

logical operator. The or creates a

Boolean expression that evaluates to

true as long as either one condition is

true.

One way to compare them is that and is

very strict. Both conditions need to be

true for the expression to be true. Or

is kind of soft. As long as one

condition is true, it is true overall

and it doesn't care which one is true.

When our character explores cold area,

he actually lose health points for being

physically exposing low temperature.

But, as long as he's either wearing warm

clothes

or he ate spicy food. Apparently, in the

game, eating spicy food give you cold

resistance. He no longer takes damage

from the cold weather.

This is a good application for the or

logical operator. If has a warm cloth or

ate spicy food, the character is staying

warm. Else, he's taking damage from the

cold weather.

You might hear the term short-circuiting

when people describe the evaluation for

chain of condition in Python.

It's natural to suspect how does

Python's logical operator and or ever

relate to a physical circuit? Although

the next part of the video does not help

with your understanding of Python, but

is pretty cool. So, I got to show you

their connection.

To begin with, suppose we have a Boolean

value true.

We can represent this as a closed gate

where electrons flows through.

If the Boolean is false, then it will be

seen as an open gate where electrons

doesn't get to flow through.

Now, here is a cool thing. Suppose we

have two Booleans, we AND them together.

This is essentially putting the two

gates in series. The only way the

electrons can flow through is for both

gates to be closed. If either one gate

is open, the electron gets stuck in the

middle, which corresponds to the

expression evaluating to false.

On the other hand, if we OR the two

Booleans, it's like putting the two

gates in parallel. As long as one gate

is closed, doesn't matter which one,

electrons can flow through the end. When

both gates are open, that's when the

expression is false.

When we have a long chain of AND

condition together, it is essentially a

chain of gates in series.

If one gate is open, electrons cannot

flow through.

When we have a long chain of OR

conditions, the gates are parallel

together. As long as one of them is

closed, the electrons will be able to

flow through.

The lesson today was a lot of

information. I'll give a quick summary.

We first learn about the Boolean values,

the if else statement. At this point,

our program already has ability to make

simple decisions.

And then, there were the comparison

operators, logical operators, which

allows us to create Boolean expression

that ultimately evaluates to true or

evaluates to false.

With the help of elif and nested if, our

program can behave properly when there

are multiple conditions or there's

dependency between conditions.

Using all of them combined, we can

pretty much describe any software design

logic, and George Boole will be proud of

you.

Python list is a very powerful data

type. A list is like a chest box of

data. You can store any numbers of data

in there and retrieve them later

whenever you want.

But I know you behind the screen is

clearly someone clever. If I just read

over the documentation word by word,

it's boring. So instead, let's begin by

telling a story about the history of

poker suits using Python list.

Way back in the 14th century, the suits

of the playing cards in Spain were

nothing but familiar. The four suits

were cups, coins, clubs, swords.

The suits, which you and me are familiar

with, hearts and diamond, were not in

there.

Yet, it was true that clubs wasn't

there.

People decided to make things more

interesting by introducing an additional

suit, which is called shields.

And there were five different suits in a

deck.

Many decades later, the Germans decided

to build their own deck by starting from

scratch.

They added the suits hearts, bells,

acorns, and leaves.

And those four suits gained immense

popularity in Europe, but of course, not

as popular as its successor. The French

suits drew inspiration from the German

suits. They kept the hearts, but removed

the bells.

They replaced acorn with clubs and

replaced leaves with spades.

And finally, they added in the diamonds.

Hearts, clubs, spades, diamonds. They

survived all the way to the 21st

century.

All right, that was a lot of

informations. Let's take a moment to

dissect on what just happened. To create

a Python list, we use a square bracket

on a keyboard. If you ever wonder what

those weird-looking brackets are for.

They're used by programmers.

Normally, we create an empty list

without any data in there.

We can also create a list with some

initial data. We will use the comma to

separate them, distinguishing data from

datas.

Sometimes, people use the word element

referring to a particular data in a

list. I'll use those two terms

interchangeably in this video, too.

Here, you definitely notice something

strange. The variable my list does not

store the entire list, which is what

everyone expected. But, rather, it is

storing an arrow which reference to the

actual list. Why? Strange, indeed.

In later chapter called value versus

reference, we'll have a much more

in-depth conversation about this and

understand why it's really important.

For now, it's good to have this mental

image. Variables such as number, string,

boolean, the actual data is stored.

But, a list variable only stores a

reference to the actual list.

After creating list, much of your

programming interaction with Python list

stems from these four primary

operations.

Access,

modify,

add,

remove an element from the list.

Zero and foremost, when we want to

access an element from a list, we must

know its index. For example, suppose I

want to get a first element, assign it

to the variable called item. We use the

name of the list,

square bracket, index zero.

Yep, what you see is correct. To get the

first element, we don't use number one,

we use the number zero. We call this

behavior zero indexing. This is pretty

important to emphasize again. The human

understanding of first actually

translates to index zero in Python.

You cannot imagine the number of human

intelligence hours that had been wasted

on this bug. Somewhere inside a massive

software, a programmer is trying to

access the first element, but the index

one is used instead of zero, causing the

entire program to behave incorrectly.

Now, here's a question for you. Suppose

I want to get a third element of a list,

which index would you use?

Index two.

So, the pattern is whenever you want to

access the nth element, the index used

is n minus one.

The action of modifying a particular

element feels almost identical to

modifying a variable.

We can modify any variable simply by

reassigning it to something else.

In the element case, we just reassign

the list index to something else. The

first element of crypto list is Bitcoin,

and I want to change the first element

to Litecoin.

I just write crypto list index zero

equal the string Litecoin.

A variable can update from its existing

value.

So can an element inside a Python list.

This code here updates the third

element, which is index two, by

multiplying 1.2 with its existing value.

Suppose I want to modify the element

Bitcoin to Litecoin. Does this code

snippet here do the job for me?

It looks like it does, but it doesn't.

The only thing we did here was to change

the variable coin.

The element of index zero was never

changed.

A pretty easy place to make mistake if

we're not careful.

When we want to add a new element to a

list, we use the append method.

Pretty straightforward. The string Kyoto

is now added to the end.

Wait, this is a new syntax we never

seen. What is a dot doing in the middle?

So, this is called a method. In later

chapter, we will formally define what a

method is.

This syntax is pretty much just saying,

after the dot symbol, we're doing some

action, and whatever the action is is

directly related to the item here.

One thing notable to mention, when we

append a variable to a list, we're

appending its value rather than a

symbol. The variable place stores a

string Kyoto. If we append place to

travel list, the string of Kyoto is

added to the end.

However, if this is your mental image,

you'll be incorrect.

So, yeah. If this feels like déjà vu,

it's because we really emphasized this

concept back in chapter two.

When we want to remove element, we use

the pop method.

By default, pop removes the last element

from a list.

We can also give it an index, and that

particular index element will be

removed.

Sometimes we don't know the index of the

element we want to remove. Suppose we

have a list of vegetables. One day, I

find out tomato is not vegetable. Tomato

is actually fruit. We want to remove

fruit from vegetable list, but we don't

know the exact index of tomato. Frankly,

we don't really care about its index, we

just want to remove it.

We use the remove method. We just need

to specify the data we want to remove,

not the index.

Our Python list will find it and remove

it for us.

Even after learning those four primary

operations, you might still feel there's

nothing that special about Python list.

So, it's time to expand our imagination

to something bigger. How about a Python

list that contains every word in Romeo

and Juliet?

So, I first Google Romeo and Juliet txt

and there's a good website hosted by

MIT. And I just copy this entire thing

and paste it on my Google Colab.

Now,

I'm going to use the triple quotation

mark in the very front

and the very end to enclose this entire

chunk of text.

This thing now is actually one valid

Python string. Look at the color. It's

yellow.

Which I can assign this to a variable

called RJ text stands for Romeo and

Juliet.

Triple quotation mark is another valid

way to create a Python string. The

reason we don't use single quotation

mark, which is what we always do, is

because there are new lines within this

text

and there could also be existing

quotation mark in there as well.

Allow me to inject a quick lesson on

string manipulation. Although these new

methods seem somewhat overwhelming, but

in fact, they're just performing very

simple action. The dot lower method

creates a new string after turning every

single character into lowercase.

The dot replace method creates a new

string, in our case, after replacing all

occurrences of comma with an empty

space.

The dot split method, which uses a

Python string to magically create a

Python list. Any empty space in the

string indicates boundary between

elements.

Coming back, we first use the lower

method to create a lowercase string of

Romeo and Juliet.

Then, we replace all all punctuation

mark with empty spaces

And assign this to the variable

RJ_text_no_pmark.

Of course, there are other punctuation

mark besides commas. So, we update the

variable text_no_pmark based on its

existing value, but further replacing

out all the period marks.

And we repeat the same process for the

rest of them.

And then finally, we use the split

method to create a list version of the

string.

If I print RJ_list, what I see is a long

long Python list.

This list contains every single word of

Romeo and Juliet, which is what we want.

Let's ask some basic questions. What's

the first word in there?

What's the second word in there?

What's the 500th word in there?

I can use the l e n len function to

check for how many elements this list

have.

This thing is a number, so I can assign

this to a variable and print it.

Our list has 25,000 strings in there.

Besides the comparison operator, the in

keyword is another tool we have to

create a boolean expression by asking if

a certain data is indeed within the

list.

We can ask, is the string Romeo in

RJ_list?

How about the string Juliet?

False.

Oh, it's because I misspelled Juliet.

Is Shakespeare's iconic thou in there?

Is the word love in there?

False.

How come? I thought this is love story.

It's because I made a mistake. Remember,

everything has been turned into

lowercase, so it's impossible for any

capitalized string to be found within

RJ_list. I need to lowercase love as

well.

Is the string poison in there?

Since the in keyword us a boolean value,

so we can write a if-else logic.

The string robot is not in there.

The string Python is also not in there.

See, we don't even need to read the

entire thing. We can conclude that the

story is not about robot nor Python.

If anyone ask me what's the most

important concept in basic programming,

I would say for loop.

However, for us beginners, the first

time seen this idea, it seems really

abstract and non-intuitive. So, let's

motivate this concept with a real-world

example. Potato is working as a software

engineer for Google now. His job is to

print out every element of a Python list

while saying hi.

And he wrote this program.

Potato's clever solution is to access

the first element and assign it to the

variable user

and print hi user.

After that, the variable user changes to

the second element and print hi user.

And after that, user changes to the

third element and prints hi user again.

And finally, he prints work done, going

home.

As you can see, Potato's overall

strategy is to create just one variable,

user.

And he keeps recycling this variable by

manually changing it to the next index

and then print hi user. His program

executes perfectly. Good job, Potato.

Everything is fun and games until this

list starts to get really long. One

morning, Potato realized user list has

5,000 elements.

Does it imply he's going to write code

like this?

I mean, this works, but our Potato is

definitely exhausted.

Looking at his 6-hours long effort,

Potato realized that his code is

extremely repetitive. He is essentially

just printing hi user over and over

While the variable itself changes to the

next one and to the next one and to the

next one.

He wonders, what if the variable user

can be a little smarter such that it

changes on its own to the next element

one by one.

So that I only need to write hi user

once.

And this is the entire premise of for

loop, which is to automate the

repetitive simple actions finding small

patterns to solve big problems. Now,

potato writes

for user

in user list colon

indentation

print hi user.

With this type of syntax, a for loop

begins.

The loop variable user is just going to

change on its own, hopping to the next

element, changes its value to that,

hopping to the next element and changes

again. Every time after user change the

next element, the entire indented code

block under the for statement will be

executed.

The for loop is going to repeat this

change execute change execute change

execute alternating actions tirelessly

all the way to the end. There is a

sensation that the for loop is running.

No matter how long this Python list is,

whether it's 50 elements, 50,000

elements, or 50 million elements,

potato's program would run properly.

A few syntax to point out. Remember in

the previous chapter, we learned that

the in keyword can check whether data is

indeed inside a list. The same in also

appears when we're writing for loop. I

just want to say those two in means

complete different things under the two

different contexts.

This in is more like asking a question.

Is it in there?

This in is more like a statement saying

that the loop variable user will change

its value one by one to every element

inside the list.

Once again, we see the familiar colon

and indentation syntax, which we had

previously seen with if else statement.

Only the indented code block will be

executed repeatedly when the loop is

running. Things outside a for loop will

not be a part of the loop action.

And this indented code block can

definitely be well more than one line.

Up next, we're going to get ourselves

more familiarized with for loop by

tackling three coding tasks while

highlighting some common mistakes and

misconceptions along the way.

Suppose we have a list of numbers. This

list can be short or very long.

Your goal is to find out what's the

summation of the list or if we literally

add all the numbers together, what would

it be?

If you've never seen a question like

this before, I promise you the answer

will be non-obvious. So, for sure take a

moment to pause and ponder.

So, the central idea is to create a

variable outside before the loop starts

running. We initialize the variable S to

zero.

When the for loop is running, we keep

adding values into the variable S.

Currently, the loop variable number is

100. The code block to execute is S

equals to S plus number, which means we

update S by adding 100 to it. So, S

becomes zero plus 100, which is 100.

After that, the variable number hops to

the next one. Number changes value to

five. The value of S at this point is

100. We increase it by 5. So, S becomes

105. Of course, the variable number hops

onto the next one again and updates S

again.

This process repeats. So, the variable S

is getting bigger and bigger by

accumulating all the index the loop has

passed through.

By the time when the loop terminates,

the variable S has already collected all

the values along the way.

Pretty ingenious, right?

The variable S is a critical data we

want to update in the midst of a for

loop. A very common mistake, which I

definitely made often, is that we put

the variable S inside a for loop rather

than the outside.

Let's see why this is a big problem.

S equal to zero. Since the variable S

does not exist yet, this means we're

going to create the variable S and

initialize it to zero.

S equal to S plus 100, so S becomes 100.

So far, so good. Number hops to the next

element. As you can see, the line S

equal to zero is within the indented

code block. So, it's going to get itself

executed every time.

S is reset to zero.

But, what about the 100 we had seen

before?

It's not accumulating anything.

Even when this loop reaches to the end,

the variable S does not remember

anything it seen before. Obviously, this

is a problem.

So, the lesson here is we have to be

really cautious about what variable to

put inside versus the outside of a for

loop.

All right. Spent a long time on the

previous one.

Task two. Suppose we have a list of

natural numbers.

How can we find the biggest number in

there?

The solution, once again, is that we're

going to create a variable outside the

for loop called the current max. The

idea is to have this current max

variable to store the biggest number the

loop has seen so far. So, it's

initialized to the smallest natural

number.

As the loop starts running, we use a

condition statement to check whether we

should change current max.

For example, at this moment, loop

variable number is 17, and current max

is five. 17 is bigger than five, but

this also means that the current element

is bigger than every single element the

loop has yet seen. So, we must change

the value of the current max to 17.

On the contrary, if the value of number

is less than current max, for example,

number is 12 and current max is 17. That

means there definitely exists an element

somewhere before the current index it is

bigger than 12. So, we don't change

anything and move forward.

As the loop reaches through the end, the

variable current max has been compared

with every single index. Every time when

current max faces a larger number, it

changes to that. So, by the end, current

max certainly stores the biggest number

in this list.

Common question one, do I have to name

the loop variable as number?

Nope. You have complete freedom in

choosing the variable name. You can also

name it current element or just cur

or even c.

As long as you use them consistently,

it's going to work.

Common question two, when the loop

terminates, namely outside the loop's

indentation, can I do something about

the variable c? Like, can I print it?

So, we cannot. The loop variable is kind

of like a ephemeral variable that only

exists when the loop is running.

When the loop terminates, the variable C

just vanishes after having done all its

work. It disappears completely from the

environment of our program. Outside the

for loop, we cannot do anything about

this variable.

Suppose you and many friends are going

on a road trip. You surveyed everyone

for movies to watch together as a group.

You asked them to append their own

favorite movie to the list.

And since certain movies are really

popular, this list has some

redundancies.

As a group leader, you don't want to

bore everyone by asking them to watch

the same movie twice. Your goal is to

create another list in which every

element is unique. Or every movie only

appears in there once.

The idea is similar. We create an empty

list outside. As the for loop starts

running, we conditionally append movies

in there.

Since I never touch on this not logical

operator, let me inject a quick lesson

on this.

Suppose I have a Boolean true.

By putting not in front of it, it

negates to false.

By putting not in front of false, it

negates to true.

The thing on top is a Boolean expression

that evaluates to true.

By putting not in front of it, it

evaluates to false.

As the loop begin, the variable MV

stores a string Endgame.

By our design, unique list cannot have

any redundant element. We only append

new movies in there if it is currently

not in unique list.

At the moment, unique list is empty and

Endgame is not in there. We append.

Hopping to the next one. Spider-Verse

not in unique list. True, we append.

Next one.

Endgame is already in there, we do not

append.

So, if my verbal commentary of four

loops start to get pretty monotonous and

predictable for you,

hey, yeah, you start to really

internalize four loop now.

Looking back at our journey so far, we

attempted to define a word programming.

In chapter zero, we said programming is

creating interesting things. In chapter

two, we said programming is art of

changing variables. Today, the

definition is more refined. Programming

is art of changing variable in the midst

of running four loop with conditional

statement.

The reason why I cherry-picked those

three particular examples, because on

one hand, I think it really drives this

thesis home. On the other hand, there's

some concrete setting for us to engage

with programmatic thinking. Rather than

just using four loop to print out Python

list elements. Four loop is about

finding small pattern to solve big

problem using their few lines of code to

work with a list of data that could be

unimaginably long.

In many future coding situation, I

promise you that you can find archetype

of thinking stemming from these three

examples.

Next chapter, we'll learn about a more

generalized technique of looping, and

we'll see many beautiful connections

between coding and mathematics. See you

there.

In the previous chapter, we learned that

whenever there's a Python list, we can

use a four loop. The four loop is a

great method for automating repetitive

and simple actions.

The loop variable keeps hopping onto the

next element, changes value to that, and

the indented code block executes. Those

action repeats. There is a sensation

that the four loop is running.

As programmer, we call this running a

for loop over a list or simply looping

over list.

But a more professional way to call this

is iterating over a list. As vocab,

iterate means to do again, do again, do

again.

Yet, Python list is not the only thing

that can be iterated over. In fact, it

belongs to a larger abstract class of

objects called iterable.

I know this entire playlist is aimed for

beginners, so we're not going to the

details about what exactly this word

mean. So, for now, if I tell you

something is an iterable, that means it

can be a target of for loop. And the

range object is an iterable.

By calling the range function with a

start and end index, we get a range

object.

But what exactly is this range object?

You can basically think about it as a

sequence of numbers that can be loop

over.

When the for loop starts, the loop

variable I iteratively binds to all

integer from 0 to 9.

As you see, when we loop over the range

object, it logically just feels like

we're looping over a Python list, which

contains the sequential integers.

Notice range 0 10 does not give you the

number 10. It only gives you all the

number from 0 to 9.

This is because Python's end index is

always non-inclusive. If we want the

number 10 in there, we have to change

this to range 0 11.

So, what exactly can we do about this

range object? A sequence of numbers

doesn't seem any useful at all.

We can use the range to indirectly loop

over another Python list.

For the range object, the start index is

0 and the end index equals to the length

of the list.

As the for loop begins, the loop

variable I is integer,

but it conveniently also represent the

index of my list. Then, we can access

the corresponding element using this

index

and store it into variable var

and print it.

Since we're iterating over all the

indices, we ensure that every element is

visited. What you see now is another

perfect valid way of looping over a

list.

So, let's take a moment to compare and

contrast between the two strategy of

looping.

In the direct method on left, the loop

variable var directly binds to the

element, and we can use it immediately.

On the right, the indirect method, where

looping over a sequence of numbers,

the loop variable I only binds to an

integer, and then we use the integer as

the index to access the corresponding

element.

So, this one here is a two-step process.

Potato's like, "The indirect method is

so inefficient. Why would anyone ever

want to loop over a bunch of indices?

Just do it directly."

Thank you, potato. That's indeed a very

good question. It turns out looping over

indices has the advantage in certain

cases.

Consider this scenario. We have a list

of numbers, which stores the hourly

salary of six different employees,

and we want to increase everyone's money

by $5.

Potato's like, "Easy. Gotcha." He writes

a Python code for salary in salary list,

salary equal salary plus five.

As the loop begin,

you already see the problem.

The only thing that this code is doing

is just increment the loop variable

salary by five.

But the actual element in salary list is

never changed.

Therefore, this code is incorrect.

So, to fix that, we must use the

indirect method, loop through the

indices of the list.

As the for loop begin, the loop variable

I iteratively binds to all the index of

salary list, and we increase the element

sitting at index I by five.

Here, we clearly see the data inside the

Python list has been changed.

So, the lesson is if we want to modify

the actual element inside the list, we

need to modify them through index.

Therefore, we must loop over the range

object.

Hey, isn't it bit verbose to write code

like this?

Yep, I should use the more compact

syntax of updating variable, writing

plus equal five instead.

Another application of range object is

that sometimes we want our program to

make decision based on the index of the

element rather than the value of the

element. Still using the salary list as

an example, but this time we want to

increase the salary of a few workers by

$10 because they're just so amazing.

Namely, there is another list which

stores the indices of those candidates

who we deem as amazing. For everyone

else, we still increase their money by

five.

Our program logic here is very

straightforward. We iterated over all

the indices with the help of if else, we

differentially increase the salary by

checking whether if the candidate is

amazing.

Loop variable I binds to zero and the

index zero is not inside amazing list.

So, our program jumps to the else part,

increase the salary by five.

I then binds to one. The index one

inside amazing list, true.

So, we increase the element by 10.

The same logic repeats all the way till

the end.

In general, as a Python programmer, it

is important to be absolutely fluent

with both technique. So, depending on

different coding task, we can always

pick the most optimal strategy to loop

over list.

Yet, sometimes our main focus does not

have to be a list, but rather a sequence

of number themselves. In particular,

when we're doing computation that

relates to math.

Have you ever seen a funny-looking thing

like this? An exclamation mark next to a

number.

It's called the factorial of that

number.

The factorial appears often in

probability, number theory, calculus,

and many other fields of mathematics,

playing important role in mysteriously

elegant equations.

Yet, its definition is very simple. The

factorial of a number n is defined as

the product of all the numbers from n to

one.

For example, 5! is 5 * 4 * 3 * 2 * 1.

If someone throws me a pen and paper and

ask me to calculate this expression,

this is what I would do.

Firstly, I know that multiplication is

commutative, so I can rearrange the

expression by reversing the numbers.

Then, I'll iteratively multiply the two

front numbers together. 1 * 2 is 2, 2 *

3 is 6, 6 * 4 is 24, 24 * 5 is 120. So,

5! is 120.

But, the process certainly gave me some

inspiration.

Those sequential numbers just look like

a ranged object.

The action of repeated multiplication

also rings a bell with the spirit of

loop.

So, let's write a program that can

compute the factorial of any positive

integer.

We initialize the variable P as 1

outside the loop. When the loop is

running, we iteratively multiply the

variable I into P.

The variable P basically serves as a

collector, storing the product of all

the natural number it had seen as a loop

marches forward.

You might wonder, why are we setting the

outer variable P to be 1 instead of 0?

Isn't that what we always do before?

The reason is because 0 multiplied by

anything is 0.

Suppose I accidentally initialize P = 0.

This is what's going to happen. P equals

to I * P, so P equals to 0 * 1, so P is

0.

P equals to 2 * 0, so P is still 0.

P equals to 3 * 0, so P is still 0.

As you see, the value of P is trapped at

0, never accumulating anything. This is

a problem.

Normally, when the purpose of the for

loop is to add bunch of numbers

together, the outer variable is

initialized to zero.

When the purpose of the loop is to

multiply bunch of numbers together, the

outer variable is initialized to one.

N is a variable, and I can initialize it

to a different value, such as 52.

Run this again.

The factorial of 52

Huh, this number is pretty big.

You know, the lesson so far today has

been pretty intense.

So, why don't we take a break together

by taking a detour on this 52 factorial?

This number is in fact so big that

people are making videos online

explaining how big the number is.

While I was watching them, I got a sense

that human beings are actually pretty

bad at comprehending big numbers.

52 factorial is a big number. The net

worth of Elon Musk is also a big number.

Currently, in 2022, Elon's net worth is

estimated to be around 200 billion

dollars.

I believe a few years later, that number

would increase to 800 billion dollars.

But, you know what's a number so much

and so much bigger than that? The number

of atoms on Earth.

Which is estimated to be 1.33 * 10 to

the power of 50.

All right. The next part might appear

weird to you, but imagine if every tiny

little single atom on Earth, each and

every one of them, transforms into their

own pile of 800 billion dollar cash. The

aggregation of total value here is

really immense.

And that equals to Elon money times num

atoms.

And this is truly a big number.

So, which number is bigger? 52 factorial

or 800 billion times the number of atoms

on Earth?

Personally, I think the latter number

must be bigger.

Oops, I'm wrong. 52 factorial is bigger.

Well, then what fraction does this big

number occupy in 52 factorial?

1.31 * 10 to the power of minus six.

That's a small portion. To visualize,

the yellow cube represents 800 billion

times the number of atom on Earth.

The larger green cube represents

52 factorial.

Wow, this 52 factorial is so big. In

what occasion does this even appear in a

human's life?

It's all the different unique ways you

can rearrange a poker deck.

All right, break is over. Let's come

back to Forloop.

Mushroom is taking a math class and she

got this answer for a question. This

entity may look unfamiliar to some

people. It's called the sigma notation.

It appears pretty often in math,

actually. Mushroom wants to find out the

numerical value of this expression.

Since Potato knows Python, she goes to

Potato for help.

However, Potato is scared anytime when a

Greek symbol appears in math. He doesn't

know whatever this thing is. So,

Mushroom explains.

The sigma notation is actually only

doing something very simple.

Consider all the natural numbers

starting at one ending at 10.

We pattern match this expression to them

one by one.

And then, we add them together.

Sigma notation is just a compact way of

describing summation.

Potato understands now.

But, wait a second. A sequence of

consecutive numbers adding a bunch of

numbers together both of which are just

screaming out use for loop.

I mean, one day in the future, whenever

you see a sigma notation in math, you're

just going to involuntarily ask yourself

it's just a for loop, right?

Potato picks up Python and passionately

programs.

And I will stop talking to let the

animation speak for itself.

Whenever we use a for loop, we can

literally put anything inside its

indented code block. Within loop, we can

print, we can do variable manipulation,

conditional statement, we really have

complete freedom as programmer.

But what if I put another for loop

inside a for loop, which results in a

nested for loop?

Loop inside loop. And this is when

things starts to get interesting. For

me, frankly, there's something

unsettling looking into a nested for

loop. What exactly happens? Most people

have this intuition about a nested

double for loop, saying, "Well, if a

single loop is all about one loop

variable hopping over each element of

its iterable,

then a double for loop must be about

Well, there are two different loop

variable,

then two different loop variable are

simultaneously running over two

iterable. And unfortunately, this

intuition about how double for loop

works is just incorrect.

So, what is the true behavior of a

double for loop?

Remember that there are two loop

variables, VL for the outer loop and VN

for the inner loop.

The VN needs to complete its entire trip

for VL to only advance by one step.

Or you can imagine this.

Every time when VL takes one step

forward, VN needs to complete its entire

loop.

VL takes another step forward, VN

completes another trip.

So, when the outer loop terminates, the

inner loop has been iterated over many,

many, many times.

At least for me, this behavior is

slightly unexpected. This is important.

Let's watch this again.

So, if we were to look at the output

generated by the print statement here,

it's going to look something like A1,

A2,

A3,

A4,

A5,

B1, B2, B3, B4, B5. You kind of get the

point.

You also notice the value of the outer

loop variable is persistent for the

entire duration of the inner loop. This

outer loop variable, which currently is

D, is used to concatenate with every

single inner loop element before it

expires and advance forward to become E.

Despite its complexity, nested for loop

is used inevitably in programming, such

as a matrix multiplication

and dynamic programming.

But today, let's just focus on a very

simple application.

Suppose I'm coding a poker game. So, the

first thing I need to do is to create a

deck of 52 cards,

which is conveniently represented as a

Python list.

I'll just manually add each card in

there one by one. I append two of

hearts, two of diamonds, clubs, and

spades.

And after doing this 52 times

diligently, I'm done with my deck of

cards. But, this just doesn't feel like

the most efficient way of doing things.

I could make the observation that a

poker deck only has 13 different rank

and four different suits.

The formation of a deck is just each

rank take four different version of

suit.

It's just combination.

And this looks suspiciously like a

double for loop.

Therefore, I can write my Python code as

I have my outer loop iterating through

all ranks.

The inner loop iterating over each suit.

And the card is simply the concatenation

of a suit and rank.

And I append the card to my cards.

And this double for loop will get my

deck of 52 cards.

At this point, it's totally okay to feel

nested loop is kind of hard.

Absolutely. Especially if it's your

first time seeing this.

Compared to a single for loop, the

complexity of double for loop is in fact

not double, but square.

Unfortunately, things can even get

harder from here.

Let's take a moment to compare the two

different program here.

Can you spot out why the code on the

right is much more difficult to

understand?

Feel free to pause and ponder.

All right.

If we look at the left program, the

inner loop always loops over from the

range 0 to 5, independent of the outer

loop.

On the contrary, the right one, the

inner loop is iterating over range 0 to

I.

But, what is I?

I is the outer loop variable, which

means it changes through the execution

of the program.

The iterable of the inner loop depends

on the outer loop. There is a

fundamental dependency between the two

loops.

So, what does that look like?

When the outer loop just begin, the loop

variable I binds to 5. According to our

program, the inner loop needs to take a

trip from 0 to 4.

As the inner loop terminates, the outer

loop take one step forward. I is now 6,

which means the inner loop needs to

iterate from 0 to 5, which is one more

than its previous run.

I binds to 7, the inner loop goes from 0

to 6.

I binds to 8, the inner loop needs to go

from 0 to 7.

I binds to 9, the inner loop needs to go

from 0 to 8. So, you already see the

pattern. As the program execute, the

extent in which the inner loop needs to

iterate also increase. The behavior of

the inner loop, how much work it does,

is depend on the outer loop.

Why would a programmer ever use a nested

loop that has dependency?

Well, remember from last chapter, we

learned about factorial.

If we want to compute the factorial of

integer n, we use a for loop from 1 to

n, iteratively multiplying each number,

and accumulate into p.

However, what happen if someone throws

me list of integer, and ask me to

compute each one's factorial? What

should I do?

Let's look at this again. This block of

code computes the factorial of n, and n

is a variable. I can change n to 11 and

see that the factorial of 11 is a big

number.

So, why can't I change n into a loop

variable iterating over number list? And

it would just migrate this entire code

block inside, of course, indented.

Notice we have a nested loop with

dependency of the inner loop range from

1 to n + 1.

The mission of the outer loop is to

iterate all integers from this given

list. The mission of the inner loop is

compute the factorial of that

corresponding n.

Execute.

Great.

There is one detail to point out. Notice

on line two, p equal to 1 is in between

the outer loop and the inner loop. This

means that every time when the variable

n take one step forward, rather than

launching the inner loop immediately,

the first thing it does is to reset p

back to 1, then follows the entire inner

loop. This reset is critically important

because when the inner loop is

calculating the factorial, the value p

gets pretty big.

As the outer loop take one step forward,

we need to reset p back to 1, so the

residual from the previous inner loop

does not linger over.

Loop is the most important concept in

the basics of programming, which is why

we spent three chapter on this topic. We

start learning about loop from a visual

approach. We see with our eye that the

loop is really running. In part two, we

learn about how to loop with the range.

And today, we saw the unexpected

complexity of a nested for loop.

In terms of big picture of essence of

Python, we have already added these

items to our toolbox. Variable

manipulation, which is a unit of

compute, conditional statement, decision

making, Python list, data structure, for

loop, automation of logic.

These combined may only occupy 20% of

Python's programming feature and syntax,

but the core concept are definitely

relevant in at least 80% of any

programming thinking.

An interesting note aside, when Vitalik

was developing the next generation

blockchain, Ethereum, he was especially

aware about the feature of loop. He

realized that Bitcoin's foundational

limitation is that it doesn't allow

loop. So, he added a loop in Ethereum,

which enabled it to become versatile

platform for developer to make

interesting application.

When people say function, we think about

the X and Y axis. This is a linear

function. This is a quadratic function.

Our impression about function is often a

static image we see in our math

textbook. However, this is actually

quite misleading because the essence of

function is not static. It's dynamic.

Function is all about the action of

transforming input into output.

For example, this function here computes

the squared value of any number.

Five enters the function. Five squared

is 25.

And 25 is the output.

And this function here is capable of

interleaving two input string. A A A A,

B B B B are the inputs. The function

inter- leaves them

and outputs the longer string.

What you saw just now very much

resembles the essence of a Python

function. There is an input. The

function does something to the input and

returns the output back to you.

This is a good mental picture to have

before the lesson begins.

In Python, function is a great way for

organizing logic and prevents you from

writing repetitive code. To motivate

this, let's see an example.

Recall in chapter five, potato mastered

the use of for loop, and now he's a

senior engineer at YouTube.

But, what is he doing today? You can

pause the video to take a look.

Seems like potato is writing a greeting

message to members in the gold, silver,

and bronze class.

If today is a member's birthday, he

writes, "Happy birthday." Plus the

person's name.

Else, simply greet with, "Hey."

Lastly, the message is printed with the

person's class tier.

However, if you were to notice, these

three blocks of code are identical. This

is very repetitive, and this is not good

code.

Really, in those three places, potato is

seeking for the same functionality.

Given person's name and his birthday as

input, we want to get its corresponding

message as the output. This is a great

place we should use a function.

Finally, how do you make a function?

We use the def keyword, short for

define. Follow that, we give the

function a name, greet, and then, within

the parentheses, we specify what are the

inputs to the function, which is the

name and birthday today.

The professional terminology is that

they are the parameters of the function.

Now, we can write code that performs

action to the parameters.

Notice indentation here, which is saying

everything within the indentation belong

to the function greet.

The return keyword specify the output,

which is the conditional message.

I want to take a moment to emphasize

that the return statement here is very

important. If you forget to write a

return statement, you can imagine that

your desired output gets stuck inside a

function with nothing visible from the

outside.

This entire thing is a function

definition. We define the input, the

action, the output. But when a function