# this is a comment. anything that follows a '#' symbol in Python is ignored by the interpeter

# here are two ways we can represent numbers

#integers a.k.a int
x = 4  #here we store the integer value of 4 in the variable x
y = 2

#floating point numbers 
a = 0.5
b = 0.1

# strings are sequences of characters. they are always contained in single or double quotes
s = "Hello, world."

#booleans are data types that can take on only the values 'True' or 'False':

n = False
m  = True

#finally, we have the 'None' type which is basically nothing, it's like an empty variable

t = None

## so now what we've done is store some values in some variables. how can we see what those values are? print!

print(x)
print(y)
print(a, b)
print(s)
print(n)
print(m)
print(t)

#another useful thing is type-casting where we can convert some types into other types.

x = 5.0
y = "5.0"

#converts a floating point number to an integer
print(int(x))

#converts the string "5.0" into a numeric value
print(float(x))

# we can do some basic operations on these data types

print(4 + 4)  #add or subtract two integers
print(4/5)    # divide

# we can assign the value of a variable back to itself.

x = x + 1
print(x)

#we can 'concatenate' two strings

print(s + " How are you?")

# This is a list:
l = [1, 2, 3, 4]
# we can access each element in a list with its index (starting from 0)
print(l)
print(l[0]) #prints the first element in the list
print(l[1]) #prints the second element in the list
print(l[-1]) #what does this print?

#list slicing. very useful way in python to access sub-lists in python

#say we want to make a list that only has the elements between positions 2 and 4 in list l

sliced = l[2:4]

print(sliced)

#now say we want a list that contains everything but the first number in l

everything_but_first = l[1:]

print(everything_but_first)

#now make a list that has everything except the last element in the list (remember the -1 index)

everything_but_last = l[:-1]
print(everything_but_last)

#we can modify the values in the list
l[1] = 3000
print(l[1])

#we can add values to the end of the list with the append() function
print("adding a value")
l.append("hi!")
print(l)

#declare a tuple. use round brackets instead of square brackets
person = ('Martin', 50, 1.65) 
print(person)

#you can still access its elements just like in a list
print(person[1])

# dictionaries are initialized with curly braces
d = {} # is an empty dictionary

#let's add some keys to the dictionary and give it a value.
d['heights'] = []
d['weights'] = []

print(d)

#now we can add 'heights' to the list 
d['heights'].append(165.4)
d['weights'].append(221.2)

print(d)

#if we want to get the 'keys' of the dictionary we use the keys() function

print(d.keys())

mix = ['hi', 1, 2, ('a', 2, 'e')]
print(mix)

d2 = {1: [1, 2, 3], 'bob': 4}
print(d2)

# for loops store the each item in the list in the variable following the 'for' one at a time.

#let's iterate through that 'mix' list that we made in the previous cell and print each item in the list
for i in mix:
    print(i)

# we can also iterate through a range of numbers by using the range(n) command which returns a list containing the
# integers within the specified range

for i in range(10):
    print(i)

#write a for loop that adds the numbers from 1 to n. declare any variables you may need

n = 4
total = 0

#the loop will repeat whatever is under it and indented to the right
for i in range(n):
    total = total + i
    
print(total)   

#first, a bit more about booleans. we can compare two booleans using the '==' operator to obtain a 'True' if they are
# equal and 'False' if they are not equal.

print(True == True)
print(True == False)

# We can perform some operations on boolean variables to better express conditions

#the 'and' operation gives a True boolean if both elements are true
a,b = True, True
print(a and b)

a,b = True, False
print(a and b)


# the 'or' operator gives True if either one (or both) of the elements is true
print(a or b)

# the 'not' operator simply gives you the opposite of the given element
print(not a)

feel_like_it = True
raining = False
date_tonight = True


#write a boolean to decide if you should go to the gym based on the three booleans above.
go_to_gym = (feel_like_it and not raining) or date_tonight

print(go_to_gym)

#play around with different values of the variables!

#write a for loop that prints every even number up until n. (hint. use the modulo operator which returns the 
# remainder of dividing two numbers. e.g. 5 % 2 = 3, 10%2 = 0)

