CS 2120: Class #5 ================= The Boolean type ^^^^^^^^^^^^^^^^^ * We've used comparison operators (e.g., ``<,>,==``) in conditionals. * What's going on "under the hood" with the comparison, though? >>> 5>2 True >>> 5<2 False * A comparison like ``a>b`` is just an *expression*, like ``a+b``. * The difference is that the value it produces isn't an integer, it's either ``True` or ``False`` * A value that is either ``True`` or ``False`` (and nothing else) has type `Boolean `_. >>> type(5>2) .. admonition:: Activity Write a function ``is_negative(n)`` that *returns* ``True`` if the argument ``n`` is negative and ``False`` otherwise. Verify that the return type is correct. .. raw:: html More about returns ^^^^^^^^^^^^^^^^^^ * We've already seen that functions can return a value at the end. * In fact, a function can return a value *at any time*, not just the end. * We can take advantage of this fact to have multiple returns!:: def divisible_by(a,b): if a % b == 0: return True else: return False .. admonition:: Activity * What is the result of the function call ``divisible_by(4,2)``? * How about ``divisible_by(4,3)``? * Now write a new function ``not_divisible_by(a,b)`` that returns ``True`` when ``a`` is *not* divisible by ``b`` and ``False`` otherwise. * Now write this function to do the same thing with only **1** return statement. * Functions returning Boolean values are pretty handy. Why? Where do you see yourself using them? The function type ^^^^^^^^^^^^^^^^^ * In Python, *functions* have a type, too: >>> type(divisible_by) * Not all programming languages are so enlightened. * You can read up on `first-class functions `_ if you want to be a nerd about it. * This allows us to do some very "meta" things and quickly write code that is really general:: def add(a,b): return a+b def subtract(a,b): return a-b def dosomething(f,a,b): return f(a,b) .. admonition:: Activity * What is the value of ``dosomething(add,5,7)``? * How about ``dosomething(substract,5,7)``? * Now make sense of what exactly is happening! * If all of this weirds you out... good. You're normal. Passing around functions is crazy weird stuff. * Don't worry if you aren't 100% confident on this yet. We'll come back to it in more detail later. .. raw:: html Developing bigger programs ^^^^^^^^^^^^^^^^^^^^^^^^^^^ .. image:: ../img/softeigineering.jpeg * The best way to do this is still a (very) open research problem in software engineering. * Here, I'm going to suggest *bottom up*, incremental, development. * Start with an empty function that returns a constant value (e.g., 0.0) * Try the function. Works? Ok, step 1 down. * Add 1 or 2 lines of code to accomplish part of what you want to do. * Try the function. Make sure those lines worked! * Repeat. * Build up your function *incrementally* and **test** at each increment. * The alternative is to try to sit down and bang out the whole function in one go. * If you're perfect, this is faster. * I did this once in my life. I swear! * Otherwise... you'll spend a *lot* of time debugging. * Besides, I'm sorry, but you're not perfect. .. admonition:: Activity Build a function to compute compound interest given a starting amount(``P``), an annual interest rate (``r``), the number of compoundings per year(``n``) and the total number of years (``t``). Your function should return the value of the principle plus the interest after compounding. .. raw:: html * For bigger projects: break your problem down into a hierarchy of subproblems (remember, think in terms of *levels of abstraction*!). * Solve the easiest, smallest, subproblems first. * For us, solving means "writing a function to do it". * Immediately after writing the function, *test it right there and then*. * Once you've written all the really easy, low level, functions, start combining them to write the higher level ones. For next class ^^^^^^^^^^^^^^^ * Read `chapter 6 of the text `_