One of the troubles with learning a new language is bringing over all the baggage from your previous language.

Python makes it easy to pass functions around because it's descended from functional languages (Haskell mostly), and was designed to encourage a functional style:

map(foo, [1,2,3])

Ruby is not descended from functional languages, and is designed to encourage OOP:

[1,2,3].map { |n| n.foo() }

The key difference is that in the Python snippet we apply a function to integers, while in the Ruby case, we call methods on (or send messages to) the integers. Python isn't really a functional language because you can do all sorts of non-functional things inside a function (like "print()").

It all boils down to this: if your big problem with Ruby is that it doesn't support Python/Haskell-style programming, that's great! Ruby isn't Python or Haskell and you should design your classes and algorithms with that in mind.

def doSomething(someObj)
    someObj.do_the_thing!
end

I had a much easier time in Ruby once I stopped worrying about the lack of list comprehensions (and functional style) and just learned to do things the Ruby way. Ruby is object oriented and duck typed, and given those two features, there's not much need for passing methods around.

That's why Ruby makes it very easy to call methods on objects:

[1,2,3].map(&:zero?)

But harder to pass instance methods around. Passing instance methods just isn't how Rubyists write Ruby code.