Tips and Examples

• Class Exercises
• Getting Help
• Describing a Problem
• Don't Use Screenshots in Piazza
• Making Script Executable

Python Review

• for Loops
• The range Function
• Augmented Assignment Operators
• Nested Loops
• Functions
• Function Names
• Defining a Function
• Calling a Function
• Parameters
• Local Variables
• Functions that Return Values
• Returning Multiple Values
• Standard Library Functions
• Objects
• Files
• Using Files
• Creating a File Object
• Writing Data to a File
• Closing a File
• Using a File More Than Once
• Appending Data to a File
• Reading Files with a for Loop

Login Failure

If you enter the wrong password 5 times when connecting to pe15 you will be temporarily blocked from logging in to this machine.

This lock out will only last for 2 hours.

After 2 hours, you should be able try again.

If you have forgotten your password, you can change it.

Go to https://portal.cs.umb.edu/password/

Recordings of Class Meetings

You will find links to the recordings of class meetings here.

Use of Storage Space on the CS LAN

All of you will have an account on the Computer Science Department network.

With this account you get a home directory.

There is a limit on the total size of the files in your home directory.

So you should not store there anything you do not need for your classwork.

Homework 2

I have posted homework 2 here.

It is due this coming Sunday at 11:59 PM.

Class Quizzes

From now on, each class will have a Class Quiz.

The Class Quiz is ungraded.

It is designed to help you remember the material covered in class.

Here is how it works.

Go to the listing of Class Quizzes you will find here.

Click on the link for the quiz you need to take.

Answer all the questions on a piece of paper.

Go to the listing of Class Quiz Answers you will find here.

Check your answers.

First Graded Quiz

The first graded quiz will be given on Tuesday next week.

The questions from the graded quiz are taken from the ungraded quizzes of the previous week.

Unless I tell you otherwise, you should expect a graded quiz each week.

The quiz will be available on Gradescope on Tuesday.

Class Page for IT 116

You may find it useful to look at my materials for IT 116.

I have a web site where I post most of the materials for my courses for the previous semester.

You will find these materials here http://96.126.105.215/umb_classes_html/it116_html/class_page_it116.html .

I have included this link on the class page for the course.

Go to the index for the Class Notes and search for a topic.

You will find the index here http://96.126.105.215/umb_classes_html/it116_html/class_notes_it116/class_notes_index_it116.html .

Do Not Post Anything From this Class Online

There are many web site that claim to "help" students learn new material.

As far as I am concerned sites like Chegg and CourseHero get their money by helping students cheat on their assignments.

Posting ANYTHING on such sites is a violation of your Oath of Honesty and will be reported to the Provost's Office.

This includes quiz and exam questions as well as homework assignments and Class Exercises.

Questions

Are there any questions before I begin?

Tips and Examples

Class Exercises

• There is a Class Exercise for every class ...
• except the review sessions for the Midterm and final exams
• Each Class Exercise must be in a separate directory inside the ex directory
• The ex directory must be inside your it117 directory
• If you do not finish the script in class you can finish it later
• All Class Exercises must be finished before the following Sunday at 11:59 PM
• I check your Class Exercises 4 times a week
• The last check is on the weekend after they are due
• If there is a problem with your script, or it is missing ...
• I will send an email to your UMB email address
• If the exercise is not complete or it has an error ...
• you will lose two points for each day it is late
• I have have written test scripts for each of the Class Exercises
• I use these scripts to test your code
• You can run these scripts to test what you have written
• But you have to connect to pe15.cs.umb.edu to do this
• At the bottom of every Class Exercise is the command you run to test your script
• When you run this command you will be asked for your username
• After you enter this and hit return, the tests will run
• Here is how it looks for ex2.py

  $ ~ghoffman/it117_test/ex02.sh
  Unix username: ghoffman
  ghoffman 		 Glenn Hoffman
  ++++++++++++++++++++++++++++++++++
  Is file executable?
  ----------------------------------
  ex2.py is executable
  ----------------------------------
  ++++++++++++++++++++++++++++++++++
  Looking for hashbang
  ----------------------------------
  #! /usr/bin/python3
  ----------------------------------
  ++++++++++++++++++++++++++++++++++
  Error check
  ----------------------------------
  ----------------------------------
  Next? 
  ++++++++++++++++++++++++++++++++++
  Looking for:
  2017-06-01 67
  2017-06-02 71
  2017-06-03 69
  2017-06-04 88
  2017-06-05 74
  ----------------------------------
  2017-06-01 67
  2017-06-02 71
  2017-06-03 69
  2017-06-04 88
  2017-06-05 74
  ----------------------------------
  ghoffman 		 Glenn Hoffman
  -20 5
  Class Exercise 2

