diff options
| -rw-r--r-- | python.html.markdown | 298 |
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*" |