This is great , thank you for sharing this :)

Lionel.

this seems great

There's little need to see an indicator implementation, the whole point of using external libraries is delegating implementation details to someone else, and ta-lib is well tested in that regard. Moreover by using a python implementation you're possibly not using acceleration on numpy or panda's side.

It is IMHO better to understand and indicator's rationale and proper usage by reading the author's note or some specific article about it than looking at the code.

Also those are just methods from the pandas implemented module of pyTaLib with packages import rather than wildcards, I'd put the author's name back in the body (due to copyright) and remove your name from it since the file is essentially unmodified.

Your opinion granted. For me it actually helps to look at what happens and as I don't think I'm unique so that's why I put the code up.

The author Bruno is mentioned so I don't think that's an issue

The code is changed here and there and I added a few functions but I omitted to record what I added. As in my humble opinion it's useful I'll keep the post live.

In addition to that. Above code has quite a few indicators that talib does not have so only for that reason it's useful to have it around.

This is sick. I have spent way too much time trying to python talib functions for custom oscillators. Thanks.

edit: What is the good/standard way to build a dataframe with high/low/open/close/volume? I typically have/use individual history dataframes for each but I would like to know how to use the code as it is in the original post.

Thanks again

Thank you!

Robby, here is some code from one of my algos I use to build an OHLC dataframe.. It works but I don't like the method. If anyone has a more streamlined approach I would be grateful to see it.
EDIT: you may want to modify it, I made it in such a way that it appends securities in the same data columns, this was useful for the way I was using the securities data

#Define Window  
    trail = 200  
    #store OHLCV data  
    open_hist = history(trail,'1d','open_price',ffill=False)  
    close_hist = history(trail,'1d','close_price',ffill=False)  
    high_hist = history(trail,'1d','high',ffill=False)  
    low_hist = history(trail,'1d','low',ffill=False)  
    volume_hist = history(trail,'1d','volume',ffill=False)  
    opencol = []  
    closecol = []  
    highcol = []  
    lowcol = []  
    volumecol = []  
    #trinsmit OHLCV to continuous numpy arrays  
    for sec in context.secs:  
        opencol = np.concatenate((opencol, open_hist[sec][:]))  
        closecol = np.concatenate((closecol, close_hist[sec][:]))  
        highcol = np.concatenate((highcol, high_hist[sec][:]))  
        lowcol = np.concatenate((lowcol, low_hist[sec][:]))  
        volumecol = np.concatenate((volumecol, volume_hist[sec][:]))  
    print("putting in pandas")  
    #Combine arrays into dataframe  
    df = pd.DataFrame({'O': opencol,  
                      'H': highcol,  
                      'L': lowcol,  
                      'C': closecol,  
                      'V': volumecol})  

Thank you for this expansive list of indicators. This is really great.

However, I am having a hard time linking up the indicators with my algo order logic. For example, when I reference S1 for a pivot point under def handle_data, I get the following error: NameError: global name 'S1' is not defined

I start my code with the following, which I thought would define S1:

import numpy  
import pandas as pd  
import math as m

def initialize(context):  
    set_universe(universe.DollarVolumeUniverse(floor_percentile=99.9, ceiling_percentile=100))

def PPSR(df):  
    PP = pd.Series((df['High'] + df['Low'] + df['Close']) / 3)  
    R1 = pd.Series(2 * PP - df['Low'])  
    S1 = pd.Series(2 * PP - df['High'])  
    R2 = pd.Series(PP + df['High'] - df['Low'])  
    S2 = pd.Series(PP - df['High'] + df['Low'])  
    R3 = pd.Series(df['High'] + 2 * (PP - df['Low']))  
    S3 = pd.Series(df['Low'] - 2 * (df['High'] - PP))  
    psr = {'PP':PP, 'R1':R1, 'S1':S1, 'R2':R2, 'S2':S2, 'R3':R3, 'S3':S3}  
    PSR = pd.DataFrame(psr)  
    df = df.join(PSR)  
    return df

Can someone please tell me what I'm missing? I'm new to coding so I wouldn't be shocked if it was something very simple. Thanks very much.

can you share the rest of the code so I can look into it? you can share with me personally through collaborate ( peter.bakker AT alumni.insead.edu ) if you dont want to throw your code in the open