n = 25
for i in range(n):
    if i % 2 == 0:
        print(i)
    else:
        continue #the 'continue' statement lets you skip to the next iteration in the loop

if feel_like_it and raining: #whatever follows the if has to be a boolean statement
    print("i feel like it, but it's raining")
#if the previous clause is not met, the 'elif' or 'else if' block is checked
elif date_tonight:
    print("i have a date tonight"
#if neither the if or the elif match then we go into the 'else'
else:
    print("i should just stay home")

for i in range(100):
    if i % 15 == 0:
        print("fizzbuzz")
    elif i % 3 == 0:
        print("fizz")
    elif i % 5 == 0:
        print("buzz")
    else:
        print(i)

# this will grow a list where each element in the list is whatever the statement preceding the 'for' evaluates to
numbers_times_two = [n*2 for n in range(10)] 
print(numbers_time_two)

# we can also add if statements in the list comprehension
odd_numbers = [i for i in range(10) if i % 2 != 0]
print(odd_numbers)

#now try one yourself. make a list comprehension where each item is a tuple (number, number*number) 
square_tuples = [(i, i*i) for i in range(10)]

#the first line of every function is a header. headers have 3 parts. the 'def' keyword which tells python you are
#about to declare a function, then the name of the function, and finally the inputs to the function

def day_finder(day_to_find):
    days_of_week = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Satuday', 'Sunday']
    for day in days_of_week:
        if day == day_to_find:
            #the return statement ends every function and it 'sends' the output of your function to whoever called it
            return "Thank God it's %s." % (day) # the %s in the string is like a placeholder that gets filled with
                                                # the value of the string variable 'day'
        else:
            continue
    

#you can call any function just by typing its name and the arguments you want it to work on in braces ()
print(day_finder('Tuesday')) #"thank god it's tuesday" is the return value of the function day_finder()

# every object is defined in a 'class' and classes are declared with the 'class' keyword
class Recipe:
    def __init__(self, n, ig, ml, pt):
        self.name = n
        self.ingredients = ig #set the ingredients attribute of the object to the value of ig
        self.meal = ml
        self.prep_time = pt
    

#now that we've defined what a Recipe should look like, we can nicely store some new recipes. 

#let's make some recipes

sandwich = Recipe('sandwich', ['ham', 'bread', 'cheese'], 'lunch', 10)
cake = Recipe('cake', ['flour', 'sugar', 'eggs'], 'dessert', 90)

#add two more recipes of your own!


# now we can very conveniently access some information about our recipes by name. This can be done with the '.' 
# operator that we saw above

#print the ingredients in the sandwich, and the preparation time of the cake

print(sandwich.ingredients)

print(cake.prep_time)

class Cookbook:
    def __init__(self, r):
        self.recipes = r
        
    #functions declared inside a class are called 'Class functions' and they act on an object
    def get_vegetarian(self):
        """This function is going to return recipes in the cookbook that do not contain meat."""
        meats = ['ham', 'beef', 'chicken', 'fish']
        veg_dishes = []
        for recipe in self.recipes: #the 'self' keyword is used to access the object the function is being called on
            if meats not in recipe.ingredients: #hint: use the 'in' operator which returns true if a value is in the 
                                                #given list. e.g.: 5 in [1, 3, 5] returns True.
                veg_dishes.append(recipe)
        return veg_dishes
    
    #write a class function that returns a list of recipes that take under 'n' minutes to prepare
    def preptime(self, n):
        recipes = []
        for recipe in self.recipes:
            if recipe.prep_time < n:
                recipes.append(recipe)
        return recipes
                

# let's make a cookbook

#gather some recipes
recipes = []

recipes.append(Recipe('steak', ['beef', 'butter', 'mashed potatoes'], 'main', 120))
recipes.append(Recipe('toast', ['nutella', 'bread'], 'snack', 5))
recipes.append(Recipe('salad', ['lettuce', 'kale', 'tomatoes'], 'main', 15))
recipes.append(Recipe('chicken parm', ['chicken', 'sauce', 'cheese'], 'main', 90))
recipes.append(Recipe('brownie', ['chocolate', 'flour', 'eggs'], 'dessert', 15))

#put them in a cookbook

cookbook = Cookbook(recipes)

#get vegetarian recipes

print(cookbook.get_vegetarian())

#get recipes that take less than 20 minutes to prepare

print(cookbook.preptime(20))

#oops what is that? because our functions are returning lists of objects we are seeing how the objects are represented
# when we print them. What you see are addresses in memory where the objects are stored. Let's print it in a way
# we can understand


#print the name and ingredients of recipes that take under 20 minutes to prepare
short_recipes = cookbook.preptime(20)

for s in short_recipes:
    print(s.name)

#help prints what the given function does
help(abs)

#a set is a group of unique items from a list
pop_stars = ["beyonce", "rihanna", "lady gaga", "lady gaga"]

hip_hop_stars = ["rihanna", "nicki minaj", "lil kim"]

pop = set(pop_stars)

hip_hop = set(hip_hop_stars)

print(pop, hip_hop)

#you can perform some set operations. look up the Python set documentation an print the intersection between both sets.

overlap = pop.intersection(hip_hop)

print(overlap)

#sort a list

s = sorted([1, 5, 3, 2])
print(s)

#max and min of a list
print(max(s))
print(min(s))

#print the sum of a list's elements

print(sum(s))

#get length of list

print(len(s))

#write a for loop that iterates through each *index* in s and prints the index

for i in range(len(s)):
    print(i)

#the enumerate() function gives you the item and the index of a list at the same time

for i, number in enumerate(hip_hop_stars):
    print(i, number)

#let's import some libraries so we can use their functions
import math 
import random
#python numerical tools
import numpy as np

#generate a random floating point number between 0 and 1
ran = random.random()
print(ran)

#print a random integer in the given range
random_integer = random.randint(2, 100)
print(random_integer)

#sample randomly from a list
print(np.random.choice(["watermelon", "mango", "pineapple"]))

#compute e^(n)
print(math.exp(10))

#compute x^n
print(math.pow(2,3))

# you can remove characters from the end of a string with the strip() function

disney = "I'm Walt Disney."

print(disney.strip(".")) #removes the character from the given string

#the join function inserts characters between elements in a list and joins them into a string

print("-".join(disney))

#the opposite of join is the split() function which breaks a string up into a list of sub-strings

print(disney.split()) #you can also tell split() which characters to break on

#to open a file you just use the open() function along with the 'with' context manager (more on this below)

#the 'with' block takes care of opening and closing the file, and giving us the lines of the file to iterate over
with open("food.csv", "r") as food: # the "r" argument tells open() that we want to read the file
    for item in food:
        print(item.strip("\n")) #let's get rid of the linebreak character

#we can also write to a file
with open("helloworld.txt", "w+") as hello:
    hello.write("Hello, world!")
    
#check to see if the file was created

import multiprocessing
import time #this module allows us to do some operations involving time.

MAX_PROC = 4

def square(x):
    time.sleep(3) #let's make it a bit slower by making python sleep for 10 seconds before returning the output
    return x*x

to_do = [1, 2, 3, 4, 5, 6, 7, 8]

#let's write a loop that squares each element in that list in series

#record the time at which we start the computation
t_start_serial = time.time() 

squared_serial = []
for i in to_do:
    squared.append(square(i))

#get the difference in time between now and the start time to get total time.
t_end_serial = time.time() - t_start_serial 

print("Serial job took %s seconds." % (t_end_serial))
print(squared_serial)

#that was slow! now let's do this in parallel

pool = multiprocessing.Pool(MAX_PROC) #we start a 'pool' of workers that we can send processing jobs to

t_start_para = time.time()

squared_para = []
for squared_number in pool.map(square, to_do):
    squared_para.append(squared_number) 

t_end_para = time.time() - t_start_para
print("Parallel job took %s seconds!" % (t_end_para))
print(squared_para)

import os
#this is python's main plotting library
import matplotlib.pyplot as plt

#tell the notebook to make plots appear inline
%matplotlib inline

#set the size of figures
plt.rcParams['figure.figsize'] = 12, 10

#the os module lets us take care of operating system operations. let's use it to specify the path to a  file for opening

#let's load the name dataset
babypath = os.path.join("/", "Users", "carlosgonzalezoliver", "Projects", "Notebooks", \
                       "BabyNames.csv")

def read_names(file_path):
    names_dict = {}
    with open(file_path) as f:
        for row_number, row_string in enumerate(f):
            #first we need to check if we're at a header row
            if row_number == 0:
                #let's store the years so we can use them as labels later             
                #we split the row_string by the comma since this is a csv file
                years = row_string.split(",")[1:]
                
                #convert each year to an integer
                int_years = [int(y.strip()) for y in years]
                
            else:
                row_info = row_string.split(",")
                name = row_info[0]
                counts = [float(c.strip()) for c in row_info[1:]]
                
                names_dict[name] = counts
    #return a dictionary with all the names and their data, and a list with the years 
    return names_dict, int_years

baby_dict, year_list = read_names(babypath)

#look up your name in the dictionary!
print(baby_dict['Carlos'])

#first let's look for an individual name and plot its popularity trend in time.

#this function takes as input a name to search for, and the dataframe. it will return a list of years that name
# appears in, and a list of the counts for each of those years

#one obstacle for this task is that some names have multiple counts for the same year. so we will have to deal with
# this. we'll take the average of the years and use that as our count.


#notice the 'title=' argument. this is known as keyword argument. it is useful for giving a default value to a function
#so in this case the user can decide whether or not he gives the title of the plot. If he/she doesn't then the title
#defaults to "Plot Title"

def name_plot(name, names_dict, year_list, title="Plot Title"):
    #we give the matplotlib function plot() the x and y lists that we would like to plot
    plt.plot(year_list, baby_dict[name], label=name)
    plt.title(title)
    plt.xlabel("Year")
    plt.ylabel("Count")
    
    pass
   

#let's try out the function. give it a name and the names_df
name_plot("Carlos", baby_dict, year_list, title="Carlos Popularity")

# we define a hipster name with the three following criteria. let's say a name is popular if it reaches 1000 babies in 
# a given year.
# Criteria:
# * was very popular a long time ago (at least 1000 count between 1915-1930)
# * very unpopular 30 years ago (under 1000 between 1980-2000)
# * popular in recent years (more than 1000 after 2010)


def hipster_names(baby_dict, year_list):
    
    #let's start an emty list to contain all the matching 'hip' names
    hip_names = []
    
    #let's establish the ranges of time to look at
    popular_range = range(1915, 1930)
    unpopular_range = range(1960, 2000)
    recent = 2010
    
    names = baby_dict.keys()

    #we go through each row in the name group
    for name in names:
        #set some booleans with some initial values that will tell us together if the name is hip
        was_popular = False
        was_unpopular = True
        becoming_popular = False
        
        #we go through each year in the name
        for index, count in enumerate(baby_dict[name]):
            current_year = year_list[index]
            #check if the name was popular a long time ago
            if current_year in popular_range and count >= 1000:
                was_popular = True
                continue
            #check if the year was unpopular recently
            if current_year in unpopular_range and count >= 1000:
                was_unpopular = False
                continue
            #check if the name is growing in popularity
            if current_year >= recent and count >= 1000:
                becoming_popular = True
                continue

        #combine all the booleans to tell us if the name matches all our criteria. if it does, add it to the list
        if was_popular and was_unpopular and becoming_popular:
            print(name)
            hip_names.append(name)

    #return the list.
    return hip_names

#now we just have to call the function hipster_names. give this a couple of minutes as it's a lot of data!
hip_names = hipster_names(baby_dict, year_list)
print(hip_names)

#let's plot the trendlines of each hip name
for n in hip_names:
    name_plot(n, baby_dict, year_list, title="Hipster Names")

#we set the legend, x-axis label, y-axis label, and title of the plot
plt.legend(loc="upper left")