Python Overview

adapted from https://docs.python.org/3.4/tutorial/

Version

There were incompatible changes between Python 2 and Python 3. Treat Python 2 and Python 3 as similar, but distinct, languages.

This tutorial will discuss Python 3. Specifically, Python 3.5.1, because that’s the latest version available on the CSU lab machines as of this writing (October 2016).

Invoking Python

For backward compatibility, the default is Python 2. Therefore, you have to execute python3 to get Python 3.

    % python -V
    Python 2.7.12

    % python2 -V
    Python 2.7.12

    % python3 -V
    Python 3.5.1

    % ls -l /usr/bin/python
    lrwxrwxrwx 1 root root 7 Sep 29 07:31 /usr/bin/python -> python2

Help

The pydoc3 program tells you about functions:

    % pydoc3 abs
    Help on built-in function abs in module __builtin__:

    abs(...)
        abs(number) -> number

        Return the absolute value of the argument.

Help

pydoc3 can also tell you about control flow:

    % pydoc3 for

    The ``for`` statement
    *********************

    The ``for`` statement is used to iterate over the elements of a
    sequence (such as a string, tuple or list) or other iterable object:

       for_stmt ::= "for" target_list "in" expression_list ":" suite
                    ["else" ":" suite]

    ...

Interpretive mode

python3, with no arguments, starts in a “calculator” mode:

    % python3 -q
    >>> 2+2
    4
    >>> a=10
    >>> from math import sqrt
    >>> sqrt(a)
    3.1622776601683795
    >>> control-D to exit
    %

The previous lines can be edited using the arrow keys.

One-liner

To execute a single line of Python, use -c:

    % python3 -c 'v=355/113; print(v)'
    3.1415929203539825

Script

A Python script starts with #! /usr/bin/python3:

    % cat hi
    #! /usr/bin/python3
    print("Hello, world!")
    % ./hi
    Hello, world!
    %

Names Do Matter

Some people name their Python scripts whatever.py, and execute them like this:

    python3 foo.py

Why? We don’t care that your program is a Python script. Think of object encapsulation—don’t unnecessarily expose implementation details. A significant implementation detail is the implementation language.

If you’ve exposed the implementation language, like this, then you’re no longer free to change it.

Data Type Overview

Name	Examples	Notes
Boolean	`True`, `False`	capitalized
Number	`1`, `3.4`, `4.5e8`, `2**1000`	big big big
String	`"Don't" 'believe' r'\all/' """you` `read!"""`	immutable
List	`[1,2.3,"fruit",[45,5]]`	mutable, heterogeneous
Tuple	`(23, "skidoo")`, `('Jack', 58.99, "970-555-1212")`	immutable, heterogeneous
Set	`{1,2,3}`	mutable, heterogeneous
Dictionary	`{"Jack":"CT320", "Chris":"CS160"}`	mutable, heterogeneous

Variables

    # Note lack of declaration and fixed type

    val=42			    # First this type
    val="hello there folks"	    # Now this type
    Δ=[val, 42]			    # Unicode!

Indentation Determines Block Structure

Note the colon and lack of braces and then/fi

    if a>100:
        print("Holy Toledo, a is too big at", a)
        a=100
    b=a

Tabs are interpreted as every eight character positions. Changing the tab stops in your editor will not alter how Python interprets tab characters.

Wise Pythoners have their editor expand tabs to spaces, which avoids the whole problem.

if

    if age<30:
        print("You’re a punk")
    elif age>=65:
        print("You’re a geezer")
    elif age==58:
        print("You’re the ideal age")
    else:
        print("Whatever.")

This is as close as we get to a switch statement.

while

    while a>=0:
        print(a, end=" ")
        a-=1                    # No ++ or --
    print("Blastoff!")

for

The for loop iterates over a list:

    for p in [2,3,5,7,11,13,17,19]:
        print(p)

Or anything else that’s iterable:

    sum=0
    for n in range(100):
        sum+=n
    print("The sum of 0..99 is", sum)

Though a real Pythoner will do this:

    print("The sum of 0..99 is", sum(range(100)))

Sorry, C fans: no C-style for loop. range() does most of it, however.

break/continue/pass

break: end this loop, as in C
continue: go to the next iteration, as in C
pass: do nothing—used when the syntax requires a statement

for/else

    for n in range(2, 100):
        for x in range(2, n):
            if n % x == 0:
                print(n, 'equals', x, '*', n/x)
                break
        else:
            # loop fell through without finding a factor
            print(n, 'is a prime number')