Hi,

I'm working on this Python Pandas implementation of technical indicators.
I've made a standalone project (with a pip package) for this.
It's available at https://github.com/femtotrader/pandas_talib
Feel free to help. This is still is "work in progress" state.
I've add some unit tests and I'm facing some errors

    ERROR: tests.test_pandas_talib.test_indicator_ATR  
    ----------------------------------------------------------------------  
    Traceback (most recent call last):  
      File "//anaconda/lib/python3.4/site-packages/nose/case.py", line 198, in runTest  
        self.test(*self.arg)  
      File "/Users/femto/pandas_talib/tests/test_pandas_talib.py", line 45, in test_indicator_ATR  
        result = ATR(df, n)  
      File "/Users/femto/pandas_talib/pandas_talib/__init__.py", line 75, in ATR  
        while i < df.index[-1]:  
    TypeError: unorderable types: int() < datetime.datetime()  

I think that's because I'm using index as datetime (and not int)

Kind regards

Dears,

Can anyone nominate a good trading Algo for me? I need to buy a good one with monthly ROI 10%

Thank you

Hi Ahmed,

sorry your question is out of topic here. Maybe you should try to make you own post.

About Pandas implementation of technical indicators.

I think

 while i < df.index[-1]:  

should be replaced by

 while i < len(df) -1:  

I also noticed some errors (KeyError: 1) with:

df.get_value(..., ...)  

maybe

.iloc[...]

should be used instead

@Peter... maybe you can provide.. a sample... a working backtest for these... on how it is implemented.... ;)

I also noticed that ROC Pandas implementation doesn't return same values that TA-Lib's one

