CS2 Lab 6 2024, Python II 💸

<<< Back to main site

Due Date: 11/21/2023
Complete this lab after Python I lab.

Need help? Remember to check out Edstem and our Website for TA help assistance.

Background 💸

Be sure to read all background notes, as they are vital to do the assignment.

In Lab 6: Python Part II, you will be learning about some of the most powerful components of programming - functions, loops, and variable scope.

Nearly every electronic device on the planet uses these ideas, and even the most complicated bits of code rely on these building blocks to work.

---

Let's learn some more python!

For Loops

In programming, we often want to loop or iterate over data. We can "loop over" or go through each item in a collection using for loops.

Here's how we break down a for loop:

    for item in collection:
        print(item) # prints the selected item.

Say our collection was:

    collection = [1, 2, 3, 4]

Then running

    for item in collection:
        print(item) # prints the selected item.

Will print:

1
2
3
4

So think of a loop as "going through" each item in a collection, and then doing something with that item. In this example, we just print-ed that item out to our console.

After the loop iterates over every element in a collection, it terminates and code beyond the loop body will be executed.

So, if we had:

    for item in collection: # for ever item in collection
        print(item) # prints the selected item.
    
    print("hey!")

"hey!" would only print after every item in the collection was visited.

The collection to be iterated over can also be a number! If we wanted to produce an output a certain number of times, we can use a range of numbers:

    for num in range(10): # every number between 0 and 10 (exclusive)
        print(num) # prints the current number.

Will print:

0
1
2
3
4
5
6
7
8
9

You can also use number ranges to execute code a certain number of times. For example:

    for num in range(10): # every number between 0 and 10 (exclusive)
        print("Hi!") # prints the string "Hi!"

Will print the word "Hi!" ten times.

Think of why we would want to use a number loop in some cases, vs a loop that goes over a collection in other places!

Functions

The purpose of functions is to contain code that has to be done repeatedly. If, on the other hand, a task is only to be done once, then it should be written directly in the main program.

Functions don’t have to take in a parameter, or an input, but they often do. The body of a function is as follows:

def function_name(parameter1, parameter 2...):
        #Code inside the function
# Code outside of function

The body of a function, or the code that the function will execute, is everything that is indented below the function declaration. Anything on the same alignment level as the function declaration is not in the function.

Below is an example of a function that adds three parameters together and prints the total.

    def add_three_numbers(number1, number2, number3):
        print(number1 + number2 + number3)

You can think of the parameters as inputs that generate some output. Parameters let us call functions with different inputs, and run the same code on them.

Think, parameters let us call the add_three_numbers function on different sets of numbers.

We can "call" this function and have it execute through the following:

    add_three_numbers(1, 2, 3) # Will print the total of 1 + 2 + 3.

Notice we invoke the name of the function, followed by parentheses, and put the parameters inside the parentheses as arguments. An argument is the actual input you give a function. (Think of parameters as placeholders, and arguments as the real deal.)

We can re-use this function as many times as we want, just by calling it and trying different numbers as arguments!

The order of your parameters matters!

    def divide(numerator, denominator):
        print(numerator / denominator)

Think of the outputs:

    divide(1, 2) # prints 0.5, 1 = numerator, 2 = denominator
    divide(2, 1) # prints 2 2 = numerator, 1 = denominator

Many times it is useful to have a function return some data instead of simply printing it. You can think of return as outputting some variable. For example, perhaps you want to access the sum of three numbers outside the function in order to use that value later, perhaps by storing the returned value into a variable.

Let's change our divide function from before:

    def divide(numerator, denominator):
        return (numerator / denominator)

Now instead of printing the division result, it will return the value for us to use.

We can assign a variable to this returned value.

    divisor = divide(2 / 1)

Will assign the variable divisor to the return value of the function divide. We can then use that divisor variable for some other things…

Variable Scope

The last new information for this lab is variable scope, which refers to where assigned variables can be accessed.

There are two types of variables:

global variables : variables assigned / declared just within a file, and can be used anywhere inside the file, including functions and loops!

x = 300 # globally assigned
def my_func():
    print(x) # can be accessed in a function
my_func()
print(x) # can be accessed outside a function too!

local variables : variables assigned / declared within a specific function or loop, and can only then be used within that function or loop.

def my_func():
    x = 300 # locally assigned
    print(x) # can be accessed in the same function
my_func()
print(x) # can NOT be accessed outside its home function, will throw an error!

You're ready for the next part of the lab! Great job :).

---

Lab Description 💸

The goals of this lab include:

• Understand and write comments in Python
• Understand and write loops in Python
• Understand and write functions in Python
• Understand and implement different variable scopes
• Understand how to import and use libraries in Python

The practice sections of this lab below will go over new concepts and provide already written code to practice with. The task sections of this lab at the bottom of this page will let you apply your new knowledge and write your own code.

---

Tasks 💸

Now let's pick off from what we learned in part I!

Hand-In 💸

---