I've used both a fair bit. They are similar in many ways so it's mostly a matter of preference.
I've found Ruby makes it easy to explore objects and see what can be done with them. The consistent OO model makes it easy to perform concise data manipulation. Here's a quick example:
irb(main):001:0> arr = ["1", "2", "3", "4"]
=> ["1", "2", "3", "4"]
irb(main):002:0> arr.methods - Object.methods
=> [:to_a, :to_ary, :[], :[]=, :at, :fetch, :first, :last, :concat, :>>, :push, :pop, :shift, :unshift, :insert, :each, :each_index, :reverse_each, :length, :size, :empty?, :find_index, :index, :rindex, :join, :reverse, :reverse!, :rotate, :rotate!, :sort, :sort!, :sort_by!, :collect, :collect!, :map, :map!, :select, :select!, :keep_if, :values_at, :delete, :delete_at, :delete_if, :reject, :reject!, :zip, :transpose, :replace, :clear, :fill, :slice, :slice!, :assoc, :rassoc, :+, :*, :-, :&, :|, :uniq, :uniq!, :compact, :compact!, :flatten, :flatten!, :count, :shuffle!, :shuffle, :sample, :cycle, :permutation, :combination, :repeated_permutation, :repeated_combination, :product, :take, :take_while, :drop, :drop_while, :bsearch, :pack, :entries, :sort_by, :grep, :find, :detect, :find_all, :flat_map, :collect_concat, :inject, :reduce, :partition, :group_by, :all?, :any?, :one?, :none?, :min, :max, :minmax, :min_by, :max_by, :minmax_by, :member?, :each_with_index, :each_entry, :each_slice, :each_cons, :each_with_object, :chunk, :slice_before, :lazy]
irb(main):003:0> arr.pop
=> "4"
irb(main):004:0> arr.join
=> "123"
irb(main):005:0> arr.map { |i| i.to_i }
=> [1, 2, 3]
irb(main):006:0> arr.map(&:to_i).reduce(&:+)
=> 6
Here's the same thing in Python:
In [1]: arr = ["1", "2", "3", "4"]
In [2]: dir(arr)
Out[2]:
[(stuff removed, fucking lameness filter) 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
In [3]: arr.pop()
Out[3]: '4'
OK, it's pretty similar so far, but then we want to join the array. OO came late to Python, so while some things are implemented as methods on the array, a lot of things are functions which operate on an array. As such, they don't appear on the list above. Bizarrely, it's a method on string acting as a function on an array:
In [4]: "".join(arr)
Out[4]: '123'
Perhaps that's intuitive to someone, but to me, they took join which is a natural thing to do to an array and put it somewhere else so I had to look it up in the docs.
The list comprehension handles the simple mapping okay:
In [5]: [int(i) for i in arr]
Out[5]: [1, 2, 3]
But the map-reduce example gets messy:
In [6]: reduce(lambda x, y: x+y, map(int, arr), 0)
Out[6]: 6
Speaking of lambdas, Ruby makes this convenient:
irb(main):001:0> def retry_loop(tries)
irb(main):002:1> yield
irb(main):003:1> rescue
irb(main):004:1> retry if (tries -= 1) > 0
irb(main):005:1> end
=> nil
irb(main):006:0> retry_loop(3) { puts "failing"; raise }
failing
failing
failing
=> nil
irb(main):007:0> retry_loop(3) { puts "succeeding" }
succeeding
=> nil
Doing this in Python is miserable: http://code.activestate.com/recipes/578163-retry-loop/
Another difference is namespacing. Ruby imports libraries as classes or extensions to classes. Python imports them selectively into the global namespace. Python's finer grained control helps mitigate the collisions this causes, but it means that every Python script has to start with a long list of imports. Ruby can include a lot by default because all the additions are neatly contained in a class.
Python's docs are verbose and comprehensive, like a full manual. Ruby's docs tend to be concise and somewhat incomplete, like a reference guide. Take a read through these and see how long it takes you to figure out how to simply start a thread in each language:
http://docs.python.org/3/library/threading.html
http://www.ruby-doc.org/core-2.1.0/Thread.html
Both styles have their place, but I like that I can get the reference guide by just googling a feature. Python doesn't really have the short form. On the other hand, the full manual for Ruby will set you back $28: http://pragprog.com/book/ruby4/programming-ruby-1-9-2-0
Python has a thing: "There should be one -- and preferably only one -- obvious way to do it". This is a good philosophy to keep the language clean, but sometimes it means they don't provide some functionality since it's supposed to be obvious how to do it yourself. And thus, it's self-defeating: http://tomayko.com/writings/cleanest-python-find-in-list-function . In Ruby, it's simple:
irb(main):007:0> arr.grep(/[12]/)
=> ["1", "2"]
irb(main):008:0> arr.grep(/[12]/).first
=> "1"
And having simple things BE simple makes it really easy to go exploring. Hey look, here are all the methods on an array which return a boolean, or which cast it to another class:
irb(main):014:0> arr.methods.grep(/\?/)
=> [:frozen?, :eql?, :empty?, :include?, :all?, :any?, :one?, :none?, :member?, :nil?, :tainted?, :untrusted?, :instance_variable_defined?, :instance_of?, :kind_of?, :is_a?, :respond_to?, :equal?]
irb(main):015:0> arr.methods.grep(/to_/)
=> [:to_s, :to_a, :to_ary, :psych_to_yaml, :to_yaml, :to_yaml_properties, :to_enum]
I could go on, but perhaps this gives you some idea. I'm focusing a lot on where I think Ruby has things right (since you asked), but they're both well designed languages with many similarities. Ruby is a carefully self-consistent language which encourages concise but semantic style. Python is an evolved and quite complete language which encourages verbose but readable style.
I personally find Ruby cleaner, easier to navigate, and more intuitive, and the docs are easier to read. For me that makes it faster, more fun, and less frustrating. YMMV.
