Merge pull request #2 from lodin/master

Add Python

1 files changed, 298 insertions, 0 deletions

diff --git a/python.html.markdown b/python.html.markdown
new file mode 100644
index 00000000..8a9ea48f
--- /dev/null
+++ b/python.html.markdown
@@ -0,0 +1,298 @@
+---
+language: Python
+author: Louie Dinh
+author_url: http://ldinh.ca
+---
+
+Python was created by Guido Van Rossum in the early 90's. It is now one of the most popular languages in existence. I fell in love with Python for it's syntactic clarity. It's basically executable pseudocode.
+
+```Python
+# Single line comments start with a hash.
+""" Multiline comments can we written
+    using three "'s
+"""
+
+----------------------------------------------------
+-- 1. Primitive Datatypes and Operators
+----------------------------------------------------
+
+# You have numbers
+3 #=> 3
+
+# Math is what you would expect
+1 + 1 #=> 2
+8 - 1 #=> 9
+10 * 2 #=> 20
+35 / 5 #=> 7
+
+# Division is a bit tricky. It is integer division and floors the results automatically.
+11 / 4 #=> 2
+
+# Enforce precedence with parentheses
+(1 + 3) * 2 #=> 8
+
+# Boolean values are primitives
+True
+False
+
+# negate with not
+not True #=> False
+not False #=> True
+
+
+# Equality is ==
+1 == 1 #=> True
+2 == 1 #=> False
+
+# Strings are created with " or '
+"This is a string."
+'This is also a string.'
+
+# Strings can be added too!
+"Hello " + "world!" #=> "Hello world!"
+
+# A string can be treated like a list of characters
+"This is a string"[0] #=> 'T'
+
+# None is an object
+None #=> None
+
+
+----------------------------------------------------
+-- 2. Variables and Collections
+----------------------------------------------------
+
+# Printing is pretty easy
+print "I'm Python. Nice to meet you!"
+
+
+# No need to declare variables before assigning to them.
+some_var = 5    # Convention is to use lower_case_with_underscores for variables
+some_var #=> 5
+
+# Accessing a previously unassigned variable is an exception
+some_other_var  # Will raise a NameError
+
+
+# Lists store sequences
+li = []
+# You can start with a prefilled list
+other_li = [4, 5, 6]
+
+# Add stuff to the end of a list with append
+li.append(1)    #li is now [1]
+li.append(2)    #li is now [1, 2]
+li.append(4)    #li is now [1, 2, 4]
+li.append(3)    #li is now [1, 2, 4, 3]
+
+# Access a list like you would any array
+li[0] #=> 1
+# Looking out of bounds is an IndexError
+li[4] # Raises an IndexError
+
+# Remove elements from a list with del
+del li[2] # li is now [1, 2, 3]
+
+# You can add lists
+li + other_li #=> [1, 2, 3, 4, 5, 6] - Note: li and other_li is left alone
+
+# Concatenate lists with extend
+li.extend(other_li) # Now li is [1 ,2 ,3 ,4 ,5 ,6] 
+
+# Check for existence in a list with in
+1 in li #=> True
+
+# Examine the length with len
+len(li) #=> 6
+
+# Tuples are like lists but are immutable
+tup = (1, 2, 3)
+tup[0] #=> 1
+tup[0] = 3  # Raises a TypeError
+
+
+# Dictionaries store mappings
+empty_dict = {}
+# Here is a prefilled dictionary
+filled_dict = {"one": 1, "two": 2, "three": 3}
+
+# Look up values with []
+filled_dict["one"] #=> 1
+
+# Get all keys as a list
+filled_dict.keys() #=> ["three", "two", "one"] Note - Dictionary key ordering is not guaranteed. Your results might not match this exactly.
+
+# Get all values as a list
+filled_dict.values() #=> [3, 2, 1] Note - Same as above regarding key ordering.
+
+# Check for existence of keys in a dictionary with in
+"one" in filled_dict #=> True
+1 in filled_dict #=> False
+
+
+# Sets store ... well sets
+empty_set = set()
+# Initialize a set with a bunch of values
+filled_set = set([1,2,2,3,4]) # filled_set is now set([1, 2, 3, 4])
+
+# Add more items to a set
+filled_set.add(5) # filled_set is now set([1, 2, 3, 4, 5])
+
+# Do set intersection with &
+other_set = set([3, 4, 5 ,6])
+filled_set & other_set #=> set([3, 4, 5])
+
+# Do set union with |
+filled_set | other_set #=> set([1, 2, 3, 4, 5, 6])
+
+# Check for existence in a set with in
+2 in filled_set #=> True
+10 in filled_set #=> False
+
+
+----------------------------------------------------
+-- 3. Control Flow
+----------------------------------------------------
+
+# Let's just make a variable
+some_var = 5
+
+# Here is an if statement. INDENTATION IS SIGNIFICANT IN PYTHON!
+# prints "some var is smaller than 10"
+if some_var > 10:
+    print "some_var is totally bigger than 10."
+elif some_var < 10:    # This elif clause is optional.
+    print "some_var is smaller than 10."
+else:           # This is optional too.
+    print "some_var is indeed 10."
+
+
+"""
+For loops iterate over lists
+prints:
+    dog is a mammal
+    cat is a mammal
+    mouse is a mammal
+"""
+for animal in ["dog", "cat", "mouse"]:
+    print "%s is a mammal" % animal     # You can use % to interpolate formatted strings
+
+"""
+While loops go until a condition is no longer met.
+prints:
+    0
+    1
+    2 
+    3
+"""
+x = 0
+while x < 4:
+    print x
+    x += 1  # Short hand for x = x + 1
+
+# Handle exceptions with a try/except block
+try:
+    raise IndexError("This is an index error")  # Use raise to raise an error
+except IndexError as e:
+    pass    # Pass is just a no-op. Usually you would do recovery here.
+
+
+----------------------------------------------------
+-- 4. Functions
+----------------------------------------------------
+
+# Use def to create new functions
+def add(x, y):
+    print "x is %s and y is %s" % (x, y)
+    return x + y    # Return values with a return statement
+
+# Calling functions with parameters
+add(5, 6) #=> 11 and prints out "x is 5 and y is 6"
+# Another way to call functions is with keyword arguments
+add(y=6, x=5)   # Equivalent to above. Keyword arguments can arrive in any order.
+
+# You can define functions that take a variable number of positional arguments
+def varargs(*args):
+    return args
+
+varargs(1, 2, 3) #=> (1,2,3)
+
+
+# You can define functions that take a variable number of keyword arguments
+def keyword_args(**kwargs):
+    return kwargs
+
+# Let's call it to see what happens
+keyword_args(big="foot", loch="ness") #=> {"big": "foot", "loch": "ness"}
+
+
+# Python has first class functions
+def create_adder(x):
+    def adder(y):
+        return x + y
+    return adder
+
+# Let's create a new function that always adds 10 to the argument
+add_10 = create_adder(10):
+add_10(3) #=> 13
+
+# There are also anonymous functions
+(lambda x: x > 2)(3) #=> True
+
+# There are built-in higher order functions
+map(add_10, [1,2,3]) #=> [11, 12, 13]
+filter(lambda x: x > 5, [3, 4, 5, 6, 7]) #=> [6, 7]
+
+# We can use list comprehensions for nice maps and filters
+[add_10(i) for i in [1, 2, 3]]  #=> [11, 12, 13]
+[x for x in [3, 4, 5, 6, 7] if x > 5] #=> [6, 7]
+
+----------------------------------------------------
+-- 5. Classes
+----------------------------------------------------
+
+# We can define classes with the class statement
+class Human():    # By convention CamelCase is used for classes. 
+    pass
+
+# We subclass from object to get a "new-style class". All your code should do this.
+class Human(object):
+
+     # A class attribute. It is shared by all instances of this class
+    species = "H. sapiens"
+
+    # Basic initializer
+    def __init__(self, name):
+        self.name = name        # We are assigning the argument to the instance's name attribute
+
+    # A method. All methods take self as the first argument, including the initializer
+    def say(self, msg):
+       return "%s: %s" % (self.name, msg)
+
+    # A class method is shared among all instances
+    @classmethod
+    def get_species(cls):
+        return cls.species
+
+    # Static methods are called without a parameter reference to the class or instance
+    @staticmethod
+    def grunt():
+        return "*grunt*"
+
+
+# Instantiate a class
+h = Human(name="Harry")
+print h.say("hi")     # prints out "Harry: hi"
+i = Human("Ian")
+print i.say("hello")  #prints out "Ian: hello"
+
+# Call our class method
+h.get_species() #=> "H. sapiens"
+
+# Change the shared attribute
+h.species = "H. neanderthalensis"
+h.get_species() #=> "H. neanderthalensis"
+i.get_species() #=> "H. neanderthalensis"
+
+# Call the static method
+Human.grunt() #=> "*grunt*"