Review

• Local Variables
• Parameters

New Material

• Default Values for Parameters
• Named Arguments
• Global Variables
• Global Constants
• Pausing Execution of a Script
• Functions that Return Values
• Returning Multiple Values
• Standard Library
• Creating Random Numbers
• The random Module
• Other random Functions
• Random Number Seeds

Homework 7

I have posted homework 7 here.

It is due this coming Sunday.

Mid-term

The mid-term exam will be given on Tuesday, March 23rd.

It will consist of questions like those on the quizzes along with questions asking you to write short segments of Python code.

60% of the points on this exam will consist of questions from the Ungraded Class Quizzes.

The other 40% will come from four questions that ask you to write a short segment of code.

The last class before the exam, Thursday, March 12th, will be a review session.

You will only be responsible for the material in the Class Notes for that class on the exam.

The Mid-term is a closed book exam.

To prevent cheating, certain rules will be enforced during the exam.

Today's New Material Not on Mid-term

The new material in today's class will not appear on the Mid-term.

You will only be responsible for the material in the Class Notes for the next class.

They will cover Class Notes 2 through 12.

Review

Local Variables

• Any time you create a variable inside a function you are creating a local variable
• A local variable created inside a function can only be used inside that function
• The variable only exists while the function runs
• This means the variable is invisible outside the function
• Outside the function, the local variable does not exist
• Local variables defined in one function are invisible to other functions
• This means we can use the same variable name in more than one function
• Another way of saying this is that the scope of a local variable is the function in which it is defined

Parameters

• Parameters are a special kind of local variable
• They are defined in the function header inside the parentheses
• They get their value from the corresponding argument in the function call
• Like other local variables, they disappear after the function ends

New Material

Default Values for Parameters

• A function with many parameter needs a value for each one
• This is particularly annoying when some parameter normally has the same value
• Here is a function for converting feet and inches into either total inches or total centimeters

  # converts feet and inches to inches or centimeters
  def convert(feet, inches, units):
      total_inches = 12 * feet + inches
      if units == "inches":
          print(total_inches)
      else:
          print(total_inches * 2.54)

• When we call this function we must supply three arguments

  >>> convert(6, 5, 'inches')
  77

• America is the only major country in the world that does not use the metric system
• In this country the third argument would almost always be 'inches'
• Having to enter a third argument which is almost always the same is very annoying
• Fortunately, Python gives you an alternative
• Python lets you define a function with a default value
• A default value is a value that is supplied automatically if it is left out
• The format for writing a function with default values is

  def  FUNCTION_NAME([PARAMETER, ...], PARAMETER_NAME=DEFAULT_VALUE [, PARAMETER_NAME=DEFAULT_VALUE]):
      STATEMENT
      ...

• Notice that the default values must come at the end of the parameter list
• You can have as many defaults as you want
• But defaults must come after the parameters that do not have defaults
• Let's rewrite the previous function to use a default value

  # converts feet and inches to inches or centimeters
  def convert(feet, inches, units='inches'):
      total_inches = 12 * feet + inches
      if units == "inches":
          print(total_inches)
      else:
          print(total_inches * 2.54)

• Most of the time only two arguments will be given

  >>> convert(6, 5)
  77

• But we can also supply the third argument when we need it

  >>> convert(6, 5, 'cm')
  195.58

• With this particular function we can go a step further
• What if the measure had no inches
• You would still have to provide a second value

  >>> convert(6, 0)
  72

• Why not give the second argument a default value of 0?

  def convert(feet, inches=0, units='inches'):
      total_inches = 12 * feet + inches
      if units == "inches":
          print(total_inches)
      else:
          print(total_inches * 2.54)

• Now we can call the function with only one argument

  >>> convert(6)
  72

Named Arguments

• The latest version of the conversion function has two default values
• But what if we wanted to change the second default value
• But not the first?
• Would we have to supply all three arguments?

  >>> convert(7, 0, 'cm')
  213.36

• Python gives us another option called named arguments
• The textbook calls this feature keyword arguments
• You do this by writing the name of the parameter followed by the assignment operator, = followed by the value for that parameter

  >>> convert(6, units='cm')
  182.88

• Named parameters lets you give a value to any parameter in any order
• You don't have to use the order specified in the function header
• We used named parameters when we changed the default values of the print parameters end and sep

Global Variables

• Parameters and variables declared inside a function are local variables
• Local variables cannot be seen outside the function
• But what about the variables declared outside any function?
• These variables live in the outermost memory space
• This gives them special properties
• Variable declared outside of functions can be seen inside any function
• These variables are called global variables
• Here is an example

  def cheer():
      print('Go ' +  team) + '!')
  
  team = 'Red Sox'
  cheer()

