Zip Code Wilmington’s Programming in Python

Python is an easy programming language to learn, and we’re going to use it in this book to describe the basic fundamentals of coding. Its form is modern and it is widely used. It can be used for many purposes, from web applications, machine learning, data science to back-end server processing. We’re going to use it for learning simple, programming-in-the-small, method-functions and concepts; but make no mistake - Python is world-class language capable of amazing things.

Zed A. Shaw is a popular author of several books where he describes learning a programming language The Hard Way. Zed suggests, and we at Zip Code agree with him whole-heartedly, that the best, most impactful, highest return for your investment when learning to code, is type the code using your own fingers ^[1]

That’s right. Whether you are a "visual learner", a "video learner", or someone who can read textbooks like novels (are there any more of these out there?), the best way to learn to code is to code and to code by typing out the code with your own fingers. This means you DO NOT do a lot of copy and paste of code blocks; you really put in the work, making your brain better wired to code by coding with your own typing of the code.

You’re here, reading this, because you’re thinking (or maybe you know) that you want to become a coder. It’s pretty straight-forward.

You may have heard a friend wistfully dream of making a career at writing. "Oh," they say, "I wish I had time to write a great novel, I want to be a writer someday".

So you can ask them: Did you write today? How many words? And the excuses flow: "Oh, I have to pick up the kids" "Ran out of time, I’m so busy at work." "I had to cut the grass" and so on. Well, I’m here to tell you that all the excuses in the world don’t stop a real writer from writing. They just sit down and do it. As often as they can, sometimes even when they can’t (or shouldn’t).

Coding, like writing, isn’t something you can do when all your other chores, obligations, and entertainments are done. If you’re serious about learning coding, you must make time for coding.

Watching hours of YouTube videos will not make you a coder.

Reading dozens of blog posts, Medium articles, and books will not make you a coder.

Following along with endless step-by-step tutorials will not make you a coder.

The only way you’re going to learn to code is by doing it. Trying to solve a problem. Making mistakes, fixing them, learning from what worked and what didn’t at the keyboard.

Many have heard my often-repeated admonition: If you coded today, you’re a coder. If not, you’re not a coder. It really is as simple as that.

I happen to be among those who feel anyone can learn to code. It’s a 21st century superpower. When you code, you can change the world. Being proficient at coding can be a life-changing skill that impacts your life, your family’s life and your future forever. Time and time again, I’ve seen that the ability to learn to code is evenly distributed across the population, but the opportunity to learn to code is not. So, we run Zip Code to give people a shot at learning a 21st century superpower, no matter where you come from.

And fortune favors the prepared. Some day, you may be working at a great company, making a decent living, working with professionals in a great technical job. Your friends may say "You are so lucky!"

And you will think: Nope. It wasn’t luck. You’ll know that truly. You got there by preparing yourself to get there, and by working to get there, working very hard. Ain’t no luck involved, just hard work. You make your own luck by working hard.

As many know, getting a spot in a Zip Code cohort is a hard thing to do. Many try but only a few manage it. I often get asked "what can I do to prepare to get into Zip Code?"

The best way is to start solving coding problems on sites like https://hackerrank.com - HackerRank (among others) has many programming assignments, from extremely simple to very advanced. You login, and just do exercise after exercise, relieving you of one of the hardest of coding frustrations, that of trying to figure out what to code. Solving programming assignments is a good way to start to cultivate a coding mindset. Such a mindset is based on your ability to pay very close attention to detail, a desire to continually learn, and being able to stay focused on problem solving even if it takes a lot of grit and dedication.

Spending even 20 minutes a day, making progress on a programming task can make all the difference. Day after day your skills will grow, and before long you’ll look back on the early things you did and be astonished as to how simple the assignments were. You may even experience embarrassment at remembering how hard these simple exercises seemed at the time you did them. (It’s okay, we’ve all felt it. It’s part of the gig.)

Working on code every day makes you a coder. And coding everyday will help with your ability to eventually score high enough on the Zip Code admissions assessment that you get asked to group and potentially final interviews. And then, well, then you get to learn Java or Python and work yourself to exhaustion doing so. Lots and lots more hours.