x and y nan location mismatch:  
 x: array([            nan,             nan,  -1.6632517e-02,  -1.7376779e-03,  
        -8.6422326e-04,  -6.5179861e-03,  -1.9357306e-02,  -1.4724111e-03,  
         2.5237212e-02,   4.0374865e-02,   1.4385414e-02,  -2.9944823e-02,...  
 y: array([            nan,             nan,             nan,  -2.3665359e+00,  
         4.5841804e-01,  -1.3623165e+00,  -1.3147031e+00,  -1.4223587e+00,  
         1.8396280e+00,   4.5821285e+00,   3.4569644e+00,  -1.0468660e+00,...

https://github.com/femtotrader/pandas_talib/issues/7

Hi guys, I created a repository of technical indicators on github. The library works similarly to the famous ta-lib library, and contains some indicators that I wanted to use in my strategies and are not included in ta-lib. Enjoy, and even better- contribute!
talibextensions

That seems nice, but this thread was aimed at having python indicators without the use ot TAlib, your package is the opposite of that concept since it relies on it.

That apart I suggest to add a little info in the README; at the very least add docstrings in the functions, people should know the functions' purpose without having to read the code (and even then sometimes it's not obvious).

The package hierarchy and code look quite strange for a python package, they got "java-ish" feeling. Lose the semicolons and the src/ folder.
I'd also switch from package to a module, since you're already using the single file approach.

Hi Guys, newbie here.
I am using the function code by Peter to anlayze a stock. Unfortunately being new to python, I have issue using the functions in my code as it did not run properly.

import numpy  
import pandas as pd

#Moving Average  
def MA(df, n):  
    MA = pd.Series(pd.rolling_mean(df['Close'], n), name = 'MA_' + str(n))  
    df = df.join(MA)  
    return df

#MACD, MACD Signal and MACD difference  
def MACD(df, n_fast, n_slow):  
    EMAfast = pd.Series(pd.ewma(df['Close'], span = n_fast, min_periods = n_slow - 1))  
    EMAslow = pd.Series(pd.ewma(df['Close'], span = n_slow, min_periods = n_slow - 1))  
    MACD = pd.Series(EMAfast - EMAslow, name = 'MACD_' + str(n_fast) + '_' + str(n_slow))  
    MACDsign = pd.Series(pd.ewma(MACD, span = 9, min_periods = 8), name = 'MACDsign_' + str(n_fast) + '_' + str(n_slow))  
    MACDdiff = pd.Series(MACD - MACDsign, name = 'MACDdiff_' + str(n_fast) + '_' + str(n_slow))  
    df = df.join(MACD)  
    df = df.join(MACDsign)  
    df = df.join(MACDdiff)  
    return df


data = pd.read_csv("NAIM.csv", index_col='Stock', usecols =[0,6])

print data.head(3)  
vol = data['Close']  
print vol  
print MA(data,5)  
print MACD(data,12,26)  

But the MA result was not correct and MACD has ValueError: negative dimensions are not allowed.
The csv file is as below:

Stock,Date,Time,Open,High,Low,Close,Volume
NAIM,2015-01-02,00:00:00,2.9,3.0,2.9,3.0,46900
NAIM,2015-01-05,00:00:00,2.95,3.05,2.92,3.05,225900
NAIM,2015-01-06,00:00:00,2.95,2.96,2.9,2.9,682000
NAIM,2015-01-07,00:00:00,2.88,2.95,2.88,2.9,160900
.
.
.
NAIM,2016-01-06,00:00:00,2.48,2.61,2.47,2.6,3260900
NAIM,2016-01-07,00:00:00,2.64,2.74,2.6,2.65,3906100
NAIM,2016-01-08,00:00:00,2.65,2.71,2.62,2.64,1875000
NAIM,2016-01-11,00:00:00,2.65,2.7,2.65,2.68,1089400
NAIM,2016-01-12,00:00:00,2.68,2.71,2.65,2.69,965200
NAIM,2016-01-13,00:00:00,2.69,2.74,2.69,2.73,2091500
NAIM,2016-01-14,00:00:00,2.71,2.71,2.66,2.66,1206000
NAIM,2016-01-15,00:00:00,2.66,2.67,2.62,2.62,738600

Hi Ching, As Andrea wrote in an earlier the post, I suggest that instead of using the code in the script, use ta-lib library for technical analysis. (installation guide included in the link). Most of the famous and widely used indicators are implemented and the library's api is very friendly. If there's an indicator that you want to use and is not included in ta-lib, only then should you bother to implement it yourself. I shared a github repository link for implementing more indicators and you are invited to contribute :)

Hi Tom,
I try to install ta-lib(same link that you provided) but fail to do so on my windows Python2.7. I extract the zip file at the site-packages folder, but unable to import the ta-lib library (ImportError: No module named talib)
So using function code from Peter is my second choice since ta-lib was not working for me.

Try to install ta-lib from the binaries here (one of the cp27 should do - as you are using python2.7)

@tom
Thanks. I did manage to install with anaconda.
However, I am unable to use with my above script as I encounter an error when I apply talib.MA(data,12)
TypeError: Argument 'real' has incorrect type (expected numpy.ndarray, got Series)
any idea?

For help with Zipline, the open-source backtest engine that powers Quantopian, you should post in the Zipline Google group. That community has deep Zipline expereience. This community is generally more for financial or algorithmic topics related to Quantopian.

@tom The problem with ta-lib is it depends on the C ta-lib. A pure Python TA library would be great.

Speaking of which, @peter do you plan on making this into a proper Python library and putting it up on github?

For pure Python TA lib implementation library you might have a look at https://github.com/femtotrader/pandas_talib
This is base on Bruno Franca / Peter Bakker code
You might also have a look at https://github.com/davidastephens/pandas-finance/issues/1 and https://github.com/bpsmith/tia

Thanks!

Hi
in :
EMA = pd.Series(pd.ewma(df['Close'], span = n, min_periods = n - 1), name = 'EMA_' + str(n))
I don't understand why min_periods=n-1.
Not that it makes any difference at all, but shouldn't it be min_periods = n ?

I am looking for a python code for the indicator McGinley Dynamic. Kindly share.

Thanks Peter. Great code, for newbies like me to learn!

I tried implementing your code. However, I get the following error : TypeError: list indices must be integers, not str EMA = pd.Series(pd.ewma(df['Close'], span = n, min_periods = n - 1), name = 'EMA_' + str(n))

I enter the data via Excel which feeds into Python xlwings.

Any idea what's going on?

@xw.func
def EMA(df, n):
EMA = pd.Series(pd.ewma(df['Close'], span = n, min_periods = n - 1), name = 'EMA_' + str(n))
df = df.join(EMA)
return df

Kind regards

*****I am on the quantopian algo page, not the notebook. I don't understand the notebook for the life of me.

I have been using talib for indicators but I cannot figure out what the input is for the ADOSC - the Chaikin Oscillator. My question can be answered one of two ways with the first preferable.

1) What goes into the ADOSC arguments/parameters for the function to work? I get the error "function requires four arguments (2 given)" with the below code. No idea if these are even close to the correct inputs.

import talib as ta

price_history_hlc_20 = data.history(context.security, ['high', 'low', 'close'], 30, '1d')
volume_history_20 = data.history(context.security, 'volume', 20, '1d')

adosc = ta.ADOSC(price_history_hlc_20, volume_history_20, fastperiod = 3, slowperiod = 10)

2) How do I use the indicator if I decide to use the code from this post that puts it into its own def? The way I developed my algo, I am doing all the calculations/defining indicators in the same def that I run the logic to trade.

