Intro to Python

Orthogonality.

Extreme orthogonality is when everything is as consistent as possible even if it's different. :-) For example, LISP seems to want everything to be lists, and for the calling syntax to be the same for all features, i.e.
(FUNCTIONNAME param1 param2 ...)

         ; LISP: do something with the 2nd item in array.
         (do-something-with (aref myarray 2))
       

         // C/C++: do something with the 2nd item in array.
         do_something_with(myarray[2]);
       

         # Python: do something with the 2nd item in array.
         do_something_with(myarray[2])
       

On the other hand, the rejection of orthogonality in favor of terseness can be taken rather far. For example, Perl (which for most of the popular history of the WWW has probably been the most-used scripting language for generating webpages) has an amazing number of special uses of special characters and special variables in special circumstances.

      while (<>) {   # A Perl programmer is expected to remember
                     # that the default input to the line-input operator <>
                     # is STDIN, and that the default place for a line
                     # of data that was read in to be stored is $_.
          if ($_ > 0) {
              do_something_for_the_number($_)
          }
          if ($_ =~ /^\s+(\w+)/o {
              do_something_for_the_letters_numerals_and_or_underlines($1);
                # =~ is the pattern match operator.
                # // surrounds a pattern.
                # In a pattern match, ^  indicates the beginning
                #                          of a line or of the string, depending...
                #                     \s indicates whitespace.
                #                     +  indicates repeated one or more times.
                #                     \w indicates a letter, numeral, or underline.
                # $1 is the string matched by the first substring surrounded by ()
                #   within the pattern match.
          }
      }
      

For readability, some people might somewhat prefer the Python:

        import re  # for regular expressions package.

        ...

        pat = re.compile(r'^\s+(\w+)')  # This regexp syntax standard is Perl's fault, or to Perl's credit.
        while 1:                        # Python won't let us do variable assignment
            iline = raw_input()         #   within a conditional, to prevent accidental = for ==.
            if raw_input > 0:
                do_something_for_the_number(iline)
            matchobj = pat.match(iline)
            if matchobj != None:
                do_something_for_the_letters_numerals_and_or_underlines(matchobj.groups[1])


      

Easy and quick to write, easy to read.

• Supports code that is readable but fairly terse for its degree of readability.
  • Desired features can usually be invoked with not much typing, er, I mean keyboarding.
    e.g.
    • Variables don't have to be declared. (But is this 100% good?)
    • A module (like a small library) is a file containing Python code, having the same name as the file's name.
      (Some languages would require you to enter the name twice. :-) )
    • The most fundamental basics of the syntax attempt to reduce extra characters repeated continuously to little purpose.
      • Statement terminates at end of line by default
        (with some convenient exceptions that are easy to parse and read.)
        We avoid, for example, the consistent semicolons of C, C++, Perl; and the inconsistent semicolons of Pascal.
      • No curly brackets, BEGIN / END around a code block! Code blocks are indicated by indentation, which we already needed anyway to make our code readable.
      • Parentheses around conditional are optional.

                  ...
                  if weight > 2500 :
                      print "weight is excessively high."
                      raise MyWeightError(2500)
                  do_next_thing(some_var)
                  ...
                                              

      • Possible exception? Instead of the semicolon penalty for ending a line, we have a \ (continuation character) penalty in some cases for making an expression multiline. Does this tend to mark long hideous expressions as such? :-)
        • \ --> Warning: This is a long hideous conditional? :-)

                   if 1900 < year < 2100 and 1 <= month <= 12 \
                     and 1 <= day <= 31 and 0 <= hour < 24 \
                     and 0 <= minute < 60 and 0 <= second < 60:   # Looks like a valid date
                         return 1
                                    

        • Expressions in (), [], or {} don't need \.

                   month_names = ['Januari', 'Februari', 'Maart',      # These are the
                                  'April',   'Mei',      'Juni',       # Dutch names
                                  'Juli',    'Augustus', 'September',  # for the months
                                  'Oktober', 'November', 'December']   # of the year
                                    

        • So use parentheses, you hideous conditional-writer, you. :-)

                   if (     1900 < year < 2100 and 1 <= month <= 12
                        and 1 <= day <= 31 and 0 <= hour < 24
                        and 0 <= minute < 60 and 0 <= second < 60
                      ):   # Looks like a valid date
                          return 1
                                    

        So this feature probably fits into "Interesting design decisions to encourage readability" below.
  • Easy to remember how to write the code.
    • Generally very orthogonal, as we mentioned.
  • Interesting design decisions to encourage readability.
    • Some are great; but not everyone will agree with all of these decisions.
    • As we mentioned, blocks defined by indentation.
    • Assignment cannot occur inside expressions.

                              // OK C++ :
                              if (c = getc(f)) { ...
      
                              # Bad Python!  Won't run!
                              if (c = f.read(1)) :
                                  ...
      
                              # Good Python:
                              c = f.read(1)
                              if (c) :
                                  ...
                          

    • Exception? I wonder if declaring variables would be a good thing for documentation, although language doesn't require it.

'It's only a bit slower than Perl.'

• Are further comments required? :-)
• Actually, this is a surprisingly difficult issue, and I will cover it as a special topic near the end of the presentation if we have time.
  [In the actual presentation, I verbally summarized some conclusions and never displayed the special topic presentation notes.]

