############### Notes on Tuples, Strings and Arrays ################

# Python has a type of expression called "tuples", which are just 
# sequences of expressions grouped into a single expression.

m = (3,5,7,9)  # m is a tuple of integers
print( len(m) )   # prints 4, which is the length of the tuple.

# We can also access the individual members of the tuple m by specifying an
# *index*.  The first element of the tuple is the zeroth element, and the
# last element has index len(m)-1:

print(m[0])  # prints 3, the first element
print(m[2])  # prints 7, the third element.
print( m[len(m)-1] ) # will always print the last element (in this case 9)

### Arrays (Lists)

# Arrays are similar to tuples with one big exception.  Arrays are MUTABLE.
# This means that the contents of an array can CHANGE.  Syntactically,
# arrays are indicated by square brackets instead of parentheses.
# Arrays are also called lists in Python.  Sometimes they're also called
# "vectors".

n = [2,3,5,7,11]
p = ["abc",23]    # arrays (and tuples) can contain elements of different types.

# typical loop that visits each element of the array:
i = 0 # starting index
while i<=len(n)-1:  # same as i<len(n)
  print(n[i])  # prints the ith element of the array
  i += 1       # same as i = i+1
# while i

## Changing an element of the array:
p[0] = "hello"   # this is a new type of assignment statement
print(p)

# loop to square each number in array n
i = 0
while i<len(n):
  n[i] = n[i] * n[i]   # square each element.
  i += 1
#while
print(n)

## We can also add new elements to the end of the array:
n.append(13)
print(n)

## We can test if some element is in the array using a BOOLEAN expression
#  of the form (x in n):
print(2 in n)   # prints False because n does not contain 2
print(13 in n)  # prints True because n contains 13

## We can remove the last value from an array with
last = n.pop()
# This line does two things: last is assigned to 13, which WAS the
# last value in n. Furthermore, n now no longer contains 13.  That is,
# n.pop is both a statement (it does something in place) and an
# expression (it computes and returns a value).

# QUIZ!!
# What's the difference between print(A[len(A)-1]) and print(A.pop())?


### To join two arrays together, use the EXPRESSION  A + B

A = [1,2,3]
print(A + [6,7,8])   # prints [1,2,3,6,7,8]

### IMPORTANT: unlike append, this operation does NOT change A:
print(A)  # still [1,2,3].

A = A + [6,7,8]   # Now it's been changed.

### The difference here is similar to the difference between the
#   EXPRESSION x+1 and the STATEMENT x = x+1.
# When an operation such as assignment and .append changes something,
# we say that it is DESTRUCTIVE (this is a technical term).  When it
# doesn't change anything, we say that it is NON-DESTRUCTIVE or CONSTRUCTIVE.

## A.append(2) and A = A+[2]  are equivalent statements.

A.append([2,4,5])
# what do you expect A to be now?  Has it been changed?  To what?


#######  Creating Arrays  ########

##  We often do A = [] to initialize a variable to an empty array, then
#   append to A one element at a time:

## The following loop builds an array of powers of two.
P = []  # initialize array
i = 0   # for computing 2**i power
while i<=20:
  P.append(2**i)
  i += 1
# while
print(P)

## If you know how large an array must be beforehand, it is more efficient
# to create the entire array with some initial value (such as 0) for all
# positions.
A = [0]*10
# this will create the array [0,0,0,0,0,0,0,0,0,0].  


### Note to Java/C++ programmers: Python's arrays are much more flexible,
#   though not as efficiently managed compared to arrays in C++ and Java.
#   For example, you can have elements of different types in the same array.

############# Strings are tuples.
#  A string can be used also as a tuple of individual characters:

s = "abcd"
print(len(s))  # prints the length of the string (4)
print(s[0])    # prints the 1st character
i = len(s)-1   # initialize string index to last character
while i>=0:
  print(s[i], end="")  # end="" does not add newline char at end
  i -= 1       # same as i = i-1