Why?

You do that hard work, you put in those hours, you create lots of great code, you’ll make your own luck, and someone will be impressed and they will offer you a job. And that is the point, right? A job, doing what you love, coding. Right? RIGHT?

You’re Welcome,

-Kristofer

Ready?

Okay, let’s go.

An expression is something that needs to be computed to find out the answer. Here are a few simple ones.

Each of these lines is something we’d like Python to compute for us. That computation is often referred to as "evaluation" or "evaluate the expression" to get to the answer. There are two kinds of expressions in Python, arithmetic expressions and boolean expressions.

Arithmetic expressions are, as their name implies, something that require arithmetic to get the answer. An expression like "5 + 8 - 3" gets evaluated to 10.

Boolean expressions result in either a True or a False value. Example: "maxSpeed > 500.0" - this is either true or false depending on the value of maxSpeed.

A statement is just a line of Python.

And this is what a Python program looks like. It’s just a list of statements, one after the other, that get computed from the top down.

Some of the statements have expressions in them (like totalGroceries * salesTaxRate), while some are just simple assignment statements (like totalGroceries = 38.99, where we assign the variable 'totalGroceries' the value 38.99). Don’t panic. These are just some simple examples of Python to give you a feel for it. We’ll go thru each of these kinds of things slowly in sections ahead.

In this book, you may see that the code used in examples is longer than can fit on one line in the code boxes. In Python, we have to add a line "continuation" character. So to be clear, a statement with long variable names is the same as one with a short name, but you may have to add "\" (backslashes) to make Python happy.

When you come across code that goes onto multiple lines, do like Python does, look for the backslash, when you find it, think of the line being spread out.

Very often in Python, we will see a block of statements. It is a list of statements indented the same amount. (Yes, unlike many languages, in Python, white space is important.) It acts like a container to make clear what statements are included in the block.

It is so important that indentation, and making sure you have everything aligned properly, is one of the most important thing to learn about Python when you are a beginner. Many a beginner discovers that the braces { } that other languages use to manage the way code is grouped together are missing from Python. Java, JavaScript, and many other languages use braces to handle how code gets grouped together.

Not Python, that’s why is SO very important to get it right.

See those SPACES (and confusingly, they might be TABs but you cannot tell that by looking at the line). All the indented lines below the IF statement are part of what gets run when the IF is True. Then you also see a nested IF below that, one that has an else statement. But the key thing is to look at the lines of code and notice how they are indented, because that tells what you need to know about how the program works, and what gets done depending on the states of the variables. (Don’t worry, we will be going into all this a lot more carefully later.)

Editing tools that let you work on Python do their best make the indentations are correct, but it is a common problem for beginner Python programmers to think the indentation isn’t important and spend far too much time tracking down silly indentation errors.

So, the wise Python beginner spends a fair amount of time making sure the details are exact on indentation. Making sure code is indented correctly is part of being a Pythonista.

Indentation is rejected as inconsistent if the code mixes tabs and spaces it gets flagged as an error in the code; a TabError is raised in that case.

In Python, variables are containers used to store data while the program is running. Variables can be named just about anything, and often are named things that make you think about what you store there.

Think of them as little boxes you can put data into, to keep it there and not lose it.

There are some rules about variables.

So this means the following are fine for variable names in Python:

And uppercase and lowercase letters are different. So each of these are DIFFERENT variables even though they are based on the same word(s).

So be careful with UPPERCASE and lowercase letters in variable names.

Constants are like variables but they contain values that SHOULD NOT change such as a person’s date of birth. Convention is to capitalize constant variable names.

They are usually declared in a file named 'constants.py'.

Note: In reality, we don’t use constants in Python. (The language doesn’t have them.) Naming them in all capital letters is a convention to separate them from variables, however, it does not actually prevent reassignment. So be careful.

Python can keep track of a number of different kinds of data, and these are known as "data types". Here are a few of them.

