Values and statements

• The primitive elements that a program manipulates are values. 1, 4.5, and "hello" are examples of values.
• An expression is some combination of elements that the interpreter can evaluate:
  • 1
  • 4.5
  • 1 + 4.5
  • 'hello'
  • 'hello' * 3
• We say that the expression 1 + 4.5 "evaluates to" 5.5.
• A literal is an expression that evaluates to itself. There are two kinds of literals: numbers, like 18 and 24.3, and strings, like "Indiana University" and '5 + 3'.
• A statement is a primitive expression that the Python interpreter can execute, for example, an expression like 1+3 is a statement because the interpreter executes it by evaluating it.

Functions (1)

• A function is a named sequence of statements that performs some computation. For now, we'll only consider functions that are built into Python. Next week we'll learn how to define our own functions.
• You have already seen the built-in function type. From the examples we've looked at, you can see what the basic syntax of functions is like in Python: the name of the function is followed by its arguments surrounded by parentheses.
• When the intepreter evaluates an expression like type(3.5), it first evaluates all of the arguments, then it applies the function to those values and returns that result.
• Applying the function to its arguments is also referred to as calling the function.
• The function type takes only a single argument. When we call it, it returns the type or class of the value of its argument.

  >>> type("spam, spam, spam, spam")
  <class 'str'>
  >>> type(3-2)
  <class 'int'>

• Another very important built-in function is print. This function takes any number of arguments. The arguments of a function are separated by commas. The function print prints out the values of its arguments, with spaces separating them, and then prints out a newline character. (Note that it doesn't return the values of its arguments; it just prints them out to the screen.)

  	
  >>> print("Hello world!")
  Hello world!
  >>> print("Hello" + " world!")
  Hello world!
  >>> print("Hello", "world!")
  Hello world!
  >>> print(3, 8)
  3 8
  >>> print(3 + 8)
  11
  >>> print(3 + 8, 8 + 3)
  11 11
  >>> print("The answer is", 3 + 8)
  The answer is 11

• Note: print was not a function in Python 2; it had a very different syntax. In the book, examples of print will appear using that old syntax.

Variables

• At many points in a program, we need to "hold on" to a value so that we can do something else with it.

  >>> print("Agent's current position", (3 + 8 * 2), (3 + 8 * 1))
  Agent's current position 19 11
  >>> print("Agent's distance from right wall", 50 - (3 + 8 * 2))
  Agent's distance from right wall 31
  >>> print("Agent's distance from bottom wall", 50 - (3 + 8 * 1))
  Agent's distance from bottom wall 39

• A variable is a symbol that is a placeholder for a value.
• To create a variable and give it a value, we use an assignment statement.
• An assignment statement consists of the variable name, followed by the = operator, followed by an expression that evaluates to the value we are giving the variable. Note that an assignment statement is not a function, so it does not have arguments within parentheses.

  >>> agent_x = 3 + 8 * 2
  >>> agent_y = 3 + 8 * 1
  >>> print("Agent's current position", agent_x, agent_y)
  Agent's current position 19 11
  >>> print("Agent's distance from right wall", 50 - agent_x)
  Agent's distance from right wall 31
  >>> print("Agent's distance from bottom wall", 50 - agent_y)
  Agent's distance from bottom wall 39

• We also use an assignment statement to update the value of a variable that already exists.

  >>> agent_x = 19 + 5 * 2

• The variable being reassigned can also appear on the right side of the assignment operator.

  >>> agent_y = agent_y + 5 * 1
  >>> print("Agent's new position", agent_x, agent_y)
  Agent's new position 29 16

• There are some constraints on what can be a variable name.

  >>> position1 = 3
  >>> 1position = 3
  SyntaxError: invalid syntax
  >>> agent position = 3
  SyntaxError: invalid syntax
  >>> agent-position = 3
  SyntaxError: can't assign to operator
  >>> agent_position = 3
  >>> print = 'print'
  SyntaxError: invalid syntax

• In Python, you can assign multiple variables in the same statement. The names and values are separated by commas.

  >>> agent_x, agent_y = agent_x + 2, agent_y + 1
  >>> print("Agent's new position", agent_x, agent_y)
  Agent's new position 31 17

Scripts

• A script is a series of statements separated by newlines and stored in a file. When a script is run, the statements are executed in the order they appear in.
• A script can be run in a shell by typing

  python <file>

  where <file> is the file containing the script. (Don't forget to use python3.2 if there are other versions of Python on your computer.)
• In IDLE, we create a new file by selecting "New Window" in the File menu, and we save it by selecting "Save". If the file is to contain Python source code, the file name should end in ".py".
• In IDLE, we run a script by selecting the file containing the script and then selecting "Run module" in the Run menu.
• Notice what happens when we run the following script:

  5 + 3
  print(5 + 3)
  x = 5 + 3
  x
  print(x)

• In interactive mode, when we evaluate an expression (by typing it in and hitting "Return"), we see its value. This is not true when we evaluate the expression as part of running a script.
• Calling print results in something being printed out, whether the function is called in interactive mode or as part of a script.
• Practice
  • Write a script that prints out the following when it is run (using your name). Don't use any string literals (like "Michael") in the print functions; instead use variables.

    My name one way: Michael E. Gasser
    My name another way: Gasser, Michael E.
    

Comments

• Comments are notes in natural language that explain what a portion of a program is doing and that are ignored by the interpreter.
• In Python, comments are preceded by the # character.
• Everything on a line following a # is ignored by the interpreter.

  ## Initialize the Agent's internal state.
  agent_hunger = 0     # Start full of food
  agent_thirst = 0     # ... and liquid.
  agent_fatigue = 0    # Ready for action.

Importing other modules

• The basic arithmetic operators are built into Python, but if we want to do something like square root or exponential, we have to rely on one of the modules in the Python library.
• A module is the contents of .py file.
• To use a module in a program, we must import it.
• An import statement has this form:

  import <module>

  where <module> is the name of the file containing the module, without the .py extension.
• To use a function in a module that we have imported, we precede it with the name of the module, followed by a dot.

  >>> import math
  >>> math.sqrt(20)
  4.4721359549995796
  >>> math.exp(2)
  7.3890560989306504

• To generate a random number between 0.0 and 1.0, we use the function random(), which is found in the random module.

  >>> import random
  >>> random.random()
  0.16032592299859239

• Look in the Python documentation to see what other built-in modules there are. (There is also a local copy of the documentation that comes with Python. You can get to it through the IDLE Help menu.)
• Practice
  • Write a script that creates two random numbers, prints out the numbers, then prints out their sum, and finally prints our their difference. Here's what the output might look like when you run the script.

    x: 0.6242929322521281
    y: 0.02276168663140743
    x + y = 0.6470546188835355
    x - y = 0.6015312456207207

Answers

Answers to problems in these notes: script 1, script 2