Course Logistics

• Instructors:
  • Tom Ferrin
    • Office: GH-N472
    • Email: tef@cgl.ucsf.edu
  • Conrad Huang
    • Office: GH-N453A
    • Email: conrad@cgl.ucsf.edu
• Text:
  • Think Python 2e (free download)
• Web Site:
  • www.cgl.ucsf.edu/Outreach/pc204
• Sign up form:
  • www.cgl.ucsf.edu/cgi-bin/pc204_signup

Logistics (cont.)

• Course prerequisites:
  • You have a good understanding of computers, files, and directories
  • You know how to send and receive e-mail with attachments
  • You want to learn how to write useful, good quality programs
• Computing resources:
  • The best approach is to set up your laptop with Python and any other programming tools you might need. If you have a Mac or Windows just download and install Python from www.python.org
• Grading:
  • Homework: 50%
  • Final project: 50%
  • Homework due no later than beginning of class the following week
  • Email homework to pc204@cgl.ucsf.edu

Logistics (cont.)

• Think Python vs Course Lectures:
  • We’ll basically be marching through Think Python from beginning to end. The lecture notes cover most of the same material but often in a different fashion, so you’ve got the opportunity to think and learn about concepts in a couple different ways.
  • Course slides can be viewed at www.cgl.ucsf.edu/Outreach/pc204/lecture_notes/weekN/LectureN.html
• Python 2 vs Python 3
  • Python 3.x is the present and future of the language.
  • Python 2.7 is the widely used predecessor. They are 98% compatible!
  • We'll use Python 3 for most code examples, but will point out any differences between Python 2 and Python 3 along the way.
  • For more information see wiki.python.org/moin/Python2orPython3

How Hard Can Good Code Be?

Some famous computer software bugs

Why Python?

• Python has many language features that facilitate writing Good Code. It's a widely-available, easy-to-learn, object-oriented, interpreted language that provides high-level language constructs. Python home page: www.python.org

• Alternatives programming languages:
  • C and C++ - Standardized, efficient general purpose languages with lots of features but pretty steep learning curve
  • Fortran - Same disadvantages as C; mostly used for numerically intensive programming tasks
  • Java - Widely available, but more "systems oriented" and often requires more coding than Python to accomplish the same task; popular for client-side web applications
  • Javascript - Mostly used for adding dynamics to web pages; no object-oriented language features
  • Perl - Similar to Python (high-level, general-purpose, interpreted), but its syntax is often strange and it's not easy to build large and complex programs

The Python Interpreter

$ python3
Python 3.6.4 (v3.6.4:d48eceb, Dec 19 2017, 06:54:40) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
>>> print("Hello world!")
Hello world!
>>> course = "pc204"
>>> print(course)
pc204
>>> pi = 3.14159265
>>> print(pi)
3.14159265
>>> exit()
$

What is a Program?

Make our Python commands into a program

• Step 1 - Create a file named "prog.py" containing the same commands:

  #
  # hello.py - a simple python program
  # Author: Tom Ferrin
  # Updated: Sep 25, 2018
  #
  print("Hello world!")
  course = "pc204"
  print(course)
  pi = 3.14159265
  print(pi)
  

• Step 2 - Execute the commands in the file:

  $ python3 prog.py
  Hello world!
  pc204
  3.14159265
  $
  

Our first program (cont.)

• Text preceeded by #'s are called comments and are ignored by the Python interpreter. But comments are a vital component of all programs! They provide a means of informing a reader about your code. Stuff like who wrote it and when, or what version it is, or why some particular operation is being done. Comments are a mandatory component of all Good Programs.


