Tim Isganitis's List: Learning Python

• When a python file is run directly, the special variable "__name__" is set to "__main__". Therefore, it's common to have the boilerplate if __name__ ==... shown above to call a main() function when the module is run directly, but not when the module is imported by some other module.
• In a standard python program, the list sys.argv contains the command line arguments in the standard way with sys.argv[0] being the program itself, sys.argv[1] the first argument, and so on.

• One unusual Python feature is that the whitespace indentation of a piece of code affects its meaning. A logical block of statements such as the ones that make up a function should all have the same indentation, set in from the indentation of their parent function or "if" or whatever. If one of the lines in a group has a different indentation, it is flagged as a syntax error.

    

  Python's use of whitespace feels a little strange at first, but it's logical and I found I got used to it very quickly. Avoid inserting tabs into a python file, as they greatly complicate the indentation scheme. Set your editor to insert spaces instead of tabs for python code.
• Python does very little checking at compile time, deferring almost all type, name, etc. checks on each line until that line runs.
• One file of Python code is called a *module*. The file "binky.py" is also known as the module "binky". A module essentially contains variable definitions like, "x = 6" and "def foo()". Suppose the file "binky.py" contains a "def foo()". The fully qualified name of that foo function is "binky.foo". In this way, various python modules can name their functions and variables whatever they want, and the variable names won't conflict -- module1.foo is different from module2.foo.
• There is another import form that looks like this: "from hashing import sha1, md5". That makes sha1() and md5() available by their short names.

• Python is packaged with many standard modules which are bundled with a standard installation of the python interpreter, so you don't have do anything extra to use them. Commonly used standard python modules include:

    
   
  • sys -- access to exit(), argv, stdin, stdout, ...  
  • re -- regular expressions  
  • os -- operating system interface, file system

5 more annotations...