It is common for a computer language to want to know if data is a bunch numbers or text. Tracking what type a piece of data is is very important. And it is the programmer’s job to make sure all the data get handled in the right ways.

So Python has a few fundamental data types that it can handle. And we will cover each one in turn.

Now, you try it. Write down a variable name and assign a normal value to it.

Python has a series of different data structures built into the language. Its built-in data structures include lists, tuples, sets, and dictionaries.

Say we needed to multiply two numbers. Maybe 2 times 3. Now we could easily write a program that printed that result.

And that will print 6 on the console. But maybe we’d like to make it a little more complete.

Using this as a model, how would you write programs to solve these problems?

We know that we can do regular division. If have a simple program like this, we know what to expect:

But sometimes, we have a need to know what the remainder of a division is. The remainder operator %, despite its appearance, is not related to percents.

The result of a % b is the remainder of the integer division of a by b.

Now what’s this about '%' (the remainder) operator?

A strange thing about these operators is the order in which they are evaluated. Let’s take a look at this expression.

We can do this one of two ways:

Wait! Which is right? How can the answers be so different, depending on the order we do the math in? Well, this shows us that the Order of Operations is important. And people have decided upon that order so that this kind of confusion goes away.

Basically, multiply and divide are higher priority than add and subtract. And exponents (powers) are highest priority of all.

There is a simple way to remember this.

There is a useful thing in Python called the math object which allows you to perform mathematical tasks on numbers.

To make these work, you need to import the math module.

math.pow() Example

Say we need to compute "6² + 5"

What will the answer be? 279936 or 41?

How did Python solve it?

Well, 6² is the same as 6 * 6. And 6 * 6 = 36, then add 36 + 5 = 41.

And notice, when we raise a number to the 0.5 power, it’s the same as taking its square root!. And that can be handy sometimes.

You’ll learn a lot more about working with numbers in your career as a coder. This is really just the very basics of the very beginnings.

The word trigonometry comes from the Greek words, trigonon ("triangle") + metron ("measure"). We use trigonometry to find angles, distances and areas.

For example, if we wanted to find the area of a triangular piece of land, we could use the equation AreaOfaTriangle = height * base / 2

Therefore we just need to create variables for each and use the operators to calculate the area.

Hint: You’ll need to use a constant Math property!

Here is a possible solution to the calculation.

See how we used math.pi to handle the equation?

Let’s create a simple problem to solve with Python.

What do we need figure out? We need a variable for our result: totalMilesDriven. So we start our program this way…​

It’s often good to start with a very simple template. If we run that, we will see 0 (zero) as the result, right?

Next step, let’s add the variables we know.

Okay, good. We’ve added all the stuff we know about the computation. Well, except the part of the actual computation.

You probably know that if you multiply the milesPerGallon by the totalGasGallons, that will give you totalMilesDriven. And if you divide the totalMilesDriven by the milesPerHour, you will get the totalHoursTaken.

So let’s add those as Python statements.

We get as a result 264 miles driven in 4.8 hours. And that’s how a simple Python program can get written.

Let’s do another.

A friend of ours is offering you a "free cat". You’re not allergic to cats but before you say yes, you want to know how much it’ll cost to feed the cat for a year (and then, approximately how much much each month).

Looking at it, this may be quite simple. If we know each can feeds the cat for a day, we then know that we need 365 cans of food. So we can describe that as

What’s going to be the answer? ^[5] Run it in your Repl window to work it all out.

And let’s do one more.

A cell phone company charges a monthly rate of $12.95 and $1.00 a gigabyte of data. The bill for this month is $21.20. How many gigabytes of data did we use? Again, let’s use a simple template to get started.

Let’s add what we know: that the monthly base charge (for calls, and so on) is $12.95 and that data costs 1 dollar per gigabyte. We also know the monthly bill is $21.20. Let’s get all that written down.

Now we’re ready to do the computation. If we subtract the monthlyRate from thisBill, we get the total cost of data. Then, if we divide the total cost of data by the cost per gigabyte, we will get the dataUsed.

