I don't know how you have tested it the first time, here is my logic. It supposes the first element in flag is 0!

df = pd.DataFrame({'memberid': [1]*11,
                   'flag': [0,0,1,1,0,1,0,0,0,1,1],
                   })
df['seq'] = ""
for i in range(0, len(df)):
    df.loc[i, 'seq'] = 1 if df.loc[i, 'flag'] == 0 else  df.loc[i - 1, 'seq'] + 1
print(df)

Another solution using lambda:

df = pd.DataFrame({'memberid': [1] * 11,
                   'flag': [0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1]
                   })

def f(flag):
    global previous_seq
    previous_seq = 1 if flag == 0 else previous_seq + 1
    return previous_seq

previous_seq = 0
df['seq'] = df[['flag']].apply(lambda x: f(*x), axis=1)
print(df)

I am not sure if it is faster than the first solution....

I stumbled upon the answer which was embarrassingly simple. The groupby statement has a 'cumcount()' option which will enumerate group items.

df['sequence']=df.groupby('patient').cumcount()

The caveat is that the records have to be in the order you want them enumerated.

There are ways to do this using column operations, but there's nothing wrong with looping through the values in the column for something like this:

FlagA = df['FlagA'].tolist()
FlagA_sequence = ["".join(FlagA[i:i+5]) for i in range(5,len(x)-5)]

if you're looking to make it a columns in the dataframe, you can either do:

df['FlagA_sequence']=[np.nan]*5 + ["".join(FlagA[i:i+5]) for i in range(5,len(x)-5)]

or use .shift() for a more pandas-oriented solution:

df['FlagA_sequence']= pd.concat([df['FlagA'].shift(i) for i in range(5)], axis=1).dropna(how='any').sum(1)

Use groupby with GroupBy.cumcount and add scalar 1:

df['Seq'] = df.groupby(['P_Id','Time_Point','Date']).cumcount().add(1)
print (df)
    P_Id  Time_Point        Date  Seq
0   B001           0  2015-07-22    1
1   B001           0  2015-07-22    2
2   B001           0  2015-07-22    3
3   B001           0  2015-07-22    4
4   B001           0  2015-07-22    5
5   B001           3  2015-10-01    1
6   B001           3  2015-10-01    2
7   B001           3  2015-10-01    3
8   B001           3  2015-10-01    4
9   B001           3  2015-10-01    5
10  B001          12  2016-08-01    1
11  B001          12  2016-08-01    2
12  B001          12  2016-08-01    3
13  B001          12  2016-08-01    4
14  B001          12  2016-08-01    5

The snippet below should do what you're looking for. First, check for rows less than 1.0 apart from the preceding row. In order to catch the first row of the group, do the same thing with the following row. Combine these with np.logical_or and create group numbers by once again using shift.

Finally, filter to the groups we created that have all 'True' values; that is, every value within the group is within one of its neighbor. Once we have the all-positive groups, take the biggest one (not necessarily a group of five). Once we get that group number, return those rows from the original df.

df.columns = ['curve']
a = abs(df.curve - df.curve.shift()) < 1.0    
b = abs(df.curve - df.curve.shift(-1)) < 1.0  
c = np.logical_or(a, b)                       
d = (c != c.shift()).cumsum()                 
df['c'] = c
df['d'] = d

df = df.groupby(d).filter(lambda x: all(x['c']))
max_group = df.loc[df.groupby(d).cumcount().idxmax()]['d']

df_added = df.loc[df['d'] == max_group]

EDIT: I should also note that the concerns raised in the comments to your original question are valid.

As seen in the docs for pandas.Series, all that is required for your data parameter is an array-like, dict, or scalar value. Hence to create a series for a range, you can do exactly the same as you would to create a list for a range.

one_to_hundred = pd.Series(range(1,101))

pd.DataFrame([np.arange(6, 18, 3)]*7)

alternately,

pd.DataFrame(np.repeat([np.arange(6, 18, 3)],7, axis=0))

    0   1   2   3
0   6   9   12  15
1   6   9   12  15
2   6   9   12  15
3   6   9   12  15
4   6   9   12  15
5   6   9   12  15
6   6   9   12  15

Use get_loc. From documentation:

Get integer location, slice or boolean mask for requested label.

>>> x.index.get_loc('b')
1

df.insert(0, 'New_ID', range(880, 880 + len(df)))
df

Assuming you just want to create a sequence number column, you can use ngroup:

df = pd.DataFrame({'group Nr':[50,50,50,53,53,53,53,56,56,59,59,59]})
df["sequence Nr"] = df.groupby("group Nr").ngroup() + 1

ngroup numbers each group starting from 0, so you'll want to add 1.

There can be a lot of solutions. In the comments of the code block (#) you will find a few links for more information:

import pandas as pd
import numpy as np
import random
import string

k = 5
N = 10

#http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.randint.html
#http://stackoverflow.com/a/2257449/2901002

df = pd.DataFrame({ 'A' : range(1, N + 1 ,1),
    'B' : np.random.randint(k, k + 100 , size=N),
    'C' : pd.Series(random.choice(string.ascii_uppercase) for _ in range(N)) })

print df
#    A   B  C
#0   1  60  O
#1   2  94  L
#2   3  10  W
#3   4  94  X
#4   5  60  O
#5   6  20  K
#6   7  58  Y
#7   8  40  I
#8   9  49  X
#9  10  65  S

Numpy solution:

import pandas as pd
import numpy as np

k = 5
N = 10

alphabet = list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')

#http://docs.scipy.org/doc/numpy/reference/generated/numpy.random.choice.html

df = pd.DataFrame({ 'A' : range(1, N + 1 ,1),
    'B' : np.random.randint(k, k + 100 , size=N),
    'C' : np.random.choice(np.array(alphabet, dtype="|S1"), N) })

print df
#    A    B  C
#0   1   16  U
#1   2   76  X
#2   3  101  N
#3   4   61  F
#4   5   52  J
#5   6   62  A
#6   7   99  L
#7   8   23  N
#8   9   75  D
#9  10   16  Q

You can set_index and reindex using a range from the Sequence's min and max values:

(df.set_index('Sequence')
   .reindex(range(df.Sequence.iat[0],df.Sequence.iat[-1]+1), fill_value='')
   .reset_index())

   Sequence Value
0         1     x
1         2     x
2         3      
3         4     x
4         5      
5         6     x
6         7     x
7         8      
8         9     x
9        10     x