• The Error check which looks for syntax errors in your code
• If you see nothing between the two dashed lines, no errors ...
• no syntax errors were detected
• If the output of your script is missing something ...
• or produces incorrect output ...
• you will hear a beep and see an error message

Getting Help

• This course makes you do things that you may not have done before
• Whenever you do something new there is always a good chance you will make a mistake
• When this happens, the first thing you should do is reread the instructions
• Mistakes often happen when we read too fast
• If you cannot fix the problem in a reasonable amount of time, ask for help
• There are two ways you can do this
  • Post a question in the class discussion area
  • Talk to another student in this class
• DO NOT EMAIL ME with your question
• I have over 100 student each semester
• With that workload I must be very careful how I spend my time
• I would rather respond to your question on Piazza than in an email
• Only one student will see an email response
• But an answer on Piazza can be seen by the entire class
• Only send me an email when you have an issue that affects you and you alone
• Like being out of the country due to a family emergency

Describing a Problem

• You can't get help with a problem unless you describe it well
• Statements like the following are useless when asking for help
  • It does not work
  • I get an error when I run the code
• You have to describe the specific circumstances that caused the problem
• The best way to do this is with the actual text from the ssh client window
• Copy both what you typed, and what happened after you hit Enter
• Something like this

  >>>  print "Hello World"
  SyntaxError: Missing parentheses in call to 'print'. Did you mean print("Hello World")?
  >>>

Don't Use Screenshots in Piazza

• Many students paste screenshots of code into Piazza
• This is not a good idea
• I have a hard time reading some of the screen shots
• And I can't copy the code into the Python interpreter to test it
• Instead copy the code to your class directory
• And type the name of your file into your Piazza entry
• This way I can run the code myself
• And use various debugging techniques

Making Script Executable

• All scripts submitted for this course must be executable
• If not you will lose points
• You make a file executable by doing two things
  • Using the hashbang line
  • Running the Unix command chmod
• The hashbang line must be the very first line of the script
• The first two characters of this first line must be #!
• This must be followed by the absolute address of the Python 3 interpreter
• For this course the hashbang line must be

  #! /usr/bin/python3

• You can make a file executable by running the following Unix command on it

  chmod 755 FILENAME

• FILENAME is a placeholder
• You replace this with the name of the file you are making executable
• If I wanted to make the file hw2.py executable ...
• I would would write the following on the Unix command line

  chmod  755  hw2.py

• In FileZilla you can give execute permission by right clicking on the script file ...
• selecting "Permissions" from the menu ...
• and entering "755" in the box provided

Attendance

Python Review

for Loops

• The counted loop in Python is the for loop
• It has the following format

  for VARIABLE_NAME in LIST_OF_SOME_SORT:
      STATEMENT
      STATEMENT
      ...

• The for keyword is followed by a variable
• Next comes the in keyword followed by a list of values
• The first value in the list is assigned to the loop variable
• The loop variable keeps that value as it runs through the code block
• After the last statement in the code block ...
• the loop variable gets the next value in the list
• The loop stops when every value in the list has been used

The range Function

• Creating the list of integers is not hard if the list is short
• But what if we wanted to add the numbers from 1 to 100?
• Creating that list would be very tedious
• Python's range function makes it easy to create a list of integers

  >>> for number in range(10):
  ...   print(number)
  ... 
  0
  1
  2
  3
  4
  5
  6
  7
  8
  9

• Notice that the sequence of numbers started with 0
• And ended with one less than the value of the argument
• You can also give the range function two arguments
• In this case the first argument is the starting number
• And the second argument is one more than the last number

  >>> for number in range(5, 11):
  ...   print(number)
  ... 
  5
  6
  7
  8
  9
  10

• You can even give three arguments to the range function
• If you do the first two arguments do the same thing as the two argument version
• But the third argument is the step value
• The step value is the amount by which each number is changed ...
• from the number that came before

  >>> for number in range(2, 11, 2):
  ...  print(number)
  ... 
  2
  4
  6
  8
  10

Augmented Assignment Operators

• When writing code we often want to change a variable by a certain amount
• If I wanted to add 1 to the variable num I could write

  num  =  num  +  1

