Is using one line loops, even nested loops always a good practice in Python? I see a lot of people just love "one-liners", but to me they're hard to read sometimes, especially if we're talking about nested loops.
Moreover most of nested loops I've seen so far exceed the recommended 79 characters per line.
So I'd like to know if "one-liners" offer anything extra apart being compact? Do they use less memory maybe?
Yes, they may be easily faster, since more code may be run in C (in explicit loop all of immediate steps has to be available to interpreter, in one-liner list comprehension it does not have to). There is also overhead of .append method call, method look-up etc. In list comprehension all of that is avoided:
import timeit
def f1():
result = []
for x in range(100):
for y in range(100):
result.append(x * y)
return result
def f2():
return [x * y for y in range(100) for x in range(100)]
print('loop: ', timeit.timeit(f1, number=1000))
print('oneliner:', timeit.timeit(f2, number=1000))
Results (Python 3):
loop: 1.2545137699926272
oneliner: 0.6745600730064325
Depends on the one-liner, some can be much more efficient and very readable.
Take the case of list comprehension. Lets say you want to take all numbers from 1 to 10 and output a list of their product multiplied by 2.
Input: [1,2,3,...,9,10]
Output: [2,4,6,...,18,20]
You can do it in a for loop like so:
output = []
for i in range(1, 11):
output.append(i*2)
Or you can just use list comprehension:
[i*2 for i in range(1,11)]
You'll see the list comprehension is MUCH faster, and also quite readable.
The same can be said for dict comprehension, set comprehension and generator expressions. Also the use of map() and filter() are highly encouraged as long as it's understandable.
For discussion... they all do the same.
'a' a list comprehension... the smoking one-liner... 'b' same thing, but you can provide annotation within a list comprehension... it is still technically a one-liner 'c' the conventional approach. If speed is a concern, I am less worried about the speed unless, I perform the same task day in day out and it takes a really long time to perform. Comparing speed when you are talking micro or nanoseconds may be of academic interest, but it will not impact the vast majority of users. I always vote for clarity of expression over compactness of code.
a = [i**2 for i in range(20) if i > 5 and i < 10]
b = [i**2 # do this
for i in range(20) # using these
if (i > 5) and # where this and
(i < 10) # this is good
]
c = []
for i in range(20):
if (i > 5) and (i < 10):
c.append(i**2)
EDIT The example given of producing the product of a range of numbers, is a good indicator, that the oneliner need not be the issue, but the method used to obtain the result. I will illustrate with determining the product using only 10 values... try it with 100 if you like. I will do it in full format, but could reduce everything to a oneliner if need (import excluded).
>>> import numpy as np
>>> a = np.arange(10)
>>> b = np.arange(10).reshape(10,1)
>>> a
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> b
array([[0],
[1],
[2],
[3],
[4],
[5],
[6],
[7],
[8],
[9]])
>>> a*b
array([[ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
[ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18],
[ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27],
[ 0, 4, 8, 12, 16, 20, 24, 28, 32, 36],
[ 0, 5, 10, 15, 20, 25, 30, 35, 40, 45],
[ 0, 6, 12, 18, 24, 30, 36, 42, 48, 54],
[ 0, 7, 14, 21, 28, 35, 42, 49, 56, 63],
[ 0, 8, 16, 24, 32, 40, 48, 56, 64, 72],
[ 0, 9, 18, 27, 36, 45, 54, 63, 72, 81]])
or as a one-liner
>>> out = np.arange(10) * np.arange(10).reshape(10,1)
and of course there are built-in functions to do this without the full expression I have shown.
The point being made, speed isn't everything. Clarity of code AND choosing the right tools to do the job should be considered first.
Yes. This is good practice.
Usually experienced programmers use anonymous functions (see, lambda: http://www.secnetix.de/olli/Python/lambda_functions.hawk) in one-line loops and it gives better performance.
