15-112: Fundamentals of Programming and Computer Science
Class Notes: Data and Expressions


  1. Some Builtin Types
  2. Some Builtin Constants
  3. Some Builtin Functions
  4. Some Builtin Operators
  5. Types Affect Semantics
  6. Operator Precedence
  7. Integer Division
  8. The Modulus or Remainder operator (%)
  9. Integer vs Floating-point Division
  10. Approximate Values of Floating-Point Numbers
  11. Floating-Point Numbers and almostEqual
  12. Short-Circuit Evaluation
  13. Truthy and Falsey
  14. Boolean Arithmetic

  1. Some Builtin Types
    import math
    def f():
        print "This is a user-defined function"
        return 42
    
    print "Some basic types in Python:"
    print type(2)           # int
    print type(2**500)      # long
    print type(2.2)         # float
    print type("2.2")       # str  (string)
    print type(2 < 2.2)     # bool (boolean)
    print type(math)        # module
    print type(math.tan)    # builtin_function_or_method
    print type(f)           # function (user-defined function)
    print type(type(42))    # type
    
    print "#####################################################"
    
    print "And some other types we will see later in the course..."
    print type(Exception()) # Exception
    print type(xrange(5))   # xrange
    print type([1,2,3])     # list
    print type((1,2,3))     # tuple
    print type({1,2})       # set
    print type({1:42})      # dict (dictionary or map)
    print type(2+3j)        # complex  (complex number) (we may not see this type)
    

  2. Some Builtin Constants
    print "Some builtin constants:"
    print True
    print False
    print None
    
    print "And some more constants in the math module:"
    import math
    print math.pi
    print math.e
    

  3. Some Builtin Functions
    print "Type conversion functions:"
    print bool(0)   # convert to boolean (True or False)
    print float(42) # convert to a floating point number
    print int(2.8)  # convert to an integer (int)
    
    print "And some basic math functions:"
    print abs(-5)   # absolute value
    print max(2,3)  # return the max value
    print min(2,3)  # return the min value
    print pow(2,3)  # raise to the given power (pow(x,y) == x**y)
    print round(2.354, 1) # round with the given number of digits
    

  4. Some Builtin Operators
    CategoryOperators
    Arithmetic+, -, *, /, //, **, %, - (unary), + (unary)
    Relational <, <=, >=, >, ==, !=, <>
    Assignment+=, -=, *=, /=, //=, **=, %=, <<=, >>=
    Logicaland, or, not
    Note: for now at least, we are not covering the bitwise operators (<<, >>, &, |, ^, ~, &=, |=, ^=).

  5. Types Affect Semantics
    print 3 * 2
    print 3 * "abc"
    print 3 + 2
    print "abc" + "def"
    print 3 + "def"
    

  6. Operator Precedence
    print 2+3*4  # prints 14, not 20
    print 2**4/2 # prints 8, not 4
    

  7. Integer Division
    print " 6/3 =", ( 6/3)
    print " 5/3 =", ( 5/3)
    print " 2/3 =", ( 2/3)
    print "-4/3 =", (-4/3)
    

  8. The Modulus or Remainder Operator (%)
    print " 6%3 =", ( 6%3)
    print " 5%3 =", ( 5%3)
    print " 2%3 =", ( 2%3)
    print " 0%3 =", ( 0%3)
    print "-4%3 =", (-4%3)
    print " 3%0 =", ( 3%0)
    

  9. Integer vs Floating-Point Division
    print 10 / 3
    print 10.0 / 3
    print 10 / 3.0
    
    x = 10
    print x / 3
    print 1.0 * x / 3
    print float(x) / 3
    print float(x / 3)  # careful!
    

  10. Approximate Values of Floating-Point Numbers
    print (0.1 + 0.1 == 0.2)       # True, but...
    print (0.1 + 0.1 + 0.1 == 0.3) # False!
    print (0.1 + 0.1 + 0.1)        # prints 0.3, which seems ok, but...
    print (0.1 + 0.1 + 0.1) - 0.3  # prints 5.55111512313e-17 (tiny, but non-zero!)
    

  11. Floating-Point Numbers and almostEqual
    d1 = 0.1 + 0.1 + 0.1
    d2 = 0.3
    print (d1 == d2)                # still False, of course
    epsilon = 10**-10
    print (abs(d2 - d1) < epsilon)  # True!
    
    # Once again, using an almostEqual function (that we will write)
    
    def almostEqual(d1, d2, epsilon=10**-10):
        return (abs(d2 - d1) < epsilon)
    d1 = 0.1 + 0.1 + 0.1
    d2 = 0.3
    print (d1 == d2)           # still False, of course
    print almostEqual(d1, d2)  # True, and now packaged in a handy reusable function!
    

  12. Short-Circuit Evaluation
    def yes():
        return True
    
    def no():
        return False
    
    def crash():
        return 1/0 # crashes!
    
    print (no() and crash()) # Works!
    print (crash() and no()) # Crashes!
    print (yes() and crash()) # Also crashes (but does not short-circuit)
    
    # Once again, using the "or" operator
    
    print (yes() or crash()) # Works!
    print (crash() or yes()) # Crashes!
    print (no() or crash()) # Also crashes (but does not short-circuit)
    
    # Yet another example:
    
    def isPositive(n):
        result = (n > 0)
        print "isPositive(",n,") =", result
        return result
    
    def isEven(n):
        result = (n % 2 == 0)
        print "isEven(",n,") =", result
        return result
    
    print "Test 1: isEven(-4) and isPositive(-4)"
    print (isEven(-4) and isPositive(-4)) # Calls both functions
    print "----------"
    print "Test 2: isEven(-3) and isPositive(-3)"
    print (isEven(-3) and isPositive(-3)) # Calls only one function!
    

  13. Truthy and Falsey
    # "x is Truthy" means "bool(x) == True"
    # "x is Falsey" means "bool(x) == False"
    # Also: Python returns the last value it required
    # to determine the Truth value of a logical expression.
    # So, what do these do?
    
    print (True and 5)
    print (False and 5)
    print (1 and 2) or 42
    print (1 and 0) or 42
    

  14. Boolean Arithmetic
    # In general, you should not use boolean arithmetic (it can be confusing).
    # Instead, use "if" statements or expressions.  That said, you need to
    # understand how boolean arithmetic works (in case someone else uses it,
    # and also because you cannot use "if" for hw1 or quiz1!).
    
    # In numeric expressions...
    #     True is treated as 1
    #     False is treated as 0
    
    # So...
    print 5 * True  # 5
    print 5 * False # 0
    print 5 + True  # 6
    print 5 + False # 5
    
    # 112 Boolean Arithmetic Style Rule #1:  Do not use boolean arithmetic!
    # But if you really can't help yourself, then....
    
    # 112 Boolean Arithmetic Style Rule #2: If you do use boolean arithmetic,
    # be sure to first explicitly convert the boolean to an int using int().
    # So...
    print 5 * int(True)  # 5
    print 5 * int(False) # 0
    print 5 + int(True)  # 6
    print 5 + int(False) # 5