Learning fundamental differences between functional programming and Object Oriented Programming I've been trying to learn the differences between Functional Programming and OOP, but I can't seem to find a comparison of the two.

A Google search did not yield any chart or table showing such a comparison.

From the unclear Google search, however, I have come up with this:
OOP keeps actions and data encapsulated in objects, Functional Programming separates the two.

But that doesn't actually give a useful comparison of the usecases for each one.

So, my question is where might I find a thorough comparison between the two, which can explain which should be used for some kinds of tasks\projects? I'm looking for some explanation\comparison of various aspects of these paradigms.

The types of projects or tasks I am referring to are varied, but can be classified into: Computer Management (similar to what userscripts allow in browsers) and Utilities (units conversion, custom shell). 

(off site resources are considered an answer, as well as answers giving such a comparison without an off site resource)
There are beautiful answers to this question already here, and I will not try to reiterate any of the ground that has already been covered.  However, something important that I have not seen here so far is that comparing OOP to FP is not actually terribly meaningful.  It's a bit like comparing glass (the material) to tables (the furniture).  They each have properties that can be explored, but even if discussions of these properties can help you learn about them, the comparison itself doesn't actually tell you much about either.  Glass tables exist, and have the properties of both.  Similarly, Scala, Clojure, and Swift are languages that are both functional and OO.

A more meaningful comparison for functional programming is imperative programming.  The most popular languages in the world right now are all imperative1.  Imperative languages focus on mutable values and states, and are historically based on Turing Machines.  Functional languages are all about function calls and immutable constants, and are historically based on Church's $\lambda$-Calculus.  

The two mathematical systems were developed around the same time in order to solve the same question: what is fundamentally computable?  The Church-Turing Thesis, which was published before electronic computers existed, proved that the two systems were equally powerful, and further hypothesized that they could both compute any computable function, and that any sufficiently complex system could embody exactly this same computability power.

A more meaningful comparison for Object-Oriented programming would be... well, nothing.  The Object-Oriented philosophy, which is about grouping data with functions that govern that data, can be applied to any programming paradigm.  Object-Oriented programming is all about the scope and membership of functions and data.  It doesn't matter if the data is mutable, if the order of operations is defined, how data is stored, whether functions are mutable... if we are creating instances of data that are bundled with their own functions, the we have the kernel of object-oriented programming.

1 - Only if you discount Excel, which is actually a light functional programming language, and is almost certainly used by many more people than any other programming language on earth.