You could use list comprehension with a little modications your list, l, first.

print(df)

   a  b  c
0  1  1  1
1  2  2  2
2  3  3  3
3  4  4  4
4  5  5  5
5  6  6  6
6  7  7  7
7  8  8  8


l = [2,5,7]
l_mod = [0] + l + [max(l)+1]

list_of_dfs = [df.iloc[l_mod[n]:l_mod[n+1]] for n in range(len(l_mod)-1)]

Output:

list_of_dfs[0]

   a  b  c
0  1  1  1
1  2  2  2

list_of_dfs[1]

   a  b  c
2  3  3  3
3  4  4  4
4  5  5  5

list_of_dfs[2]

   a  b  c
5  6  6  6
6  7  7  7

list_of_dfs[3]

   a  b  c
7  8  8  8

Use groupby on the index from which we subtract an increasing by 1 sequence, then stick each group as a separate df in the list

all_dfs = [g for _,g in df.groupby(df.index - np.arange(len(df.index)))]
all_dfs

output:

[            col
 49082 -0.217514
 49083 -0.217834,

             col
 49853  0.844116
 49854  0.800125
 49855  0.824554]

Use slice:

In [11]: s = pd.Series([1,2,3,4])

In [12]: s.iloc[::2]  # even
Out[12]:
0    1
2    3
dtype: int64

In [13]: s.iloc[1::2]  # odd
Out[13]:
1    2
3    4
dtype: int64

You can get at the index you need directly without relying on a counter:

# Get index for 2nd occurrence of pattern in 1st column
cutoff = df.loc[(df.index < 40) & (df.iloc[:, 0].str.contains(r'^[4-6][A-z]*[0-9]'))].index[1]

# Using loc, not iloc, because we have the actual index
df1 = df.loc[:cutoff]
df1 = df.loc[cutoff:]

I also added a '^' to your regex, assuming this pattern needs to occur at the start.

Assuming you want to group rows based on whether or not their row indices differ by 1, we can try the following:

import pandas as pd
import numpy as np

# Generate toy data
random_data = np.random.random(14) 

# Create a dataframe with toy data. Adjacent indices don't always differ by 1 here. 
df = pd.DataFrame(data={'Exit_frame': random_data}, index=[1, 2, 3, 4, 5, 7, 8, 11, 12, 13, 15, 18, 19, 20])
# print(df)

# Store grouped rows as a dataframe in a list
grouped_rows = []

# `df.index` is a list. Track the position of the first element in the group by storing its index in the `df.index` list.
first_in_group = 0

for i in range(len(df.index)):
    # Ignore the first row. We need two indices to compare!
    if i==0:
        continue

    # If adjacent indices don't differ by 1, start grouping rows:
    if df.index[i] - df.index[i-1] != 1:

        # Select 'adjacent rows' using indices; used `.loc` to select multiple rows at once
        grouped_rows.append(df.loc[df.index[first_in_group]:df.index[i-1]])

        # Update the position of the first element for an upcoming group
        first_in_group = i

print(grouped_rows)
print(type(grouped_rows[0]))

This gives us:

[   Exit_frame
1    0.236379
2    0.217071
3    0.470676
4    0.767448
5    0.125440,    Exit_frame
7    0.930271
8    0.985220,     Exit_frame
11    0.042104
12    0.483714
13    0.270400,     Exit_frame
15    0.047957]
<class 'pandas.core.frame.DataFrame'>

The fact that the column is the index makes no difference when extracting components from it but you need to be careful when assigning those components back to the original dataframe.

# Extract the components from the index
# pandas allowed us to name the columns via named captured groups
pattern = r'(?P<Quarter>\d{4}Q\d)\/(?P<CIK>\d+)_(?P<Year>\d{4})-(?P<Month>\d{2})-(?P<Day>\d{2})'
tmp = df.index.str.extract(pattern) \
        .assign(Date=lambda x: pd.to_datetime(x[['Year', 'Month', 'Day']]))

# Since `df` and `tmp` are both dataframe, assignments between them
# will be based row label. We want them to align by position (i.e. 
# line 1 to line 1) so we have to convert the right hand side to
# numpy array
cols = ['Quarter', 'CIK', 'Date']
df[cols] =  tmp[cols].values

You add reset_index instead df_test1['index1'] = df_test1.index and for clean df add rename_axis - it remove column name place:

df_test1 = df_test.groupby(['code' , 'year', 'week',  'place'])['vl'].sum() \
                  .unstack(fill_value=0) \
                  .reset_index() \
                  .rename_axis(None, axis=1)
print (df_test1)

            code  year  week  region1  region2  region3
0  111.0002.0056  2017    28        0        1        0
1  111.0002.0056  2017    29        1        1        0
2  111.0002.0056  2017    30        0        1        0
3  111.0002.0114  2017    31        0        0        1
4  112.5600.6325  2017    30        0        2        0
5  112.5600.8159  2017    28        0        0        1
6  112.5600.8159  2017    30        0        1        0
7  112.5600.8159  2017    31        0        0        1
8  112.6500.2285  2017    31        0        1        0

Last if necessary change ordering of columns:

#all cols are columns in df_test1
cols = ['code' , 'year', 'week']
df_test1 = df_test1[[x for x in df_test1.columns if x not in cols] + cols]
print (df_test1)
   region1  region2  region3           code  year  week
0        0        1        0  111.0002.0056  2017    28
1        1        1        0  111.0002.0056  2017    29
2        0        1        0  111.0002.0056  2017    30
3        0        0        1  111.0002.0114  2017    31
4        0        2        0  112.5600.6325  2017    30
5        0        0        1  112.5600.8159  2017    28
6        0        1        0  112.5600.8159  2017    30
7        0        0        1  112.5600.8159  2017    31
8        0        1        0  112.6500.2285  2017    31