How many GBs of data did we use? Turns out to be 8.25 gigabytes.

Now if the bill was $24.00? How many GBs then? (go ahead, I’ll wait…​) ^[6]

Think about the words on this page. The text here is made up of a bunch of letters, and spaces. Now, when we write by hand, we don’t really think about the space between the words, do we? If we truly ignored the notion of space between the words, wewouldendupwithtextlikethis. And while it is possible to read, our modern eyes are trained on well-edited texts; having no spaces tires us pretty quickly.

So yes, what we see as text in this book is really a series of letters and spaces strung together in a line - line after line, paragraph after paragraph. In modern computing, that kind of data is often called a String. It is one of the most fundamental aspects of coding: the manipulation of strings by programs to transform, present or store text in some fashion.

Many programming languages use some kind of quote or double quote to show where strings start and end. There is really no difference between using single or double quotes in Python. So a string like "the quick brown fox" would be a string from the 't' to the 'x'. And notice the three spaces within the string. If they were not there, the string would be "thequickbrownfox". And that’s important, because to the computer, if it keeps these two strings around, it doesn’t really understand that 'the' and 'quick' are just two common English words. The spaces are there to retain more of what the human meant.

No, to the computer, each letter, including the space 'letter', is just a piece of data and very important.

String - a string of letters and numbers and spaces and punctuation, kept altogether for some use. Here are some strings for you to consider.

Think of strings as a tightly packed list. Each item and letter is numbered. The entire string can be "indexed", meaning I can reach in and copy out, say, the fifth letter easily. String indexes are zero-based; therefore, the first character (element) is in index position 0.

So here, "H" is at 0, "e" is at 1, 'l' is at 2 & 3, and 'o' is at index position 4. Computers often start numbering things like strings, lists, and arrays at 0, not at one. It’s just one of those things: all strings and arrays (which are coming up) start at zero.

Now we have a string variable named name and it’s value is "Wacka Flocka".

A common and often used string property is length.

We can use len() builtin function to find the length of a string

As mentioned before, we can reach into a string and copy out the stuff we find there.

When you see something like word[0], it is pronounced like "word sub zero". If you have word[5], you would say "word sub five". This is just verbal shorthand for the expression.

This simply means joining strings together using the + operator. We have to turn the 20 (which is a number) into a string. We do this by calling the builtin str() function.

Or perhaps a little more useful example:

The output would be:

Getting a substring is a common operation. This is how we extract the characters from a string, between two specified indices. (Which is why it’s important to remember the indexes start at 0.) Python offers many ways to substring a string. It is often called ‘slicing’. It follows this pattern:

somestring[start: end: step] and each of the start, end and step indices are optional.

start: The starting index of the substring. The character at this index is included in the substring. If start is not included, it is assumed to equal to 0.

end: The ending index of the substring. The character at this index is NOT included in the substring. If end is not included, or if the value is greater than the string length, it is assumed to be equal to the len() of the string by default.

