Today: loose ends: comprehension-if, truthy logic, floating point, open-source

Comprehensions - Recall 1-2-3

• Recall - comprehension re-uses syntax of other constructs
• 1. type in a pair of outer brackets [ ]
• 2. inside write a foreach "for n in nums" - choose var name "n" or "s" ..
  e.g. typical Python: choose var name to keep your ideas straight
• 3. then the result expression "n * n" goes on the left

>>> nums = [1, 2, 3, 4, 5, 6]
>>> [n * n for n in nums]
[1, 4, 9, 16, 25, 36]

Comprehension + If

• Can add "if" filter on the right hand side
  add at right: if n > 3
  Mnemonic: re-use syntax again
• Left hand side can be just "n" to pass value through unchanged

>>> nums = [1, 2, 3, 4, 5, 6]
>>> [n for n in nums if n > 3]
[4, 5, 6]
>>> [n * n for n in nums if n > 3]
[16, 25, 36]

Example/Exercises Comprehensions

These are all 1-liner solutions with comprehensions. We'll just do 1 or 2 of these.

Syntax reminder - e.g. make a list of nums doubled where n > 3

[2 * n for n in nums if n > 3]

Section on server: Comprehensions

> diff21

> first_up

> up_only (has if)

> even_ten (has if)

Comprehensions Replace map()

Comprehensions are easier to write than map(), so you can use them instead. Why did we learn map() then? Because map() is the ideal way to see how lambda works. At this point, you can use comprehensions instead of map, (and exam problems will give full credit to either form, your choice).

Comprehension Fever - 1 Line Is Ideal

Programmers can get into Comprehension Fever - trying to write your whole program as nested comprehensions. Probably 1-line is the sweet spot.

Using regular functions, loops, variables etc. for longer phrases is fine.

Pre-Truthy Example

Say we want to print a string if it is non-empty, this code works fine and you can write it this way, but there is a shorter way to do it shown below.

if len(s) > 0:
    print(s)

Truthy True/False

The if and while are a little more flexible than we have shown thus far. They use the "truthy" system to distinguish True/False.

You never need to use this in CS106A, just mentioning it in case you see it in the future.

For more detail see "truthy" section in the if-chapter Python If - Truthy

Truthy False

Truthy logic says that "empty" values count as False. The following values, such the empty-string and the number 0 all count as False in an if-test:

# Count as False:
''
0
0.0
None
[]
{}

Truthy True

Any other value counts as True. Anything that is not one of the above False values:

# Count as True:
6
3.14
'Hello'
[1, 2]
{1: 'b'}

How To Use Truthy

With truthy-logic, you can use a string or list or whatever as an if-test directly. This makes it easy to test, for example, for an empty string like the following. Testing for "empty" data is such a common case, truthy logic is a shorthand for it. For CS106A, you don't ever need to use this shorthand, but it's there if you want to use it. Also, many other computer languages also use this truthy system, so we don't want you to be too surprised when you see it.

# pre-truthy way:
if len(s) > 0:
    print(s)


# truthy equivalent:
if s:
    print(s)

(optional) Truthy Example/Exercise

> no_zero

> not_empty

Finally Explain Other Code Lines in
wordcount.py / pylibs.py

The pylibs.py example file begins..

#!/usr/bin/env python3

"""
Stanford CS106A Pylibs Example
Nick Parlante
"""

import sys
import random


...lots of code...


if __name__ == '__main__':
    main()

1. #!/usr/bin/env python3

• #!/usr/bin/env python3
• This should be the very first line of your python file
• This indicates that it's a python-3 file
• Older, spec that it's a Python-2 file
  #!/usr/bin/python
• Not a requirement, but a good practice
• This is an ancient Unix syntax for specifying the type of a file
• Unix is ancient and influential
• Most modern Operating Systems follow Unix conventions: Mac OS, Linux, iOS, Android
  Windows is the exception
  But windows software can still use that line

Python-2 vs. Python-3

There are not huge differences between Python version-2 and version-3. You could easily write Python-2 code if you needed to, but Python-3 is strongly preferred for all new work. That said, many orgs may have old python-2 programs laying around, and it's easiest if they just use them and don't update or edit them. The first line #!/usr/bin/env python3 is a de-facto way of marking which version the file is for.

2. What's this if __name__ Thing?

What is this if __name__ test at the bottom of the file. Basically, every Python file has this at the bottom.

if __name__ == '__main__':
    main()