Some rudiments of actual Python code

Hello world.

  # "Hello, world" program.
  print "Hello, world."

(Relatively) simple built-types.

• Integers, floating point, complex numbers, strings, Unicode strings.
• Complex number example:

         >>> 1j * 1J
         (-1+0j)
         >>> 1j * complex(0,1)
         (-1+0j)
         

• Different ways to express a string literal in your source code.
  • single-quoted, double-quoted are simple.
  • 'raw' string literal

            >>> s = "format:\n  vcheck [driveletter]"
            >>> print s
            format:
              vcheck [driveletter]
                  

  • raw strings avoid interpretation of \. sequences, and interpret actual newlines as newlines.

            >>> s = r"  0
                ---
                / \"
            >>> print s
              0
             ---
             / \
                  

  • triple-quoted strings are convenient for including newlines and quotes as such.

            >>> s = """State-run lotteries:
            >>>   a "tax" on mathematical illiterates.
            >>>   Still think millions of people can't be wrong?"""
            >>> print s
                State-run lotteries:
                  a "tax" on mathematical illiterates.
                  Still think millions of people can't be wrong?
                  

  • Strings can be concatenated with +, repeated with *.
  • Portions of a string can be copied out using the 'slice' notation we will explain later that applies to all sequences.
• Unicode strings. These similarly include raw strings, character codes including numeric Unicode codes for a character.

         >>> s1 = u'\u10e7\u0020\ua09f'
         >>> s2 = u'Hello\u0020world.'
         >>> print s2
         Hello world.
         

• Sequences
  • String (see above)
    (Strings are not mutable, but with slicing and appending it's easy to make the new string that you want.)
  • List

    •          a = ['Mike', u'\u10e7\u0020\ua09f', 1, 1234]
                           

    • Lots of convenient high-level list functions, rather like what you'll find in Perl or LISP.
    • Queue and stack features included.
  • Tuple

    •          point1 = 5, 16, 73   # A geometric point specified in x, y, z coordinates.
                           

    • For reasons I am not certain of, tuples are not mutable. My favorite statement on this: " The main difference between tuples and lists is that tuples provide integrity, while it is not possible in lists."
         -- a presentation at http://www.cs.rit.edu/~kxt0498/python.txt
    • I suspect that not having to allow for mutability might permit savings of time and memory resources by Python interpreter.
• Dictionaries ("associative array")
  
  • Keys can be strings, numbers, or tuples holding only strings and/or numbers.
  • Fairly similar to Perl's, C++ STL library's hash tables, etc.
  • "I am too short on time to give the wonderful examples." :-)
    [I had planned that if I had enough time in the actual presentation, I would demonstrate this feature in the Python interpreter. Alas, my prediction that there would not be quite enough time was correct.]
• Object-orientation permits you to define your own.
• Operations generally are defined orthogonally when reasonable.
  Examples:
  • [] (accessing a member or a slice of a data structure)
    
    • on a string.
    • on a list.
    • on a tuple.
    • Works similarly on sequences: strings, lists, tuples.
    • Code examples:

               >>> word = 'Help' + 'A'
               >>> print word[4]
               A
               >>> print word[0:2]
               He
               >>> print word[2:4]
               lp
               >>> print word[:2]
               He
               >>> print word[2:10000]
               lpA
      
               >>> garbage = ['banana peel', 'cardboard', 'paper', 'can', 'bus transfer']
               >>> print garbage[1:3]
               ['cardboard', 'paper']
                           

      [Thanks to the audience member who pointed out that I needed to fix one of the above examples. I entered the example into a Python interpreter displayed on the projection screen, just to prove that he was right. :-) ]
  • Many operators work similarly on all sequences. This nice table from http://www.cs.rit.edu/~kxt0498/python.txt shows some examples of operator orthogonality:

    STRING: LIST: TUPLE: ------------------------------------------------------------------------------- Operation operation operation | interpretation s1 + s2 L1 + L2 t1 + t2 | Concatenation s1 * 3 L1 * 3 t1 * 3 | Repeat s1[i] L1[i] t1[i],t2[i][j] | Index s1[i:j] L1[i:j] t1[i:j] | Slice len(s1) len(L1) len(t1) | Length for x in s1 for x in L1 for x in t1 | Iteration 'm' in s1 3 in L1 for 3 in t1 | Membership