• Statements like this are very common
• So Python has a set of special operators that will do three things
  • Get the current value of the variable
  • CHANGE this number by applying the operator to the number on the right
  • Assign this new value to the variable
• So instead of writing the statement above we could write

  num  +=  1

• This operator works as follows
  • Get the current value of the variable on the left
  • Get the current value of the expression on the right
  • Add the two values
  • Assign this new value to the variable
• Using this operator makes the code shorter
• Which reduces the risk of errors
• An operator like this is called an augmented assignment operator
• Python has an augmented assignment operator for every arithmetic operator

  Operator	Example	Equivalent To
  +=	numb += 5	numb = num + 5
  -=	num -= 5	num = num - 5
  *=	x *= 5	x = x * 5
  /=	x /= 5	x = x / 5
  //=	x //= 5	x = x // 5
  %=	x %= 5	x = x % 5
  **=	x **= 5	x = x ** 5

Nested Loops

• Just as you can have an if statement inside another if statement
• You can have a loop inside another loop
• When you have one loop inside another it is called a nested loop
• You can nest any type of loop inside another loop
• But nested for loops are the most common
• When you use a nested loop be sure each loop variable has different name
• If you don't you will get very strange results
• Let's write a script to create a times table

  $ cat times_table.py 
  # This script creates a times table using nested for loops
  
  for row in range(1, 11):
      for column in range(1, 11):
          entry  = row * column
          print(entry, end="\t")
      print()
  
  $ python3 times_table.py 
  1   2   3   4   5   6   7   8   9   10
  2   4   6   8   10  12  14  16  18  20
  3   6   9   12  15  18  21  24  27  30
  4   8   12  16  20  24  28  32  36  40
  5   10  15  20  25  30  35  40  45  50
  6   12  18  24  30  36  42  48  54  60
  7   14  21  28  35  42  49  56  63  70
  8   16  24  32  40  48  56  64  72  80
  9   18  27  36  45  54  63  72  81  90
  10  20  30  40  50  60  70  80  90  100

• The loop variable row gets a new value with each pass through the loop
• It keeps that value while the inner loop variable column ranges from 1 to 10
• Notice the print statement in the innermost loop
• It print a number followed by a Tab
• This keeps the output for each row on its own line
• We need a call to print after the inner loop to move to the next line

Functions

• The trick to writing software is to break down a big task into smaller tasks
• Then work on these smaller tasks one-by-one
• Functions are a great help in splitting the work into smaller tasks
• A function is a group of statements that has a name and performs a specific task
• Each function operates in its own environment so it can be isolated from the rest of the program
• The Python interpreter has a number of function that are predefined inside it
• They are called built-in functions
• They are always available for you to use in your scripts
• You can see a list of them here
• But you can also define your own Python functions
• Most Python scripts contain a number of functions written specially for that script
• If you find yourself using certain function over and over again ...
• you can put them in a file
• These files are called modules
• You can bring these functions into your script using an import statement

Function Names

• Function names must follow the same rules as variable names
  • You cannot use keywords variable names
  • Function names cannot have spaces
  • The first character of a function name must be a letter, a-z and A-Z, or an underscore, _
  • After the first character you can use letters, digits or the underscore
  • Uppercase and lowercase letters are distinct
• Just as with variable names, you can use several words in a function name ...
• if you separate each word with an underscore, _
• A function name should describe what the function does
• Since functions do things, most function names use verbs

  calculate_gross_pay
  get_hourly_rate
  calculate_overtime

Defining a Function

• A function definition has the following format

  def FUNCTION_NAME([PARAMETER][...]):
      STATEMENT
      STATEMENT
      ...

• The first line of a function definition is called the function header
• There are four parts to the function header
  • The keyword def
  • The function name
  • The parameter list enclosed in parentheses, ( )
  • A colon, :, at the end of the line
• All of these must be present
• If there are no parameters, you must still have parentheses in the header
• Following the function header is a series of indented statements ...
• that form the code block

Calling a Function

• To use a function, you make a function call
• A function call has two parts
  • The function name
  • A list of arguments enclosed in parentheses
• You must always have parentheses
• Even if the function takes no arguments
• Here is an example of a function that takes no arguments

  >>> def hello():
  ...   print("Hello world")
  ... 
  >>> hello()
  Hello world
  >>> 

Parameters

