Input, Processing, and Output

• Typically, computer performs three-step process
  • Receive input
    • Input: any data that the program receives while it is running
  • Perform some process on the input
    • Example: mathematical calculation
  • Produce output

---

Statements

Statements in Python are made up of:

• reserved words - words that have pre-defined meanings in the Java language
• identifiers - words that are created by programmers for names of variables, functions, classes, etc.
• literals - literal values written in code, like strings or numbers
  • integer literal - an actual integer number written in code (4, -10, 18)
  • float literal - an actual decimal number written in code (4.5, -12.9, 5.0)
  • character literal - a character in single quotes: ('F', 'a', '\n')
  • string literal - a string in double quotes: ("Hello", "Bye", "Wow!\n")
• operators - special symbols that perform certain actions on their operands
  • A unary operator has one operand
  • A binary operator has two operands
  • A ternary operator has three operands (there's only one of these)
• Calls to methods (functions)

---

Displaying Output with the print Function

• Function: piece of prewritten code that performs an operation
• print function: displays output on the screen
• Argument: data given to a function
  • Example: data that is printed to screen
• Statements in a program execute in the order that they appear
  • From top to bottom

---

Variables

A name that represents a value stored in the computer memory

• Used to access and manipulate data stored in memory
• A variable references the value it represents
• Use assignment statement to create a variable and make it reference data
  • General format: variable = expression
  • Example: age = 29
  • Assignment operator: the equal sign (=)

The structure of a variable:

• Name -- chosen by the programmer (aka identifier)
• Type -- derived from the declaration of the variable
• Size -- determined by the type
• Value -- the data stored in the variable's memory location

Identifiers

Identifiers are the names for things (variables, functions, etc) in the language. Some identifiers are built-in, and others can be created by the programmer.

• User-defined identifiers can consist of letters, digits, underscores, and the dollar-sign $
• Must start with a non-digit
• Identifiers are case sensitive (count and Count are different variables)
• Reserved words (keywords) cannot be used as identifiers
• an identifier can be any length

Style-conventions (for indentifiers)

• While you can legally pick any name for a variable that follows the rules, it's also a good idea to follow common programming conventions, for easy-to-read code. Here are some conventions used:
  • class names use the CapWords convention: each name start with an uppercase letter.
    Example: MyClassName
  • variable names and method names start with a lowercase letter
  • constants are usually in ALL CAPS
  • When using names that are made up of multiple words, capitalize the first letter of each word after the first. Example:
    • numberOfMathStudents
• In addition, it's good to pick mostly meaningful identifiers, so that it's easy to remember what each is for

  numStudents, firstName   # good
  a, ns, fn                # not so good
  

More Python naming conventions

---

Data Types

There are a small set of what are known as primitives. These are basic data types that are determined for you by the interpreter.

• boolean - has two possible values, True or False
• integer (int) types - for storage of integer values
• floating (float) point types - for storage of decimal numbers (i.e. a fractional part after the decimal)
• string (str) type used to store strings in memory.
• list - are also refered to as arrays that can contain mixed datatypes.
• object - user defined types.
• Numeric literal determine the type: number written in a program with no decimal point considered integer, otherwise, considered float.
• Some operations behave differently depending on data type
• A variable in Python can refer to items of any type
  

More on Python types.

• Printing variables: Python allows one to display multiple items with a single call to print
  • Items are separated by commas when passed as arguments
  • Arguments displayed in the order they are passed to the function
  • Items are automatically separated by a space when displayed on screen

---

Strings and String Literals

• String: sequence of characters that is used as data
• String literal: string that appears in actual code of a program
  • Must be enclosed in single (') or double (") quote marks
  • String literal can be enclosed in triple quotes (' ' ' or " " ")
• Enclosed string can contain both single and double quotes and can have multiple lines

---

Comments

• Comments: notes of explanation within a program
  • Ignored by Python interpreter, its intended for a person reading the program's code
  • Begin with a # character
    # This is a comment.
• End-line comment: appears at the end of a line of code
  • Typically explains the purpose of that line
    item = 100 # This is an end-line comment.

---

Operators

• Special built-in symbols that have functionality, and work on operands
• operand -- an input to an operator
• Arity - how many operands an operator takes
  • unary operator -- has one operand
  • binary operator -- has two operands
  • ternary operator -- has three operands
• Math expression: performs calculation and gives a value
  • Math operator: tool for performing calculation
  • Operands: values surrounding operator
    • Variables can be used as operands
  • Resulting value typically assigned to variable
  • Examples:

    
    z = 10          # assignment operator (binary)
    x = y + z       # addition (binary operator)
    x = -y          # -y is a unary operation (negation)
    x++             # unary (increment)
    

  • cascading - linking of multiple operators, especially of related categories, together in a single statement:

    x = a + b + c - d + e        # cascading arithmetic operators
    x = y = z = 3                # cascading assignment operators
    

    This works because the result of one operation sends back the answer (i.e. a return value) in its place, to be used in the next piece of the statement. In the above, (a + b) happens first, then the answer becomes the first operand in the next + operation.
     
  • Precedence - rules specifying which operators come first in a statement containing multiple operators

      x = a + b * c        # b * c happens first, since * has higher
                           #  precedence than +
    

  • Associativity - rules specifying which operators are evaluated first when they have the same level of precedence.
    • Most (but not all) operators associate from left to right.
  
  

  ---

  Assignment Operator

  • Value on the right side (R-value) is assigned to (i.e. stored in) the location (variable) on the left side (L-value)
    • R-value -- any expression that evaluates to a single value (name comes from "right" side of assignment operator)
    • L-value -- A storage location! (not any old expression). A variable or a reference to a location. (name comes from "left" side of assignment operator
    • Typical usage:
      

      variable_name = expression
      

  • The assignment operator returns the L-value (which now stores the new value)
  • Examples

    x = 5
    y = 10.3
    z = x + y   # right side can be an expression
     
    a + 3 = b   # ILLEGAL!  Left side must be a storage location
    

  • Associates right-to-left

    x = y = z = 5    # z = 5 evaluated first, returns z
    

  • Creating types when assigning values to variables:

    x = 5843
    y = -1234     # assigning integers will create an int variable reference
    
    a = 12.98
    b = -345.8    # assigning a decimal numbers to create type double
     
    letter = 'Z'
    symb = '$'    # can assign character literals to char types
     
    flag = True  
    flag = False  # can assign true or false to boolean variables
    

  • Be careful to not confuse assignment = with comparison ==

  ---

  Arithmetic Operators

  Name	Symbol	Arity	Usage
  Add	+	binary	x + y
  Subtract	-	binary	x - y
  Multiply	*	binary	x * y
  Divide	/	binary	x / y
  Modulus	%	binary	x % y
  Exponent	**	binary	x ** y
  Minus	-	unary	-x

  • Division is a special case
    • Two types of division:
      • / operator performs floating point division
      • // operator performs integer division
      • Positive results truncated, negative rounded away from zero
    • For types float the / operator gives the standard decimal answer

      x = 19.0
      y = 5.0, z
      z = x / y        # z is now 3.8
      

    • For integer types, / gives the quotient, and % gives the remainder (as in long division)

      x = 19
      y = 5
      q = x / y         # q is 3
      r = x % y         # r is 4
      

  • An operation on two operands of the same type returns the same type
  • An operation on mixed primitive types (if compatible) returns the "larger" type (floating point types are "larger" than integer types, because no data is lost converting from integer to decimal precision)

    x = 5
    y = 3.6
    z = x + y          # what does z need to be?  x + y returns a double.
    

  Operator precedence

  • Arithmetic has usual precedence
    1. parentheses
    2. Unary minus
    3. *, /, and %
    4. + and -
    5. operators on same level associate left to right
  • Many different levels of operator precedence
  • When in doubt, can always use parentheses
  • Example:

    z = a - b * -c + d / (e - f)      # 7 operators in this statement
    

    What order are they evaluated in?
  
  

  Some short-cut assignment operators (with arithmetic)

   
  v += e   # means    v = v + e
  v -= e   # means    v = v - e
  v *= e   # means    v = v * e
  v /= e   # means    v = v / e
  v %= e   # means    v = v % e