Why is an integer not considered as a real?

Question

Please consider the following:

zeros={0.,0};   
data={1, 0., 0}; 
DeleteCases[data, #]&/@zeros
Head/@zeros
(*{Real, Integer}*)
(*{{1, 0}, {1, 0.}}*)

For my understanding all integers (e.g. 0, 2) are element of the real numbers (e.g. 0.00000, 2.00000). So why would Mathematica not delete all zeros form data.

I know from here that one can solve the DeleteCases-problem via DeleteCases[Rationalize@data,0] but this is not the point here.

EDIT

The following test may explain my problem slightly better:

sets={Integers,Reals,Complexes};
test=Table[Element[j, i], {i, sets}, {j, zeros}];
(*{{False, True}, {True, True}, {True, True}}*)

test returns as expected that 0 is element of Integers, Reals and Complexes for which reason I would expect for DeleteCases[data, #]&/@zeros the following result:

{{1}, {1, 0.}}

For the latter 0. can not be deleted from data because I called delete all 0-Integers whereas in the first case all zeros can be deleted as I called delete all 0-Reals.

Note: Instead of 0 and 0. we could use also 2 and 2.. The value does not matter.

Answer 1

Element (of) is a mathematical operation, which is why it (correctly) says that 0 is an element of Integers, Reals and Complexes. However, $0.$ is a floating point representation of zero and is not an exact integer, hence it returns False for Element[0., Integer]. On the other hand, 0. certainly is an element of Reals, and by extension, an element of Complexes which is a superset of Reals, which is why it returns True for both these cases.

DeleteCases uses pattern matching and relies on the heads (or the FullForm) and does not do a mathematical comparison, which is why DeleteCases[list, 0] will not remove instances of 0. in list. The solution in this case is to either use 0 | 0. as the pattern, or use PossibleZeroQ to test the elements of list:

DeleteCases[data, _?PossibleZeroQ]
(* {1} *)

The difference between mathematical operations and the pattern matching logic is something you need to get comfortable with in order to use Mathematica effectively. Another example of a common mistake is to use pattern matching to perform algebraic manipulations.

Answer 2

DeleteCases uses the pattern matcher which matches against the FullForm of expressions. Just use Alternative:

In[]:= DeleteCases[{1, 0., 0}, 0. | 0]
Out[]= {1}

or a conditional pattern

In[]:= DeleteCases[{1, 0., 0}, _?(# == 0 &)]
Out[]= {1}

or

In[]:= DeleteCases[{1, 0., 0}, x_ /; x==0]
Out[]= {1}

This happens a lot with infinity be careful of the heads: Infinity // FullForm is DirectedInfinity[1]