Python編程訓練營2020｜學習用Python編程[教程和練習]。 (Python Programming Bootcamp 2020 | Learn to Code in Python [Tutorial and Exercises])

字幕列表影片播放

In this lecture, you will see values act as the most basic (or primitive) data elements
necessary to form not only variables, but any expressions.
A prominent example of conditional statements in Python is the “If” statement.
What you can use it for is intuitive, but it is very important to learn the syntax.
Think of the following: if 5 equals 15 divided by 3, then print “Hooray!”
First, don’t forget we should use the double equality sign here, because we are checking
whether 5 is equal to 15 divided by 3, and we are not assigning the value of 15 divided
by 3 to be 5.
5 is not a variable name; it is a number.
 Good.
Now it is crucial to place a colon.
The colon will tell the computer what to do if the condition we just wrote has been satisfied.
For achieving good legibility, we advise you to write the print statement on a new line.
Please, remember it should be indented; otherwise, you will run into an error.
All right, now this should work correctly.
Yes, 5 is equal to 15 divided by 3.
Hooray!
 Will it work if we check for 5 being equal
to 18 divided by 3?
It is not supposed to, since 5 differs from 6.
We got nothing, because we have not told the machine what to do, if the provided condition
is not satisfied.
So, there is no reason for the machine to print out “Hooray!”
The graph could help you imagine the process of the conditionals.
Before it displays the outcome of the operation, the machine follows these logical steps.
If the conditional code is not to be executed because the if-condition is not true, our
program will directly lead us to some other output or, as it is in our case, to nothing.
After any of the two situations, the machine will go to the next black point and will progress
from there on.
Let’s try with an inequality sign, which can be written with an exclamation mark and
an equals sign.
Isn’t 5 different from 3 times 6?
Yes, it is.
It is True that it is different.
Hence, we have “Hooray!” as an output.
This was a brief introduction to if-statements.
This logic will help you proceed to the next lecture, where we will complicate things a
little bit.
But not too much 
Let’s assign the value of 1 to x.
We can ask the computer to display “Case 1” if x is greater than 3, and “Case 2”
if it is less than or equal to 3.
Ok, we could write two if-statements one after the other.
Let’s see if we get the correct outcome.
Yes, we are in case 2.
There is a shorter and better way to express ourselves here.
In the second part, instead of saying “If x is smaller than or equal to 3”, we could
write directly “else” and insert a colon.
“Else” will tell the computer to execute the successive command in all other cases.
In our little program, that would mean “in all cases when x is not greater than 3”.
That translates into “when x is less than or equal to 3”.
Let’s verify if what we did was correct.
Bingo!
Case number 2!
This picture adds up to the one we saw in the previous lesson.
Instead of leading to no output, if the condition is false, we will get to an else code.
In our case, this is the command “print “case 2”.
Regardless whether the initial condition is satisfied, we will get to the end point, so
the computer has concluded the entire operation and is ready to execute a new one.
Wonderful!
Now, please allow me to share two notes on the subject.
Don’t fall into the trap of organizing your code on a whim.
There is a strict manner to do that, and indentation plays a key role again.
Should you put the “else” keyword, just underneath the first print word, nothing will
happen.
Remember to place the if and the else keywords on the same vertical line!
This is the right moment to introduce you to the notion of blocks of code.
The if-statement, meaning the condition plus the relevant “print” command, form the
first block of code.
The entire else-statement forms another block of code on its own.
In a long sheet with much code, you’ll have a whole lot of blocks.
And larger programs are constructed on a block by block basis.
In this lesson, we’ll learn an elegant way of adding a second “if” statement to one
of our expressions.
This is done with the help of the elif keyword, as shown in this example.
If y is not greater than 5, the computer will think: “else if y is less than 5”, written
“elif y is less than 5”, then I will print out “Less”.
And the else-statement follows as a tail with the respective block that says “return “Equal”.
Let’s confirm we wrote the code correctly.
We can print out the “compare to five” function with a value of y equal to 10 in
the following way... then we’ll expect to see a statement that says “Greater” because
10 is greater than 5.
Correct?
Ok.
Perfect.
What if we carry out this operation for the number 2?
The machine tells us that 2 is less than 5.
And that’s what we expected.
To obtain the third outcome, we must compare the number 5 with a number that is not greater
or smaller than 5.
This will happen only if the argument of the function is 5, right?
Shall we try this one?
Great!
We obtained “Equal”, as expected.
Know that you can add as many elif- statements as you need.
Let’s provide an example.
If y is less than 0, the string “Negative” should be displayed.
I will place this block between the if and the other elif statement.
Let’s see what happens.
The function with an argument of minus 3 shows “negative”, just as it should.
Let me just control whether our little program will run properly if I asked it to “compare
to five” a value that lies in the range between 0 and 5, say 3.
Yes, we see “Less”, so everything is ok.
A very important detail you should try to remember is the computer always reads your
commands from top to bottom.
Regardless of the speed at which it works, it executes only one command at a time.
Scientifically speaking, the instructions we give to the machine are part of a control
flow.
This is something like the flow of the logical thought of the computer, the way the computer
thinks – step by step, executing the steps in a rigid order.
When it works with a conditional statement, the computer’s task will be to execute a
specific command once a certain condition has been satisfied.
It will read your commands from the if- statement at the top, through the elif-statements in
the middle, to the else- statement at the end.
The first moment the machine finds a satisfied condition, it will print the respective output
and will execute no other part of the code from this conditional.
In our example, if the first statement is correct, we will see the corresponding output
number 1, which is printing the string "Greater”.
The computer will disregard the elif and the else statements, and will proceed with the
rest of the code.
If the first statement is not correct, we will move forward, and the computer will check
whether our second statement is true.
If yes, we will see output number 2, which is printing the string “Negative”.
If not, we will get to statement number 3 and so on until the computer finds a satisfactory
outcome to print out.
Now, I will switch the order of the two elif statements to prove that the order of instructions
matters.
Ok?
Let me print “compare to five” of minus 3.
Ha!
Instead of “Negative” we obtained “Less”.
This is how the computer reasons: assume y equals -3.
Print out “Greater” if y is greater than 5.
Is it greater than 5?
No, so the computer continues and checks if there are any other statements in our code.
Given we have other statements, it moves forward.
So, is y less than 5?
Yes, it is.
At this moment, the computer thinks, “Lovely, I got it!
My number is less than 5, I satisfy what my programmer asked me to do, I print out “Less”
and I am fine”.
And the machine stops there and does not execute a single letter of the code that follows in
this block.
The fact that you examined the cases when y is less than 0 or equal precisely to 5 have
no application.
They become useless.
Whether you ask for the output of minus 3 or 3, you will still have to be satisfied
with the “Less” label.
You found this interesting, didn’t you?
Stay focused for the next lecture, when we will share something more about computational
logic.
You probably noticed we talked about Boolean values a few times.
Here, we would like to provide a short video that aims to explain their application.
Let x be equal to 2.
What you see next is the following if-else construction: – if the value of the x variable
is greater than 4, print out “Correct”.
In all other cases, print “Incorrect”.
So, which is the Boolean element we have in this computational logic?
Basically, after you insert your if-statement, the computer will attach a Boolean value to
it.
Depending on the value of its outcome, “True” or “False”, it will produce one of the
suggested outputs, “Correct” or “Incorrect”.
If the first statement is True, that is, if x is greater than 4, the machine will print
the corresponding statement “Correct”.
Else, which means if the statement “x greater than 4” is untrue, or more precisely “False”,
the statement “Incorrect” will be printed.
From a certain perspective, everything in a computer system is Boolean, comprising sequences
of 0s and 1s, “False” and “True”.
This is why we are paying attention to the Boolean value.
It helps us understand general computational logic and the way conditionals work in Python.
Ok.
Excellent.
Now, you know more about conditionals in Python, and you understand the control flow of if-,
elif-, and else- statements.
In addition, you saw, once more, complying with the Pythonic syntax is crucial for the
execution of your code.
Where you type the colon sign and indentation matters.
Last, you saw the order in which you declare your commands leads to a specific outcome.
If you change the order of your commands, the outcome could change, and this may take
you to undesired results.
Wonderful!
Great!
Let’s step it up a notch.
Starting from this lesson, we’ll deal with Python’s functions - an invaluable tool
for programmers.
The best way of learning is by doing, so let’s create a function and see how it can be applied.
To tell the computer you are about to create a function, just write def at the beginning
of the line.
Def is neither a command nor a function.
It is a keyword.
To indicate this, Jupyter will automatically change its font color to green.
Then, you can type the name of the function you will use.
For instance, simple, as we will create a very simple function.
Then we can add a pair of parentheses.
Technically, within these parentheses, you could place the parameters of the function
if it requires you to have any.
It is no problem to have a function with zero parameters.
This is the case with the function we are creating right now.
To proceed, don’t miss to put a colon after the name of the function.
Since it is inconvenient to continue on the same line when the function becomes longer,
it is much better to build the habit of laying the instructions on a new line, with an indent
again.
Good legibility counts for а good style of coding!
All right, let’s see what will happen when we ask the machine to print a sentence.
Not much, at least for now.
The computer created the function “simple” that can print out “My first function”,
but that was all.
To apply the function, we must call it.
We must ask the function to do its job.
So, we will obtain its result once we type its name, “simple”, and parentheses.
See?
Great!
Ok, good.
Our next task will be to create a function with a parameter.
Let it be “plus ten” with a parameter ”a”, that gives us the sum of “a”
and 10 as a result…
Always begin with the “def” keyword.
Then, type the name of the function, “plus ten”, and in parentheses, designate the
parameter “a”.
The last thing to write on this line would be the colon sign.
Good.
What comes next is very important.
Don’t forget to return a value from the function.
If we look at the function we wrote in the previous lesson, there was no value to return;
it printed a certain statement.
Things are different here.
We will need this function to do a specific calculation for us and not just print something.
Type “return “a” plus 10”.
This will be the body of this function.
Now, let’s call “plus ten” with an argument 2 specified in parentheses.
Amazing!
It works.
Once we’ve created a function, we can run it repeatedly, changing its argument.
I could run “plus ten” with an argument of 5, and this time, the answer will be 15.
Great!
Pay attention to the following.
When we define a function, we specify in parentheses a parameter.
In the “plus ten” function, “a” is a parameter.
Later, when we call this function, it is correct to say we provide an argument, not a parameter.
So we can say “call plus ten with an argument of 2, call plus ten with an argument of 5”.
People often confuse print and return, and the type of situations when we can apply them.
To understand the concept better, try to imagine the following.
There is an argument x, which serves as an input in a function, like the one we have
here.
The function in this case is x plus 10.
Given that x is an input, we can think of it as a value we already know, so the combination
of x and the function will give us the output value y.
Well, in programming, return regards the value of y; it just says to the machine “after
the operations executed by the function f, return to me the value of y”.
“Return” plays a connection between the second and the third step of the process.
In other words, a function can take an input of one or more variables and return a single
output composed of one or more values.
This is why “return” can be used only once in a function.
Therefore, we can say the concept of a function applies to programming almost perfectly.
There are some extra advantages to consider.
You could also assign a more intuitive name to a function – “plus ten” or “addition
of 10”, and the function will still run correctly.
This is a sign of good design.
On a sheet with one thousand lines of code, if you call all your functions x1, x2, x3
and so on, your colleagues will be confused and utterly unhappy.
Naming functions clearly and concisely makes your programming code easy to understand,
and it will be accepted as one of good style.
There is another way in which you could organize the definition of your function.
Start by defining “plus ten” with an argument of “a” and a colon.
On the next line, instead of directly returning the value of “a” plus 10, another variable
can be created inside the function to carry that value.
I will use the name “result” here.
I will assign it with the desired value of “a” plus 10.
Let’s check what we just did.
If I execute the code in the cell, I will get nothing.
Why?
Because to this moment, I have only declared the variable “result” in the body of our
function.
Naturally, to obtain the desired outcome, I will also have to return that variable.
See?
When I call “plus ten” with an argument of 2, I obtain 12.
It is all fine again.
“Print” takes a statement or, better, an object, and provides its printed representation
in the output cell.
It just makes a certain statement visible to the programmer.
A good reason to do that would be when you have a huge amount of code, and you want to
see the intermediary steps of your program printed out, so you can follow the control
flow.
Otherwise, print does not affect the calculation of the output.
Differently, return does not visualize the output.
It specifies what a certain function is supposed to give back.
It’s important you understand what each of the two keywords does.
This will help you a great deal when working with functions.
The following could be helpful.
Let that same function also print out the statement “outcome”.
If we put down only “return outcome”, and then “return result”, what will we
get when we call the function?
Just the first object to return – the statement “outcome”.
If, instead, we print that statement and then return ‘result’, we will get what we wanted:
the “outcome” statement and the result of the calculation – 15.
This was to show you we can return only a single result out of a function.
It isn’t a secret we can have a function within the function.
For instance, let’s define a function called ‘wage’ that calculates your daily wage.
Say you use working hours as a parameter, and you are paid 25 dollars per hour.
So this should work.
Ok.
Good.
Notice I don’t technically need the print command here.
I could print out the wage afterwards, but I don’t really need to.
So, I’ll proceed this way, just returning the value I need.
When you do well in a day, your boss will be very happy to give a bonus of 50 dollars
added to your salary.
Hence, I’ll define a “with bonus” function for you.
And as a parameter, I will take again the working hours.
But this time, I will allow myself to return directly the wage with working hours as an
output, which would be the value obtained after the wage function has been run, plus
the extra 50 dollars you’ve earned.
This is how the first function is involved in the output of the second one – a function
within the function!
Let’s see what the output will be if you worked 8 hours today and the boss was very
happy with your performance.
Wage with an argument 8, and “with bonus” with an argument 8.
Great!
200 of base compensation and 250 with the bonus!
We know how to work with if statements, and we know how to work with functions.
In this lesson, we’ll learn how to combine the two.
This is a fundamental concept in programming, so please pay attention!
You’ll encounter it quite regularly when coding.
Johnny's mom told him that, by the end of the week, if he has saved at least 100 dollars,
she would give him an extra 10 dollars.
If he did not manage to save at least 100 dollars, though, she would prefer not to give
him the extra cash.
Clear.
Now, let’s define a function called “add 10”, which takes as a parameter the unknown
“m” that represents the money Johnny saved by the end of the week.
What should we tell the computer to do?
If “m” is greater than or equal to 100, then add 10 to the saved amount.
If it is not, return a statement that lets us know Johnny should save more.
That is, if “m” is greater than or equal to a hundred, let “m” assume the value
of “m” plus 10.
Yes, it is what you saw!
We have “m” on both sides of the equation, and that is perfectly fine.
As a matter of fact, it is not an equation.
Remember that the “equality” sign stands for assigning the expression on the right
side to what is written on the left side.
Let’s complete the if-part with “return m”.
To sum up, logically, we mention “m” as a parameter.
Then, we substitute its value with a value greater than “m” with 10.
At the end, we say: from now on, return a value equal to the new “m”.
Finally, in all other cases say, for instance, “Save more!”
(Johnny should learn it is a good habit to have some cash on the side, right?)
Let’s see if our intuition was correct.
“Add 10” of 110 – good, 120!
And if “m” was equal to 50…?
Amazing!
Everything is correct!
When you think of it from a logical perspective, it makes sense, doesn’t it?
What would you use a computer for – to solve problems for you.
And it can do that through functions.
You’ll most probably need to ask the machine to execute something if a given parameter
is within certain limits and ask it to execute another thing if the parameter is beyond these
limits.
Therefore, combining your knowledge about conditionals and functions in Python comes
right on the money.
Great!
Just keep the pace for our next video!
We are almost there.
In this lesson, we’ll learn how to work with more than one parameter in a function.
The way this is done in Python is by enlisting all the arguments within the parentheses,
separated by a comma.
Shall I call the function we have here for, say, 10, 3, and 2?
I get 4.
Seems easy to add a few parameters, right?
And it is!
Just be careful with the order in which you state their values.
In our case, I assigned 10 to the variable a, 3 to b, and 2 to c.
Otherwise, the order won’t matter if and only if you specify the names of the variables
within the parentheses like this: b equals 3, a equals 10, and c equals 2.
And of course, we could obtain the same answer – 4!
This is how we can work with functions that have multiple arguments.
Awesome!
Let’s see what’s next!
When you install Python on your computer, you are also installing some of its built-in
functions.
This means you won’t need to type their code every time you use them – these functions
are already on your computer and can be applied directly.
As a matter of fact, you saw examples of built-in functions in the lesson about data types.
The function “type” allows you to obtain the type of variable you use as an argument,
like in this cell – “Type” of 10 gives “int” for integer.
The “int”, “float”, and “string” functions transform their arguments in an
integer, float, and string data type, respectively.
This is why 5.0 was converted to 5, 3 was converted to 3.0, and the number 500 became
text.
Great!
Now, let me show you a few other built-in functions that are quite useful.
“Max” returns the highest value from a sequence of numbers.
This is why “Max” returned a value of 30 as an output in this cell.
Good.
“Min” does just the opposite – it returns the lowest value from a sequence.
So, we get 10 in that cell over here – it is the smallest among 10, 20, and 30.
Another built-in function, “Abs”, allows you to obtain the absolute value of its argument.
Let “z” be equal to minus 20.
If we apply the “abs” function to “z”, the result will be its absolute value of 20.
See?
Perfect!
An essential function that can help you a great deal is “sum”.
It will calculate the sum of all the elements in a list designated as an argument.
Consider the following list made of 1, 2, 3, and 4 as its data.
When I type “sum list 1”, my output will be equal to 1 plus 2 plus 3 plus 4.
The sum of these numbers equals 10.
“Round” returns the float of its argument, rounded to a specified number of digits after
the decimal point.
“Round” 3.555 with 2 digits after the decimal point will turn into 3.56.
If the number of digits is not indicated, it defaults to zero.
3.2 is rounded down to 3.0.
Great!
If you are interested in elevating 2 to the power of 10, you know you could type “2
double star 10”.
You can get the same result if you use the “pow” function, which stands for “power”.
Write “pow”, and in the “parentheses”, specify the base and the power, separated
by a comma.
In our case, “2 comma 10”.
Execute with “Shift and Enter” and… voilà!
1024!
And what if you wanted to see how many elements there are in an object?
The “Len” function, as in “length”, is going to help you do that.
If you choose a string as an argument, the “Len” function will tell you how many
characters there are in a word.
For instance, in the word “Mathematics”, we have 11 characters.
There are many other built-in functions in Python, but these are a few examples you will
often need to use when programming.
Great!
We’ve made excellent progress so far!
By now, you know a bit more about Python’s syntax, about if, elif, and else statements,
and about functions.
In this section, we’ll cover an important topic for Python programming – lists.
So, what is a list?
A list is a type of sequence of data points such as floats, integers, or strings.
Therefore, understanding lists relates to your ability to organize data – a crucial
skill in today’s labor market.
Moreover, you’ll see Python creates a friendly environment for dealing with lists.
Assume you wanted to create a list called Participants that contains the names of John,
Leila, Gregory, and Cate.
Follow the rules about creating a generic variable.
But be careful about two things: place the strings within square brackets and make sure
you use quotation marks.
Precisely, these brackets indicate the elements inside form a list and not some other type
of a sequence.
Good, we see the Participants list has already been prepared.
Am I going to be able to extract the name of one member of the group?
Of course, I can.
Do you remember how we extracted the letter ‘d’ from Friday?
Using brackets after the word “Friday”.
The logic here is the same.
I’ll write the name of the list, and in brackets, I’ll indicate the position corresponding
to the name I am interested in.
It is important that I don’t use parentheses or braces.
For instance, let me extract the name of Leila.
As programmers, we start counting from zero, so: 0, 1…
1 should be the correct position!
And it is!
For the sake of argument, in such a situation, a computer scientist might say you have accessed
the list by indexing the value 1.
This means you have extracted the second of the elements in this list variable.
Ok, nice.
In addition, there is a way to get to the last element from your list –start counting
from the end towards the beginning.
Then, you’d need the minus sign before the digit and don’t fall in the trap of thinking
we begin enumerating from 0 again!
To obtain “Cate”, we have to write -1; to obtain “Gregory” we need -2.
Ok!
Now, let's study a key feature of lists - replacing or deleting items in a list.
Let's assume Kate had to quit for some reason, but Maria could replace her.
Here's what we can do: access the value at position number three, which currently refers
to “Cate”, and assign it with the string “Maria”.
Let’s check if our intuition was correct.
100 percent!
Amazing!
Another scenario: unfortunately, Gregory got a better offer somewhere else, so he quit
as well.
There is nobody to replace him, but we must adjust our list accordingly.
The del keyword could deliver the required result.
Type del, then correctly index Gregory’s position by typing “Participants 2” and...
voilà!
Important to note is that deleting an element changes the indices of all successive elements.
After removing Gregory, Maria’s position shifted one place to the left and is now at
the second position.
There is no element at the third position.
So, a new name, “Dwayne”, needs to be added to the “Participants” list, and
we’ll use a method called “append”.
Think of the terms method and function as interchangeable, because in practice, methods
work quite like functions.
However, the technically correct term to use in this situation is “method”.
Here is the syntax that allows you to call ready-made built-in methods that you do not
have to create on your own and can be used in Python directly.
After the name of the object, which in this case is the “Participants” list, we’ll
put a dot called a dot operator.
The dot operator allows you to call on or invoke a certain method.
To call the method “append”, state its name, followed by parentheses.
To insert the name “Dwayne” in our list, we must put the string “Dwayne” in inverted
commas between the parentheses.
After we execute the cell, we should have Dwayne added to our group.
Shift and Enter…
Correct!
Great!
Remember this general structure, because we have to comply with it, if we wish to call
any existing method in Python.
Alternatively, the same result can be achieved by using the “extend” method.
Let’s invite George and Catherine in our group.
First, let’s invoke the “extend” method.
Ok, good.
This time, within the parentheses, we’ll have to add brackets, as we are going to extend
the “Participants” list by adding a list specified precisely in these parentheses.
Execute through Shift and Enter and… you’ll have the two pieces attached - the initial
Participants list and the extension.
Thus, you still managed to enlarge your original list, right?
A couple more things before we close this lesson.
First, let me show you that lists’ elements are directly treated as string values.
After printing this command, we can see the first participant in our list is John.
It was not necessary to put any quotation marks around the “Participants” element
to do that.
Perfect!
Finally, the “Len” built-in function counts the number of elements in an object.
For instance, if our word is “Dolphin”, this function tells us it is composed of 7
letters.
More importantly, though, this same function can be applied for obtaining the number of
elements in a list.
Applied to the list we have here, it shows us the list entails six members.
Awesome!
To summarize, observe how a built-in function takes the object “Participants” as an
argument, while when we are calling built-in methods, they are applied to the “Participants”
list with the help of the dot operator.
The different syntax helps you distinguish between the two.
By the way, lists can be sliced, too.
But more on that in our next video.
In this lesson, we’ll introduce you to another very important concept – slicing.
In the future, when working in Python, you’ll typically have to deal with data that is quite
big.
Many of the problems that must be solved will regard a tiny portion of the data, and in
such cases, you can apply slicing.
Imagine you want to use the “Participants” list we saw earlier to obtain a second much
smaller list that contains only two names - Leila and Maria.
In Pythonic, that would mean to extract the elements from the first and second position.
To access these elements, we will open square brackets, just as we did with indexing, and
write 1 colon 3.
The first number corresponds precisely to the first position of interest, while the
second number is one position above the last position we need.
In our case, 2 plus 1 equals 3.
Correct.
We can say we just sliced our Participants list to obtain a new one with the names Leila
and Maria.
I know this piece of syntax seems a bit strange, but it is not that illogical.
Let’s get the first two names from the list, John and Leila.
In this case, you don’t need a number at the beginning, and you can start by typing
a colon.
Ok, so by typing colon 2, we get exactly the first 2 elements.
Very good!
And how can I obtain the last two?
One way would be to indicate the fourth position, corresponding to “George”, and leaving
nothing after the colon.
This would mean we will extract all the elements from the fourth position included to the end
of our list.
Another way to obtain the same result would be to put a minus sign in front of the number
2.
Thus, Python will revert the direction of counting, starting from the end towards the
beginning.
How many elements are we asking for?
2.
Let’s execute.
And here’s the output – we’ve obtained George and Catherine in a new list.
Perfect.
Ok, let’s check out some additional methods that can be applied to lists.
Assume you know “Maria” is in your list, but you don’t know her position.
In other words, you’d like to obtain the index of the element “Maria” from the
Participants list.
Just call the index method and indicate the string variable of interest in parentheses.
The machine tells us Maria is in the second position.
And it is.
The next functionality is an interesting one.
I will show you it is possible to create a list of lists.
My goal will be to create a list, called “Bigger List”, which contains the “Participants”
list, and a new one I will call “Newcomers”.
Let the latter enclose the names of Joshua and Brittany.
Shift and Enter…
Ok, we created “Newcomers”.
All I need to do in the next cell is write the name of the variable “Bigger List”
and cite within brackets the names of the lists I would like to include.
Let’s verify if this works.
Yes, it does.
The two lists are shown in the suggested order.
Great!
An important method that could order the names of your participants in alphabetical order
is sort.
As you can see, after applying it to our list, Catherine comes first and Peter is last.
If within the brackets, we say we would like the names to be sorted in a reversed order
by stating “reverse equals True”, Peter would be first and Catherine last.
Naturally, if our elements were sheer numbers, instead of people’s names, this method would
function without any problems.
Observe how, in this example, I sorted the numbers from 1 to 5 from the smallest to the
largest.
And here – from the largest to the smallest.
Wonderful!
This was a very important lecture.
Tuples are another type of data sequences, but differently to lists, they are immutable.
Tuples cannot be changed or modified; you cannot append or delete elements.
The syntax that indicates you are having a tuple and not a list is that the tuple’s
elements are placed within parentheses and not brackets.
By the way, the tuple is the default sequence type in Python, so if I enlist three values
here, the computer will perceive the new variable as a tuple.
We could also say the three values will be packed into a tuple.
For the same reason, we can assign a number of values to the same number of variables.
Do you remember we went through that a few lectures ago?
On the left side of the equality sign, we just added a tuple of variables, and on the
right, a tuple of values.
That’s why the relevant technical term for this activity is tuple assignment.
In the same way we did for lists, we can index values by indicating their position in brackets.
That’s why we obtained the first number from the tuple x, namely 40.
In addition, we can also place tuples within lists.
And then, each tuple becomes a separate element within the list.
Tuples are similar to lists, but there are some subtle differences we should not overlook.
They can be quite useful when dealing with different comma-separated values.
For example, if we have age and years of school as variables, and I have the respective numbers
in a string format, separated by a comma (hence the name comma-separated values), the split
method with the proper indication within the parentheses will assign 30 as a value for
age and 17 as a value for years of school.
We can print the two variables separately to check the outcome…
Everything seems to be correct – awesome!
Last, functions can provide tuples as return values.
This is useful because a function (which can only return a single value otherwise), can
produce a tuple holding multiple values.
Check this code; I will input only the length of the side of a square, and as an output,
the “square info” function will return a tuple.
The tuple will tell me the area and the perimeter of the square.
This is how we can work with tuples in Python!
Now that you know what lists and tuples are, you will more quickly understand what dictionaries
are about.
Dictionaries represent another way of storing data.
Each value is associated with a certain key.
More precisely, a key and its respective value form a key-value pair.
In this example, we have four keys.
Different names of animals are attached to each one of them.
Pay attention that neither parentheses nor brackets will work in this case – you need
curly braces.
After a certain dictionary has been created, a value can be accessed by its key, instead
of its index!
K1 can be used for cat, while K3 – a mouse!
Similarly, as we could do with lists, we can add a new value to the dictionary in the following
way: the structure to apply here is dictionary name, new key name within brackets, equality
sign, and the name of the new value.
The value we’ll assign to key number 5 is parrot.
I’ll press Shift plus Enter and… we are goоd to go.
Replacing a value follows the same syntax; just let the new variable correspond to an
existing key.
From that moment on, attached to the second key, we won’t see a dog anymore.
Ha, it’s a squirrel now!
You feel a list should be able to take part in a key-value pair.
And you are right.
Let’s turn to another example.
Say, only Peter works in department 1, but three people work in department 2 – Jennifer,
Michael, and Tommy.
Shall we verify?
Right.
Therefore, our second element is a list.
There is another way to fill in a dictionary.
I’ll create a new variable and will use empty curly braces to indicate it’ll be
a dictionary.
I will not place any keys or values within the braces.
Instead, I will assign the keys and the values one by one, and at the end, my dictionary
will be full.
Quite nice!
And if I asked for the center, I will see Hector’s name.
Let me introduce you to an interesting Python feature.
If the get function gives us the name of the Small Forward of a given team, the machine
won’t display an error if we ask for the name of the coach, whose name does not take
part in my dictionary.
“None” is the default value Python returns in cases where an object does not actually
exist within a given dictionary.
Now, you can imagine that dictionaries could do a great job, sometimes.
For instance, when using companies’ names as keys and their prices on the market as
values… right?
Bravo!
You are going deeper into programming!
Remember things will remain quite abstract, unless you take the time to practice and apply
what you’ve learned in these lessons.
Iteration is a fundamental building block of all programs.
It is the ability to execute a certain code repeatedly.
In this section, we will focus on a few examples of iteration processes in Python.
To begin, we have prepared a list, called “even”.
It contains all the even numbers from 0 to 20.
Imagine we want these numbers printed out.
So, we can write the following “for n in even”, colon, which would mean
for every element n in the list “even”, do the following: print that element.
In this case, n is called the loop variable.
It is not required to have called it n; any other name would have worked fine.
The phrase print n acts as the body of our loop.
Don’t forget it should be indented to run the loop properly.
The command in the loop body is performed once for each element in the even list.
Now, let’s go over the steps implied by this piece of code.
The loop starts by taking an element n from our list.
Then, the computer executes the body of the loop.
In our case, it will simply print that variable.
When the computer is done with this operation, called iteration (or pass) of the loop, Python
will go back to the for statement and pick the next element “n” that is in the “even”
list.
It will then print it out and so on and so forth until the loop body has been executed
for all available elements in the list.
Right, let’s apply this code to see the outcome.
Exactly as expected, all numbers were stated in a column.
What if we wanted to see them ordered in a single line?
A comma after the element “n” in the command “print n” will help us achieve that.
The comma will indicate every next element from the loop should be placed on the same
row.
This was a short but important introduction to the concept of Iteration in programming.
The same output we obtained in the previous lesson could be achieved after using a while
loop, instead of a for loop.
However, the structure we will use will be slightly different.
Initially, we will set a variable x equal to zero.
And we’ll say: while this value is smaller than or equal to 20, print x.
But please be very careful!
And I mean it!
If you leave the code until here, you will run into an infinite loop, and your computer
will crash!
This is a situation you want to avoid, right?
So be very careful; since x will always be smaller than 20, your loop will be infinite.
It will iterate the same variable repeatedly.
This is what we did here with x = 0.
And “always” is not what we want in an iteration.
We want to get the loop to end.
What is supposed to succeed, the loop body in the “while” block, is a line of code
that specifies a change in x or what has to happen to x after it is printed.
In our case, we will tell the computer to bind x to a value equal to x plus two.
Let’s see if this works.
Awesome!
This is much better.
Actually, there is a term for what we just did.
In programming terms, adding the same number on top of an existing variable during a loop
is called incrementing.
The amount being progressively added is called an increment.
In our case, we have an increment of 2.
Furthermore, the Pythonic syntax offers a special way to indicate incrementing.
“X Plus equals two” shows we are incrementing the value of 2 on top of the base x, just
as if we had typed “x equals x plus 2”.
As you can see, the two outcomes are the same.
To conclude, whether you will use a for or a while loop will depend mainly on your personal
preferences.
What matters is that your code does not crash and provides correct results, right?