Chaikin Oscillator

def Chaikin(df):
ad = (2 * df['Close'] - df['High'] - df['Low']) / (df['High'] - df['Low']) * df['Volume']
Chaikin = pd.Series(pd.ewma(ad, span = 3, min_periods = 2) - pd.ewma(ad, span = 10, min_periods = 9), name = 'Chaikin')
df = df.join(Chaikin)
return df

def rebalance(context, data):

adosc = Chaikan? haha

Taylor,

Try this:

import talib

def initialize(context):  
    schedule_function(trade, date_rules.every_day(), time_rules.market_close())  
def trade(context, data):  
    stock, ma_f, ma_s = symbol('SPY'), 3, 10  
    H = data.history(stock, 'high', ma_s, '1d')  
    L = data.history(stock, 'low', ma_s, '1d')  
    C = data.history(stock, 'close', ma_s, '1d')  
    V = data.history(stock, 'volume', ma_s, '1d')  
    Chaikin_Osc_talib = talib.ADOSC(H,L,C,V,ma_f,ma_s)[-1]

    record(Chaikin_Osc = Chaikin_Osc_talib)  

Vlad,

Thank you so much for the quick reply! I tried to keep the same formatting I have for the rest of the algo so I didn't quite write it like that but you definitely helped me solve it. I used the below code. I must say though, it's disappointing how much variation there is between the one here and the one on stockcharts.com. I presume the stockcharts one is the most accurate. =/ (btw, I know I can do the '[-1]' on the end of the thing but I like to do it separately to keep the logic separated out =)

price_history_hlcv_20 = data.history(context.security, ['high', 'low', 'close', 'volume'], 20, '1d')

adosc = ta.ADOSC(price_history_hlcv_20['high'], price_history_hlcv_20['low'], price_history_hlcv_20['close'], price_history_hlcv_20['volume'], fastperiod = 3, slowperiod = 10)

adosc = adosc[-1]  

Hi Vlad,

Do you know what the input is for ADX? It requests 3 arguments. I gave it high, low, close, and its very similar to how it looks on stockcharts but some of the numbers are much higher/lower, more off than the adosc above was.

price_history_hlc_20 = data.history(context.security, ['high', 'low', 'close'], 20, '1d')

adx = ta.ADX(price_history_hlc_20['high'], price_history_hlc_20['low'], price_history_hlc_20['close'], timeperiod = 14)

adx = adx[-1]

Same thing for Aroon Oscillator. It's similar but not taking the same shape. Any ideas on that one?

aroonosc = ta.AROONOSC(price_history_hlc_20['high'], price_history_hlc_20['low'], timeperiod = 14)

aroonosc = aroonosc[-1]  

# ADX talib indicator

import talib

def initialize(context):  
    schedule_function(trade, date_rules.every_day(), time_rules.market_close())  
def trade(context, data):  
    stock, period = symbol('SPY'), 10  
    bars = period*2  
    H = data.history(stock, 'high', bars, '1d')  
    L = data.history(stock, 'low', bars, '1d')  
    C = data.history(stock, 'close', bars, '1d')  
    ADX = talib.ADX(H,L,C,period)  
    record(ADX = ADX[-1])  

# AROON_OSC talib indicator

import talib

def initialize(context):  
    schedule_function(trade, date_rules.every_day(), time_rules.market_close())  
