You can use assert_frame_equal and not check the dtype of the columns.

# Pre v. 0.20.3
# from pandas.util.testing import assert_frame_equal

from pandas.testing import assert_frame_equal

assert_frame_equal(df1, df2, check_dtype=False)

Due to imprecise float comparison you can or your comparison with np.isclose, isclose takes a relative and absolute tolerance param so the following should work:

Copydf['result'] = df['actual_credit'].ge(df['min_required_credit']) | np.isclose(df['actual_credit'], df['min_required_credit'])

You also need to be careful to create a copy of the DataFrame, otherwise the csvdata_old will be updated with csvdata (since it points to the same object):

csvdata_old = csvdata.copy()

To check whether they are equal, you can use assert_frame_equal as in this answer:

from pandas.util.testing import assert_frame_equal
assert_frame_equal(csvdata, csvdata_old)

You can wrap this in a function with something like:

try:
    assert_frame_equal(csvdata, csvdata_old)
    return True
except:  # appeantly AssertionError doesn't catch all
    return False

There was discussion of a better way...

If I got it correctly, you just want to find the closest value from second dataframe.

masses = mass_q_sequence['Mass']
mass_pos = df_seq2['mass_pos']
# using broadcasting and finding indices of closest mass for each mass_pos:
closest_mass_indices = np.argmin(np.abs(masses.reshape(1, -1) - mass_pos.reshape(-1, 1)), axis=1) 
df['closest_mass'] = masses[closest_mass_indices]

math.isclose is not a function that can cooperate with pandas and numpy arrays.

You need numpy.isclose:

temp_df = orig_df[
                (np.isclose(orig_df["Alpha"], num))
                & (orig_df["Method"] == method_type)
            ]

np is numpy in this case.

The columns 'b' in the example contains mixed types; strings and ints. You can't compare strings with allclose as strings are either different or not. You should, if possible, have your data organised so that columns are of a single type. If you had, you could use np.allclose to compare the numeric columns and the standard == operator to compare the columns containing strings. In the example, columns 'a' are numeric so np.allclose works:

In [25]: np.allclose(old.a, new.a)
Out[25]: False

However, it returned False because equating null values always returns False, which is another subtlety you need to be be aware of when comparing DataFrames. In this case you could do

In [25]: np.allclose(old.fillna(value=0).a, new.fillna(value=0).a)
Out[25]: True

In the small example you give, the transpose of the DataFrame has columns of a single type so maybe you should be working with that. Note, however, that simply taking the transpose won't change the data types.

In [18]: old.T.dtypes

Out[18]:
x    object
y    object
z    object

but using the convert_objects method will

In [20]: old.T.convert_objects().dtypes
Out[20]:
x    float64
y     object
z    float64
dtype: object

In general, you can check the dtypes of each columns by calling DataFrame.dtypes. You can pick out string (object) columns with something like

obj_cols = df.columns[df.dtypes == object]
num_cols = df.columns[df.dtypes != object]   #this would also include any time columns

Then do

np.allclose(df1[num_cols].fillna(0), df2[num_cols].fillna(0))

and

(df1[obj_cols].fillna('') == df2[obj_cols].fillna('')).all().all()

EDIT: In a more general setting you might want to be a bit more careful when handling nans. You could do the above, but also make sure that the null entries match exactly, since replacing nans with 0 might give an unwanted equality (you might have a 0 in one DataFrame and nan in another and you would still get equality, likewise for strings). You can do this as follow:

(old.isnull() == new.isnull()).all().all()

You could define a function containing the loop you want, and call it as a one-liner:

def compare_isclose(df1, df2, atol_list):
    feature_list = []
    for i, col in enumerate(df1.columns):
        feature_list.append(np.isclose(df1[col], df2[col], atol=atol_list[i]))
    feature_df = pd.DataFrame.from_records(feature_list).T
    return feature_df

The function can be used this way:

atol_list = [10,20,30]
feature_df = compare_isclose(df1, df2, atol_list)

It only works under the assumption that the number of elements in atol_list equals the number of columns in the dataframe, and that the column names of the 2 dataframes are identical.