Consider a Run of the Program

Say you run a program like this:

$ python3 wordcount.py poem.txt

In that case, the if __main__ thing will be True. What does it do? It calls the main() function.

So if the program is run from the command line, call its main() function. That is the behavior we want, and it is what the above "if" does.

If the "if" were no there, running the program from the command line would not run its main() function.

What Is The Other Way To Load?

What is the other way to load a python file? There is some other python code, and that code imports the python module.

# In some other Python file
# and it imports wordcount
...
import wordcount

In this more unusual case, the above "if" will be False. Loading a module does not run its main(), which is the behavior we want. Loading a module means I want to call its functions myself, not that I want its main() to start parsing the command line and doing its own thing.

Remember: End With Those Two lines

You do not need to remember all those details. Just remember this: have that if-statement at the bottom of your file as a couple boilerplate lines. It calls the main() function when this file is run on the command line.

if __name__ == '__main__':
    main()

Comparison forms: == vs. is

Use == For Comparisons

Use == to compare two things, as we have done all quarter.

Other Comparison: is

There is another comparison called is. This checks if two variables refer to the exact same object in memory.

You can go an entire lifetime and never need to use is operator in code - it just does not compute something that code typically needs to know. You should default to using == to compare values.

(optional) Demo of is

Here is a demo of is, but you do not need this for CS106A.

>>> a = [1, 2, 3]
>>> b = a
>>> a is b          # "is" True case
True
>>> c = [1, 2, 3]   # c looks like a
>>> a is c          # "is" False case
False
>>> a is not c      # "is not" variant
True
>>>
>>> a == c          # == returns True
True
>>>

PEP8 is None Rule

The one time you need to use is is for PEP8 conformance. PEP8 says to use is for the values None, True, False, but really None is the one that comes up all the time.

So for PEP8, it's preferable to use is instead of ==, like below. The reasons for this are a bit obscure, but it's simplest to just follow PEP8.

if x == None:          # Works, but not PEP8
    print('nothing')


if x is None:          # PEP8 this way
    print('nothing')

So you should use is for comparison to None. Do not use is for anything else. We will never mark off CS106A code that uses == here (which in fact will work perfectly), but for PEP8 you can write it with is.

Two Math Systems, "int" and "float" (Recall)

• Two Systems
• int and float are two different worlds
• "float" .. floating decimal point, moves around
• Float and int - each have their own area on the chip
• Look similar, but distinct
• 6 - the int six
• 6.0 - the float six

# int
3  100  -2

# float, has a "."
3.14  -26.2  6.022e23

Math Works

• Math works: + - * / min() max() for both int and float fine:
• i.e. mostly don't have to think about it
• Need to use int for indexing - [ ], grid.get(x, y)
• Foreshadow:
  Float mostly works easily
  BUT Float has one crazy flaw .. revealed below
• Clickbait: you will not believe what float does

Float - One Crazy Flaw - Do Not Panic

• Note: do not panic! We can work with this. But it is shocking.
• Float arithmetic is a little imprecise
• Off at the 15th digit .. there are erroneous "garbage" digits
• 1. Idea of 1/10th, mathematically pure
• 2. In Python code: looks like this 0.1
• 3. In the computer memory, actually: 0.100000000000076
• There are some garbage digits way off to the right
• The Math Will Not Come Out Exactly Right
• This is a deep feature of float numbers in the computer, applies to all languages
• The print routine hides a few digits, so often the garbage is hidden
  But in the computation, the garbage is there

Crazy Flaw Demo - Adding 1/10th

• Garbage digits are almost always part of a float value
• Printing omits a few stored digits at right
• So often do not see the garbage
• But eventually the garbage gets big enough to print...

>>> 0.1
0.1
>>> 0.1 + 0.1
0.2
>>> 0.1 + 0.1 + 0.1    # this is why we can't have nice things
0.30000000000000004
>>> 
>>> 0.1 + 0.1 + 0.1 + 0.1
0.4
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.5
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.6
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.7
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.7999999999999999     # here the garbage is negative

Another example with 3.14

>>> 3.14 * 3
9.42
>>> 3.14 * 4
12.56
>>> 3.14 * 5
15.700000000000001   # d'oh

Conclusion: float math is slightly wrong

Why Must We Have This Garbage?

The short answer, is that with a fixed number of bytes to store a floating point number in memory, there are some unavoidable problems where numbers have these garbage digits on the far right. It is similar to the impossibility of writing number 1/3 precisely as a decimal number — 0.3333 is close, but falls a little short.

