Unit 1 - Programming Fundamentals: Data Types and Functions

Table of Contents

1. VS Code and Terminal
2. Introduction to Python
3. More Python
4. Development and Debugging
5. Programming Basics
6. Data Types
7. User Input
8. Functions, Parameters, and Return Values

1.0. Overview

We're going to look about Computer Science by writing programs using the Python programming language. There are other programming languages, but Python is absolutely the best one for what we're going to be doing.

Let's get started!

1.1. VS Code and Terminal

[NOTE: If you haven't yet installed VS Code, see this video or follow this step-by-step guide.]

Let's set up our work environment by opening a VS Code window on the left side of your screen and a smaller Terminal window on the right side of the screen. This is a classic work environment for writing code.

We'll typically write our programs in VS Code on the left, and then run them using VS Code or the Terminal on the right. Once the program is completed, you'll use the Terminal on the right to upload the program to the server.

(NOTE: VS Code actually has its own built-in Terminal that we'll sometimes use. It's helpful for you to become familiar with using a separate Terminal application as well.)

1.2. Introduction to Python

Let's write our first program, the traditional Hello, World! exercise.

If your program ran perfectly the first time, congratulations! It doesn't usually happen that way. And if your program didn't work as you expected it would—either because you mistyped something, or because you're still trying to figure out how all of this works, well... welcome to the world of programming. We're going to be writing programs in here, but we're going to spend even more time trying to get the programs to work the way we want them to.

It's like solving a puzzle... and it's a fantastic feeling when you solve the puzzle and get your program to work.

1.3. More Python

We've got a lot more to cover as we learn the Python programming language...

1.3.1. Comments

Real programs have additional components, some of which we're going to introduce right away.

#!/usr/bin/env python3
                        
"""
hello_world.py
This is the famous Hello, World! program that one always begins with.
"""

__author__ = "Richard White"
__version__ = "2019-08-19"

def main():
    # This program prints “Hello, world!"
    print(“Hello, world!")

if __name__ == "__main__":
    main()

You could reasonably wonder why we should include in our program several blank lines and "comments" that don’t make the program run any differently.

Experienced coders already know the answers to these questions. Briefly:

• The blank lines make the program easier to read, for you and anyone else who's looking at your work.
• The comments identify important parts of the program and why you wrote them the way you did, useful to you and anyone else who’s looking at your work.

You probably don't want to write a comment for every line of code in a program, although a complex program might actually have more comments than code, to help explain what's happening to others who are trying to understand it.

And as someone who is first learning to write Python code, you will certainly benefit from the comments that will be included in the code presented here. You should do the same for others who will come along and read your code.

1.3.2. Code blocks, or Suites

Programs include logical sections of code blocks, which in Python are called suites.

1.4. Developing and Debugging

Whether you're using Python or some other language, you'll need to know this.

1.4.1. Debugging

You should know right away that programs very rarely work the first time that one writes them. Writing a program has a lot in common with writing an essay or paper:

1.4.2. The Development Process

Writing good software is challenging, but rewarding, and usually even fun.

The process of writing a program involves quite a bit more than simply sitting down at the computer and entering code. A typical problem will require that you:

1. Analyze the problem
2. Determine the specifications
3. Design the program's overall structure
4. Write the program (lots of testing and debugging here)
5. Deliver the program
6. Maintain the program (updating it as required, repairing it as needed)

In this course, you'll often be provided with the first 2 items, and #6 won't typically be something you'll have to worry about.

1.4.3. Types of Errors

There are three specific types of errors that you'll need to keep an eye out for, and fixing errors is what we spend a good amount of time doing.

1. Syntax errors are caught during compilation of your source code and represent incorrect use of the Python language. Typical syntax errors including
   • misspelling a variable name
   • incorrectly indenting a line
   • incorrect use of parentheses
   • incorrect use of a Python instruction

   The compiler will try to find as many errors as possible at one time, but realize that:

   • an error indicated for one line might have occurred on the previous line, and
   • a whole series of errors may be reported as a result of a single error earlier in the program.

   % python hello_world.py
   File "hello_world.py", line 1
   print("Hello, world!)
                       ^
   SyntaxError: EOL while scanning string literal
   % 

2. Run-time errors occur while a program is able to run, but doesn't do what it was designed or expected to do. Some examples of run-time errors will cause the program to stop running include:
   • trying to divide by 0
   • the user enters text when a number is expected
   • the user enters a float (decimal point) value when an integer is expected

   % python test.py
   Enter a number: 0
   Traceback (most recent call last):
     File "test.py", line 2, in 
       print (100/val)
   ZeroDivisionError: division by zero
   %

3. Logic errors are a specific type of error that occurs during runtime. The program will appear to run correctly, but the results produced are incorrect: a program that adds the numbers 1-10 and produces a result of 45 when the correct answer is 55, for example. The only way to catch these types of errors is with testing.

   % python sum1to10
   The sum of the integers 1 to 10 is 45
   Expected result: 55

One thing that helps with avoiding errors is defensive programming: writing well-structured code with comments, and progressively testing the code so that errors in one part don't end up cascading down into other areas of the program.

One three-part "error management" strategy:

1. learn about common errors and how to avoid them
2. learn defensive strategies for minimizing likelihood and impact of errors
3. learn debugging strategies to find and correct errors.

1.4.4. Using scp to transfer files

You can use the scp command to transfer files from one computer to another.

In order to make this command work, you'll need to provide username and server information as part of the command.

To securely copy a file from the introcs folder located on the Desktop of my laptop computer to my forInstructor directory in my home directory on the server for this course:

% cd ~/Desktop/introcs/
% scp -P 1030 hello_world.py rwhite@crashwhite.polytechnic.org:~/forInstructor/
rwhite@crashwhite.polytechnic.org's password: 
hello_world.py             100%   11KB  11.4KB/s   00:01

You'll see the "100%" confirmation above if the file was successfully able to upload. If you get an error message, it might be that your password was typed incorrectly, or you misspelled the name of the server or your userID, or perhaps you didn't capitalize the -P 1030 . Or maybe you're not in the directory where your program is actually located? Figure it out and try again!

1.5. Programming Basics

1.5.0. Overview

In this session we'll be learning how to assign values to variables, how to perform numeric calculations, how to get input, and how to write a simple program.

1.5.1. Assigning values to variables

The fundamental thing that computers do is calculate the answers to mathematical problems. To do that, we need to be able to store numbers in the computer's memory.

<variable> = <expression>

my_age = 15

height_in_feet = 5.8

height_in_inches = 12 * height_in_feet

my_age = my_age + 1    # I celebrated a birthday!

height_in_inches = height_in_inches + 0.5     # I grew this year!

Let's try writing a program that allows us to convert temperatures from one system to another.

#!/usr/bin/env python3
"""
temp converter.py
This program converts from degrees F to degrees C
"""

__author__ = "Richard White"
__version__ = "2017-09-08"

def main():
    # The main program will go here
    temp_fahrenheit = 72     
    temp_celsius = (temp_fahrenheit - 32) * 5 / 9
    print(temp_celsius)

if __name__ == "__main__":
    main()

1.6. Data Types

In this session we'll be looking at the two different types of numeric data types in Python, seeing how you can import a module to give Python additional capabilities, and looking at local text editor applications.

1.6.0. Overview

Programming languages represent different types of data differently, and it's important for you to be aware of what data type one is working with. Data types in Python include:

• int (integers)
• float numbers (floating point, or decimals)
• str (strings, of text)
• bool (boolean values that are True or False)
• list (for lists of things)
• tuple (kind of like lists, but immutable)
• dict (a key-value pair)

To begin, let's look at several of the numeric data types, operations that can be performed on those numbers, and some of the ways we can work with those numbers using functions in the math module.

1.6.1. Integers and Floating Point numbers

>>> type(3)
<type 'int'>

>>> type(3.0)
<type 'float'>

Why does a computer need to distinguish between the two? It's all about speed. It's far easier for computers to deal with integers, and therefore far faster for them to perform operations with integers. Differences in speed won't be apparent in most programs that we write, but for any program that performs the same operation thousands, million, or billions of times, working with integers where possible produces a significant increase in speed.

Of course, if you need to work with decimals (floats), then you'll have to use them where appropriate.

>>> 5 + 2

>>> 5.0 + 2

>>> 5.0 / 2

>>> 5 / 2

>>> 5 // 2  # how is this different?

>>> 5 % 2  # this is related to the last one

>>> 5 * 2

>>> 5 * 2.0

>>> 5 ** 2

>>> 2. ** 0.5

You can use Python's built-in functions to convert from one data type to another:

>>> float(3)
3.0

>>> int(3.7)
3

>>> round(3.7)
4

1.7. User Input

It's important for us to be able to store data—numbers like 2.7 and strings like "Lola"—in the computer's memory. We also want to have the person running the program—the "user"&mdashp;to be able to enter data for use in a program as well.

Let's see how to do that.

1.7.1. Entering strings

Let's take our original hello_world.py program and personalize it so that it prints out a greeting with my name in it.

def main():
    name = "Richard"
    print("Hello", name)
    
if __name__ == "__main__":
    main()

Notice that we're using the print() function to print out two things: the string "Hello" and whatever is stored in name, which is another string. The comma separates those two items in the print statement but isn't printed out itself.

This program works as you'd probably expect.

Hello Richard

Ideally, however, we want the program to print "Hello" to anybody who's running it, without the programmer having to rewrite the program.

<variable> = input()  # for entering strings

print("Enter your name: ")
name = input()

name = input("Enter your name"))

With this in mind, we could rewrite our personalized hello_world_personal.py to look like this:

def main():
    name = input("Enter your name, please: ")
    print("Hello", name)

Much nicer!

1.7.2. Entering numbers

Note that the input() function only gives us a string of characters. If the string 37 or 6.5 is entered, how can we convert those characters to numeric values?

<variable> = float(input()) # to take a string entered and
                            # evaluate it as a number with a decimal point
                            # (a "floating-point" number).

<variable> = int(input()) # to take a string entered and
                          # evaluate it as an integer

#!/usr/bin/env python3
"""
temp_converter_input.py
This program converts from degrees F to degrees C
"""

__author__ = "Richard White"
__version__ = "2017-09-08"

def main():
    name = input("Enter your name: ")
    temp_fahrenheit = float(input("Enter the temperature in degrees F: "))
    temp_celsius = (temp_fahrenheit - 32) * 5 / 9
    print(name, "the equivalent temperature in Celsius is", temp_celsius)

if __name__ == "__main__":
    main()

1.8. Functions, Parameters, and Return Values

1.8.0. Overview

In this session we'll be taking our first steps toward writing larger, more complex programs. We'll look at how writing procedural functions can help us better organize our code and make it less redundant, and how to write functions that uses parameters and return values to communicate with the programs that call them.

1.8.1. Functions and Parameters

1.8.1.0. Definition and Uses of Functions

In fact, a popular acronym among software engineers is DRY: Don't Repeat Yourself. If you do find yourself rewriting lots of segments of code, you should probably try to find a way to write the code more efficiently.

One way of reducing the amount of repeated code that we have to write is by using loops, which we'll learn about soon. Another very important strategy is to organize code into functions.

"""
Demonstrating a function
"""

def say_hello():
    print("Hello!")

def main():
    print("Check out this function!")
    say_hello()

if __name__ == "__main__":
    main()

say_hello()

1.8.1.1. Standalone functions

I'm welcoming guests to my party and I find myself saying the same thing over and over again as each guest shows up at the door. I've written a program to print what I'm saying:

"""
party.py
Welcomes guests to my party
"""

def main():
    guest = "Devi"
    print("Welcome,",guest)
    print("Food is over there,")
    print("drinks are over here,")
    print("I hope you have a great time!")
    
    guest = "Emilio"
    print("Welcome,",guest)
    print("Food is over there,")
    print("drinks are over here,")
    print("I hope you have a great time!")
    
    guest = "Apollo"
    print("Welcome,",guest)
    print("Food is over there,")
    print("drinks are over here,")
    print("I hope you have a great time!")
    
if __name__ == "__main__":
    main()

This program works just great, but you can see that I've had to repeat my little speech quite a few times. We can make the program a little more efficient by writing a function to print out the parts that are repeated.

This program produces exactly the same output:

"""
party.py
Welcomes guests to my party
"""

def welcome():
    """Prints out a welcome to party guests.
    """
    print("Food is over there,")
    print("drinks are over here,")
    print("I hope you have a great time!")
    
def main():
    guest = "Devi"
    print("Welcome,",guest)
    welcome()                   # calls the function
    
    guest = "Emilio"
    print("Welcome,",guest)
    welcome()                   # calls the function
    				
    guest = "Apollo"
    print("Welcome,",guest)
    welcome()                   # calls the function
    
if __name__ == "__main__":
    main()

This is quite a bit more efficient than what I did before. Each time I "call" the welcome() function in the main, the instructions in that welcome() function are performed.

1.8.1.2. Functions with parameters

We can make our function even more efficient by moving that print("Welcome,",name) instruction side the function, but when we first do that, we run into a problem:

def welcome():
    """Prints out a welcome to party guests.
    """
    print("Welcome,",guest)
    print("Food is over there,")
    print("drinks are over here,")
    print("I hope you have a great time!")
    
    Traceback (most recent call last):
  File "party.py", line 27, in 
    main()
  File "party.py", line 16, in main
    welcome()
  File "party.py", line 8, in welcome
    print("Welcome,",name)
NameError: global name 'guest' is not defined

The issue here is that although the main() program knows who the guest is, the function doesn't. We need to send that bit of information in via a parameter.

The working version of the program looks like this:

"""
party.py
Welcomes guests to my party
"""

def welcome(guest):
    """Prints out a welcome to a party guest.
    """
    print("Welcome,",guest)
    print("Food is over there,")
    print("drinks are over here,")
    print("I hope you have a great time!")
    
def main():
    guest = "Devi"
    welcome(guest)                   # calls the function
    
    guest = "Emilio"
    welcome(guest)                   # calls the function
    
    guest = "Apollo"
    welcome(guest)                   # calls the function
    
if __name__ == "__main__":
    main()

This works just as it should!

1.8.1.3. Scope

Take a look at this Calculator program.

"""Calculator Program
This program takes two numbers entered by the user and performs a mathematical operation on them.
"""

def add_them(number1, number2):
    total = number1 + number2
    print("The sum of", number1, "and", number2)
    print("is", total)

def main():
    n1 = float(input("Enter a number: "))
    n2 = float(input("Enter a second number: "))
    add_them(n1, n2)

if __name__ == "__main__":
    main()

In our Calculator Program, n1 and n2 are local to main(), and global to add_them. number1 and number2 are local to add_them, and undefined outside of that function.

This program works fine. When the main program calls add_them, the values for n1 and n2 are "sent" into the add_them function via the parameters number1 and number2. The function is able to use those variable, which have local scope in the function.

def add_them(number1, number2):
    answer = number1 + number2

def main():
    n1 = float(input("Enter a number: "))
    n2 = float(input("Enter a second number: "))
    add_them(n1, n2)
    print(answer)

if __name__ == "__main__":
main()

Why is Python so concerned about scope? Wouldn't it be easier if the programs could just access all of the variables from anywhere they are in the program?

1.8.1.4. Getting information back out of a function

We've learned that you can pass information into a function using parameters. But how do you get information back out?

Our programming solution is to return a value.

def add_them(a,b):
    return a + b    # Calculate a + b
                    # and send result back
                    # to function call

Here's a version of our program, then, that does work:

"""Calculator Program that works!
"""

def add_them(number1, number2):
    total = number1 + number2
    return total

def main():
    n1 = float(input("Enter a number: "))
    n2 = float(input("Enter a second number: "))
    answer = add_them(n1, n2)               # take the result returned from the function
                                            # and store it in a variable so we can use it
    print(answer)

if __name__ == "__main__":
    main()

One common use for functions is to gather user input. Writing separate functions for "initializing" a program (setting initial values for data) and actually processing that data is very common.

def get_input():
        name = input("Enter your name: ")
        age = float(input("Enter your age: "))
        return name, age            # You can return two answers, separated by commas!
    
    def main():
        user, age = get_input()   # Call the function and store the answer in two variables
        print(user, ", you are", age, "years old.")

Now try this one:

#!/usr/bin/env python3
"""
quadrilateral.py
This program identifies the area and perimeter for a quadrilateral 
of dimensions provided by the user. It also uses functions!
@author Richard White
@version 2017-09-27
"""

def get_dimensions():
    length = float(input("Enter length of quadrilateral: "))
    width = float(input("Now enter width:"))
    return length, width

def calc_area_perimeter(length, width):
    area = length * width
    perimeter = 2 * length + 2 * width
    return area, perimeter

def main():
    l, w = get_dimensions()
    a, p = calc_area_perimeter(l, w)
    print("The area and perimeter of your")
    print("quadrilateral are", a, "and", p)

if __name__ == "__main__":
    main()

As you're writing this program, you want to be able to trace exactly what values each variable has as the information is passed to and from the functions.

1.8.2. The random Module

We've already discussed the math module, and how you can import that module to use various methods that will allow your Python program to perform mathematical calculations.

Now let's look at another useful module, and learn how to get help using that module.

#!/usr/bin/env python3
"""
Using the random module to simulate rolling a die.
"""

import random

def main():
    roll = random.randrange(6) + 1      
    # randrange randomly gets an integer from 0-5 inclusive.
    # Adding one gives us a value from 1-6, inclusive.
    print(roll)

if __name__ == "__main__":
    main()