By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,190 Members | 802 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,190 IT Pros & Developers. It's quick & easy.

"and" and "or" on every item in a list

P: n/a
GHZ
Is this the best way to test every item in a list?
def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
>>alltrue(lambda x:x>1,[1,2,3])
False
>>>
alltrue(lambda x:x>=1,[1,2,3])
True
>>>
Thanks

Oct 29 '07 #1
Share this Question
Share on Google+
7 Replies


P: n/a
On Oct 29, 3:57 pm, GHZ <geraint.willi...@gmail.comwrote:
Is this the best way to test every item in a list?

def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
>alltrue(lambda x:x>1,[1,2,3])
False
>alltrue(lambda x:x>=1,[1,2,3])
True
In Py2.5, you can use the builtin any() and all() functions.

In Py2.4, use the recipes from the itertools module:

def all(seq, pred=None):
"Returns True if pred(x) is true for every element in the
iterable"
for elem in ifilterfalse(pred, seq):
return False
return True

def any(seq, pred=None):
"Returns True if pred(x) is true for at least one element in the
iterable"
for elem in ifilter(pred, seq):
return True
return False

def no(seq, pred=None):
"Returns True if pred(x) is false for every element in the
iterable"
for elem in ifilter(pred, seq):
return False
return True
Raymond

Oct 29 '07 #2

P: n/a
On Oct 29, 3:57 pm, GHZ <geraint.willi...@gmail.comwrote:
Is this the best way to test every item in a list?

def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
>alltrue(lambda x:x>1,[1,2,3])
False
>alltrue(lambda x:x>=1,[1,2,3])
True

Thanks
If you are using python 2.5 the best way would be something like this:
>>all(x 1 for x in [1,2,3])
False
>>any(x 1 for x in [1,2,3])
True

If you are using an earlier version you are still discouraged from
using reduce in place of a more readable construct. In most cases list
comprehension is encouraged over map also.

If `all' and `any' aren't defined you can use something like the
following. One advantage of these over what you posted is that they
will return as soon as an exit condition is reached as opposed to
processing the entire list.
Expand|Select|Wrap|Line Numbers
  1. if not all:
  2. def all(seq):
  3. for val in seq:
  4. if not val:
  5. return False
  6. return True
  7.  
  8. if not any:
  9. def any(seq):
  10. for val in seq:
  11. if val:
  12. return True
  13. return False
  14.  
Matt

Oct 29 '07 #3

P: n/a
On Oct 29, 6:57 pm, GHZ <geraint.willi...@gmail.comwrote:
Is this the best way to test every item in a list?

def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
Probably not, because it doesn't take advantage of short circuiting.
You could bail out of alltrue as soon as the first item you see is
false, but your version applies f to every item in the list. I would
suggest the most straightforear way is the best:

def alltrue(f,l):
for item in l:
if not f(item):
return False
return True
On Python 2.5, you could do this:

all(f(x) for x in l)
Carl Banks

Oct 29 '07 #4

P: n/a
On Oct 29, 10:57 pm, GHZ <geraint.willi...@gmail.comwrote:
Is this the best way to test every item in a list?

def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
No. In Python 2.5 there are builtins 'all' and 'any' that do exactly
these. If you're using python <2.5, then you can support shortcut
evaluation - there's no need to check every element once you find a
false in 'all' or a true in 'any'.

--
Paul Hankin

Oct 29 '07 #5

P: n/a
Is this the best way to test every item in a list?
>
def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
>>>alltrue(lambda x:x>1,[1,2,3])
False
>>>alltrue(lambda x:x>=1,[1,2,3])
True
As of Python2.5, there's an any() and all() function built into
the language.
>>any(map(lambda x: x>1, [1,2,3]))
all(map(lambda x: x>1, [1,2,3]))
Implementations for older versions are given at

http://docs.python.org/lib/built-in-funcs.html

You can adjust the "if" test in the example code so that it calls
your function...something like

def my_any(f, iterable):
for element in iterable:
if f(element):
return True
return False

def my_all(f, iterable):
for element in iterable:
if not f(element):
return False
return True

The advantage of the code in the docs is that it
short-circuits...there's no need to reduce the entire list if an
early item triggers the condition (a "true" early in an "any" or
a "false" early in an "all").

While you can use a reduce(bool.__and__, thing) call, I more
frequently see it as reduce(operator.or_, thing)

Just a few ideas,

-tkc

Oct 29 '07 #6

P: n/a
On Oct 29, 5:57 pm, GHZ <geraint.willi...@gmail.comwrote:
Is this the best way to test every item in a list?
No.

The biggest problem is, obviously, you don't take advantage of
builtins any() and all(), or write corresponding short-circuiting
versions for python versions before 2.5.

The second problem is you build an entire list that gets disposed of
just as quickly. The third problem is you use lambda, which makes your
call to map() time inefficient as well as space inefficient. Both of
these problems can be fixed by using generator expressions.
def alltrue(f,l):
return reduce(bool.__and__,map(f,l))

def onetrue(f,l):
return reduce(bool.__or__,map(f,l))
>alltrue(lambda x:x>1,[1,2,3])
False
>>all(x>1 for x in [1,2,3])
False
>alltrue(lambda x:x>=1,[1,2,3])
True
>>all(x>=1 for x in [1,2,3])
True
Thanks
HTH

Oct 30 '07 #7

P: n/a
GHZ
Thanks for the answers, I suspected something like any(), all()
existed. Also got me thinking about generator expressions, my code is
full of list comprehensions for lists I don't keep.

Oct 30 '07 #8

This discussion thread is closed

Replies have been disabled for this discussion.