The indentation is correct: the else is associated with the inner for, not the if! The else clause is executed if the for loop ended “normally”, not via break.

Functions

    def factorial(n):
        if n<=1:
            return n
        else:
            return n*factorial(n-1)

Also:

variable number of arguments
default values for arguments
keyword arguments
lambda-expressions

Scope

Ignoring modules, there are only two scopes: global and function local.

Variables that are only referenced inside a function are implicitly global. If a variable is assigned a value anywhere within the function’s body, it’s assumed to be a local unless explicitly declared as global.

Boolean Operators

Boolean operators: and, or, not

and and or are short-circuiting, and return the last value evaluated.

3 and 5 yields 5
9 or 0 yields 9
False or "hello" yields "hello"

Sorry, C fans: no &&, ||

Arithmetic Operators

The usual arithmetic operators: + - * / %
Bitwise operators: & | ^ ~ << >>
Exponentiation: **
Integer division: //
Assignment versions: +=, >>=, **=, …
Comparison operators: < > = <= >= !=
(can be chained: a<b<c)

Sorry, C fans: no ++ or --

String Operators

"hi" * 3 yields "hihihi"
"foo" + "bar" yields "foobar"
"foo" "bar" yields "foobar", for adjacent string literals
'xyz' in 'Mxyzptlk' yields True
'x' not in 'Mxyzptlk' yields False
Comparison operators: < > = <= >= !=
"%d/%d=%.3f" % (355,133,355/133)
del s[3] fails—immutable! Use: s=s[:3]+s[4:]
strings are objects, with many methods.

List Operators

l += item
del l[3]
lists are objects, with many methods.

Tuple Operators

(1,2,3)+(3,1,99) yields (1,2,3,3,1,99)
(1,2,3)*2 yields (1,2,3,1,2,3)
(a,b) = (c,d)

Set Operations

s|r: union
s&r: intersection
s^r: symmetric difference (things in s or r, but not in both)
s-r: difference (things in s but not in r)
Sets are objects, with many methods.

Dictionary Operations

d[key] = value
del d[key]
key in d
Dictionaries are objects, with many methods.

Sequence Operators

Strings, lists, tuples, and sets are all sequences, with many methods.

for item in sequence:
item in sequence
item not in sequence
len(sequence)
Slices:
- sequence[i]
- sequence[i:j] (including i, but not j)
- sequence[i:] (i until the end)
- sequence[:j] (up to but not including j)
- Negative values count from the end

Primes

    max = 100

    s = set(range(2,max))

    for candidate in range(2,max):
        s -= set(range(candidate*2, max, candidate))

    print(s)

Reference Semantics

A variable holds a reference to an object, like Java. This code:

    a=[1,2,3,4,5]
    b=a
    a[2] = 33
    print(a)
    print(b)

Produces this:

    [1, 2, 33, 4, 5]
    [1, 2, 33, 4, 5]

To make a copy, use b=a[:] or b=a.copy().

List Comprehensions

Long way:

    squares = []
    for x in range(10):
        squares.append(x**2)

Short way:

    squares = [x**2 for x in range(10)]

Multiple for loops and if statements are allowed.

Output

print(value, …, sep=' ', end='\n', file=sys.stdout, flush=False)

Prints values, separated by sep, with end after all values, to file, with optional flushing.

Right: print("hello")
Wrong: print "hello"

File I/O

Show nameserver lines in /etc/resolv.conf:

    f = open('/etc/resolv.conf', 'r')
    for line in f:
        if "nameserver" in line:
            print(line, end='')
    f.close()

or:

    with open('/etc/resolv.conf', 'r') as f:
        for line in f:
            if "nameserver" in line:
                print(line, end='')

File object methods

f.read(n): read up to n bytes
f.read(): read the rest of the file
f.readline()
f.write(string)
f.close()

Not appearing in this lecture

Classes & Objects
Exceptions / try / finally
The awesome standard module library, including:
- The re module for regular expressions.
- Operating System Services
- Invoking other programs

CT320: Network and System Administration

Fall 2016

Python

Python Overview

Version

Invoking Python

Help

Help

Interpretive mode

One-liner

Script

Names Do Matter

Data Type Overview

Variables

Indentation Determines Block Structure

if

while

for

break/continue/pass

for/else

Functions

Scope

Boolean Operators

Arithmetic Operators

String Operators

List Operators

Tuple Operators

Set Operations

Dictionary Operations

Sequence Operators

Primes

Reference Semantics

List Comprehensions

Output

File I/O

File object methods

Not appearing in this lecture