Best python style for complex one-liners

Question

I recently wrote a rather ugly looking one-liner, and was wondering if it is better python style to break it up into multiple lines, or leave it as a commented one-liner. I looked in PEP 8, but it did not mention anything about this

This is the code I wrote:

def getlink(url):
 return(urllib.urlopen(url).readlines()[425].split('"')[7])
 # Fetch the page at "url", read the 426th line, split it along
 # quotes, and return the 8th quote delimited section

But would something like this be better style?:

 def getlink(url):
 url_file = urllib.urlopen(url)
 url_data = url_file.readlines()
 line = url_data[425]
 line = line.split('"')
 return line[7]

Or perhaps something in between?

• Kien Truong: Break it up, and add error handling. For example, what happen if there's no network connection.
• Chinmay Kanchi: IMHO, the intent is clearly expressed by the one-liner. I don't see the need to split it up into multiple lines. In fact, in this case, I might go even further and do getlink = lambda url: urllib2.urlopen(url).readlines()[425].split('"'). This of course assumes that no exceptions are generated; if that is a case you want to handle within the function, the broken-up form is better, since you can add appropriate try catch finally blocks.
• Strigoides: @Dikei At the moment, if there is no network connection urllib spits out a socket error. I could add a nicer error message, but that's all it would be; it would exit at the same point.

Answer 1

My vote would be based on readability. I find your one-liner quicker to digest than the multi-line example.

One-liners are great as long as it fits in one eye-ful, and collectively they perform one distinct task.

Personally, I would write that as:

def getlink(url):
 content = urllib.urlopen(url).readlines() 
 return content[425].split('"')[7] 

(Now, venturing into downvote realm...)

Your block of comments is great for someone unfamiliar with Python, but arguably, they reduce readability by increasing the information to digest. A pythonista reading the code would quickly understand your one-liner, and yet may then proceed to read the comments just in case there are caveats or edge cases to be warned of.

I'm not saying comments are evil, just that verbose comments can have a negative effect on readability. E.g. the classic : x+=1 # increment x by 1

Naturally, this is down to the purpose and audience of the code.

• PaulMcG: Instead of just reiterating what the code indexing does, why not insert an example of what content[425] might contain, to show what the 8th section has in it?
• PaulMcG: Nevermind that this looks like one of the most fragile web-scraping scripts I've ever seen!
• Shawn Chin: @Paul I can't agree more about this not being the way to scrape pages. Regarding the inclusion of a snippet of the target line as comments, well it's an improvement but not without its shortcomings - we end up with two sections to edit when the data changes. Change one and not the other, and you end up with a spoonful of confusion.
• Walter: "... as long as it fits in one eye-full..." That is why PEP 8 still recommends limiting line lengths to 79 characters, even in a post-80-column-display world. Therefore the one-liner is still acceptable (and still reads quite easily IMHO), although debugging will likely be harder.

Answer 2

I also find the expression urllib.urlopen(url).readlines()[425].split('"')[7] rather comprehensible.

However, I would prefer:

def getlink(url):
 line425 = urllib.urlopen(url).readlines()[425]
 return line425.split('"')[7]

Answer 3

To me multi-line version is much better. With multi-line code you break up the logic and use variables to store intermediate output. The variable names then allow me to read the logic and see what my output depends on. Also you don't have to write elaborate comments in this case. I find it easier to read the multi-line version after some months than read the single line version in such cases. The example you posted is not complex, but just to keep consistency I would have written your example code in multiple lines.

Answer 4

The multi-line version conveys semantics, which the one-liner makes harder to grasp.

This is how I read it:

 def getlink(url):
 url_file = ...
 url_data = ...
 line = url_data[425]
 ... = ... .split('"')
 return line[7]

Which means I can get the important parts faster and easier, without scrumbling through a long expression mixing:

• general calls to urlopen() and readlines() (obvious for a function called getlink(url))
• and more specific parts (url_data[425] and line[7]).

However, Shawn Chin's version is even easier to read.

• Nicola Musatti: To me it's exactly the opposite. I draw more useful information from reading calls to standard library functions than from an unknown programmer's naming style, however well thought out it might be.
• eyquem: @Nicola Musatti Exactly the same for me.

Answer 5

Your one-liner is not that obscene (at least for my eyes), plus it's a good thing you've added the comments .

When write software, think of yourself in 8 months or so, looking again at this piece of code. It should be as readable then, as you perceive it today .

Answer 6

The multiline version is better Python style. It is easier to read, easier to understand, and easier to modify.

This is Python -- easy is good! :)