• Literals
• Variables and identifiers
• Operators
• Expressions
• Data types

• literal: a sequence of one or more characters that stands for itself.
• numeric literal: contains only the digits 0–9, a sign character (1 or 2) and a optional decimal point.
  • integer versus floating point value
  • e for scientific notation
  • 3, -42, +98.6, 6.033e23

• Floating point values have limited range and precision.
• IEEE 754: ±10^-308 to ±10³⁰⁸ with 16 to 17 digits of precision.
• arithmetic overflow: results when operation causes number to be “too big”.

>>> 1.5e200 * 2.0e210
inf

• arithmetic underflow: results when operation causes number to be “too small”.

>>> 1.0e-300 / 1.0e100
0.0

• Limited precision means actual values are approximations.

>>> 6 * 1/10
0.6
>>> 6 * (1/10)
0.6000000000000001

• format() produces a string version of a value with a specific number of decimal places.
• format specifier says how many places and format.

>>> 12/5
2.4
>>> format(12/5, '.2f')      # 2 places, floating point
'2.40'
>>> format(2 ** 100, '.6e')  # 6 places, scientific notation
'1.267651e 1 30'
>>> format(13402.25, ',.2f') # optional comma
'13,402.25'

• Use either single-quote or double-quote.

greeting = 'Hi there'
"Vernacular nepotism is fractious."
'A'
"A"

• Clever use:

msg = 'She said, "Yellow."'
msg = "She's making a radio."

• Characters need to be encoded as (binary) numbers.
• Python uses UTF-8 by default.
• ord() translates a single character into its UTF-8 code.
• chr() converts a UTF-8 code into a character.

>>> ord('1')
49
>>> ord('2')
50
>>> ord('a')
97
>>> ord('A')
65

• control characters: non-printing characters used to control display of output.
• Represented with escape sequences (backslash in Python).
• Most popular escape sequence is the newline control: '\n'.

>>> print('Eat\nMore\nElderberries')
Eat
More
Elderberries

• Format strings with format( value, format_specifier )

format('Hello', '<16')  # left aligned field 16 characters wide
'Hello           '
 
format('Hello', '>16')  # right aligned field 16 characters wide
'           Hello'
 
format('Hello', '.>16') # fill with '.'
'...........Hello'

• What to do with long lines in source code?
• implicit joining: you can break the line at some points without messing up logic or syntax.

print('Name:', student_name, 'Address:', student_address,
      'Number of Credits:', total_credits, 'GPA:', current_gpa)

• Doesn’t work to break up a string.

• explicit joining (backslash) can be used in some situations where implicit joining won’t.

num_seconds = num_hours * 60 * 60 + \
              num_minutes * 60 

• Also doesn’t work to break up strings.

# This program displays the Unicode encoding for 'Hello World!
 
# program greeting
print('The Unicode encoding for "Hello World!" is:')
 
# output results
print(ord('H'), ord('e'), ord('l'), ord('l'), ord('o'), ord(' '),
      ord('W'), ord('o'), ord('r'), ord('l'), ord('d'), ord('!'))

• variable: a name associated with a value.

       +--------+
num -->|   10   |
       +--------+

• assignment: take the value resulting from the expression on the right and copy it into the variable on the left.
• assignment operator: = in Python.
  • = is not “equals”!

foo = 7
num = 1 + foo
foo = foo + 1

num = 10    #        +--------+
k = num     # num -->|   10   |
            #   k -->|        | 
            #        +--------+

k = 20      #        +--------+
            # num -->|   10   |
            #        +--------+
            #        +--------+
            #   k -->|   20   |
            #        +--------+

• Use id() to see if two variables are pointing to the same thing.

>>> num = 10
k = num
>>> id(num)
??? # some number
>>> id(k)
??? # same number as above
k = 20
>>> id(num)
??? # same as before
>>> id(k)
??? # different

• identifier: a sequence of one or more characters used to provide a name for a given program element.
• identifier: names of things.
• Rules of the name:
  • letters, digits, and the underscore character only (no spaces)
  • can’t start with a digit
  • don’t use underscore for the first character for now
  • can be as long as you want

• keyword an identifier that has predefined meaning in a programming language.
• You can’t use a keyword as your own identifier in Python.
• Get a list of keywords:

>>> help()
help> keywords
# table of keywords appears
help> quit
>>> 

• Things you think should be keywords are not!
• Check “special” words using 'testword' in dir(__builtins__)

RestaurantTab.py

# Restaurant Tab Calculation Program
# This program will calculate a restaurant tab with a gift certificate
 
# initialization
tax = 0.08
 
# program greeting
print('This program will calculate a restaurant tab for a couple with')
print('a gift certificate, with a restaurant tax of', tax * 100, '%\n')
 
