##   Fundamentals of Programming I: Statements and Expressions.

# Program code in a language such a Python consists of *statements* or
# *commands*.  A statement/command is a directive for the computer to perform
# some action. In order to form statements, however, we also need *expressions*
# or *values*.  For example:

print "hello"

# This line is a statement that does something obvious.  Here, "hello" is
# an expression.  The difference between statements and expressions is 
# analogous to the difference between sentences and nouns in natural 
# language.  In the context of this analogy *print* would be the verb.

x = 3+1  # assigns 4 to memory location associated with x, prints nothing

# This is another statement: it instructs the system to calculate the
# value 4 and *assign* it to a variable named x; in other words to store
# 4 into a certain memory location it will associate with x.  In this
# statement the expressions are x and 3+1.  Note that 3+1 by itself is
# not a statement.  It does calculate 4, but 4 is also not a statement:
# we need to put this *value* into something else in order to make it a 
# statement.  Please note that this statement prints nothing, even in the
# interactive interpreter.

## Expressions/values come in many different forms or *types*.  Understanding
# the exact type of an expression is very important.  Furthermore, each
# type of expression can be divided into primitive and compound expressions.
# I list the principal types that you need to know, along with examples:

## 0. Integer expressions:  3, 3+4, 3-2*5, etc.  Here, 3 is primitive while
# the rest are compound.  A particularly important kind of integer expression
# is formed with the % operator (called the mod operator).  5%2 returns the
# remainder after dividing 5 by 2.  The expression 5/2 returns 2, the quotient
# without the remainder after dividing 5 by 2.

## 1. Floating point expressions:  3.14, 2.0, etc..

# These are numbers with decimal points, and are often called "doubles".  
# Note carefully that 2.0 is not the same as 2 (why?).  Similarly,
# the compound expression 1.0/2.0 is not the same as 1/2.  1/2 is an
# integer value (0), while 1.0/2.0 is 0.5.
# To convert a float into an int, use the following kinds of expressions:

print 1/int(2.0)
print 1/float(2)

# Here, int(2.0) is an operation that converts a float to an int.  int(2.0)
# has the same value as the integer 2, and analogously for float(2).

print int(3.9)  # prints 3 - the decimal part is discarded.
print int(3.9+0.5) # prints 4 - always add .5 if you want to round off.


## 2. String expressions: "hello world", "12", "faks3r3**(()", ""

# Strings are just sequences of zero or more characters that are taken
# as-is.  Thus do not confuse "12" with the integer 12.  "12" is just a
# sequence of two characters.  If you type "12"+3, do not expect 15!
# However, there are also operations to convert strings to and from other
# types.  Try to generalize the operations demonstrated as follows:

print "12"+str(3)
print int("12")+3

# as you can see, when + is used as an operator between two strings, it
# *concatenates* them.

# One particularly important string is the empty string "".  Do not confuse
# the empty string with " ", which is a string that consists of one character:
# the space character.  

# In Python, sometimes strings are displayed using single quotes: 'abc'.

# What if you want the character " in a string? do this:
print "say \"hello\" to him"

# OK that was easy, but what if you want to include the \ character as well?
print "who needs \\ in a string anyway"

# \ is called the "escape character."


### 3.  Variables.

# variables are important kinds of expressions.  The type of a variable is
# the same as the type of value that it's assigned to.

x = "abc"  # x is now of type string
print x
x = 14     # x is now of type int
print x+1

# x was first assigned to a string, and therefore can be used as a string
# expression until it is assigned to something of different type.


## 4. Boolean Expressions.

# This is a fundamentally important type of values in any programming
# language, though a little harder to understand than numbers and strings.
# A boolean value is either True or False (capitalized T and F).  
# All compound boolean expressions eventually evaluate to one of these 
# two values.  Here are some sample boolean expressions and what they
# evaluate to:

3<4  # True
4>4  # False
4>=4 # True:  >= means greater than or equal to
3+1 == 4  # True: note that "==" means "boolean equality", which is not
          # the same as "=", which is used to form an assignment statement.
"abc" != "ABC"  # True: Python is case sensitive, and != means "not equal"

# Compound boolean expressions are formed as follows

3<4 and 3>0  # True  because both are true
3<4 or 3>4  # True   or means either or BOTH is true.
1<2 or 2<3  # True
not(1<2)    # False: because 1<2 is True. not inverts the boolean value.

