#  This is writing to standard out:

print "Python is awesome!"

#  Basic input (These values will always be interpreted as strings)

name = raw_input("What is your name?")
print name

# Compute the area of a triangle

# Ingredients  (aka: variables)
base   = 4  
height = 7

# Instructions  (aka: an algorithm)
area = 0.5 * base * height
print area

# The area of a circle
# Must input a number or a decimal
radius = input("Enter radius: ")
area = 3.14 * radius * radius
print area

#  Area of a rectangle

width = input("What is the width?")
height = input("What is the hight?")

area_rectangle = width * height

print area_rectangle
            

# Parameter of a rectangle

width = input("What is the width?")
height = input("What is the hight?")

parameter_rectangle = 2 * width + 2 * height

print area_rectangle

print 2 + 5      # Addition

print 10 - 3     # Subtraction

print 5 * 5      # Multiplication

print 2 ** 2     # Power operator

print 5 % 2      # Modulus (aka: remainder)

print 11 / 2     # Division with an integer
print 11 / 2.0   # Division with a float

a = 10  #ASSIGNMENT
b = 20

print a > b   # Greater than
print b >= a  # Greater than or equal to
print a == b  # EQUALITY symbol
print b < a   # Less than
print a <= b  # Less than or equal to

#String
a = "apple"
print type(a)

#Integer (whole number)
b = 1
print type(b)

#Float  (real numbers with decimal places)
c = 2.2
print type(c)

#Boolean
d = True
print type(d)

a = "Hello"  # String
b = " World" # Another string
print a + b  # Concatenation

a = "World"
# Slicing
print a[0]
print a[-1]
print "World"[0:4]

name = "Jonesey"
print "Hello, %s!" % name # Simple string formatting

string = "string"
string[1] = "y"  #Here we attempt to assign the last character in the string to "y"

# String Concatination

first_name = "Bob"
last_name = "Roberts"

print first_name + " is my first name. " + last_name + " is my last name."

# String Formatting

food = "pizzas"
number = 20

print "I'm so hungry I'm going to eat %i %s." % (number, food)

name = "matt"
name.capitalize()        # Capitalizes the first letter of the string

name = "matt"
last = "jones"
" ".join([name, last])   # Creates a new string by concatenating each item in the list

# What other methods do strings have?
# You can use "dir" on any object to find out it's methods
dir(str)

# What if you don't know how to use one of the methods?

help(' matt '.strip)

# Now that you know what it does, try it out!
' matt '.strip()

# Simple Conditionality
if 2 + 2 == 4:
    print "All is right in the world!"
else:
    print "Pigs must be flying!"

# Evaluate Temperature
temperature = input("What is today's temperature?  ")

if temperature > 82:
   print "It's too hot, %i degrees will melt you." % temperature
elif temperature < 45:
   print "Are you crazy? You'll freeze at %i degrees" % temperature
else:
    print "Perfect weather! Let's go for a picnic!"

number = input("What number should I test?")

if number % 2 == 0:
    print "The number is even!"
else:
    print "The number is odd!"

#Both a and b are True

a = True
b = True

if a and b:                  
    print "a and b == True"

#Either a or c is True

b = True
c = False

if b or c:                  
    print "b and c == True"

#If d is not true

d = False

if d is not True:      
    print "d == False"

# None denotes lack of value but it is not equal to false

a = None
b = 0

if a is None:
    print "None"

if b is not None:   
    print "Not None"

print None == False

for number in range(1,10):
    print number

# You are importing the sleep function from the time module
from time import sleep

print "Cooking the bacon."

hot_enough  = 180
temperature = 62

while temperature < hot_enough:
    print "Not hot enough..."
    sleep(1)
    temperature = temperature + 15

print "Bacon is done!"

# This function takes no arguments
# Every function starts with a definition, this is where "def" comes from
def hello():
    # This is a docstring
    '''say hi'''
    print "Hello!"

# Invoke the function
hello()

# Help prints the docstring of the function
help(hello)

from time import sleep

def cook(hot_enough, temperature, food):
    print "Cooking the %s." % food
    while temperature < hot_enough:
        print "Not hot enough..."
        sleep(1)
        temperature = temperature + 15
    print "The %s are done!" % food

cook(100, 50, "coconuts")

# postional and keyword arguments
# positional arguments must go before keyword (default) arguments
def writer(name, color="blue"):
    print name + "'s favorite color is " + color
    
writer("Samantha")
writer("Sarah", "red")
writer("Susan", color="green")

def by_4(number = 4):
    '''Check if a number is evenly divisible by 4'''
    if not number % 4:
        print "Yes"
    else:
        print "No"