# while loop will print s backwards

## But strings are not arrays because you can't change a character in a
## string:  s[0] = 'z'  will give error.  Strings are not mutable.


####### ASCII CODE
# The individual characters that make up a string each has a numerical
# code (so it can be represented in binary) called its ASCII value.

print(ord('A'))  # prints 65, ascii value for upper case letter A
print(chr(66))   # prints B, the character associated with ascii code 66.

# The following loop prints the ASCII character set:
i = 32  # This is the code for the space character
while i<128:
  print(i, chr(i))
  i += 1
# while loop to print all ascii chars from 32 to 127

# Not all characters are printable.  Control characters are not included.
# Other characters not included above are ord('\n')==10, the newline 
# character, and ord('\t')==9, the tab character.
# The largest ascii value is 127.

# If you run the above code, you will see that the numerical characters
# '0' to '9' also have ascii values.  chr(0)==48, chr(1)==49, etc.
# Another point to note is that the ascii value of a lower case character
# is always 32 + the value of the corresponding upper case character.

# Don't confuse the ord function with the int function: int("2") will
# give you the number 2, but ord("2") returns 50, the ascii value of 2.

### ASCII stands for "American Standard Code for Information Interchange"
# and is very old.  It's now been extended to "Unicode", which includes
# a much larger set of characters (64K), including characters in many 
# languages.  But the ASCII part of this code still applies and is usually
# what we're going to use unless we write programs for some language other
# than English.  You're welcome to modify the loop above to try to print
# all characters up to chr(65535), but your system may not be able to display
# all these characters (you must also have the right fonts installed).

## Building Strings.

#  Two strings can be concatenated together with +:
s = "ab" + "cd"  # s is now "abcd"
# Strings are sometimes built char by char starting with the empty string "":
alph = "" # initializes s with the empty string
i = ord('a')  # ascii value of 'a'
while i <= ord('z'):
  alph = alph + chr(i) # adds next alphabetical char to end of alph
  i += 1  # i=i+1
# while
print(alph)  # prints alphabet

# EXPERIMENT: what would happen if line above was changed to
# alph = chr(i) + alph  ???

#### Let's write some code that combine what we learned about arrays,
#    strings, and ascii values:

#### The following code will convert a string into an array of ascii values:
s = input("Enter any string: ")
SA = [] # array of ascii values
i = 0 # indexes s
while i<len(s):
  SA.append( ord(s[i]) );  # read inside-out
  i += 1
#while
print(s,"in ascii:",SA)

### The following converts (destructively) all lower-case chars into
### upper case:
i = 0
while i<len(SA):
  val = SA[i]
  if val>=ord('a') and val<=ord('z'):
    val = val-32  # ascii char of uppercase
    SA[i] = val
  i += 1
#while
print("uppercase ascii values:",SA)

#### now we convert the array of upper-case ascii values back to a string:
sup =""  # start with empty array
i = 0
while i<len(SA):
  sup = sup + chr(SA[i])
  i += 1
#while
print(sup)


####### For loops.
#A while loop can always be used to "traverse" an array.  However, there is
#another convenient form that is sometimes used:

A = [2,3,5,7,11]
for x in A:
   print(x,end="")
#for loop

# This will print 2 3 4 7 11
# Note that it is the CONTENTS of the array, not the indices, that are
# printed.  Therefore, there is no need to increment x (no x+=1) inside
# the body of the for loop.  The update part is automated by the for-loop.
# In contrast, what does the following print:
x = 0
while x<len(A):
  print(x),
  x += 1
# ??

# it will print 0 1 2 3 4, which are the INDICES, not the contents.  Be sure
# not to confuse the indices of an array with their contents.

# A while loop is a much more flexible construct than a for loop, which is
# just a convenience in certain situations.  For example, you cannot traverse
# an array backwards, nor can you decide to visit every other element in an
# array using a for loop. With while loops these tasks are easily accomplished.