Booleans

• More mathematical operators: <, >, <=, >=, ==
  • In mathematics, inequality symbols represent statements about relationships, as the equals sign does.
    `x^4 ge x^2`
  • In programming languages, the corresponding comparison operators represent questions: either True or False is returned.

    >>> 3 < 8
    True
    >>> 3 >= 4
    False
    >>> angle = math.radians(60); x, y = math.cos(angle), math.sin(angle)
    >>> x < y
    True
    >>> x**2 > y**2
    False

• True and False are literal values of type boolean; the corresponding Python function is bool.

  >>> False
  False
  >>> type(False)
  <type 'bool'>
  >>> bool(0)
  False
  >>> bool(5)
  True

• The == operator asks whether its two operands are equal. Be careful to distinguish it from the assignment operator, =. Note that == can be used with values other than numbers.

  >>> x, y = 3, 4
  >>> x == y
  False
  >>> x = y
  >>> x == y
  True
  >>> 'a string' == 'A STRING'
  False
  >>> [1, 2, 3] == [1, 2, 3]
  True

• There is another equality operator, is, which is stricter than ==. (What this means will be clear later on.)
• The != operator means "is not equal to?". The stricter version of inequality is is not.

Predicates

• A function that returns a boolean is a predicate.
• Some built-in functions are predicates.

  >>> isinstance(3, float)
  False

• A predicate definition

  def are_same_type(obj1, obj2):
      """Are obj1 and obj2 of the same type?"""
      return type(obj1) == type(obj2)
  
  >>> are_same_type(3, 6.0)
  False
  >>> are_same_type('abc', '123')
  True

• Practice
  • Define a predicate that tells whether two strings have different lengths.
  • Define a predicate that tells whether the first of two numbers provided by the user is less than the second.

Boolean operators

• The boolean or logical operators and, or, and not return booleans, behaving like you would expect them to from formal logic.

  >>> x, y = -2, 2
  >>> x**2 == y**2 and x**3 == y**3
  False
  >>> x**2 == y**2 or x**3 == y**3
  True
  >>> not x**3 > y**3
  True

• Two other operators that return booleans are in and not in. These test whether the left-hand element is (or is not) a member of the right-hand element. This works with strings as both operands, for example. It also works with lists.

  >>> vowels = 'aeiou'
  >>> 'd' in vowels
  False
  >>> 'd' not in vowels
  True
  >>> 3 in [1, 2, 3, 4]
  True
  >>> vowels1 = ['a', 'e', 'i', 'o', 'u']
  >>> vowels2 = ['ai','ay', 'au', 'aw', 'ea', 'ee', 'ei', 'ey','ie',
  	   'oa', 'ou', 'ow', 'oi', 'oo', 'oy']
  >>> string = 'uw'
  >>> string in vowels1 or string in vowels2
  False
  

• Practice
  • Define a predicate that takes x and y coordinates of two points and tells whether the first point is above and to the left of the second.
  • Define a predicate that takes three strings and tells whether one or the other of the first two strings is contained within the third string.

Simple conditional statements

• Any non-trivial program will need to do different things under different circumstances, that is, to test whether certain conditions are true and to specify what to do in each case.
• A conditional statement has one or more conditions and a statement to be executed for each of these conditions.
• The simplest form for a condtional statement is the following.

  if condition:
      statement

• The condition is an expression which returns a boolean, and the statement is an expression that gets executed if the condition returns True. The condition must be followed by a colon, and the statement must be indented relative to the if line.
• An example of a condition statement in a function definition:

  def print_same_type(obj1, obj2):
      '''Print out the type of obj1 and obj2 if it's the same.'''
      if are_same_type(obj1, obj2):
          print(type(obj1))
  
  >>> print_same_type(3, 5)
  
  >>> print_same_type(3, 'three')
  >>> print_same_type(are_same_type, print_same_type)
  <class 'function'>

• Practice: define a function that takes a person's name (a string) and their age (an integer), and if the person is over 65, prints out a message saying that they (giving their name) can retire.

More complicated conditional statements

• We often want to do different things (statements) under different circumstances (conditions).
  • When there are two conditions and corresponding statements, we use if together with else:

    if condition:
        statement1
    else:
        statement2

  • We can nest if/else expressions with the keyword elif ("else if"):

    if condition1:
        statement1
    elif condition2:
        statement2
    elif condition3:
        statement3
    ...
    else:
        statement4

  • Example:

    def print_rel_value(x, lower, higher):
        '''Print out whether x is between, below, or above the other two args.'''
        if lower <= x <= higher:
            print(x, 'is between', lower, 'and', higher)
        elif x < lower:
            print(x, 'is below', lower)
        else:
            print(x, 'is above', higher)

• Whenever a statement is called for, for example, in an if expression, we can replace it with a block statement, which includes multiple statements which are to be executed in sequence.
  • In Python, a block is indented relative to the enclosing code. For example, the statements 1, 2, and 3 in the following represent a block.

    if condition:
        statement1
        statement2
        statement3
    elif:
        ...

  • Example:

    def smaller(x, y):
        '''Return the smaller of two numbers or strings and print out a message.'''
        if x < y:
            print('First is smaller:', x)
            return x
        else:
            print('Second is smaller:', y)
            return y

• Notice how return statements interact with conditional statements.
  • When a return statement is executed in a function call, the value of the expression(s) following return is (are) immediatedly returned; any statements that follow the return statement are not executed.
  • The following are equivalent.

    def rel_value_string1(x, lower, higher):
        '''Return a string specifying whether x is between, below, or above the other two args.'''
        if lower <= x <= higher:
            return 'between'
        elif x < lower:
            return 'below'
        else:
            return 'above'
    
    def rel_value_string2(x, lower, higher):
        '''Return a string specifying whether x is between, below, or above the other two args.'''
        if lower <= x <= higher:
            return 'between'
        if x < lower:
            return 'below'
        return 'above'

• For the purposes of the condition test in an if expression, the empty string (''), the empty list ([]) and the number zero (0 or 0.0) are all treated as False.

  >>> x, y = -1, 1
  >>> if x + y:
  	print('Something non-zero')
  

• Practice
  • Define a function that takes any number, a lower threshold, and an upper threshold and returns the number itself if it is between the thresholds, otherwise the lower or upper threshold, depending on whether the number is below the lower or above the upper threshold.
  • Define a function that asks the user to generate a new password, then checks to see if it contains at least one space and at least one of the characters '%' and '*'. If the password does satisfy the constraints, the function prints out 'Your new password:', followed by the password and returns the password. If the password doesn't satisfy the constraints, the function prints out either 'The password has to have at least one space' or 'The password has to contain either "%" or "*"', depending on what's wrong, and returns the empty string.

Answers

Answers to problems in these notes