# get amount of gift certificate
amt_certificate = float(input('Enter amount of the gift certificate: '))
 
# cost of ordered items
print('Enter ordered items for person 1')
 
appetizer_per1 = float(input('Appetizier: '))
entree_per1 = float(input('Entree: '))
drinks_per1 = float(input('Drinks: '))
dessert_per1 = float(input('Dessert: '))
 
print('\nEnter ordered items for person 2')
 
appetizer_per2 = float(input('Appetizier: '))
entree_per2 = float(input('Entree: '))
drinks_per2 = float(input('Drinks: '))
dessert_per2 = float(input('Dessert: '))
 
# total items
amt_person1 = appetizer_per1 + entree_per1 + drinks_per1 + dessert_per1
amt_person2 = appetizer_per2 + entree_per2 + drinks_per2 + dessert_per2
 
# compute tab with tax
items_cost = amt_person1 + amt_person2
tab = items_cost + items_cost * tax
 
# display amount owe
print('\nOrdered items: $', format(items_cost, '.2f'))
print('Restaurant tax: $', format(items_cost * tax, '.2f'))
print('Tab: $', format(tab - amt_certificate, '.2f'))
print('(negative amount indicates unused amount of gift certificate)')

operator: a symbol that represents an operation that may be performed on one or more operands. binary operator: takes two operands unary operator: takes one operand

PlaceInUniverse.py

# Your Place in the Universe Program
 
# This program will determine the approximate number of atoms that a person is
# person consists of and the percent of the universe that they comprise
 
# Initialization
num_atoms_universe = 10e80
weight_avg_person = 70  # 70 kg (154 lbs)
num_atoms_avg_person = 7e27
 
# Program greeting
print('This program will determine your place in the universe.')
 
# Prompt for user's weight
weight_lbs = int(input('Enter your weight in pounds: '))
 
# Convert weight to kilograms
weight_kg = 2.2 * weight_lbs
 
# Determine number atoms and percentage of universe
num_atoms = (weight_kg / weight_avg_person) * num_atoms_avg_person
percent_of_universe = (num_atoms / num_atoms_universe) * 100
 
# Display results
print('You contain approximately', format(num_atoms, '.2e'), 'atoms')
print('Therefore, you comprise', format(percent_of_universe, '.2e'),
      '% of the universe')

• expression: a combination of symbols that evaluates to a value.
• 4 + (3 * k) is an expression.
  • Has two subexpressions:
    • 4
    • (3 * k)
      • Has two subexpressions:
        • 3
        • k

• operator precedence determines which operations happen first.
• operator associativity determines the order when two operands have the same precedence.

• Similar to math.
• So far we have:

>>> 6 - 3 + 2
5
>>> 2 * 3 / 4
1.5
>>> 2 ** 3
8
>>> 2 ** 3 ** 2  # exponentiation is r-to-l
512

• Python differentiates between types of data.
• So far we have seen character strings and numbers.
• data type: a set of values and a set of operators that may be applied to those values.
• + on a number is different than on a string.
• can’t do / on a string.

• Python has many built-in types.
  • string : character strings
  • int : integer values
  • float : floating point (i.e., real) values
  • bool : True or False
• Use type() to get the type of a variable or literal.

>>> type(66)
<class 'int'>
>>> type(3.1)
<class 'float'>
>>> type(True)
<class 'bool'>
>>> type(3.1)
<class 'float'>

• Python is a dynamically typed language.
• The same variable can store different type values at different times.

x = 41 + 1
print(x)
x = 'I ate a donut.'
print(x)
x = False
print(x)

• In statically typed languages, once a variable is associated with a type, the type can’t be changed.

• Example: 3 + 1.2

• type coercion: the implicit (and automatic) conversion of one type to another.

3 + 1.2 → 3.0 + 1.2 → 4.2

• type conversion: explicitly converting one data type to another.

>>> str(42)    # convert into to string
'42'
>>> int('42')  # convert string to int
42
>>> int(3.9)   # convert float to int
3
>>> float('99') # convert int to float
99.0
>>> int('99.9') # nope
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '99.9'

TempConversion.py

# Temperature Conversion Program (Fahrenheit to Celsius)
 
# This program will convert a temperature entered in Fahrenheit
# to the equivalent degrees in Celsius
 
# program greeting
print('This program will convert degrees Fahrenheit to degrees Celsius')
 
# get temperature in Fahrenheit
fahrenheit = float(input('Enter degrees Fahrenheit: '))
 
# calc degrees Celsius
celsius = (fahrenheit - 32) * 5 / 9
 
# output degrees Celsius
print(fahrenheit, 'degrees Fahrenheit equals',
       format(celsius, '.1f'), 'degrees Celsius')