• while statement

                 p = 1
                 print "Let's keep doubling a number until it becomes fifty or more."
                 while p < 50:
                     print p
                     p *= 2
               

• if statement
  • elif (== else if)
  • else
• for statement
  • act on a sequence (a list or a string)

                   a = ['fish', 'alligator', 29]
                   for x in a:
                       print x
                 

    Yields the output:

                   fish
                   alligator
                   29
                 

                   s = 'allligator'
                   ells = 0
                   for c in s:
                       if c == 'l':
                           ells += 1
                   print "There are " + str(ells) + " l's in " + s + "."
    
                 

    Yields the output:

                   There are 2 l's in alligator.
                 

  • range() function provides convenient arithmetic progressions.
    
• break and continue statements
  • as in C.
  • a loop can have an else statement that executes when the loop terminates other than by a break

                   foods = ['alligator', 'gopher', 'apples', 'juicy grubs']
                   for x in foods:
                       print "I eat " + x + "."
                       if x == 'catfish':
                           print "I am allergic to catfish!  I die!"
                           break
                   else:
                       print "HURRAY!\nI ate no catfish, so I survived!"
                   

    Yields the output:

                   I eat alligator.
                   I eat gopher.
                   I eat apples.
                   I eat juicy grubs.
                   HURRAY!
                   I ate no catfish, so I survived!
                   

  • indentation indicates that the else refers to the loop, not to the if. Contrast with:

                   foods = ['alligator', 'gopher', 'apples', 'juicy grubs']
                   for x in foods:
                       print "I eat " + x + "."
                       if x == 'catfish':
                           print "I am allergic to catfish!  I die!"
                           break
                       else:
                           print "HURRAY!\nI ate no catfish, so I survived!"
                   

    Yields the output:

                   I eat alligator.
                   HURRAY!
                   I ate no catfish, so I survived!
                   I eat gopher.
                   HURRAY!
                   I ate no catfish, so I survived!
                   I eat apples.
                   HURRAY!
                   I ate no catfish, so I survived!
                   I eat juicy grubs.
                   HURRAY!
                   I ate no catfish, so I survived!
                   

• pass
  • Does nothing, like NOP in assembly.
• functions
  • Example:

                   def fib(n):    # write Fibonacci series up to n
                       """Print a Fibonacci series up to n."""
                            a, b = 0, 1
                            while b < n:
                                print b,    # Comma puts next output on same line.
                                a, b = b, a+b
                       return b
    
                   fib(2000)
                   

    Yields the output:

                   1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597
                   

  • The optional string at the beginning of the function body is the documentation string, which is used by some automated tools that analyze code to produce documentation.
  • Parameters are call by value (but objects are passed by object reference.)
  • Function has its own symbol table (variable scope) where interpreter first looks for symbol values, checking global symbol table and built-in names only later.
    Modifying a global variable requires naming it in a global statement.
  • A function without return value or without return statement returns the value None.
  • Default argument values, keyword arguments are available options.
  • A function can have an arbitrary argument list.
  • Lambda forms are also available.

                   def make_incrementor(n):
                       return lambda x: x + n
                   f = make_incrementor(100)
                   print f(5)
                   print f(200)
                   

    Yields the output:

                   105
                   300
                   

• Modules
  • A file of Python code (executable statements, function definitions, variables...)
  • The code is executed when the module is imported.

                        import re   # import module
    
                        pat = re.compile(r'^\s+(\w+)')
                      

  • File name is module name.
  • Has its own namespace. (Functions and variables can be imported into importer's namespace.)
  • Modules can import other modules. (I should hope so! :-) )
  • Can be pre-"compiled". (byte-compiled)
  • Python comes with a library of standard modules.
• Packages
  • A package is a collection of modules.
  • Convenient for naming and organization.
• Classes
  • "A mixture of the class mechanisms found in C++ and Modula-3."
  • Permit multiple inheritance.
  • In C++ terms, almost all members are public, all functions are virtual.
  • I haven't yet done object-oriented programming in Python, so I don't want to explain it. :-)

I/O

• Fancy ouput formatting.
• Methods of file objects.
• pickle module - cross-platform, extremely transportable string representations of nearly any Python object.

Error handling

• Outputs an error message and a stack trace.
• Optionally, you can handle errors as exceptions.
  • By placing the code in a try block with a corresponding catch statement that handles it.
  • Exceptions are string objects or classes.
  • Programmers may define their own exception classes.

The python.org website is a great resource. It includes Guido van Rossum's Python Tutorial.

Python Warts, by A.M. Kuchling

"While I think Python has a very elegant design that successfully straddles the fine line between the minimalism of Lisp and the rococo complexities of Perl, it's certainly not perfect. There are various design features that are ugly, or at least suboptimal in some way. This essay will examine the most significan problems in Python, as I perceive them, assisted by suggestions from the comp.lang.python crowd."

A Python/Perl phrasebook, by Jak Kirman