= Intro =
== Some Resources ==
 * dive into python - http://diveintopython.org/
 * language reference - http://docs.python.org/reference/
 * library reference - http://www.python.org/doc/2.6/library/index.html

== rickspencer3's chapters ==
 * rickspencer3.com
 * some errors
 * single space indent instead of four spaces
 * not define difference between "==" and is

== What is Python? ==
 * A language
 * A standard library
 * both parts work hand in hand, hard to separate totally
 * interpreted at run time, at least once (no compile errors! watch out)

== Python Interpreter ==
 * just type "python" in terminal, and start
 * very handy for small jobs and tests
 * ipython - install it, love it, tab it
 * >>> means sample is in interpreter

= Language Concepts =
== Indentation levels ==
 * controls scoping instead of {}, "end", etc...
 * standard is to use 4 spaces for each indentation level
 * you will get used to it, and probably format you code this way anyway
 * at first, many errors will be caused by this

{{{
#!python
for i in xrange(5,20):
    print i
}}}

2. Strong Dynamic Typing
 * Object and sibclasses, int, float, etc...
 * A variable can change type
 * don't declare variables with types
 * can convert a *variable* to another type, not casting and assigning

=== Dynamic Typing ===
{{{
>>> x = 1 
>>> x 
1 
>>> type(x) 
<type 'int'> 
>>> x = "string" 
>>> x 
'string' 
>>> type(x) 
<type 'str'> 
}}}

=== Strong Typing ===
{{{
>>> x = 1 
>>> print x + " is a string" 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
TypeError: unsupported operand type(s) for +: 'int' and 'str' 
}}}

== Types ==
=== Numeric types ===
 * Integer, Long Integer, Float, Complex
 * Normal operands and conversion functions float(), int(), etc...
 * Can mix and match them in math, will convert to use least "restrictive" type

{{{
>>> x = 5 
>>> y = 5L 
>>> x * y 
25L 
>>> x = 5 
>>> y = 5.0 
>>> x * y 
25.0 
>>> x = 5L 
>>> y = 5.0 
>>> x * y 
25.0 
>>> x = 25 
>>> y = 5.01 
>>> x / y 
4.9900199600798407
}}}

=== Strings ===
 * lots of functions
 * not difference between characters and strings
 * concatenation with +, +=, etc...
 * ",' are the same
 * """ can included \n, ",', etc...

=== None is an object of NoneType ===
 * like Null, null, etc...
 * None is an object of type NoneType
 * undefined variables are not None, just undefined errors

== Lists and Tuples ==
 * Like an array
 * Not typed, can contain anything
 * Tuples are immutable lists
 * modify with "append", +/-, etc...

=== create a tuple ===
{{{
>>> wintermonths = ("December","January","February") 
>>> wintermonths 
('December', 'January', 'February') 
}}}

=== create a list ===
{{{
>>> grades = ["A","A-","B","C"] 
>>> grades 
['A', 'A-', 'B', 'C'] 
}}}

=== Accessing ===
Indexed with [] as you are used to
{{{
>>> wintermonths 
('December', 'January', 'February') 
>>> wintermonths[0] 
'December' 
}}}
A handy trick for starting from the back
{{{
>>> grades 
['A', 'A-', 'B', 'C'] 
>>> grades[-1] 
'C' 
>>> grades[-2] 
'B' 
}}}

=== in ===
Test if a list or tuple contains a value
{{{
>>> grades = ["A","A-","B","C"] 
>>> grades 
['A', 'A-', 'B', 'C'] 
>>> "A" in grades 
True 
>>> "F" in grades 
False 
}}}

=== Dictionaries ===
 * Like hash tables
 * "foo in bar" syntax like tuples and lists
 * how to append, remove, etc...
 * are NOT ordered!
{{{
>>> grades 
['A', 'A-', 'B', 'C'] 
>>> i = grades.index("A") 
>>> i 
0 
>>> i = grades.index("B") 
>>> i 
2 
}}}
Test with "in" first, or you are liable to get an error
{{{
>>> grades 
['A', 'A-', 'B', 'C'] 
>>> i = grades.index("F") 
Traceback (most recent call last): 
  File "<stdin>", line 1, in <module> 
ValueError: list.index(x): x not in list 
}}}

== Comparisons and branching ==
 * True and False
 * if, ==, !=, <=, >=, etc....
 * is, is not
 * or, and
 * else, elif

{{{
a = "xxx"

if a is "boo":
    print "a is boo"
elif a is not "foo":
    print "a is not foo"
else:
    print "a is foo"

a = 1

if a == 1:
    print "a is 1"
}}}

== Loops ==
 - for foo in bar:
 - while loops
 - for i in xrange(10)

{{{
>>> for g in grades: 
...  print g 
... 
A 
A- 
B 
C 
}}}
{{{
>>> x = 0 
>>> while x < 10: 
...  x += 1 
...  print x 
... 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
}}}
{{{
>>> grades = [] 
>>> for i in xrange(10): 
...  digits.append(i) 
... 
>>> digits 
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 
}}}

== Error Handling ==
 * try, except
 * Exception type: except Exception
 * Exception instance: except Exception instance:
 * lots of built in exceptions
 * derive your own, just end it in "Error"

{{{
>>> grades = ['A', 'A-', 'B', 'C'] 
>>> 
>>> grades = ['A', 'A-', 'B', 'C'] 
>>> try: 
...  grades.index("F") 
... except ValueError: 
...  print "no Fs" 
... 
no Fs 
}}}


== comments and doc comments ==
 * #comment is just for folks reading code
 * using """ in strategic places == doc comments, pydoc

= Modules, Files, Classes =
== file overview ==
 * shbang, tell bash what interpreter to use
 * imports section
  * like #include
  * import os
  * from foo import bar 
 * code section
 * {{{if __name__ == "__main__"}}}
  * runs if module is called directly not from another module
  * start your program, also useful for writing test apps

{{{
#!/usr/bin/env python
import pygtk
pygtk.require('2.0')
import gtk

class program2:
    def __init__(self, startval):
       self.x = startval

    def run(self):
        for i in range(1,10):
            self.x += 1
            self.output()

    def output(self):
        if self.x > 9:
            print "x is greater than 9"
        else:
            print "x is not greater than 9"

if __name__ == "__main__":
    p = program2(0)
    p.run()
    p = program2(1)

    p.run()
}}}

== Code section ==
=== class overview ===
  * class decleration, define superclass, call {{{super.__init__(self)}}}
  * {{{__init__}}}, more or less the constuctor, not required
{{{
#!python
class program3(program2):
    def __init__(self):
        program2.__init__(self, 5)
}}}

 * member functions, what's this "self" thing?
  * the object that the function is acting on
  * required for all member function
  * added automatically when calling on self or instantiated class
  * must add when calling in a super class (see above)

 * member variables
  * instance variables are defined with a function using self.foo
  * class variables declared outside a functions, once instance of the variable for all instances of the class (weird?)
{{{
#!/usr/bin/env python

z = 1
class program:
    x = 2 #class variable
    def __init__(self):
        print self.x #not necessarily 2, could have been modified by another instance
        print z
        self.y = 3 #instance variable

if __name__ == "__main__":
    p = program()
    print p.y
}}}

 * can define multiple classes in a file
 * can define functions variables outside classes

== OO syntax ==
 * instantiating object
 * no private variables, really?
  * convention: start with _ for members that should be private and inheritable
  * start with {{{__}}} for members that should be private and not heritable (munging)