# As another example, assume that x and y are two integer variables, then
# the boolean expression x != y is equivalent to not(x==y), which is also
# equivalent to (x<y or y<x).  Python also conveniently allows you to
# use expressions such as 0 < x <= 10, which is equivalent to
# (x>0 and x<=10).


### When do you need spaces?  Expressions such as x<=0 and x <= 0 are the
# same.  But do not use x < = 0: <= is one symbol.  Usually symbols are
# divided into "alphanumeric" and non-alphanumeric.  An alphanumeric term
# starts with a letter (upper or lower case), and is followed by zero or
# more letters and digits.  For example, x2ab3d is alphanumeric, and can
# be used as the name of a variable.  Non-alphanumeric symbols include
# ==, =, <=, %, etc.  A number like 24 is also non-alphanumeric because
# it does not start with a letter. In general, use spaces between different
# alphanumeric symbols.  For example, what's wrong with 0<xory>10 ?  Spaces
# are needed to separate the alphanumeric symbols 'x', 'or', and 'y'.  So
# this should be written as 0<x or y>10.  However, there does not need to
# be spaces between alphanumeric and non-alphanumeric symbols: 0<x is ok.
# When confused, use ()s to disambiguate.
###


## 5. Expressions returned by function calls.

# In the example int(3.9), int is a built-in function that take a floating
# point number as an *argument* and returns a integer value.  It therefore
# can be used as any integer value, such as in 1/int(3.9).  Functions can
# be user-defined, but we'll learn about those later.  For now, learn the
# following:

y = input("Enter an integer:")
print "this number squared is ", y*y
x = raw_input("Enter a String:")  # x is assigned to string returned by function
print "You entered", x

# Note that raw_input instead of input is usually used to ask the user to
# enter a string.


## 6. Tuples.

# A tuple is a sequence of expressions such as 1,2,3.  

x,y = input("Enter a pair of numbers, separated by a comma: ")
print "x is ", x, " and y is ", y

A tuple is just a way to group a fixed number of values into a single value.

t = 4,8

Here I'm assigning a single variable t to a tuple of two integers.
To extract the individual values of a tuple, use
print t[0]  # prints 4, the first value of the tuple
print t[1]  # prints 8, the second value of the tuple

The *FIRST* element of a tuple (or list, array, etc) is always the ZEROTH
element.

The expression len(t) will return the number of elements of a tuple (in this
case 2).

Warning: tuples are not the same as arrays: tuples cannot be changed.



#######
## Statements

# Now that we've learned some basic expressions, we can use them to form
# program segments.  We've already seen two kinds of statements: 
# print statements and assignment statements.  The python operation print
# can print an expression of any type, including tuples. In the example
# print "x is ", x, " and y is ", y 
# we are instructing the system to print a tuple of 4 values separated by
# commas: two of these values are strings and two are integers.

# As explained, assignment statements associate variables with values.
# They can also be used to change the value of existing variables.

x = 3
x = x+2  # please explain to your math teacher that this is not "x==x+2" !
# x is now 5.

# Let's write a little program that converts feet to meters.  One foot is 
# equal to 0.3048 meters.  Keep in mind  that "=" is not the same as "==".  

f = input("Enter distance in number of feet: ")
m = f * 0.3048
print f, " feet is equal to ", m, " meters"

## NOW YOUR TURN: WRITE A PROGRAM TO CONVERT CENTIMETERS TO INCHES.


## More interesting programs can only be written using boolean expressions.

x,y = input("Enter a pair of floating point numbers: ")
if y!=0.0: print x/y
else: print "can't divide by zero!"

# if-else is an important kind of statement.  The else clause is optional:
# if it's not present then nothing will be done if the boolean expression 
# evaluates to False.

# Here's the equivalent to the first program I ever wrote myself, although
# I didn't write it in python:

x = 1
while x<10:
  print "hello"
  x = x+1
# end while x
print "done"

# In python, indentation is important.  The while statement says to keep
# executing the two statements print "hello" and x=x+1 until the boolean
# condition x<10 becomes False.  This will print "hello" NINE times (not ten!).
# Afterwards, it will print "done" just once, because that's outside the loop.
# I made this mistake when writing my first program because I had wanted
# it to print "hello" ten times.  The two statements form the "body" of the
# while loop.  The body or *scope* of the while loop is determined by 
# indentation: thus you are REQUIRED to comment the end of your loops as
# shown, otherwise it would be very hard to keep track of indentation when
# your program gets large.

# That's yet for now.  Experiment with what you have learned.