Comparison with astype(int)

Tentatively convert your column to int and test with np.array_equal:

np.array_equal(df.v, df.v.astype(int))
True

float.is_integer

You can use this python function in conjunction with an apply:

df.v.apply(float.is_integer).all()
True

Or, using python's all in a generator comprehension, for space efficiency:

all(x.is_integer() for x in df.v)
True

You can use pd.to_numeric to try to convert the strings to numeric values. Then, check for each element in the converted columns whether it is an instance of float type by using .applymap() and isinstance(x, float). Finally, check for any column value in a column is of type float by .any():

df.apply(pd.to_numeric, errors="ignore").applymap(lambda x: isinstance(x, float), na_action='ignore').any()

Result:

column1     True
column2    False
dtype: bool

True value of column1 corresponds to it has at least one element of type float

Actually, this solution can also check for individual elements whether of float type by removing the .any() at the end:

df.apply(pd.to_numeric, errors="ignore").applymap(lambda x: isinstance(x, float), na_action='ignore')

Result:

   column1  column2
0     True    False
1     True    False
2     True    False

This is conciser:

# select the float columns
df_num = df.select_dtypes(include=[np.float])
# select non-numeric columns
df_num = df.select_dtypes(exclude=[np.number])

One way to do this will be to divide the value in the column by 1. if the mod returns 0, then its an integer. If all the values of the mod is 0, then the column is an integer. With that, you can do the following to convert the column to integers.

Check if dataframe contains only float & ints

import pandas as pd
df = pd.DataFrame({'col1':[1,2,3,4,5,6],
                    'col2':[1.0,2.0,3.0,4.0,5.0,6.0],
                    'col3':[1.1,2.1,3.1,4.1,5.1,6.1]})

print (df.info())

for col in df.columns:
    if all(df[col]%1==0): df[col] = df[col].astype(int)

print (df.info())

Sample df is:

   col1  col2  col3
0     1   1.0   1.1
1     2   2.0   2.1
2     3   3.0   3.1
3     4   4.0   4.1
4     5   5.0   5.1
5     6   6.0   6.1

Info gives us:

Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   col1    6 non-null      int64  
 1   col2    6 non-null      float64
 2   col3    6 non-null      float64

After the check and conversion, the dtypes are:

 #   Column  Non-Null Count  Dtype  
---  ------  --------------  -----  
 0   col1    6 non-null      int64  
 1   col2    6 non-null      int64  
 2   col3    6 non-null      float64

Check if dataframe contains varying dtypes

Since you want to test this only for floats and ints, you can add the condition before you check for mod of 1.

import pandas as pd
df = pd.DataFrame({'col1':[1,2,3,4,5,6],
                    'col2':[1.0,2.0,3.0,4.0,5.0,6.0],
                    'col3':[1.1,2.1,3.1,4.1,5.1,6.1],
                    'col4':['a','b','c','d','e','f'],
                    'col5':[True,True,True,False,False,False],
                    'col6':pd.date_range('2021.01.01', '2021.01.06').tolist()
                })

print (df)

print (df.info())

for col in df.columns:
    if df[col].dtype.kind in ('if') and all(df[col]%1==0): df[col] = df[col].astype(int)

print (df.info())

dtype.kind can be used to check i for int, f for float, b for bool, O for object and M for datetime. More details about numpy.dtype.kind available in the link here.

The output of this will be:

col1  col2  col3 col4   col5       col6
0     1   1.0   1.1    a   True 2021-01-01
1     2   2.0   2.1    b   True 2021-01-02
2     3   3.0   3.1    c   True 2021-01-03
3     4   4.0   4.1    d  False 2021-01-04
4     5   5.0   5.1    e  False 2021-01-05
5     6   6.0   6.1    f  False 2021-01-06
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   col1    6 non-null      int64         
 1   col2    6 non-null      float64       
 2   col3    6 non-null      float64       
 3   col4    6 non-null      object        
 4   col5    6 non-null      bool          
 5   col6    6 non-null      datetime64[ns]
dtypes: bool(1), datetime64ns, float64(2), int64(1), object(1)
memory usage: 374.0+ bytes
None
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 6 entries, 0 to 5
Data columns (total 6 columns):
 #   Column  Non-Null Count  Dtype         
---  ------  --------------  -----         
 0   col1    6 non-null      int64         
 1   col2    6 non-null      int64         
 2   col3    6 non-null      float64       
 3   col4    6 non-null      object        
 4   col5    6 non-null      bool          
 5   col6    6 non-null      datetime64[ns]
dtypes: bool(1), datetime64ns, float64(1), int64(2), object(1)
memory usage: 374.0+ bytes
None

Iteritems is returning a tuple, ((123, '1.07'), 1.07) and since you want to loop over each value try the below code. You just need to remove .iteritems() and it will work like a charm.

df['feature2']=[1.07,2.08,'ab',3.04,'cde']
for item in df.feature2:
    if isinstance(item,float):
       print('yes')
    else:
       print('no')

Here is your output:

yes
yes
no
yes
no

You can get the type of the entries of your column with map:

df['ABC'].map(type)

So to filter on all values, which are not stored as str, you can use:

df['ABC'].map(type) != str

If however you just want to check if some of the rows contain a string, that has a special format (like a date), you can check this with a regex like:

df['ABC'].str.match('[0-9]{4}-[0-9]{2}-[0-9]{2}')

But of course, that is no exact date check. E.g. it would also return True for values like 0000-13-91, but this was only meant to give you an idea anyways.

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:

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

Try:

frame[pd.to_numeric(frame.event, errors='coerce').notnull()]

Or even:

frame.query("event != 'None'")

Outputs:

        state  year event
0        Ohio  2000   1.5
2       Texas  2000   3.6
3  Washington  2000   2.4
5      Nevada  2000   3.2