A first approximative intuition is to think of Functors as containers (or more like a context) and of fmap as a way to apply a transformation function of your choice on the contained value, respecting the signification of that context.
For example, Maybe represents the possibility of having or not having a value, therefore, fmap will apply your transformation on that value if it exists, otherwise you're still left with nothing.
This example might seem straight forward but it had to be defined somewhere, thus, made possible by the Functor instance implementation for the type Maybe.
Let's have a look at it:
fmap :: Functor f => (a -> b) -> f a -> f b
Specialized:
fmap ~ (a -> b) -> Maybe a -> Maybe b
And concretize further:
fmap ~ Num n => (n -> n) -> Maybe n -> Maybe n
As you can see, given a transformation function and maybe some numeral, you'll get maybe another numeral.
The implementation lools like this:
fmap f (Just n) = Just (f n)
fmap f Nothing = Nothing
Thus, starting with Nothing, we cannot apply our tranformation so you stay with Nothing. Similarly, with Just n, we're able to pattern match to obtain that n, apply our transformation f on that n, and then rewrap everything back into Just.
You can see how the value cannot escape its container / context.
Of course there are more complex such containers / context.
Either represents a choice between two values. [] contains multiple values, IO contains (side-)effects, and so on.
Hope this helps.
nitrix