I much prefer Python's argument-passing to Perl's barely-there conventions. Python gives me positional arguments, named arguments, named positional arguments, required arguments, and default values. Perl gives me @_. I can, of course, build almost everything that Python gives me using @_, but I'd rather not have to do it all.

For example, I can write:

def frobnicate(a, b, snozz=True):
pass

frobnicate(1, 2)
frobnicate(a=1, b=2)
frobnicate(1, 2, False)
frobnicate(1, 2, snozz=False)
frobnicate(1) # Error, need to pass at least two args.
frobnicate(1, 2, snooze=False) # Error, no such argument.

I'm certain there's a "Modern" Perl module that will help with doing this sort of thing, but it's nice to have it there in the language. Back when I wrote a lot of Perl, I'd always end up with something like this:

sub frobnicate {
my($a, $b, %args) = @_;
$args{snozz} //= 1;
}

frobnicate(1, 2);
frobnicate(1, 2, snozz => 0);

Of course, this doesn't include any of the basic error checking I get for free in Python.

I like having OO support in the language syntax. Yes, Perl has Moose now, but the blending of packages and classes is still there. In Python, I can declare a new class with just a couple lines of code; even a minimal Moose class declaration takes substantially more. For example:

class XPathError(Exception):
"""Base exception class for all XPath exceptions."""

Two lines of code to get a useful class.

That, of course, ties into one of Perl's big weaknesses, which is exception handling. I know that there are modules which try to patch over Perl's very weak exception handling model, but again, Python is just so much better. What's the Perl equivalent of this?

try:
x = int(s)
except ValueError:
x = 42

Perl's core still uses strings for exceptions, which is just horribly fragile and painful to deal with. Python has solid, pervasive exception handling with exceptions defined as objects in a sane and simple hierarchy.

I like the fact that people understand Python. I was a pretty good Perl coder, back in the day, and I like to think I had a quite deep understanding of the language. The problem was that I kept dealing with code written by people who didn't. To some degree, this is a problem in any language, but Perl contains so many traps and pitfalls for the unwary.

Consider context. I understand the difference between scalar context and list context. I understand why the following two lines of code are equivalent:

foo(1, 2, 3, 4, 5, 6);
foo(1, (2, 3, (4), ((((5))))), 6);

I understand when the above lines aren't equivalent.

But entirely too many people don't understand this. And, in my opinion, they shouldn't have to. I've never once missed list flattening in Python.

Perl is big and complicated and powerful. Some of that complexity is wonderful, but I find that I don't really miss any of it. Python isn't as big, and it isn't as complicated, but it's just as powerful for me.

I haven't missed CPAN. It's a wonderful collection of code, but Python's PyPi (formerly the cheeseshop) is also wonderful. We could quibble about what packages are available for each language or the technical details of CPAN vs. PyPi, but let's just say that I'm happy with both.

I could go on.

Let's just say, however, that I've found there's nothing in Perl that I can't do faster, easier, or more maintainably in Python. Oh, there's the occasional area where I take a couple lines more code to do something in Python. There's also the occasional area where I take a couple lines less. But, overall, things just feel cleaner to me in Python.

I used to love Perl unreservedly, but I've been over it for some time now. When I go back, the idiosyncrasies that I once found charming just annoy me. I've moved on.

You still like Perl, and that's fine. I hope I've given you some sense, however, of why some of us prefer other languages.