• When you call a function it is given its own bit of memory
• This is what allows functions to operate independently
• A function can change anything in its own section of memory
• But those changed do not affect anything else
• Once the function has finished its work ...
• its memory disappears
• Most functions need information from the function call to do their work
• They get this information using parameters
• Parameters are variables the live inside the function's memory space
• They are listed inside the parentheses of the function header
• The function below has a single parameter named team

  def cheer(team):
      print("Go", team, end="!\n")

• Parameters get their values ...
• from the expressions inside the parentheses of a function call
• These expressions are called arguments
• In the statement below the argument is "Red Sox"

  cheer("Red Sox")

Local Variables

• A function runs inside its own space in memory
• It gets this chunk of memory when the function is called
• As soon as the function finishes, this memory disappears
• All functions variables are stored in the functions memory space
• So they disappear when the function is done
• Variables defined inside a function are called local variables
• All local variables are invisible outside the function
• They can only be used inside the function
• There are two types of local variables
  • Parameters
  • Other variables
• Parameters are defined inside the parentheses of the function header
• The other variables are defined inside the function's code block
• Parameters get their values from the arguments in the function call
• The other variables get their values from assignment statements ...
• inside the body of the function
• In the function below, team is a parameter but first_word is not

  def cheer(team):
      first_word = "Go"
      print(first_word, team, end="!\n")

Functions that Return Values

• Functions that return values can be used in assignment statements

  >>> result = math.sqrt(7) 
  >>> result
  2.6457513110645907

• Functions use a return statement to send a value back to the function call
• Here is the format

  return  EXPRESSION

• Remember, an expression is anything that the Python interpreter can turn into a value
• A return statement does two things
  • It ends the execution of the function
  • It sends a value back to the function call
• A return statement always causes the function to quit
• So any Python statements after return will never be executed
• Here is a new version of the cheer function that returns a value

  >>> def cheer(team):
  ...    return "Go " + team + " !"

• This version does not actually print anything
• So we need to put the call to the function inside the parentheses of print

  >>> print(cheer("Red Sox"))
  Go Red Sox!

• We can do this because cheer now returns a value
• So a call to this new version of cheer is an expression
• And we can always use an expression as the argument to a function

Returning Multiple Values

• A Python return statement can return more than one value
• To do this you follow the return with a comma separated list of expressions

  return EXPRESION [, EXPRESSION, ...]

• Using this feature I can write a function to get both the first and last name

  >>> def get_full_name():
  ...     first_name = input("Please enter your first name: ")
  ...     last_name = input("Please enter your last name: ")
  ...     return first_name, last_name
  ... 

• When this function is called it will ask for two values
• So we will need two variables to receive these values

  >>> fname, lname = get_full_name()
  Please enter your first name: Glenn
  Please enter your last name: Hoffman
  >>> print("Hello", fname, lname)
  Hello Glenn Hoffman 

Standard Library Functions

• All computer languages come with functions that perform useful operations
• Here are some examples from Python
  • print
  • int
  • float
  • input
  • range
• All of these are built-in functions
• Built-in functions are actually part of the Python interpreter
• So they are always available
• You do not have to do anything special to use them
• But every time you install Python you get many other useful functions
• These are called the standard library
• The standard library consist of many files called modules
• Each module contains functions and variables that do related things
• For example the math module contains many common mathematical functions
• But you cannot use a module functions inside a script ...
• unless you imported them
• You do this with an import statement
• import statements have the following form

  import MODULE_NAME

  The MODULE_NAME is the file name without the .py extension.
• When using function or variable imported from a module you must do something special
• You must use dot notation
• First you write the name of the module ...
• followed by a dot ( . ) ...
• followed by the name of the function or variable
• Here are some examples

  >>>  math.pi # trying to use a math module variable before importing math
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
  NameError: name 'math' is not defined
  >>> import math
  >>> math.pi
  3.141592653589793
  >>> math.sin(math.pi)
  1.2246467991473532e-16
  >>> math.cos(math.pi)
  -1.0
  >>> math.ceil(4.3)
  5
  >>> math.floor(4.3)
  4
  >>> math.floor(-4.3)
  -5
  >>> math.ceil(-4.3)
  -4

Objects

• A variable is a place in memory with a name that holds a single value ...
• like an integer, float or boolean
• Objects can hold more than one value
• They can also contain functions that work with those values
• The functions inside an object are called methods
• Objects do not have names
• Instead they have a location in memory
• In order to work with an object, this location has to be stored in a variable
• You can think of this variable as pointing to the object
• To refer to function or variable inside an object you use dot notation