Why? Why Must There Be This Garbage?

• We think in base 10
• So 0.1 and 2.5 come out "even"
• But 1/3 does not come out even
• Try to write 1/3 out as a decimal number
  Say stop at 10 digits: 0.3333333333
  This number differs from 1/3 by a tiny "error" amount
• Some fractions come out even in base 10, and some don't
• The computer uses base 2 internally - 0's and 1's
• In base 2, a different set of numbers don't come out even
• The garbage digits off to the right are due to the tiny error

Crazy, But Not Actually A Problem

• Everyone needs to remember:
• float arithmetic always comes out a tiny bit wrong
• (int arithmetic, comes out perfect)
• The error is typically far less than 1-trillionth part
• But the error is not zero
• Most computations can handle an error of 1-trillionth part
• Actually not a problem
• How many digits of accuracy in the inputs, 6 digits?

Must Avoid One Thing: no ==

• There is one concrete coding rule
• Do not use == with float
• Exception: 0.0 is reliable for ==
• Any float value * 0.0 will be exactly 0.0

>>> a = 3.14 * 5
>>> b = 3.14 * 6 - 3.14
>>> a == b   # Observe == not working right
False
>>> b
15.7
>>> a
15.700000000000001

How To Compare Floats

• Compare float values
• Instead of ==, look at abs(a - b)
• abs(x) - the absolute value function
• Check if absolute value of difference is very small
• There is also a builtin function math.isclose() that does this

>>> abs(a - b) < 0.00001
True
>>>
>>> import math
>>> math.isclose(a, b)
True

int Arithmetic is Exact

• int arithmetic does not have the error problem of float
• int results are exactly correct and repeatable
• Except overflow - many languages, have a maximum possible int
  Int arithmetic that goes over the max will get the wrong answer - aka "overflow"
  Uniquely, Python does not have a max int
• Bank balance example:
  Bank balances can be stored as int number of pennies
  That way balance add/subtract comes out exactly right

>>> # Int arithmetic is exact
>>> a = 6
>>> b = 24
>>> 
>>> a * 5
30
>>> a * 5 - 6
24
>>> a * 5 - 6 == b
True

int Bitcoin

Bitcoin wallets use this int strategy - the amount of bitcoin in a wallet is measured in "satoshis". One satoshi is one 100-millionth of 1 bitcoin. Each balance is tracked as an int number of satoshis, e.g. an account with 0.25 Bitcoins actually has 25,000,000 satoshis. Using ints in this way, the addition and subtraction to move bitcoin (satoshis) from one account to another comes out exactly correct.

Float Conclusions

• Two systems, int 67 and float 3.14
• Math works for both int/float seamlessly
• Float has tiny error many digits to the right, don't use ==
• In contrast, int gives exact/repeatable + - * // results
  Except for overflow (in languages like C/C++)

Open Source - Python is an Example

You have noticed that Python works well on your machine, and yet it's free. How does that work? Python is a great example of "open source" software.

Much of the internet is based on open standards - TCP/IP, HTML, JPEG - and open source software: Python (language), Linux (operating system), R (statistics system).

How Open Source Works:

Let's look at Python

Open Source License - Contributions

• Python is distributed for free
• The "source code" of Python is the code to produce Python itself
  Python itself is written in the computer language "C" (CS106B, CS107)
• Python has an "open source" license
  The source code of Python is distributed liberally
  The license encourages contributing improvements back to Python source code to benefit everyone
• There are many variations in open source licenses, but freely available source code and contribute-back are two key attributes

Open Source Economics

• This is an incredibly successful model
• Anyone can build their work on Python, free, not dependent on one vendor
  e.g. Build on Microsoft Visual Basic
  Microsoft charged for it
  And in fact, as sole vendor, they could charge a lot
  And eventually in fact Microsoft discontinued Visual Basic
  Building your expensive technology depending on one vendor looks bad!
• Google, Microsoft, and Apple .. all compete with each other
• But they all use Python
• All contribute to Python, knowing that others contribute also - a sort of truce
• Open source: common infrastructure, we'll all use, nobody's competitive advantage
• Lack of duplication of effort creates value
  vs. suppose Microsoft, Google each had their own privately maintained language
• Obviously in other domains Microsoft, Google etc. have their own tech and compete

This open/free/shared model of technology is surprising and does not look like other markets. It is an incredibly successful model.