Ruby delivers on the promise of being "optimized for programmer happiness." But I think that in order to experience that you have to become fairly immersed. In fact, some of the best parts seem outright offensive at first (question marks in method names?!). No language is perfect. But once you get past the idiosyncrasies, I honestly do think Ruby feels better. That's pretty esoteric, so I'll try to call out some specifics as well.

I agree with most of what's already been said, but I'll try to add a few things. In order of most to least significance (for me):

The standard library, especially with regard to collection methods. Want to slice/filter/sort/chunk an array/hash in some weird way? Ruby's standard library almost certainly supports it. So many amazing things are built-in across the board.

Not relying on indentation for scoping. It's one of my biggest beefs with Python. Yes, of course, code should be indented properly. But goodness....let my linter enforce that, not the interpreter. I don't love ruby's do/end keywords (I prefer curly-braces), but at least having a visual cue for end-block is a vast improvement over python.

A more consistent interface. Everything is an object, and you invoke methods on those objects. I think [].size just makes more intuitive sense than len([]).

Great readability boosts from things like question-marks or exclamation-points in method names (admittedly that felt gross and wrong at first), trailing if-statements, unless-conditionals, invoking methods without parens (though I only sanction this if not passing args).

A more helpful, less snobby community. 100% just my personal experience, maybe I've just had bad luck with pythonistas.

No __init__.py nonsense. Maybe that's fixed/improved in python3? But I hate it. In fact, I hate any use of dunders...littering the code with unreadable symbols.

Ruby's type system is much simpler and cleaner and allows a smaller and simpler language core. And, you write scripts that don't look like OOP in Ruby just as easily because the default "global" namespace is the body of a default "main" object, which just implements all the usual imperative functions like print, gets, eval, etc. Ruby also allows you to write scripts that don't really look like you're using objects. Ruby people complain about Python's lack of blocks, the difficulty of doing dynamic code generation, the awkwardness of trying to modify existing classes. They complain about these things

You Can Also Check This Link

Python Example

Functions are first-class variables in Python. You can declare a function, pass it around as an object, and overwrite it:

def func(): print "hello"
def another_func(f): f()
another_func(func)

def func2(): print "goodbye"
func = func2

This is a fundamental feature of modern scripting languages. JavaScript and Lua do this, too. Ruby doesn't treat functions this way; naming a function calls it.

Of course, there are ways to do these things in Ruby, but they're not first-class operations. For example, you can wrap a function with Proc.new to treat it as a variable--but then it's no longer a function; it's an object with a "call" method.

Ruby's functions aren't first-class objects

Ruby functions aren't first-class objects. Functions must be wrapped in an object to pass them around; the resulting object can't be treated like a function. Functions can't be assigned in a first-class manner; instead, a function in its container object must be called to modify them.

def func; p "Hello" end
def another_func(f); method(f)[] end
another_func(:func)      # => "Hello"

def func2; print "Goodbye!"
self.class.send(:define_method, :func, method(:func2))
func                     # => "Goodbye!"

method(:func).owner      # => Object
func                     # => "Goodbye!"
self.func                # => "Goodbye!"    

Python and Ruby are both very mature languages with good standard libraries and a huge collection of supporting libraries ("gems" in Ruby parlance). I wouldn't say one has "more" developers than the other, but due to the libraries and communities that have developed around them, you will find their popularity varies in different circles.

In the web development world, Ruby reigns supreme. Projects like Ruby on Rails, Sinatra, and Jekyll are still going strong. Chef, which is used for configuring and managing servers, is Ruby (although you can deploy any kind of server with it, not just Ruby/Rails ones).

I also use Ruby for day-to-day shell scripting as a much nicer alternative to bash.

Python is (was?) huge at Google, and is also very popular within scientific communities due to the good support of mathematical libraries like NumPy, matplotlib, and others (I know much less in this area). Python also has a web framework, Django, which is moderately popular and follows in the footsteps of Rails.

In the end, since you're just learning OOP concepts, either will work totally fine. If you like Ruby, then go for it. You'll be able to transfer the knowledge to other OOP languages quite easily. Ruby also leans heavily on functional concepts, which will aid you when you inevitably pick up functional languages.