learnxinyminutes-docs/python.html.markdown

---
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] #=> 'H'

# 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()

# Get all values as a list
filled_dict.values()

# 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!
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
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.
x = 0
while x < 10:
    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" % (this.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(self):
        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*"