• Python has a built-in string class named "str" with many handy features (there is an older module named "string" which you should not use).
• A string literal can span multiple lines, but there must be a backslash \ at the end of each line to escape the newline. String literals inside triple quotes, """" or ''', can multiple lines of text.
• Characters in a string can be accessed using the standard [ ] syntax, and like Java and C++, Python uses zero-based indexing, so if str is 'hello' str[1] is 'e'.
• If the index is out of bounds for the string, Python raises an error.
• The len(string) function returns the length of a string.
• The '+' operator can concatenate two strings.
• Unlike Java, the '+' does not automatically convert numbers or other types to string form. The str() function converts values to a string form so they can be combined with other strings.
• For numbers, the standard operators, +, /, * work in the usual way. There is no ++ operator, but +=, -=, etc. work.
• The "print" operator prints out one or more python items followed by a newline (leave a trailing comma at the end of the items to inhibit the newline).
• • s.lower(), s.upper() -- returns the lowercase or uppercase version of the string
    
  • s.strip() -- returns a string with whitespace removed from the start and end
    
  • s.isalpha()/s.isdigit()/s.isspace()... -- tests if all the string chars are in the various character classes
     
  • s.startswith('other'), s.endswith('other') -- tests if the string starts or ends with the given other string
    
  • s.find('other') -- searches for the given other string (not a regular expression) within s, and returns the first index where it begins or -1 if not found
    
  • s.replace('old', 'new') -- returns a string where all occurrences of 'old' have been replaced by 'new'
    
  • s.split('delim') -- returns a list of substrings separated by the given delimiter. The delimiter is not a regular expression, it's just text. 'aaa,bbb,ccc'.split(',') -> ['aaa', 'bbb', 'ccc']. As a convenient special case s.split() (with no arguments) splits on all whitespace chars.
    
  • s.join(list) -- opposite of split(), joins the elements in the given list together using the string as the delimiter. e.g. '---'.join(['aaa', 'bbb', 'ccc']) -> aaa---bbb---ccc
• Python does not have a separate character type. Instead an expression like s[8] returns a string-length-1 containing the character. With that string-length-1, the operators ==, <=, ... all work as you would expect, so mostly you don't need to know that Python does not have a separate scalar "char" type.
• The "slice" syntax is a handy way to refer to sub-parts of sequences -- typically strings and lists. The slice s[start:end] is the elements beginning at start and extending up to but not including end.
• • s[1:4] is 'ell' -- chars starting at index 1 and extending up to but not including index 4  
  • s[1:] is 'ello' -- omitting either index defaults to the start or end of the string  
  • s[:] is 'Hello' -- omitting both always gives us a copy of the whole thing (this is the pythonic way to copy a sequence like a string or list)  
  • s[1:100] is 'ello' -- an index that is too big is truncated down to the string length

• Python uses negative numbers to give easy access to the chars at the end of the string: s[-1] is the last char 'o', s[-2] is 'l' the next-to-last char, and so on. Negative index numbers count back from the end of the string:

    
   
  • s[-1] is 'o' -- last char (1st from the end)

• Python has a printf()-like facility to put together a string. The % operator takes a printf-type format string on the left (%d int, %s string, %f/%g floating point), and the matching values in a tuple on the right (a tuple is made of values separated by commas, typically grouped inside parenthesis):

    

    # % operator
    text = "%d little pigs come out or I'll %s and %s and %s" % (3, 'huff', 'puff', 'blow down')

    

  The above line is kind of long -- suppose you want to break it into separate lines. You cannot just split the line after the '%' as you might in other languages, since by default Python treats each line as a separate statement (on the plus side, this is why we don't need to type semi-colons on each line). To fix this, enclose the whole expression in an outer set of parenthesis -- then the expression is allowed to span multiple lines. This code-across-lines technique works with the various grouping constructs detailed below: ( ), [ ], { }.

    

    # add parens to make the long-line work:
    text = ("%d little pigs come out or I'll %s and %s and %s" %
      (3, 'huff', 'puff', 'blow down'))
• Regular Python strings are *not* unicode, they are just plain bytes. To create a unicode string, use the 'u' prefix on the string literal
• Python does not use { } to enclose blocks of code for if/loops/function etc.. Instead, Python uses the colon (:) and indentation/whitespace to group statements. The boolean test for an if does not need to be in parenthesis (big difference from C++/Java), and it can have *elif* and *else* clauses (mnemonic: the word "elif" is the same length as the word "else").
• The boolean operators are the spelled out words *and*, *or*, *not* (Python does not use the C-style && || !).
• Unlike Java and C, == is overloaded to work correctly with strings.

17 more annotations...

• Python has a great built-in list type named "list". List literals are written within square brackets [ ]. Lists work similarly to strings -- use the len() function and square brackets [ ] to access data, with the first element at index 0.
• The *for* construct -- for var in list -- is an easy way to look at each element in a list (or other collection). Do not add or remove from the list during iteration.
• The *in* construct on its own is an easy way to test if an element appears in a list (or other collection) -- value in collection -- tests if the value is in the collection, returning True/False.

• The range(n) function yields the numbers 0, 1, ... n-1, and range(a, b) returns a, a+1, ... b-1 -- up to but not including the last number. The combination of the for-loop and the range() function allow you to build a traditional numeric for loop:

    

    ## print the numbers from 0 through 99
    for i in range(100):
      print i
• Python also has the standard while-loop, and the *break* and *continue* statements work as in C++ and Java, altering the course of the innermost loop.

3 more annotations...

• Python's efficient key/value hash table structure is called a "dict". The contents of a dict can be written as a series of key:value pairs within braces { }, e.g. dict = {key1:value1, key2:value2, ... }. The "empty dict" is just an empty pair of curly braces {}.
• Looking up or setting a value in a dict uses square brackets, e.g. dict['foo'] looks up the value under the key 'foo'. Strings, numbers, and tuples work as keys, and any type can be a value.

• The % operator works conveniently to substitute values from a dict into a string by name:

    

    hash = {}
    hash['word'] = 'garfield'
    hash['count'] = 42
    s = 'I want %(count)d copies of %(word)s' % hash  # %d for int, %s for string
    # 'I want 42 copies of garfield'
• The "del" operator does deletions. In the simplest case, it can remove the definition of a variable, as if that variable had not been defined. Del can also be used on list elements or slices to delete that part of the list and to delete entries from a dictionary.
• The open() function opens and returns a file handle that can be used to read or write a file in the usual way. The code f = open('name', 'r') opens the file into the variable f, ready for reading operations, and use f.close() when finished. Instead of 'r', use 'w' for writing, and 'a' for append.
• The f.readlines() method reads the whole file into memory and returns its contents as a list of its lines. The f.read() method reads the whole file into a single string
• or writing, f.write(string) method is the easiest way to write data to an open output file. Or you can use "print" with an open file, but the syntax is nasty: "print >> f, string". In python 3000, the print syntax will be fixed to be a regular function call with a file= optional argument: "print(string, file=f)".

5 more annotations...