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)

I actually don’t know if the issue is directly related to the years being int. I actually think it’s related to a being assigned to a Python ‘type’ and not actually an empty data frame.. To validate you can just print(a) given your current code.

On mobile so I can’t test completely but try this assignment instead.

a = pd.DataFrame()

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.

I guess you can achieve this with something simplier, like that :

df_list=[df1, df2, df3]
for i, df in enumerate(df_list, 1):
    df.columns = [col_name+'_df{}'.format(i) for col_name in df.columns]

If your DataFrames have prettier names you can try:

df_names=('Home', 'Work', 'Park')
for df_name in df_names:
    df = globals()[df_name]
    df.columns = [col_name+'_{}'.format(df_name) for col_name in df.columns]

Or you can fetch the name of each variable by looking up into globals() (or locals()) :

df_list = [Home, Work, Park]
for df in df_list:
    name = [k for k, v in globals().items() if id(v) == id(df) and k[0] != '_'][0]
    df.columns = [col_name+'_{}'.format(name) for col_name in df.columns]

Use a dictionary:

frames = {}
for item in data['item'].unique():
    frames[item] = data[data['item'] == item]

You actually have already achieved what you want when you assign the data to a new variable name.

Say for example you have a dataframe called df_original, if you assign it to a new variable called 'df_new' such as:

df_new = df_original

In this case, the data frame is NOT copied, it just gets a new name that refers to the original data saved in the memory.

If you run 'df_new is df_original' the output is 'True'. So these are just different names pointing to the same dataset saved in the memory.

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.

I think you gave the answer yourself: you have to use ?assign.

Try something like that:

for (i in 1:5) {
  assign(paste0("DF", i), data.frame(A=rnorm(10), B=rnorm(10)))
}

This loops through the integers from 1 to 5 and creates five data.frames "DF1" to "DF5". For your example, you should just replace

name<-read.tucson(files[i],header=NULL)

with

assign(name, read.tucson(files[i],header=NULL))

Note, however, that name is a base function in R, so I would use another naming convention or just skip the first line:

assign(paste("t",files[i],sep=""), read.tucson(files[i],header=NULL))

I hope this is what you are looking for.

Use a dictionary for organizing your dataframes, and groupby to split them. You can iterate through your groupby object with a dict comprehension.

Example:

>>> data
      Sport  random_data
0    soccer            0
1    soccer            3
2  football            1
3  football            1
4    soccer            4

frames = {i:dat for i, dat in data.groupby('Sport')}

You can then access your frames as you would any other dictionary value:

>>> frames['soccer']
    Sport  random_data
0  soccer            0
1  soccer            3
4  soccer            4

>>> frames['football']
      Sport  random_data
2  football            1
3  football            1

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