by_4(10)
by_4()

 # A new list
 groceries = []

 # Add to list
 groceries.append("Snails")  
 groceries.append("Nutella")
 groceries.append("Cactus")

 # Access by index
 print groceries[2]
 print groceries[0]

 # Find number of things in list
 print len(groceries)

 # Sort the items in the list
 groceries.sort()
 print groceries

 # Remove from list
 groceries.remove("Cactus")

 #The list is mutable
 groceries[0] = 2
 print groceries

# Tuple grocery list

groceries = ('Cactus', 'Nutella', 'Snails')

print groceries

numbers = range(10)
evens = [2, 4, 6, 8]

evens = set(evens)
numbers = set(numbers)

# Use difference to find the odds
odds = numbers - evens

print odds

# Note: Set also allows for use of union (|), and intersection (&)

# A simple dictionary

obvious = {'sky': 'blue'}

# Access by key
print obvious['sky']

# A longer dictionary
obvious = {
    'sky': 'blue',
    'dog': 'woof'
}

# Check if item is in dictionary
print 'two plus two' in obvious

# Add new item
obvious['two plus two'] = 4
print obvious['two plus two']

# Print just the keys
print obvious.keys()

# Print just the values
print obvious.values()

# Print dictionary pairs another way
for key, value in obvious.items():
    print key, value

# Complex Data structures
# Dictionaries inside a dictionary!

employees = {
    "eid0001": {
        "name": "Bob Jones",
        "department": "Marketing",
        "interests": ["fishing", "deep breathing", "gatorade",]
    },
    "eid0002": {
        "name": "Sherry Lorenzo",
        "department": "Human Resources",
        "interests": ["cooking", "steganography", "cycling",],
    }
}

for employee in employees:
    print employees[employee]["name"]

# Reading from a file
with open("example.txt", "r") as f:
    data = f.readlines()
    for line in data:
        words = line.split()
        print words

# Count lines and words in a file
lines = 0
words = 0
the_file = "example.txt"

with open(the_file, 'r') as f:
    for line in f:
        lines += 1
        words += len(line.split())
print "There are %i lines and %i words in the %s file." % (lines, words, the_file)

class Person(object):
    """
    Base class for all people
    """
    
    #An attribute of the class
    population = 0
    
    def __init__(self, name, age):
        self.name = name
        self.age = age
        Person.population += 1
    
    def displayCount(self):
        print "Total people: %d" % Person.population
    
    def displayPerson(self):
        print "My name is %s and I am %i years old." % (self.name, self.age)

## INHERITENCE ##
# Rude inherits from person
class Rude(Person):
    
    def displayPerson(self):
        print "I don't have to tell you anything!"


# Create Person instance
bob = Person("Bob", 35)
bob.displayPerson()
bob.displayCount()

# Create Rude Person Instance
rude = Rude("None of your business", None)
rude.displayPerson()
rude.displayCount()

#!/usr/bin/env python
# clock
# Prints out the time specially formatted

"""
Prints out the time specially formatted
"""

##########################################################################
## Imports
##########################################################################

import sys
from datetime import datetime
from dateutil.tz import tzlocal

##########################################################################
## A Clock Printer Object
##########################################################################

class Clock(object):

    # The "default" formats. Add more formats via subclasses or in the
    # instantation of a Clock object (or just add more here).

    # These formats are more complicated string formatting
    FORMATS = {
        "code":"%a %b %d %H:%M:%S %Y %z",
        "json":"%Y-%m-%dT%H:%M:%S.%fZ",
        "cute":"%b %d, %Y",
    }

    # class method - bound to the class
    # Get the current time
    # tzlocal will get the local timezone
    @classmethod
    def local_now(klass):
        return datetime.now(tzlocal())

    def __init__(self, formats={}):
        self.formats = self.FORMATS.copy()
        self.formats.update(formats)

    # strftime takes a format and returns a string representing the date
    def _local_format(self, fmt):
        return Clock.local_now().strftime(fmt)

    def get_stamp(self, name):
        # strips "-" from beginning and end of string
        # the string is "-code", "-json" or "-cute"
        name  = name.strip("-")

        if name in self.formats:
            return self._local_format(self.formats[name])

        return None

    def print_stamp(self, name):
            stamp = self.get_stamp(name)
            if stamp:
                print stamp
            else:
                print "No stamp format for name %s" % name

##########################################################################
## Main Method, handle inputs to program from command line
##########################################################################

# print __name__ in the python shell to see how this works
if __name__ == "__main__":

    args  = sys.argv[1:]
    clock = Clock()
    for arg in args:
        clock.print_stamp(arg)