How to use the quandl.get function in Quandl

def test(year, stock, window=10, up=0.05, down=0.05, get_plots=True, verbose=True):
	quandl.ApiConfig.api_key = "FDEDsMbK1E2t_PMf7X3M"
	df = quandl.get('NSE/ZEEL', start_date='2017-01-01', end_date='2017-12-31')
	prices = df["Close"]
	dates = df["Date"]

	agent = EMA_Agent(window, up, down)

	test = Backtest(agent, 10000)

	output = test.run(prices)

	# class Evaluation takes for initialization - prices, output, name of algorithm, name of security

	evaluator = Evaluation(prices, dates, output, "EMA", stock)
	return evaluator.complete_evaluation(get_plots, verbose)

def get_data_from_quandl(stocks, save=True):
    """
    Returned dataframe is indexed by Date. So, no need to externally parse dates and change index column.
    :param stocks: Stocks to be downloaded
    :param save: If True, then save the downloaded stock.
    :return: A list of pandas dataframe containing the details of requested stocks.
    """
    quandl.ApiConfig.api_key = QUANDL_KEY
    df_list = []
    for stock in stocks:
        print("DOWNLOADING {0} DATA".format(stock))
        df = quandl.get(stock, start_date=RETRIEVAL_START_DATE, end_date=RETRIEVAL_END_DATE)
        df = df[REL_DATA_COLUMNS]
        df_list.append(df)
        if save:
            df.to_csv('{0}/{1}.csv'.format(DATA_DIR, stock.split('/')[-1]))
    return df_list

if math.isnan(tmp_var_1):
                tmp_var_1 = 0
            if math.isnan(tmp_var_2):
                tmp_var_2 = 0
            tmp_list.append(float(tmp_var_1))
            tmp_list.append(float(tmp_var_2))
            main_list.append(tmp_list)

        for i in range(len(high_prices)):
            if math.isnan(high_prices[i]):
                high_prices[i] = 0

        main_list = np.asarray(main_list)
        high_prices = np.asarray(high_prices)

        PREDICT_FOR = quandl.get(QUAND_REF, collapse="daily")
        PREDICT_FOR_price_list = data['Low'].values.tolist()
        PREDICT_FOR_volume_list = data['Volume'].values.tolist()
        PREDICT_x = PREDICT_FOR_price_list[-1]
        PREDICT_y = PREDICT_FOR_volume_list[-1]

        print ("PREDICT_x : " + str(PREDICT_x))
        print ("PREDICT_y : " + str(PREDICT_y))

        # Initialize the model then train it on the data
        genius_regression_model = LinearRegression()
        genius_regression_model.fit(main_list,high_prices)
        # Predict the corresponding value of Y for X
        pred_ict = [PREDICT_x,PREDICT_y]
        pred_ict = np.asarray(pred_ict) #To Numpy Array, hacky but good!! 
        pred_ict = pred_ict.reshape(1, -1)
        price_prediction = genius_regression_model.predict(pred_ict)

import quandl, math
import numpy as np
import pandas as pd
from sklearn import preprocessing, cross_validation, svm
from sklearn.linear_model import LinearRegression
import matplotlib.pyplot as plt
from matplotlib import style
import datetime
import pickle

style.use('ggplot')

df = quandl.get("WIKI/GOOGL")
df = df[['Adj. Open',  'Adj. High',  'Adj. Low',  'Adj. Close', 'Adj. Volume']]
df['HL_PCT'] = (df['Adj. High'] - df['Adj. Low']) / df['Adj. Close'] * 100.0
df['PCT_change'] = (df['Adj. Close'] - df['Adj. Open']) / df['Adj. Open'] * 100.0

df = df[['Adj. Close', 'HL_PCT', 'PCT_change', 'Adj. Volume']]
forecast_col = 'Adj. Close'
df.fillna(value=-99999, inplace=True)
forecast_out = int(math.ceil(0.1 * len(df)))

df['label'] = df[forecast_col].shift(-forecast_out)

X = np.array(df.drop(['label'], 1))
X = preprocessing.scale(X)
X_lately = X[-forecast_out:]
X = X[:-forecast_out]

def get_data(security):
    """
    This function obtains data under certain parameters from Quandl and returns the following information as a Pandas
    DataFrame: date, adjusted closing, and percentage change in adjusted closing from the last week.

    :param security:  Holds information about the requested security
    :return: A Pandas DataFrame with columns: Date, Adjusted Close, and Percentage Change.
    """
    quandl.ApiConfig.api_key = "7NU4-sXfczxA9fsf_C8E"
    name = security.get_name()
    start = security.get_start()
    end = security.get_end()
    period = security.get_period()
    raw_df = quandl.get("YAHOO/" + name, start_date=start, end_date=end, collapse=period)
    adjusted_df = raw_df.ix[:, ['Adjusted Close']]
    adjusted_df["Percentage Change"] = adjusted_df['Adjusted Close'].pct_change() * 100
    return adjusted_df

def getSingleStock(symbol, from_date, till_date):    
    repeat_times = 3
    message = ""
    for _ in range(repeat_times): 
        try:
            data = quandl.get("HKEX/"+symbol, start_date=from_date, end_date=till_date)
            data.index = pd.to_datetime(data.index)
            return data, ""
        except Exception as e:
            message = ", fetch exception: " + str(e)
            continue   
        else:
            time.sleep(0.1)
    return '', message

def HPI_Benchmark():
	df = quandl.get('FMAC/HPI_USA' , authtoken=api_key)
	df['United States'] = (df['Value'] - df['Value'][0]) / df['Value'][0] * 100.0
	
	pickle_out = open('us_pct.pickle', 'wb')
	pickle.dump(df, pickle_out)
	pickle_out.close()

def get_currency_data(currency_list, currency_quandl_list, num_days_regression, end_date , api_key):
	# Calculate dates to begin and end
	start_date = end_date  - timedelta(num_days_regression)

	# Initialize data table
	data_table = None
	# Run through currencies, first assignment is initialized
	# Anything past first currency is joined into table 
	for currency in currency_quandl_list:
		current_column = qdl.get(currency, start_date= start_date, end_date = end_date , authtoken= api_key)
		current_column.columns = [currency]
		if data_table is None:
			data_table = current_column
		else:
			data_table = data_table.join(current_column, how= 'left', rsuffix= '')
	data_table.columns = currency_list 
	if 'USD/MXN' in currency_list:
		data_table['USD/MXN'] = 1 / data_table['USD/MXN']
	return data_table

def crypto_data(chart_exchange):
    # Download and cache Quandl dataseries
    path = '{}.csv'.format(chart_exchange).replace('/', '-')
    df = quandl.get(chart_exchange, returns='pandas')
    df.to_csv(path)
    return df

import quandl
import pandas as pd

# Not necessary, I just do this so I do not show my API key.
api_key = 'rFsSehe51RLzREtYhLfo'
fiddy_states = pd.read_html('https://simple.wikipedia.org/wiki/List_of_U.S._states')

main_df = pd.DataFrame()

for abbv in fiddy_states[0][0][1:]:
    query = "FMAC/HPI_"+str(abbv)
    df = quandl.get(query, authtoken=api_key)

    if main_df.empty:
        main_df = df
    else:
        main_df = main_df.join(df)