• In this example, team is a global variable
• You can think of functions as looking at the program memory through a one way mirror
• Functions can see the variables declared in the body of the program
• But the body of the program cannot see variables declared inside the function
• What if a local variable has the same name as a global variable
• In that case the Python interpreter will use the value of the local variable

  >>> def cheer_2():
  ...     team = 'Red Sox'
  ...     print('Go', team, end="!\n')
  ... 
  >>> team = 'Pats'
  >>> cheer_2()
  Go Red Sox!

• This is called variable shadowing
• If I try to run the first version of cheer without having defined team outside the function I will get an error

  >>> cheer()
  Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
    File "<stdin>", line 2, in cheer
  NameError: name 'team' is not defined

• For this reason, it is not a good idea to use global variables inside functions
• If you forget to define the global variable the function will not work
• Also, useful functions are often put into modules
• They can then be imported into any program as needed
• If functions in a module cannot depended on global variables in the script
• That would make them hard to use
• Don't use global variables in a function unless you have a good reason

Global Constants

• Some things in life, and in programming, never change
  • The number of days in the week
  • The number of months in a year
  • The first date of the year
  • The ratio of the circumference of a circle to its diameter (π)
• For this reason, some languages have special variables called constants
• A constant is a variable whose value cannot be changed
• Python does not have constants
• But you can use a global variable for this purpose
• You just give it value and don't change it
• Global variables in Python can be changed inside a function
• But you need a special construction
• It is customary to write the names of constants in ALL_CAPITALS
• This serves as a reminder never to change their values
• Global variables used as constants should be declared once at the top of the program
• You will sometime find globals in modules

Pausing Execution of a Script

• Sometimes you need to pause a script that is printing a lot of output
• A script should try to limit its output to the size of the window
• I do this in the scripts that I create to check class exercises
• I use a call to input without using the return value in an assignment statement

  input("Hit Enter to see more")

• The interpreter always stops when it come to a statement with input
• It resumes when the user hits Enter or Return

Functions that Return Values

• Functions that return values can be used in assignment statements

  >>> result = round(8.765) 
  >>> result
  9

• To return a value, a function must use return statement
• Return statements have the form

  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 code after the return statement will never be executed
• Here is a new version of the cheer function that returns a value

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

• To see the output we have to put a call to the function inside a call to print

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

• Since this version of cheer returns a value, it is an expression
• So we can always use the function call as the argument to a print

Returning Multiple Values

• A Python return statement can return more than one value
• All you have to do is follow the return keyword with a comma separated list of expressions

  return EXPRESION, EXPRESSION [, 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
• And return each to a separate variable

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

• You have to be careful when calling a function that return more than one value
• You must have a variable ready to receive each value
• On the left hand side of the assignment statement
• Assigning more that one variable a value with a single assignment statement is called multiple assignment

Standard Library

• Computer languages come with functions that are always available
• You don't have to do anything to use these functions
• Here are some examples from Python
  • print
  • int
  • float
  • input
  • range
• They are called built-in functions
• Built-in functions are actually part of the Python interpreter
• But Python also comes with other useful functions found in modules contained in the standard_library
• Each module in the standard library has functions and constants that deal with a specific topic
• The standard library modules are copied to your machine when you install Python
• For example, the math library contains many mathematical functions
  • log - Logarithm to base e
  • log10 - Logarithm to base 10
  • sin - Sine
  • cos - Cosine
  • tan - Tangent
  • ceil - Ceiling, the smallest integer larger than some value
  • floor - Floor, the largest integer smaller than some value
• It also comes with some constants
  • pi - the ratio of the circumference of a circle to its diameter
  • e - the base of the natural logarithms
• To use the math module you must first import it

  >>> import math

• Using a function in a module is different from using a built-in
• When we use a built-in we simply type the function name

  >>> print("Hello")
  Hello

• But when you use something in a module you must first write the name of the module
• This must be followed by a . followed by the name of the function or constant
• This is called dot notation
• Here are some examples

  >>> 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

Creating Random Numbers

• Many things in nature are random
  • The number of dust particles in a room
  • Whether a coin comes up heads or tails
  • The number of leaves in my yard
  • The number of water droplets in a cloud
• Random events are things that cannot be exactly predicted
• In other word, events with no patterns
• When writing programs, we often need random numbers
• We need them in writing
  • Games
  • Simulations
• Would a game of solitaire be any fun if the cards always appeared in the same order?
• Simulations are extremely important in many sciences
• Astronomers use simulations to study the evolution of galaxies
• Climate scientists use simulations to see what global warming will bring
• For both games and simulations we need random numbers
• But we have a problem
• Nothing that a computer does is random
• If you give a program the same input you will always get the same output
• In other words, the output of a program is completely determined
• There is nothing random about it
• But the need for random numbers in computing is very great
• So mathematicians have developed algorithms that create pseudorandom numbers
• These algorithms create a sequence of numbers
• In a truly random sequence, the numbers would never repeat
• In a pseudorandom sequence the numbers eventually repeat
• But the interval between repeats is so long that they are "random" enough for most purposes
• The functions that create these pseudorandom sequences are called pseudorandom number generators
• Sometimes they are simply called random number generators, although that term in not really accurate

The random Module

• One of the modules in the standard library is random
• It contains several several functions that create pseudorandom numbers
• The function randint takes two integers as arguments
• And returns a pseudorandom integer
• The two numbers specify the minimum and the maximum numbers created
• We can call this function several times and each time it will return a different number

  $ cat random_1.py 
  # demonstrates the use of the randint function of the random module
  
  import random
  
  for i in range(10):
      print(random.randint(1,100))
  
  $ python3 random_1.py 
  89
  98
  93
  73
  32
  40
  63
  100
  76
  80
  
  $ python3 random_1.py 
  66
  49
  1
  29
  63
  17
  91
  3
  70
  5

• We can use randint to simulate throwing dice

  $ cat dice.py 
  # this program emulates a throw of two dice
  
  import random
  
  die_1 = random.randint(1,6)
  die_2 = random.randint(1,6)
  print("You rolled", str(die_1), "and", str(die_2), "for a total of", str(die_1 + die_2))
  
  $ python3 dice.py 
  You rolled 4 and 3 for a total of 7
  
  $ python3 dice.py 
  You rolled 7 and 1 for a total of 8
  
  $ python3 dice.py 
  You rolled 5 and 3 for a total of 8

• If we kept calling randint long enough it would eventually repeat
• But we would have to call it a very large number of times

Other random Functions

• The random module has other pseudorandom functions
• Each of them has advantages in different situations
• The randrange function also returns an integer
• But it gives you more options when specifying the range
• While randint takes two arguments
• The arguments to the randrange function work just like the arguments to the range function
• When run with one argument randrange creates a sequence starting at 0
• And ending with one less than the argument

  $ cat random_2.py 
  # demonstrates the use of the randrange function of the random module
  # with one argument
  
  import random
  
  for i in range(10):
      print(random.randrange(5))
  
  $ python3 random_2.py 
  1
  3
  2
  0
  1
  1
  2
  2
  0
  4

• Notice that all the numbers are between 0 and 4
• When called with two arguments the first argument specifies the start of the range
• And the second number specifies one more than the end of the range

  $ cat random_3.py 
  # demonstrates the use of the randrange function of the random module
  # with two arguments
  
  import random
  
  for i in range(10):
      print(random.randrange(1, 6))
  
  $ python3 random_3.py 
  1
  3
  1
  2
  5
  5
  2
  3
  1
  1

• Here all the numbers fall between 1 and 5
• When called with 3 arguments the third argument specifies the difference between any two values

  $ cat random_4.py 
  # demonstrates the use of the randrange function of the random module
  # with three arguments
  
  import random
  
  for i in range(10):
      print(random.randrange(2, 11, 2))
  
  $ python3 random_4.py 
  6
  6
  4
  6
  8
  10
  10
  4
  8
  2

• The values are all even numbers between 2 and 10
• Both randint and randrange return integers
• If you want a decimal number, use random
• It generates a random number between 0.0 and 1.0

  $ cat random_5.py 
  # demonstrates the use of the random function of the random module
  
  import random
  
  for i in range(10):
      print(random.random())
  
  $ python3 random_5.py 
  0.3366683809865726
  0.6243291094221154
  0.47182435685723234
  0.3079697111617222
  0.5048399470937616
  0.11682962682702247
  0.08597187089498437
  0.10398098486344709
  0.8667164814826076
  0.15337564523669833

• uniform takes two arguments and creates decimal numbers
• The numbers lie between the two arguments which specify the range

  $ cat random_6.py 
  # demonstrates the use of the uniform function of the random module
  
  import random
  
  for i in range(10):
      print(random.uniform(1, 5))
  
  $ python3 random_6.py 
  3.987702460027857
  2.776217942732739
  2.890534381287354
  1.5377836190792888
  3.1461905324732022
  1.010886780905638
  1.4452549292653458
  4.558908792372804
  4.934363837349949
  2.1135109420482228

Random Number Seeds

• The numbers generated by the functions in the random module are not truly random
• They use algorithms that need a starting value to work
• The starting value is called a seed
• If the seed is the same the numbers created by the random functions will be the same
• To prevent this from happening the functions in random use a trick
• Instead of choosing the same seed value each time they run they use the system time instead
• Every computer keeps track of the time and date in a variable called the system time
• The system time counts seconds and is a very large integer that keeps changing
• This means the random functions will create different number sequences each time they are run
• But what if we wanted the sequence of numbers to be the same?
• Let's say that you were writing a simulation of a complicated system
• Say the weather over a continent
• You run the simulation once and get a result
• Then you want to know what would change if you added another variable to the simulation
• Say you added calculations to take account of the presence of dust in the atmosphere
• Dust helps rain clouds form
• We would want to test this new simulation when the same sequence of numbers used before
• We can do this using the seed function
• The seed function assigns a specific value to the seed
• If we use the seed function to set the seed value to the same number
• each time the program is run, we will get the same number sequence

  $ cat random_6.py 
  # demonstrates the use of the seed function in the random module
  # to generate the same series of numbers each time the program is run
  
  import random
  
  random.seed(67)
  for i in range(10):
      print(random.randint(1, 100))
  
  $ python3 random_6.py 
  10
  15
  99
  53
  60
  54
  35
  77
  55
  63
  
  $ python3 random_6.py 
  10
  15
  99
  53
  60
  54
  35
  77
  55
  63

Attendance

Graded Quiz

Class Quiz