Lecture 2

A. Syntax: how we put together legal

    Semantics: how do we deduce the meanings associated with those expressions, which is going to let us solve the problems that we want.

B.

Input (source code)/output (result)/Checker, compiler, object code, interpreter (computational process)

1. Low level: at the level of machine.

Source code (low level) ->checker ->Interpreter -> Output

Low level language uses instructions similar to internal control unit:

– Move data from one location to another

– Execute a simple ALU operation (arithmetic logic unit operation)

– Jump to new point in sequence based on test

• Checker confirms syntax, static semantics correct

• Interpreter just follows sequence of simple instructions

2. High level: 

Source code (High level) ->checker ->complier ->object code -> Interpreter -> Output

• A high level language uses more abstract terms –invert a matrix, compute a function

• In a compiled language, those abstractions are converted back into low level instructions, then executed (Fast but cannot figure out why and where bug occurred)

OR

Source code (high level) ->checker -> interpreter -> Output

• In an interpreted language, special program converts source code to internal data

structure, then interpreter sequentially converts each step into low level machine

instruction and executes (little lower that complied language)

Like Python.

C. Python program

• Program (or script) is a sequence of definitions and commands

– Definitions evaluated and commands executed by Python interpreter in a shell

– Can be typed directly into a shell, or stored in a file that is read into the shell and evaluated

• Command (or statement) instructs interpreter to do something

D. Object

• At heart, programs will manipulate data objects

• Each object has a type that defines the kinds of things programs can do to it

• Objects are:

– Scalar (i.e. cannot be subdivided), or

  1. int: used to represent integers, e.g., 5 or 10082

  2. float: used to represent real numbers, e.g., 3.14 or 27.0

  3. bool: used to represent Boolean values True and False

– Non-scalar (i.e. have internal structure that can be accessed)

   1. many different kinds of compound objects, just like strings (str)

       a. str:

              eg: 3 * 'ab' = 'ababab' 

              'a' + 'b' = 'ab' 

              Operator overloading (little weird...)

        b. len: length

               eg: len('abc') = 3

The built in Python function type returns the type of an object

E. Expression

•Objects and operators can be combined to form expressions, each of which denotes an object of some type

• The syntax for most simple expressions is:

-<object><operator><object>

like

a. i + j – sum – if both are ints, result is int, if either is float, result is float

b. i - j – difference

c. i * j – product

d. i/j - float

e. i//j – division – if both are ints, result is int, representing quotient without remainder

f. i%j – remainder

g. i**j – i raised to the power of j

h. i > j – returns True if strictly greater than

i. i >= j – returns True if greater than or equal

j. i < j

k. i <= j

l. i == j – returns True if equal

In Python, if there is a float value in expression, then all available interpreters will be converted to float first.

strings always greater than number (including ins and float)

m. i != j – returns True if not equal

order: without parenthess, ** ->* ->/ -> +/- executed left to right, as appear in expression

F. Binding

If want to change the value of one name, just re-give the new value to the name. But if there are any name compose by the changing the name, the name will still constantly the same. The reason is that the value of the "composed" name have already been stored.

G. Extracting part of str

• Indexing:

– ‘abc’[0] returns the string ‘a’

– ‘abc’[2] returns the string ‘c’

– ‘abc’[3] is an error (as we cannot go beyond the boundaries of the string)

– ‘abc’[-1] returns the string ‘c’ (essentially counting backwards from the start of the string)

• Slicing:

– If s is a string, the expression s[start:end:step] denotes the substring that starts at start, and ends at end-1

• ‘abc’[1:3] has the value ‘bc’

further read: 1. http://stackoverflow.com/questions/509211/explain-pythons-slice-notation

                    2. https://docs.python.org/2/tutorial/introduction.html#strings

H. miscellaneous

1. Comments appear after a #

2. any string is always bigger than any int.

3. under compounding test, if condition satisfied first if, Python will not evaluate any other elif.