As some of you may know, I’m a huge perl person. I’ve written a lot of it, and I know it very well. That’s not to say there aren’t people who know it better than I do, but I know it well.<\/p>\n
Now, while I’m a big Perl fan, it’s worth noting I’m well aware of Perl’s flaws: a poor OO model, poor (or some might argue non-existent) exception handling, and some very dangerous implicitness to name a few.<\/p>\n
So, recently, I decided to give both Ruby and Python a shot. Now, I’ve looked at python a few times – but the whole whitespace-means-stuff thing really turned me off. Explicit blocking is a good thing. As such, I never really looked far enough past that to give it a fair chance. So I decided it was time to give python a fair shot.<\/p>\n
After playing with it for a while and writing a few small scripts and then rewriting them, I found the following really disheartening things. But just to make sure I wasn’t just expecting python to act like Perl, I ran them by a friend of mine who’s a big python guy, and he admitted not being thrilled with these aspects of the language either.<\/p>\n
So here you are – a day in Python from a Perl guy.<\/p>\n
The string’s split function uses regexes but doesn’t support them<\/strong><\/p>\n If I have a string object and I call it’s split() method with no argument, it automatically splits on the regex returns the expected 3-element array returns the single-element array I get, This code will return the desired 3-element array Or better yet, why can’t the re<\/em> class extend or overload the string class’s split() method to type-check and use its own method if it’s a regex or the original method if its a string? There’s several ways to make this intuitive or consistent, but none of them appear to be implemented as far as I can tell.<\/p>\n What happened to constructors?<\/strong><\/p>\n Speaking of regexes, it seems cumbersome to require the programmer to call the compile() method when creating a regex object. When instantiating a regex object, clearly I want to make a regex, so why doesn’t the constructor take the string and “compile” the regex? It’s not clear to me that this concept even exists in python. That would be a shame.<\/p>\n I am OO, I’m not OO, I am OO, I’m not OO…<\/strong><\/p>\n Python touts itself has having done OO better than Perl (this isn’t hard), and as being an OO language at its core instead of as a bolt-on. So if I have a string that contains simply an integer, one would expect some method to get an int object out of it. For example, if I have A global function to cast<\/em> to another type. Yeah, that’s OO. By the way, there’s no OO method for doing addition either (while I find those ugly, it would at least be consistent). There’s objects and types and global functions and in most cases things are objects, but not in others. This is a Perl problem Python was trying to get away from.<\/p>\n Poor interpreter errors<\/strong><\/p>\n One of the great things about interpreted languages is that an interpreter is around at run-time and as such, has more data and can hopefully provide better error messages. There are far less of those fun cryptic compiler and linker errors. So, I’d expect python to be able to tell me something simple like “you forgot to declare a variable.” Take this code:<\/p>\n Not very useful code, but easy enough to read. There’s a problem though – I haven’t declared the dictionary (that’s a hash or an associative array for those of you not familiar with python nomenclature) variable That’s not a type error; that’s an undeclared variable! This code works fine:<\/p>\n It’s perfectly reasonable to require variables be declared, but then your interpreter should be able to error when they’re not!<\/p>\n None of these are show-stopping. None of them are evil. But it’s a large number of fairly annoying things to hit within your first half-hour with a language and not find some really good explanation within the first day. No language is perfect; and Python seems to have a lot of strengths. I’m continuing to play with it and with Ruby; we’ll see how it goes.<\/p>\n","protected":false},"excerpt":{"rendered":" As some of you may know, I’m a huge perl person. I’ve written a lot of it, and I know it very well. That’s not to say there aren’t people who know it better than I do, but I know it well. Now, while I’m a big Perl fan, it’s worth noting I’m well aware […]<\/p>\n","protected":false},"author":2,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[5],"tags":[],"_links":{"self":[{"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=\/wp\/v2\/posts\/82"}],"collection":[{"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=82"}],"version-history":[{"count":0,"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=\/wp\/v2\/posts\/82\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=82"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=82"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.phildev.net\/phil\/blog\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=82"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}\\s+<\/code>. However, the method only takes strings as parameters. Which means you can’t even pass in \\s+<\/code> as an argument. OK, well you can, but only if you want to match the literal string ‘\\s+’. So, this code:<\/p>\n\nfoo = 'b a r'\nprint foo.split()\n<\/pre>\n
['b', 'a', 'r']<\/code>, but this code:<\/p>\n\nfoo = 'b a r'\nprint foo.split('\\s+')\n<\/pre>\n['b a r']<\/code>. Doing foo.split(\/\\s+\/)<\/code> as a ruby-coder might try is a syntax error and foo.split(\\s+)<\/code> is as well. But alas, we look through python.org\/docs to find – aha! there’s a regex class! Sadly, you cannot pass a regex object to string’s split() method. This code’s last line is a syntax error:<\/p>\n\nimport re\np = re.compile('\\s+')\nfoo = 'b a r'\nprint foo.split(p)\n<\/pre>\nTypeError: expected a character buffer object<\/code>. The way to actually do this is completely counter-intuitive, you can’t use the string’s split() method, you must use the regex’s split() method, and pass the string in:<\/p>\n\nimport re\np = re.compile('\\s+')\nfoo = 'b a r'\nprint p.split(foo)\n<\/pre>\n['b', 'a', 'r']<\/code>. So, why wouldn’t the string function do a type-check on it’s parameter so you can pass in a regex object?<\/p>\nfoo = \"1\"<\/code> and want to do a mathematical operation on it (add 4 and get 5 as a result), one would expect something like foo.int()<\/code> or foo.atoi()<\/code> or foo.toint()<\/code> to exist. Instead there are global functions. Global functions<\/em>? In an object-oriented language<\/em>? Yup, this is the code you’d be looking for:<\/p>\n\nfoo = \"1\"\nbar = int(foo)\nprint bar + 5\n<\/pre>\n
\nfor x in range(10):\nhash['foo'] = 'bar'\n<\/pre>\n
hash<\/code> when I attempt to assign to its foo<\/code> index. But instead python tells me I have a type mis-match:<\/p>\n\nTraceback (most recent call last):\nFile \"<stdin>\", line 2, in ?\nTypeError: object does not support item assignment\n<\/pre>\n
\nhash = {}\nfor x in range(10):\nhash['foo'] = 'bar'\n<\/pre>\n