• For all homework assignments and final project:
  • Write your code as one of more .py files
  • Always include code that demonstrates that your program is working properly
  • Make sure your name is included in each file as a comment
  • If your program is written to run under Python 2 make sure you note this at the beginning of the file
  • Email you program as an attachment to pc204@cgl.ucsf.edu
    (Please don't mail to individual course instructors or the TA.)

The Program Development Cycle

In a typical traditional programming language...

The same using an "interpreted" programming language

And the same using Python in particular

Variables, Expressions, and Statements

Values

• All programming languages support the fundamental programming concepts of variables and values. Values are things like numbers or strings of characters. Variables are just names that refer to values.
• These things are values:
  • 1
  • 3.14159265
  • "Hello there, my name is Tom."
• The three values above are actually of three different types: an integer, a floating-point number (most often just called a float), and a string. Python has many more types of values, but these three are the most common.

Variables

• You associate a value with a variable by using an assignment statement. Assignment statements are just a variable name, an equal sign, and a value:
  • one = 1
  • pi = 3.14159265
  • my_string = "Hello there, my name is Tom."
• Variable names can be anything you choose, so long as they begin with a letter or underscore ( _ ) and only have letters, numbers, or underscores in them. [Exception: variable names cannot be Python keywords - see below.] These are all valid variable names:
  • foundit, default, meters, photons, PSheader, line, foundBlank, point14, my_string, InvalidInput
  
  Note that names are case sensitive, so InvalidInput is not the same as invalidinput.

Variables, Expressions, and Statements (cont.)

• Statements are units of code that the Python interpreter can execute, like the series of assignment statements from a couple of slides back.
   
  
• Operators are symbols that represent computation. Some common ones are +, -, *, /, and ** (the last one means exponentiation). You can use these in expressions to combine values and variables, for example:
  • answer = pi * 100
  • radians = degrees / 360 * 2 * pi
  • fraction = 59 / 60

Python 2 vs Python 3

fraction = 59 / 60

fraction = 59. / 60

quotient = 59 // 60

Precedence

• Parentheses have the highest precedence and can be used to explicitly control the order of evaluation.
• Exponentiation has the next highest precedence.
• Multiplication and Division have the same precedence and come next.
• Addition and Subtraction have the same precedence and come next.
• Operators of the same precedence are evaluated left to right.

Precedence Examples

1 + 1 ** 5 - 2          <== evaluates to 0
(1 + 1) ** (5 - 2)      <== evaluates to 8
6 + 4 / 2               <== evaluates to 8
degrees / 2 * pi        <== is different than... 
degrees / (2 * pi)

Python Operators
in increasing order of precedence

Mixing numeric types

a = 3.14159
b = 5
c = a + b

1. Integers
2. Long integers
3. Floating-point (float)
4. Complex numbers

Operations on non-numeric types

• "first" + "second" performs the concatenation operation and results in the string "firstsecond"


• "first" * 3 performs repetition and result in the string "firstfirstfirst"

Python Development Environments

Development Environments (cont.)

• In a traditional development environment the programmer uses a "plain" text editor such as Vim or Emacs to write and modify their Python programs. (Microsoft Word won't do, as it inserts all sorts of formatting and font data into your files which Python won't know what to do with.) Programs are then run from the Unix/Linux command line via the Unix shell. The shell provides all sorts of short cuts and tools to make your life as a programmer easier.
   
  
• Alternatively you can use IDLE, the standard Python development environment. Its name is an acronym of "Integrated DeveLopment Environment" and it works well on both Unix and Windows platforms. IDLE has a Python interpreter "shell" window, and also has a simple file editor that lets you create and edit existing Python source files. This web page describes how to access IDLE on OS X, Windows, and Linux.
   
  
• [short demo in class of vim, the Unix shell, and IDLE]

Functions

def MyFunction():
    print("hello world")
    pi = 3.14159265
    print(pi)

MyFunction()

def MyOtherFunction(arg):
    ans = (arg + 7) * 10.0
    return ans

x = MyOtherFunction(5)
print(x)    <=== prints 120.0

Functions (cont.)

• Functions are great for packing up chunks of code into manageable pieces that are easy to understand and can be used (i.e. called) from more than one place in a program. They make your programs easier to write and debug as small units and then combine together into something much bigger that accomplishes the overall desired task.
• Python has several built-in functions. The most commonly used ones are int(), float, and str():
  • int() takes any value and converts it to an integer.
  • float() converts an integer to a floating point number.
  • str() converts numbers to strings.
• Python also has a math module that you can import into your program. It defines many mathematical functions. Go to the www.python.org web site and type "math module" in the search box to see all the functions available.

Functions (cont.)

• Functions allow for code reuse (sections of code to be packaged together and then used in more than one place and more than one time) and for procedural decomposition (splitting large pieces of code into smaller, more manageable chunks).
• Syntax:

  def function_name(arg1, arg2, ... argN):    # header line
      statements                              # function body
      statements                              # function body
      return some_expression                  # end of function
  

• Notes:
  1. "def" creates a function object and assigns it to a name.
  2. The "return" statement is optional. If included, it sends a value back to the caller of the function. If not included, the special object "None" is returned to the caller. (The None object is just an empty placeholder.)
  3. All names assigned inside a function are local to that function and exist only while the function executes except when you specify a name in a "global" statement.
  4. Arguments (also known as "parameters") are passed to functions by assignment (object reference). The caller and the function share these objects.

Function Example

def printProduct(i, j):
    print(i * j, end=' ')    # "end" replaces newline character with space

def printRow(n):
    for i in range(1, 10):   # this is a "for" loop (more about this in week 3)
        printProduct(i, n)   # call function printProduct 10 times
    print()                  # start a new line

def printTable():
    for i in range(1,10):
        printRow(i)

printTable()	# function printTable must be defined before here

1 2 3 4 5 6 7 8 9
2 4 6 8 10 12 14 16 18 
3 6 9 12 15 18 21 24 27 
4 8 12 16 20 24 28 32 36 
5 10 15 20 25 30 35 40 45 
6 12 18 24 30 36 42 48 54 
7 14 21 28 35 42 49 56 63 
8 16 24 32 40 48 56 64 72 
9 18 27 36 45 54 63 72 81

Python 2 vs Python 3

print i * j

print(i * j)

def printProduct(i, j):
    print i * j,             # the comma suppresses a new line after each number

def printRow(n):
    for i in range(1, 10):   # this is a "for" loop (more about this in week 3)
        printProduct(i, n)   # call function printProduct 10 times
    print                    # start a new line