--- 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*"