This won't work. Use a dictionary.

I think the best is create dict of objects - see How do I create a variable number of variables?

You can use dict of DataFrames by converting groupby object to dict:

d = dict(tuple(df.groupby('month')))
print (d)
{1:    month dest
0      1    a
1      1   bb, 2:    month dest
2      2   cc
3      2   dd, 3:    month dest
4      3   ee, 4:    month dest
5      4   bb}

print (d[1])
   month dest
0      1    a
1      1   bb

Another solution:

for i, x in df.groupby('month'):
    globals()['dataframe' + str(i)] = x

print (dataframe1)
   month dest
0      1    a
1      1   bb

Just to underline my comment to @maxymoo's answer, it's almost invariably a bad idea ("code smell") to add names dynamically to a Python namespace. There are a number of reasons, the most salient being:

1. Created names might easily conflict with variables already used by your logic.

2. Since the names are dynamically created, you typically also end up using dynamic techniques to retrieve the data.

This is why dicts were included in the language. The correct way to proceed is:

d = {}
for name in companies:
    d[name] = pd.DataFrame()

Nowadays you can write a single dict comprehension expression to do the same thing, but some people find it less readable:

d = {name: pd.DataFrame() for name in companies}

Once d is created the DataFrame for company x can be retrieved as d[x], so you can look up a specific company quite easily. To operate on all companies you would typically use a loop like:

for name, df in d.items():
    # operate on DataFrame 'df' for company 'name'

In Python 2 you were better writing

for name, df in d.iteritems():

because this avoids instantiating the list of (name, df) tuples that .items() creates in the older version. That's now largely of historical interest, though there will of course be Python 2 applications still extant and requiring (hopefully occasional) maintenance.

Creating variables with dynamic names is typically a bad practice.

I think the best solution for your problem is to store your dataframes into a dictionary and dynamically generate the name of the key to access each dataframe.

import copy

dict_of_df = {}
for ym in [201511, 201612, 201710]:

    key_name = 'df_new_'+str(ym)    

    dict_of_df[key_name] = copy.deepcopy(df)

    to_change = df['YearMonth']< ym
    dict_of_df[key_name].loc[to_change, 'new_col'] = ym   

dict_of_df.keys()
Out[36]: ['df_new_201710', 'df_new_201612', 'df_new_201511']

dict_of_df
Out[37]: 
{'df_new_201511':     A    B  ID                       t  YearMonth  new_col
 0  -a    a   1 2016-12-05 07:53:35.943     201612   201612
 1   1  NaN   2 2016-12-05 07:53:35.943     201612   201612
 2   a    c   2 2016-12-05 07:53:35.943     201612   201612,
 'df_new_201612':     A    B  ID                       t  YearMonth  new_col
 0  -a    a   1 2016-12-05 07:53:35.943     201612   201612
 1   1  NaN   2 2016-12-05 07:53:35.943     201612   201612
 2   a    c   2 2016-12-05 07:53:35.943     201612   201612,
 'df_new_201710':     A    B  ID                       t  YearMonth  new_col
 0  -a    a   1 2016-12-05 07:53:35.943     201612   201710
 1   1  NaN   2 2016-12-05 07:53:35.943     201612   201710
 2   a    c   2 2016-12-05 07:53:35.943     201612   201710}

 # Extract a single dataframe
 df_2015 = dict_of_df['df_new_201511']

You can use a dictionary (here with dummy values) :

names = ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']
pvalues = {}
for i in range(len(names)):
    pvalues["pvalues_" + names[i]] = i+1

print(pvalues)

Output:

{'pvalues_first': 1, 'pvalues_second': 2, 'pvalues_third': 3, 'pvalues_fourth': 4, 'pvalues_fifth': 5, 'pvalues_sixth': 6}

To access pvalues_third for example :

pvalues["pvalues_third"] = 20
print(pvalues)

**Output: **

{'pvalues_first': 1, 'pvalues_second': 2, 'pvalues_third': 20, 'pvalues_fourth': 4, 'pvalues_fifth': 5, 'pvalues_sixth': 6}

Best way is to create a dict with the dynamic names as keys:

chunks = {f'{sub}{i}':chunk for i, chunk in enumerate(np.array_split(df, 10))}

If you absolutely insist on creating the frames as individual variables, then you could assign them to the globals() dictionary, but this method is NOT advised:

for i, chunk in enumerate(np.array_split(df, 10)):
    globals()['{}{}'.format(sub, i)] = chunk

I think it is easy to handle the dataframes in a dictionary. Try the codes below:

review_categories = ["beauty", "pet"]
reviews = {}

for review in review_categories:
     df_name = review + '_reviews' # the name for the dataframe
     filename = "D:\\Library\\reviews_{}.json".format(review)

     reviews[df_name] = pd.read_json(path_or_buf=filename, lines=True)

In reviews, you will have a key with the respective dataframe to store the data. If you want to retrieve the data, just call:

reviews["beauty_reviews"]

Hope it helps.

Assign your DataFrames to values in a dictionary and change the key for each DataFrame. Ex

    dict_of_dfs = {}
    l=0
    for key, value in dicstagefolder.items():
        for v in value:
            l=l+1
            name = key+"-"+str(l)
            dict_of_dfs.update(**{name: pd.read_csv(v)})

Also, try using for v in value in your inner loop. Otherwise, you might face problems with the value keyword getting overwritten.

I used two answers from here. I think your best option is just storing the DataFrames in a dictionary but this should work to create your query_* variables.

query_dict = {}

for n, v in enumerate(state_abbrevs.values()):
    t = gtab.GTAB()
    t.set_options(pytrends_config={"geo": f"US-{v}", "timeframe": "2020-09-01 2020-10-01"})
    query = t.new_query("weather")
    key = "query_" + str(n)
    query_dict[key] = query

for k in query_dict.keys():
    exec("%s = query_dict['%s']" % (k,k))

This isn't a pythonic thing to do, have you thought about instead creating a list of dataframes?

df=pd.DataFrame.copy(mef_list)
form=['','_M3','_M6','_M9','_M12','_LN','_C']
list_of_df = list()
for i in range(0, len(form)):
    df=pd.DataFrame.copy(mef_list)
    df['Variable_new']=df['Variable']+str(form[i])
    list_of_df.append(df)

Then you can access 'df0' as list_of_df[0]

You also don't need to iterate through a range, you can just loop through the form list itself:

form=['','_M3','_M6','_M9','_M12','_LN','_C']
list_of_df = list()
for i in form:
    df=pd.DataFrame.copy(mef_list)
    df['Variable_new']=df['Variable']+str(i) ## You can remove str() if everything in form is already a string
    list_of_df.append(df)

Using a dict is probably a better option for your need. You store each dataframe with the corresponding year as a key:

PROD_years = {}
year=int(datetime.datetime.today().year)

for i in range (year, 2016, -1 ):
  df = df_PROD.filter(col("Year") == i)
  if df.count() > 0:
    PROD_years[i] = df

print(PROD_years)