Python and Ruby implement very similar models, and have similarly powerful libraries and communities. The biggest distinction is in syntax. That said, Ruby does have several syntactic features which make dynamic extension of high-order interaction with external code (e.g., libraries) more straightforward, such as:
Blocks. They allow arbitrary, multi-line closures to be cleanly passed in-line anywhere. Python has two syntaxes for in-line closures: lambdas and nested def statements. Lambdas are equivalent to Ruby blocks, but they can only easily express a single expression, not multiple nested statements, leaving nested def statements -- which are statements, not expressions, and cannot be used in-line.
Mix-ins. They allow imported classes and modules to be extended and overridden by user code after it is imported. Python's runtime model is dynamic enough to inject new or altered methods and fields into an external class or object, but the syntax is procedural rather than declarative and identical to the standard class definition syntax.
Despite that, most everything that can be implemented in blocks and mix-ins, is also achievable with Python. It just isn't as syntactically natural, and thus not commonly used in major libraries. So, Ruby does allow for more transparent use of metaprogramming, but that's a double-edge sword.
Personally, I prefer Python. It's my language of choice for most projects.
Guido recognized the fact that you'll spend a lot more time reading code than writing it, and focuses on guiding developers to write readable code. Yes, that's opinionated, but I don't see that as a negative. There's one way to do something in Python, if you want to write Pythonic code.
Not a huge fan of Ruby's syntax, it's looks like half-baked Perl at times. Do I have to use parentheses here, or wait, do I only have to use them when doing X? It also doesn't help there's several expressions that are all equivalent. In other words, there's more than one way to achieve the same result. Again, half-baked Perl. This is what people mean when they say Ruby is expressive, but Python is far more readable. Being clever doesn't exactly make for easily readable and maintainable code.
Which brings me to monkey patching (that double-edge sword). It used to be heavily encouraged within the Ruby community, though not so much anymore; however, I still run across it often enough to make me cringe. It makes upgrading libraries, and maintaining other people's code, in general, a nightmare. There's so much magic going on at times, that it's sometimes not trivial to understand where and how your code is actually running.
A few other reasons I'm not a big Ruby fan: no tail call optimization -- you'll exceed stack depth far faster than in Python (which is impressive, but not in a good way); can't right associate operators (well, there's the coerce method, but then all your operators are commutative); mutable strings.
Also, as others have pointed out, that infographic isn't entirely accurate as well. For example, Ruby doesn't adhere to the principle of least astonishment, as evidenced by its object model.
