Week 2 - Variables and Statements

Variables and Statements

Introduction

• Previous chapter: Operators and arithmetic expressions
• This chapter: Variables, statements, import statement, print function
• New vocabulary: “argument” and “module”

Variables

Definition

• A name that refers to a value or a storage location for a value.

Creating variables (Assignment statements)

1. Syntax: variable_name = expression
2. Examples:

   n = 17
   pi = 3.141592653589793
   message = 'And now for something completely different'
   

3. No visible output when running assignment statements in the Python interpreter or Jupyter Notebook (i.e. Google Colab).

Using variables

1. As expressions

   message
   # Output: 'And now for something completely different'
   

2. In arithmetic expressions

   n + 25
   # Output: 42
   2 * pi
   # Output: 6.283185307179586
   

3. In function calls

   round(pi, 2)
   # Output: 3
   len(message)
   # Output: 42
   

State diagrams

• Graphical representation of variables and their values
• Used throughout the book to model Python’s variable storage, but you can generate better ones on Python Tutor
• Python Tutor or your IDE Debugger can be used (and we will later) to give you a better understanding of how the internals of Python work (i.e. stack/frames, heap/objects)

Python Variable naming rules (Other languages have slightly different rules)

1. Can be any length (Though choose to be reasonable!)
2. Can contain letters and numbers
3. Cannot start with a number
4. Conventionally lowercase (PEP Standards)
5. Underscore (_) is the only allowed punctuation
   • Used for multi-word names: your_name, airspeed_of_unladen_swallow
   • snake_case_it_is
6. Cannot use keywords as variable names
   • They are reserved in the Python grammar to designate features supported by python like class, import, etc.

Illegal variable names (examples)

million! = 1000000                          # SyntaxError: invalid syntax
76trombones = 'big parade'                  # SyntaxError: invalid decimal literal
class = 'Self-Defence Against Fresh Fruit'  # SyntaxError: invalid syntax

Keywords in Python

• There currently exist 36 keywords in Python 3.12
• They will get highlighted in your PyCharm IDE

Keyword	Description
and	Logical AND operator.
as	Used in import statements to alias modules or packages.
assert	Used for debugging, raises an AssertionError if a condition is false.
async	Indicates an asynchronous function or expression.
await	Used within asynchronous functions to wait for a coroutine to complete.
break	Terminates the innermost loop.
class	Defines a new class.
continue	Skips the current iteration of a loop and starts the next.
def	Defines a function.
del	Deletes an object or variable.
elif	Used in if statements for alternative conditions.
else	Used in if and try statements for a default block.
except	Used in try statements to handle exceptions.
False	Boolean value representing false.
finally	Used in try statements to execute code regardless of exceptions.
for	Used for creating loops that iterate over a sequence.
from	Used in import statements to import specific objects from a module.
global	Declares a variable as global.
if	Used for conditional statements.
import	Used to import modules or packages.
in	Used to check membership in a sequence.
is	Compares the identity of two objects.
lambda	Used to create anonymous functions.
None	Represents the absence of a value.
nonlocal	Declares a variable as nonlocal within a nested function.
not	Logical NOT operator.
or	Logical OR operator.
pass	Used as a placeholder for a statement.
raise	Raises an exception.
return	Returns a value from a function.
True	Boolean value representing true.
try	Used for exception handling.
while	Used for creating loops that continue as long as a condition is true.
with	Used for context management, often with file handling or resource management.
yield	Used in generator functions to return values one at a time.

The import Statement

• Purpose: Importing Python features
• Syntax or Usage: import module_name

Modules

• Collections of variables and functions

• Example We’ve seen: math module

  import math
  print(math.pi)  # Output: 3.141592653589793
  

• Accessing module contents, like functions stored in the module.

• Use the dot operator (.)
• Examples:

  math.sqrt(25)  # Output: 5.0
  math.pow(5, 2)  # Output: 25.0
  

Expressions and Statements

Types of expressions - These are Evaluated

Evaluating an expression means Computing its value

1. Single values (integer, float, string)
2. Collections of values and operators (i.e. x + y)
3. Variable names
4. Function calls

Complex expression example

19 + n + round(math.pi) * 2

Statements - These are Executed