step:` Every ‘step’ character after the current character to be included. If the step value is not there, Python sets it to 1.

A start position is required, where to begin the extraction (or substring). Remember, first character is at position 0. Characters are extracted from a string between "start" and "end", not including "end" itself.

Now let’s use the 3 substring method-functions on firstName and extract and print out "Chris"

We took the firstName string and extracted the characters 0 to 4. BUT, let’s try to extract the string "stop" from the name.

Let’s try a little harder idea…​

Well?

Want to bet there is also a ".lower()" method-function as well?

Take a look at these various ways to copy out a substring from the source string named 'rapper', which contains the string 'mikaila'.

How about a few more?

We’re using a variety of examples to copy out some smaller piece of the 'rapper' string. This is a powerful way to handle strings in Python.

Now, using the firstName variable again, let’s reverse the string "STOP" to say "POTS".

Solution

Strings are perhaps the most important data type in almost any language. Being able to manipulate them easily and do powerful things with them in Python, makes you a better coder.

Declaring and initializing some lists in Python:

We use square brackets to get elements by their index. We’ll use an list of strings to identify our donuts. Sometimes, we say something like "donuts sub 2" to mean donuts[2].

We can also add things to the end of the list.

We can use the length property to find the size of an array.

Note: A string is an LIST of single characters

If we use the len() function carefully, we can always get the last element in a list. The index of the last element in the list is 'length minus 1'.

Some computer languages have arrays. Python’s Lists are like arrays and even more powerful.

The first conditional statement is the if statement.

Here are a few simple examples.

Python also has an else part to the if statement. When the if condition is False, the else part gets run. Here, if the account doesn’t have enough money to fulfill the amountRequested, the else part of the statement gets run, and the customer gets an insufficient funds receipt.

Python can also "nest" if statements, making them very flexible for complicated situations. You can also see here how the elif works. There can be zero or more elif parts, and the else part is optional.

Notice how this becomes a 3-way choice, depending on the timeOfDay.

You should use an if statement for your solution!

Finally, make sure to change the value of the age variable in the repl, to output out different results and test that all three options can happen. What do you have to do to make the else clause happen?

If statements are one of the most commonly used statements to express logic in a Python program. It’s important to know them well.

Loop through a block of code (the body) WHILE a condition is true.

See the code below. In this case, we start with a simple counter in x = 1. Then, after the loop starts, it checks to see if x < 6, and 1 is less than 6, so the loop body gets executed. We print out 1 and then increment x. Then we go to the top of the loop and check to see if x (now 2) is less than 6. Since that’s true so we print out 2 and increment x again. This continues like this for three more times, printing 3, 4, and 5.

Then, x is incremented to 6, and the check is made again, 6 < 6 …​ well, no that is false. So we don’t execute the loop’s body and we fall through to the last print line, and print out x.

While loops work well in situations where the condition you are testing at the top of the loop is one that may not be related to a simple number.

This will keep letting player[1] take a turn in the game until the player dies. Another way to do something like this is with an infinite loop. (No, infinite loops are not necessarily a bad thing, watch.) We’re going to use both continue and break in this example, and we will describe them better after we’re done with loops.

Here, we are using the continue statement to force the flow of control to the top of the loop if the player is still alive after the 'take turn' code. We are also using the break statement to break out of the infinite loop when the player dies, letting us do other things after the player has 'died'.

The for loop is more complex, but it’s also the most commonly used loop.

In Python, the for loop is very powerful. It has a number of different forms, including one which is remarkably simple.

Maybe we have a list of donuts. And we want to print out each one.

This is called a for-each loop. It steps thru the list, and For Each donut in list_of_donuts, it does whatever the code in its block specifies - here just printing out the donut. It has the ability to iterate over the items of any sequence, such as a list or a string. A sequence here is a list, or a string, or a couple of other data structures we haven’t yet talked about.

Just like slicing a string, a list (or any sequence of data) can be thought of a series of data point where the index start at zero and goes to len(thing)-1. Just like a string "hello" which goes from 0..4, our donut list goes from 0..2 - in this example you see the range() function for the first time. And in python code, you see a lot of range().

Here the index was set to 0 and then 1, and then 2, and the index was used to retrieve from the list the donut name at the index. list_of_donuts[1] is "glazed". This example’s out is the same as the for-each loop above.

Let’s use range() is much more common usage.

Here’s one where we go from 0 to 4.

Notice how in this case, the loop prints out 0..4!

Now say we wanted to print out the sum of all the numbers from 1 to 10.

Wait! Notice how we have to ask range to one beyond the last number we want added to the sum! That’s because the range starts at 0 and includes every whole number up to, but not including, the number that you have provided as the stop number.

There are three versions to the range()'s mechanism.

So if you have:

Let’s show you a glimpse of the break statement.

Jumps out of the loop when p is equal to 4.

What about if we print from 10 to 1 with a for loop and a while loop (hint: we need to decrement).

Look, we had to range(10, 0, -1) to get the one to print. Otherwise if we had had used range(10,1,-1), we would have only printed 10 to 2.

The range() function gets used a lot in Python, and is the envy of many programmers in other languages who have use the for loop that was handed down from the C programming language. So use it widely, and don’t gloat — too much :-)

The pass statement does nothing. It can be used when a statement is required syntactically but the program requires no action. For example:

That was an infinite loop!

pass is commonly used for creating minimal classes:

Another place pass can be used is as a place-holder for a function or conditional body when you are working on new code, allowing you to keep thinking at a more abstract level. The pass is silently ignored:

Normally, a loop exits when its condition becomes false. But we can force the exit at any time using the special break statement.

Here, you are asking the user to type in a command. If the command is "exit", then quit the loop and output "Exiting", and end the program. Otherwise, execute the command and go around to the top of the loop and ask for another command.

The continue statement doesn’t stop the whole loop. Instead, it stops the current iteration and forces the loop to start a new one (if the condition allows).

We can use it if we’re done with the current iteration and would like to move on to the next one. This loops prints odd number less than 10.

What’s interesting here is the use of the remainder operator (%) to see if a number is odd. The expression (i % 2) is zero if the number is even, if not, the number must be odd. You want to remember this trick of how to find odd or even numbers. It’s a common programming problem that you will get asked. The continue statement starts the loop over, not letting the print to print out the number when it’s even.

But you, being a newbie pythonista might say: 'yeah, but why not just use range(1,10,2) instead of all the IF and Modulo and continue??'

And me, being the crusty old instructor might say, 'Bah, Humbug!'

If you wanted to find the larger of two values, x and y, and assign it to 'max':

Related to it, if we have two variables x and y, and we want the smaller in x, and the larger in y.

Do you see the three statements in the block there? That’s called a 'swap'. If you need to swap two values in two variables, you just create a quick temporary variable 't' and use it as a place to make a copy of the first variable’s value.

But let me show you a really cool trick in Python. It’s related to a data type we haven’t talked about yet, call a tuple (which I pronounce "two-pell").

I can in python do things like this:

If I needed to make sure a number is always positive (greater than zero), it’s easy - this is called taking the "absolute value" of a number.

The next few are examples of the handy use of loops to do a bunch of math easily and quickly. Imagine a problem where you have to "add all the numbers from 1 to 100 and print the sum." It might also be expressed as "sum all the number from x to y" (where x and y are two integers). Turns out there is a very easy pattern to learn here.

Now, if you wanted to find the average of a bunch of numbers, that’s as easy as taking the sum of the numbers and dividing the sum by the number of numbers (or n).

Pretty easy, yes? And the other common pattern here is doing a product of all the numbers from 1 to n. (Let’s try 20)

Perhaps you want to print a table of values of some equation.

Lists are often something that confuses beginning coders. Let’s look at some code patterns with lists that you see how lists and loops can work together to get a lot of work pretty easily.

The list we are going to use in all these cases is pretty simple. It’s a list of 7 numbers.

Here how to print out the list, one value per line.

If we needed to find the smallest number in the list, we could do:

We should look carefully here. First, notice how I have taken the first element a[0] and made my first 'min' that value. Then we step through the list, looking at each value and if the new value is smaller than the previous one, we update it; otherwise, we just do the next value.

NOW, if you wanted to find the largest value in the list, you really only have to change a couple things.

Carefully look at the code, comparing to the one above. What’s different? Well, for one, we changed the variable from 'min' to 'max'. (But did we need to do that? We could have left it max, but it’s cleaner to make the change so people who read it aren’t confused.) We also changed the comparison in the 'if' statement from "less than <" to "greater than >" which lets us decide if the new number is larger than the previous largest we found.

In both of these cases, we start with an initial value, then we step through the list, look at each value comparing it to the smallest (or largest) value we have yet found. If we need to update the 'carrying variable', we do; otherwise, we just ignore the value.

What about finding the average of the values in the list? Well, we do it a lot like the average of the series of numbers.

Yep, the "len(a)" is very handy, it has exactly the count of the numbers in the list!

Finally, if we wanted to reverse the values in the list, we could write some code:

But perhaps the easier way to reverse an list in Python is to just call the library function:

It can be useful to look at the "longer" way to continue to get a feel for how to do small, useful things with simple logic.

An example of how you write a function definition:

You end up with a function named 'add' that takes two parameters and adds them, returning the result. (Yes, you could just write (p1 + p2) and everyone would understand. It’s just a very simple example.) Here is another example:

Functions are meant to be invoked. So you can have one function call another function which calls a third function and so on; it’s very common.

Imagine we have a program that gets an airplane ready for flight. We can imagine a whole series of functions we’d have to write. Things like 'loadPassengers', 'loadBaggage', 'loadFuel', 'checkTirePressures', and so on. Then we might have a 'higher level' functions which brings all these pieces together:

You can see how functions you perform different things in a particular order, and while you might have no idea how 'loadBaggage' does what it does, you can see how the program preps the airplane object for flight and makes sure everything important is done. Each of the functions from 'loadBaggage' to 'takeoff' is invoked and returns so the next one can be invoked. This is the power of functions - the ability to take some code and put it a function so that it much easier to understand.

A common pattern used in Python revolves around an lambda function. Something like:

This gives us another way to wrap up a little code into a function. We could redo the first example in this chapter with a lambda function.

Once Python reaches a return statement, the function will stop executing. Functions often compute a return value. The return value is "returned" back to the "caller". You can have many returns in a functions, depending on how the flow of control is changed.

Or like this:

Notice how in this case, we check to see the scoring results with two conditions (which are, what? yes, boolean expressions). If neither condition is true, the third one must be the case. But if either condition is true, then we return right away, and the function is done.

Again, to be clear, we might use this function like this:

As you just saw, functions can also take parameters to be used within a function.

Remember how we had the expression ot see if a number was even? ( x % 2 === 0) Now, here’s a way to decide is number was divisible cleanly by another, it’s a standard arithmetic expression:

So to see if a number is even, we could use '(number % 2 == 0)':

And we can use the same technique to see if a number is evenly divisible by 3 or 5.

Try to write a function that will perform the following requirements:

OKAY! Write it yourself!

Do it.

Just write it yourself.

C’mon, write your own version first.

No, really.

Wait.

Do you want to be a ZipCoder, or just a Copy-Paste Stylist?

Well, here’s one solution:

Creating a dictionary is easy:

Modifying a dictionary and getting values from them is very easy.

You can add another dictionary key:value pairs.

We can print it out.

And one of the very cooler aspects is the testing of whether or not a key is in the dictionary. You use in and not in to determine

We could use them to hold information about some object we’re holding data about.

Or this dictionary

Dictionaries are a tremendous tool. They are used in many, many places within Python systems. Dictionaries are built-in data types in Python that associate (map) keys to values, forming key-value pairs. You can access, add, modify, and delete key-value pairs.

We can imagine an object as a container where everything is collected about some thing in the program:

Which isn’t very helpful, is it? We need to create a method in our class. One that gets called whenever we want to display which spacecraft to a user.

There a few things to point out in this class. First, notice how the str function is indented? It’s defined inside the class. That makes the function a method; objects have methods. You can call a method on a particular object.

This example also shows how you use a class to create multiple objects. It helps with making code simpler, and easier to follow when reading it.

There are a number of very powerful things we have left out of this discussion about Python objects. We have not covered the ideas of inheritance or the idea of subclassing. And there is much more in Python about objects. Master what we’ve written about here and then forge ahead into more complicated and powerful capabilities.

There is a lot more to learn about Python.

Now, if you wanted to print out each item’s name in the grocery list to the console, you could do something like this:

This is a very common code pattern in Python. It’s also a pretty simple loop.

Rather, how about this:

It is list comprehension, and in Python its remarkably powerful. Say we wanted to print the total cost of our grocery list. If we did it with a loop and sum variable:

Not too bad, but we can put it all on one line, and only one loop:

This example step through the grocery list, pulling out each item, and the item['price'] pulls out the price and places it in a list. When loop is done, the sum() function sums and returns all the prices in the list.