def trade(context, data):  
    stock, period = symbol('SPY'), 10  
    bars = period + 1  
    H = data.history(stock, 'high', bars, '1d')  
    L = data.history(stock, 'low', bars, '1d')  
    AROON_OSC = talib.AROONOSC(H,L,period)  
    record(AROON_OSC = AROON_OSC[-1])  

Yeah I set them up that way but they are off compared to stockcharts. Lame. Thanks for the reply!

Last one Vlad. xD What do you input for the STOCHRSI ta lib indicator?

Try this:

    stoch_rsi = talib.STOCHRSI(C,period,fk,fd,fdma )[1][-1]

    # where fdma --> fast D moving average type = 0 --> SMA  

Worked great! Thanks bro! What does the [1][-1] on the end mean?! I know [-1] gets you the last value

thank you for this

Stochastic Oscillator formula is wrong. Here is correct code.

# Stochastic Oscillator, EMA smoothing, nS = slowing (1 if no slowing)  
def STO(df,  nK, nD, nS=1):  
    SOk = pd.Series((df['Close'] - df['Low'].rolling(nK).min()) / (df['High'].rolling(nK).max() - df['Low'].rolling(nK).min()), name = 'SO%k'+str(nK))  
    SOd = pd.Series(SOk.ewm(ignore_na=False, span=nD, min_periods=nD-1, adjust=True).mean(), name = 'SO%d'+str(nD))  
    SOk = SOk.ewm(ignore_na=False, span=nS, min_periods=nS-1, adjust=True).mean()  
    SOd = SOd.ewm(ignore_na=False, span=nS, min_periods=nS-1, adjust=True).mean()  
    df = df.join(SOk)  
    df = df.join(SOd)  
    return df  
# Stochastic Oscillator, SMA smoothing, nS = slowing (1 if no slowing)  
def STO(df, nK, nD,  nS=1):  
    SOk = pd.Series((df['Close'] - df['Low'].rolling(nK).min()) / (df['High'].rolling(nK).max() - df['Low'].rolling(nK).min()), name = 'SO%k'+str(nK))  
    SOd = pd.Series(SOk.rolling(window=nD, center=False).mean(), name = 'SO%d'+str(nD))  
    SOk = SOk.rolling(window=nS, center=False).mean()  
    SOd = SOd.rolling(window=nS, center=False).mean()  
    df = df.join(SOk)  
    df = df.join(SOd)  
    return df  

Just one little thing...this code has been written a long time ago (from now). So maybe would be interesting to look for possible "depracated" warnings in different functions of pandas and update it!

Thanks for sharing

@Alex Brunt, according to this source:

The standard settings for the full version would look like "14, 3, 3",
which is nothing but the slow version of stochastic with the settings
"14,3". Change the parameter in middle to anything else, say 7, and
you are smoothening out the main line by it's SMA of 7 periods and
then taking out a 3 period SMA of that to have your trigger line.

This suggests that D% should be the average of post-smoothed K% instead of pre-smoothed K%. Furthermore, I don't think D% needs to be smoothed again because it's already an EMA/SMA of an EMA/SMA. I've also multiplied K% by 100 to get the more common chart number, removed default arguments, changed the argument names to be more intuitive coming from popular charting software, and renamed columns to simply D% and K%. My final code looks like this:

# Stochastic Oscillator (EMA method)  
def StochEMA(df, period, fast, slow=3):  
    K = pd.Series(((df['close']-df['low'].rolling(period).min()) /  
        (df['high'].rolling(period).max()-df['low'].rolling(period).min()))*100, name='K%')  
    K = K.ewm(span=slow, min_periods=slow-1).mean()  
    D = pd.Series(K.ewm(span=fast, min_periods=fast-1).mean(), name = 'D%')  
    df = df.join(D)  
    df = df.join(K)  
    return df

# Stochastic Oscillator (SMA method)  
def StochSMA(df, period, fast, slow=3):  
    K = pd.Series(((df['close']-df['low'].rolling(period).min()) /  
        (df['high'].rolling(period).max()-df['low'].rolling(period).min()))*100, name='K%')  
    K = K.rolling(window=slow).mean()  
    D = pd.Series(K.rolling(window=fast).mean(), name = 'D%')  
    df = df.join(D)  
    df = df.join(K)  
    return df  