• Executing a statement: Running it and performing its action
• Definition: Units of code with an effect but no value
• Examples: Assignment statements, import statements import math or x = 5

The print Function

Purpose: Displaying multiple values

Basic usage

print(n+2)
print(n+3)

Working with different data types

print('The value of pi is approximately')
print(math.pi)

Multiple arguments

- (Yes, we will learn how to make our own functions that can take multiple arguments, both named and unnamed)
    ```python
    print('The value of pi is approximately', math.pi)
    ```
- Note: print function ALWAYS adds a space between values when passing multiple arguments to the function.
    - BUT you can change it:
        ```python
        print("Hello", "world!", sep="---")
        ```

Printing Formmatted Strings and Format Specifiers

• Using variables in format string

  print(f"{variable_name}")
  

• Using variables and utilizing data-type specific formatting

  print(f"{math.pi:.2f}")  # 2 decimal spots
  print(f"{my_int:05d}")   # 5 spaces padded with 0
  

• Using variables and aligning in formatting

  print(f"Hi {math.pi:>10.2f}")  # 2 decimal spaces with 10 padded spaces aligned right
  print(f"Hi {math.pi:<10.2f}")  # 2 decimal spaces with 10 padded spaces aligned left
  print(f"Hi {math.pi:^10.2f}")  # 2 decimal spaces with 10 padded spaces aligned center
  

Arguments

• Definition: Expressions in parentheses when calling a function

Functions with different numbers of arguments

1. Single argument: int('101')
2. Two arguments: math.pow(5, 2)
3. Optional arguments: int('101', 2), round(math.pi, 3)
   • We will learn how to write functions and methods that take optional arguments, just not yet.
4. Variable number of arguments: print('Any', 'number', 'of', 'arguments')
   • We will learn how to write functions and methods that take a variable number of arguments and allow for packing and unpacking them, but not yet.

Argument errors

1. Too many arguments: TypeError
   • This implies the function does not allow variable arguments.
2. Too few arguments: TypeError
   • This implies the function has required arguments (i.e. non-optional) and you are missing one or more.
3. Incorrect argument type: TypeError
   • This implies there could be a datatype mismatch among other posibilities.
   • Type Hints/Annotation were introduced in Python 3.5 to abet in addressing common TypeError issues in Python, but they are used by IDEs because the Python Interpreter does not enforce them.

     def add_numbers(a: int, b: int) -> int:
         """Add two numbers and return the result."""
         return a + b
     
     def concatenate_strings(strings: List[str]) -> str:
         """Concatenate a list of strings and return the result."""
         return "".join(strings)
     
     age: int = 76
     first_name: str = "Alice"
     last_name: str = "Cooper"
     concatenate_strings(first_name, last_name)
     add_numbers(age, 24)
     

Comments

• Purpose: Adding notes to explain code
• Syntax/Usage: # symbol

Types of comments

1. Full-line comments

   # number of seconds in 42:42
   seconds = 42 * 60 + 42
   

2. End-of-line comments
   • The standard says 2 spaces befor the comment # in end of line comments.

     miles = 10 / 1.61  # 10 kilometers in miles
     

Best practices

• Document non-obvious features
• Explain WHY, not what
• Avoid redundant comments
• Use good variable names to reduce need for comments

Debugging

Types of errors

1. Syntax errors
   • Related to program structure
   • Prevent program from running
   • Example: Illegal variable names
2. Runtime errors (exceptions)
   • Occur during program execution
   • Example: Using unsupported operators
3. Semantic errors AKA Logic errors
   • Program runs but doesn’t do what’s intended
   • Example: Incorrect order of operations

Additional Notes on Variables and Statements not Covered by the Book

1. Type Hints/Annotations (introduced in Python 3.5) were already mentioned above in Argument Errors section.
2. F-strings or Format Strings (introduced in Python 3.6) were already mentioned above in the Variable Printing section.

3. Walrus operator := (introduced in Python 3.8)

   • Allows assignment within expressions

     if (n := len(data)) > 10:
         print(f"List is too long ({n} elements, expected <= 10)")
     

   name = "Alice"
   age = 30
   print(f"{name} is {age} years old")
   

4. Underscores in numeric literals (introduced in Python 3.6) just to make large numbers simpler to read.

   million = 1_000_000