on 01-Jan-2017 (Sun)

Every powerful language has three such mechanisms:

• primitive expressions and statements, which represent the simplest building blocks that the language provides,
• means of combination, by which compound elements are built from simpler ones, and
• means of abstraction, by which compound elements can be named and manipulated as units.

data is stuff that we want to manipulate, and functions describe the rules for manipulating the data

One kind of primitive expression is a number. More precisely, the expression that you type consists of the numerals that represent the number in base 10

The most important kind of compound expression is a call expression, which applies a function to some arguments.

the operator is an expression that precedes parentheses, which enclose a comma-delimited list of operand expressions.

The operator specifies a function. When this call expression is evaluated, we say that the function max is called with arguments 7.5 and 9.5, and returns a value of 9.5.

The order of the arguments in a call expression matters. For instance, the function pow raises its first argument to the power of its second argument.

Function notation has three principal advantages over the mathematical convention of infix notation. First, functions may take an arbitrary number of arguments:

 >>> max ( 1 , - 2 , 3 , - 4 ) 3 

No ambiguity can arise, because the function name always precedes its arguments.

Second, function notation extends in a straightforward way to nested expressions, where the elements are themselves compound expressions. In nested call expressions, unlike compound infix expressions, the structure of the nesting is entirely explicit in the parentheses.

 >>> max ( min ( 1 , - 2 ), min ( pow ( 3 , 5 ), - 4 )) -2 

There is no limit (in principle) to the depth of such nesting and to the overall complexity of the expressions that the Python interpreter can evaluate. However, humans quickly get confused by multi-level nesting. An important role for you as a programmer is to structure expressions so that they remain interpretable by yourself, your programming partners, and other people who may read your expressions in the future.

Third, mathematical notation has a great variety of forms: multiplication appears between terms, exponents appear as superscripts, division as a horizontal bar, and a square root as a roof with slanted siding. Some of this notation is very hard to type! However, all of this complexity can be unified via the notation of call expressions. While Python supports common mathematical operators using infix notation (like + and - ), any operator can be expressed as a function with a name.

If a value has been given a name, we say that the name binds to the value

we can establish new bindings using the assignment statement, which contains a name to the left of = and a value to the right:

he = symbol is called the assignment operator in Python (and many other languages)

Assignment is our simplest means of abstraction, for it allows us to use simple names to refer to the results of compound operations

memory that keeps track of the names, values, and bindings. This memory is called an environment.

To evaluate a call expression, Python will do the following:

1. Evaluate the operator and operand subexpressions, then
2. Apply the function that is the value of the operator subexpression to the arguments that are the values of the operand subexpressions.

Next, observe that the repeated application of the first step brings us to the point where we need to evaluate, not call expressions, but primitive expressions such as numerals (e.g., 2) and names (e.g., add ). We take care of the primitive cases by stipulating that

• A numeral evaluates to the number it names,
• A name evaluates to the value associated with that name in the current environment.

Notice the important role of an environment in determining the meaning of the symbols in expressions

A pedantic note: when we say that "a numeral evaluates to a number," we actually mean that the Python interpreter evaluates a numeral to a number. It is the interpreter which endows meaning to the programming language.

Pure functions. Functions have some input (their arguments) and return some output (the result of applying them).

Pure functions have the property that applying them has no effects beyond returning a value. Moreover, a pure function must always return the same value when called twice with the same arguments.

Non-pure functions. In addition to returning a value, applying a non-pure function can generate side effects, which make some change to the state of the interpreter or computer. A common side effect is to generate additional output beyond the return value, using the print function.

Pure functions are restricted in that they cannot have side effects or change behavior over time.

Second, pure functions tend to be simpler to test.

Third, Chapter 4 will illustrate that pure functions are essential for writing concurrent programs, in which multiple call expressions may be evaluated simultaneously.

We have identified in Python some of the elements that must appear in any powerful programming language:

1. Numbers and arithmetic operations are primitive built-in data values and functions.
2. Nested function application provides a means of combining operations.
3. Binding names to values provides a limited means of abstraction.

How to define a function. Function definitions consist of a def statement that indicates a <name> and a comma-separated list of named <formal parameters> , then a return statement, called the function body, that specifies the <return expression> of the function, which is an expression to be evaluated whenever the function is applied:

An environment in which an expression is evaluated consists of a sequence of frames, depicted as boxes. Each frame contains bindings, each of which associates a name with its corresponding value. There is a single global frame. Assignment and import statements add entries to the first frame of the current environment.

The name of a function is repeated twice, once in the frame and again as part of the function itself. The name appearing in the function is called the intrinsic name. The name in a frame is a bound name. There is a difference between the two: different names may refer to the same function, but that function itself has only one intrinsic name.

This principle -- that the meaning of a function should be independent of the parameter names chosen by its author -- has important consequences for programming languages. The simplest consequence is that the parameter names of a function must remain local to the body of the function.

the scope of a local name is limited to the body of the user-defined function that defines it. When a name is no longer accessible, it is out of scope.