Python’s built-in range function can help us by creating a list of numbers.
The syntax of the function is the following: type “range” and in parentheses mark a
start, stop, and step value.
The start value will be the first number in the list.
The stop value will be greater than the last value in the list.
It is going to be equal to the last number plus one (just classical Pythonic logic, right?).
The so-called step value represents the distance between each two consecutive values on the
list.
The stop value is a required input, while the start and step values are optional.
If not provided, the start value will be automatically replaced with a 0, and the step value would
be assumed to be equal to 1.
You could also remember the stop value as most important, the start value as less important,
and the step value as least important.
For this reason, “range of 10” will provide a list of 10 elements, starting from 0, implied
after not indicating a start value, and ending at the tenth consecutive number – number
nine.
In another cell, if in the “range” function we declare as arguments 3 and 7, for instance,
Python will accept 3 as a start value, and 7 as a stop value of the range.
So, we’ll have 4 elements – 3, 4, 5, and 6.
Good.
To specify a step value in a range, the other two arguments must be chosen as well.
In this situation, I’ll obtain a list with all the odd numbers from 1 to 19 included.
I will start with the number 1, and the list will end with number 19 (which equals the
stop value 20 minus 1), stating only the odd numbers.
This is how we can create lists with Python’s range function.
In our next lecture, we’ll see how it can be applied in practice.
Now that you know what the “range” function does, let’s see it in a for- loop.
To print all the values from 2 to the power of 0, 2 to the power of 1, and so on, until
2 to the power of 9, we can use the following code: for “n” in range of 10, print “2
double star n”.
I will also have to insert a comma, because I would like to see the output on a single
line.
Good.
I guess you can agree it was not necessary to specify the name of a list that exists
in our code – using a list created through the “range” function is going to work
too!
Now, let’s be brave and create an iteration that includes a conditional in the loop body.
We can tell the computer to print all the even values between 0 and 19 and state “Odd”
in the places where we have odd numbers.
Let’s translate this into computational steps.
If x leaves a remainder of 0 when divided by 2, which is the same as to say “if x
is even”, then print x on the same line.
“Else”, which means unless x is even, or if x is odd, print “Odd”.
Lovely!
This is an example of a combination of an iteration and a conditional in Python.
There are two main ways to program a loop, and until this moment, we paid attention only
to the first one.
We have a list x that contains the numbers 0, 1, and 2.
We saw we can print out each of its elements by typing “for each item in the x list,
print out that item”.
The second way finds its practical application in more sophisticated codes.
Its structure takes advantage of the range and len functions in the following way: “for
each item in a range that goes through the elements from the list x, that is “len with
an argument x”, print out each item”.
If we do this, the variable item will loop through a new list created by range, and that
has as many elements as the x list itself.
Please note that, in this situation, the second line of our code needs indexing to extract
each item from the “x” list.
In practice, we will print out the element at position 0 from the list x, then the element
at position 1, and finally the element at position 2.
To conclude, both approaches can lead to the same outcome.
Although the second one looks unnecessarily complicated, in advanced coding, it might
turn out to be a lot more useful.
So, it is important you know both.
We use iterations when we have to go through variables that are part of a list.
In this lesson, I’ll show you how to count the number of items whose value is less than
20 in a list.
First, define a function that takes as an argument numbers, where “numbers” will
be a certain list variable.
The trick is to create a variable that, so to speak, “departs” from 0.
Let’s call it total.
The idea is that, when certain conditions are verified, total will change its value.
This is why, in such a situation, it is appropriate to call this variable a rolling sum.
More technically, when we consider x in the numbers list, if it is smaller than 20, we
will increment the total by 1 and finally return the total value.
This means that, if x is less than twenty, total will grow by 1, and if x is greater
than or equal to 20, total will not grow.
So, for a given list, this count function will return the amount of numbers smaller
than 20.
Let’s verify if this function works properly.
In this list, we have four numbers that are less than 20, right?
Let’s check that out.
Great!
Now, if I add 17, for example, somewhere in the list, the outcome will adjust accordingly.
5.
Exactly!
Perfect!
By the way, look how the whole if-statement is indented even more to the right.
This allows us to separate it logically from the rest of the code in the cell that refers
to this function.
If you are eager to know how to iterate over a dictionary in Python, and I am sure you
are, you will see this in our next video.
Thank you for watching!
Let’s look at something a bit more challenging- iterating over a dictionary.
We have a couple of examples here.
The prices of a box of spaghetti, of a portion of lasagna, and of a hamburger are stored
in a dictionary, called “prices”.
Jan went to the supermarket and bought 6 boxes of spaghetti, 10 pieces of lasagna, and no
hamburgers.
This data was stored in a dictionary, named “quantity”.
Our problem is: how much did Jan spend in the supermarket?
Well, it is obvious you’ll need to multiply the quantity of each food by its price.
You must have noticed our dictionaries have exactly the same keys.
We should exploit this.
The procedure to go to the “box of spaghetti” in the first dictionary and take the value
of 4, then get the value of 6 from the quantity dictionary, and then multiply those two, must
be repeated for each food product.
That must ring a bell.
 I am sure you probably think the same – we need a loop.
Ok, that’s clear, but what are we going to do with it?
What is the loop’s body going to contain?
Before anything else, some variable must account for the amount of money spent, right?
Let’s implement a well-known trick.
I’ll create a rolling sum, called “money spent”, which will initially assume the
value of 0.
So, we can start by iterating over each item in prices, “i” in prices for short.
At every step of the loop, I would like the “money spent” variable to grow by the
product of the price and the quantity of a certain good “i”.
And that should be enough.
Let’s print the result to check whether we were working correctly.
Apparently, yes!
Wow!
Such a simple problem in terms of mathematics, required to connect knowledge on dictionaries,
iteration, and creating a variable with an increment.
So, from a programmer’s perspective, the problem looks different.
The good thing is that, at the end, this whole thing boiled down to a mere four lines of
coding!
As a side note, do you realize that, if we put quantity instead of prices here, the outcome
will remain the same?
So, what is the conclusion?
It does not matter if you loop through prices or through quantity, because the two dictionaries
contain the same keys.
And this is the reason this loop works correctly, too.
Thanks for watching!