This was great to come across! I am currently trying to run a python script in 64-bit Windows and installing TA-Lib on x64 doesn't work, so I needed a way to do my program's talib-dependent calculations without it. I created a Talib class for only the functions I need (EMA, ATR, RSI, and BBANDS).

Rather than change the input lines that were using the talib library, I modified the functions above to work exactly like running a talib line would. For example, the input for many of the talib functions are multiple arrays, not single dataframes; the "n"s used above are referred to as "timeperiod" in talib, etc.

I also noticed the RSI in the original post above is wrong. RSI only takes a Close as its input, not Highs or Lows (The RSI function above looks more like what you'd need for an ADX calculation).

I tried to simplify the 4 functions below (some of the pandas functions used above, like pd.rolling_mean, are scheduled to be deprecated, so I swapped those out) and keep the logic more in line with what steps a user would see if they looked up how to calculate these indicators online.

Perhaps this code may be useful to someone trying to emulate the talib library more in line with how the library itself works, using the same input datatypes and returning the same output.

(I like to instantiate this with Talib = TalibClass() so I only have to capitalize the "T" in "talib" throughout my code to shift from using the talib library to using this custom class)

class TalibClass():  
    #Exponential Moving Average  
    def EMA(self, array, timeperiod):  
        EMA = pd.Series(array).ewm(span = timeperiod, min_periods = timeperiod - 1).mean().rename('EMA_' + str(timeperiod))  
        return EMA.values  
    #Average True Range  
    def ATR(self, highArray, lowArray, closeArray, timeperiod):  
        TRL = [highArray[0] - lowArray[0]]  
        ATRL = [np.nan]  
        i = 1  
        while i < len(highArray):  
            TR = np.nanmax([(highArray[i] - lowArray[i]), abs(highArray[i] - closeArray[i]), abs(lowArray[i] - closeArray[i])])  
            TRL.append(TR)  
            if i < timeperiod:  
                ATRL.append(np.nan)  
            elif i == timeperiod:  
                ATR = np.nanmean(TRL)  
                ATRL.append(ATR)  
            else:  
                ATR = ((ATRL[-1] * (timeperiod - 1)) + TR) / timeperiod  
                ATRL.append(ATR)  
            i += 1  
        return pd.Series(ATRL).values  
    #Relative Strength Index  
    def RSI(self, closeArray, timeperiod):  
        changeL = [np.nan]  
        avgGainL = [np.nan]  
        avgLossL = [np.nan]  
        RSIL = [np.nan]  
        i = 1  
        while i < len(closeArray):  
            changeL.append(closeArray[i] - closeArray[i - 1])  
            if i < timeperiod:  
                avgGainL.append(np.nan)  
                avgLossL.append(np.nan)  
                RSIL.append(np.nan)  
            elif i == timeperiod:  
                avgGainL.append(abs(np.nansum([x for x in changeL[-timeperiod:] if x >= 0]) / timeperiod))  
                avgLossL.append(abs(np.nansum([x for x in changeL[-timeperiod:] if x < 0]) / timeperiod))  
                RS = avgGainL[-1] / avgLossL[-1]  
                RSI = 100 - (100 / (1 + RS))  
                RSIL.append(RSI)  
            else:  
                if changeL[-1] >= 0:  
                    currGain = changeL[-1]  
                    currLoss = 0  
                else:  
                    currGain = 0  
                    currLoss = abs(changeL[-1])  
                avgGain = (avgGainL[-1] * (timeperiod - 1) + currGain) / timeperiod  
                avgLoss = (avgLossL[-1] * (timeperiod - 1) + currLoss) / timeperiod  
                avgGainL.append(avgGain)  
                avgLossL.append(avgLoss)  
                RS = avgGain / avgLoss  
                RSI = 100 - (100 / (1 + RS))  
                RSIL.append(RSI)  
            i += 1  
        return pd.Series(RSIL).values

    #Bollinger Bands  
    def BBANDS(self, closeArray, timeperiod, nbdevup, nbdevdn):  
        middle = pd.Series(closeArray).rolling(window=timeperiod).mean().values  
        stdev = pd.Series(closeArray).rolling(window=timeperiod).std().values  
        upper = middle + (stdev * nbdevup)  
        lower = middle - (stdev * nbdevdn)  
        return upper, middle, lower