Files

• A file is simply a linear arrangement of data on some long term storage device ...
• like a hard drive, thumb drive or CD ROM
• Files are identified by their name and their location
• The data inside a file can be in any one of a number of formats
• As far as Python is concerned, there are two types of files
  • Text
  • Binary
• Text files contain characters, symbols and digits which make sense to us
• Binary files store their information a sequences of binary numbers
• All of the work we will be doing in this class will be with text files

Using Files

• All operations inside a computer take place in the computer's RAM
• But files live in some external storage device like a hard drive or a CD
• To work with a file the computer needs a structure in RAM ...
• that can access the file
• This structure is called a file object
• To work with a file you must create a file object connected to the file

Creating a File Object

• You create a file object using the open function
• open is a built-in
• You do not have to import it
• open does two things
  • It creates a file object
  • It returns the location of the object
• We need to store the location returned by open in a variable ...
• so we can use the file
• Here is the format

  FILE_VARIABLE  =  open(PATHNAME, MODE)

• FILE_VARIABLE is the name of the variable that points to the file object
• PATHNAME is a string giving the name and location of the file
• In this class the file will always be in the same directory as the script
• So the pathname will just be the name of the file
• MODE is a letter specifying what we want to do with the file
• The three most commonly used access modes are

  Mode	Description
  "r"	Open a file for reading only
  "w"	Open a file for writing
  "a"	Open a file for writing to the end of the file

• These access modes only apply to text files
• If you open a file for writing that does not exist, it will be created
• If the file does exist what it contains will be lost
• It will be replaced by what you now write to the file
• The "a" in the last mode stands for "append"
• When you write to a file in append mode ...
• the text is added to the bottom of the file
• This means you do not lose the previous contents of the file

Writing Data to a File

• Objects contain values and the functions that work with those values
• The functions inside objects are called methods
• To call a method you must use dot notation
• Dot notation for methods has the following format

  OBJECT_VARIABLE.METHOD_NAME

• To write data to a file we must first open it for writing

  teams_file = open("teams.txt", "w")

• The variable teams_file points to the new file object
• Now we can use the write method of this new file object to send some text to the file

  teams_file.write("Red Sox\n")

• If you want to write a line to a text file you must include the newline character ...
• which we write as \n

Closing a File

• When you have finished working with a file you should close it
• This will allow other programs to use the file
• To close a file you use the close method
• The general format for using the close method is

  FILE_VARIABLE.close()

• Closing destroys the file object ...
• and breaks the connection to the file
• To close the file object pointed to by file you would write

  file.close()

Using a File More Than Once

• The file objects created with the access modes above only move in one direction
• If you have read or written a line, you cannot go back
• If you need to read the lines in a file more than once you have to
  • Close the first file object
  • Create a new file object on the same file

Appending Data to a File

• Appending means adding lines to a text file that already exists
• You open the file using the append access mode like this

  file = open(filename, "a")

• If you open a file for writing it overwrites the contents of the file
• But opening a file for appending adds text to the bottom of the file

Reading Files with a for Loop

• The best way to read a file is with a for loop
• You create a file object for reading
• And then use the variable that points to this object after in in the loop header
• The general form of a for loop is

  for LOOP_VARRIABLE in LIST_OF_SOME_SORT:
  	STATEMENT
  	STATEMENT
  	...

• The LIST_OF_SOME_SORT can be many things
  • List
  • Tuple
  • String
• It can also be a file
• Text files contain strings with a newline character at the end
• So you can think of a text file as a list of lines
• To read a file you put the variable pointing to the file object after the keyword in

  for VARIABLE in FILE_VARIABLE:
      STATEMENT
      ...

• Here is an example

  $ cat print_file.py 
  #! /usr/bin/python3
  
  # prints the lines in a file with a for loop
  
  filename = input("Filename: ")
  file = open(filename, "r")
  
  for line in file:
      print(line)
  
  $ cat numbers.txt 
  3
  3
  9
  5
  2
  7
  6
  8
  10
  1
  
  $ ./print_file.py 
  Filename: numbers.txt
  3
  
  3
  
  9
  
  5
  
  2
  
  7
  
  6
  
  8
  
  10
  
  1
  

• Why is there a blank line after every number?
• Because the loop variable line contains the entire line of text
• Including the newline character at the end of the line
• To fix this we should write

  print(line.strip())

Class Exercise

Class Quiz