Loops and Iterators



<p>List comprehensions</p>

{{{id=0|
[ i^2 for i in [1, 3, 7] ]
///
[1, 9, 49]
}}}

{{{id=1|
[ i^2 for i in range(1,10) ]
///
[1, 4, 9, 16, 25, 36, 49, 64, 81]
}}}

{{{id=2|
[ i^2 for i in range(1,10) if not is_prime(i) ]
///
[4, 9, 25, 49]
}}}

{{{id=3|
[ (i,j) for i in range(1,6) for j in range(1,i) ]
///
[(2, 1), (3, 1), (3, 2), (4, 1), (4, 2), (4, 3), (5, 1), (5, 2), (5, 3), (5, 4)]
}}}

{{{id=4|
[ [ binomial(n, i) for i in range(n+1) ] for n in range(10) ]
///
[[1],[1, 1],[1, 2, 1],[1, 3, 3, 1],[1, 4, 6, 4, 1],[1, 5, 10, 10, 5, 1],[1, 6, 15, 20, 15, 6, 1],[1, 7, 21, 35, 35, 21, 7, 1],[1, 8, 28, 56, 70, 56, 28, 8, 1],[1, 9, 36, 84, 126, 126, 84, 36, 9, 1]]Iterators ::
}}}

{{{id=5|
it = (binomial(8, i) for i in range(9))
it.next()
///
1
}}}

{{{id=6|
it.next()
///
8
}}}

{{{id=7|
sum( [ binomial(8, i) for i in range(9) ] )
///
256
}}}

{{{id=8|
sum( binomial(8, i) for i in xrange(9) )
///
256
}}}

<p>Typical uses of iterators:</p>

{{{id=9|
all([True, True, True, True])
///
True
}}}

{{{id=10|
all([True, False, True, True])
///
False
}}}

{{{id=11|
any([False, False, False, False])
///
False
}}}

{{{id=12|
any([False, False, True, False])
///
True
}}}

{{{id=13|
all( is_odd(p) for p in range(1,100) if is_prime(p) and p&gt;2 )
///
True
}}}

{{{id=14|
def mersenne(p): return 2^p -1
[ is_prime(p) for p in range(20) if is_prime(mersenne(p)) ]
///
[True, True, True, True, True, True, True, True]
}}}

{{{id=15|
all( is_prime(mersenne(p)) for p in range(1000) if is_prime(p) )
///
False
}}}

{{{id=16|
all( [ is_prime(mersenne(p)) for p in range(1000) if is_prime(p)] )
///
False
}}}

{{{id=17|
exists( (p for p in range(1000) if is_prime(p)), lambda p: not is_prime(mersenne(p)) )
///
}}}

{{{id=18|
contre_exemples = (p for p in range(1000) if is_prime(p) and not is_prime(mersenne(p)))
contre_exemples.next()
///
}}}

{{{id=19|
cubes = [t**3 for t in range(-10,11)]
exists([(x,y) for x in cubes for y in cubes], lambda (x,y): x+y == 218)
///
}}}

{{{id=20|
exists(((x,y) for x in cubes for y in cubes), lambda (x,y): x+y == 218)
///
}}}

<p>complexite memoire?</p>
<p>itertools:</p>

{{{id=21|
import itertools
///
}}}

{{{id=22|
[(i, cubes[i]) for i in range(len(cubes))]
///
}}}

{{{id=23|
list(enumerate(cubes))
///
}}}

{{{id=24|
list(Permutations(3))
///
}}}

{{{id=25|
list(itertools.islice(Permutations(3), 1, 4))
///
}}}

{{{id=26|
list(itertools.imap(lambda z: z.cycle_type(), Permutations(3)))
///
}}}

{{{id=27|
list(itertools.ifilter(lambda z: z.has_pattern([1,2]), Permutations(3)))
///
}}}

<p>Defining new iterators:</p>

{{{id=28|
def f(n):
     for i in range(n):
         yield i
[ x for x in f(5) ]
///
[0, 1, 2, 3, 4]
}}}

{{{id=29|
def words(alphabet,l):
      if l == 0:
          yield []
      else:
          for word in words(alphabet, l-1):
              for a in alphabet:
                  yield word + [a]
///
}}}

{{{id=30|
[ w for w in words(['a','b','c'], 3) ]
///
}}}

{{{id=31|
sum(1 for w in words(['a','b','c'], 3))
///
}}}

{{{id=32|
def dyck_words(l):
       if l==0:
           yield ''
       else:
           for k in range(l):
               for w1 in dyck_words(k):
                   for w2 in dyck_words(l-k-1):
                       yield '('+w1+')'+w2
///
}}}

{{{id=33|
list(dyck_words(4))
///
['()()()()','()()(())','()(())()','()(()())','()((()))','(())()()','(())(())','(()())()','((()))()','(()()())','(()(()))','((())())','((()()))','(((())))']
}}}

{{{id=34|
sum(1 for w in dyck_words(5))
///
42
}}}

<p>Standard Iterables:</p>

{{{id=35|
sum( x^len(s) for s in Subsets(8) )
///
x^8 + 8*x^7 + 28*x^6 + 56*x^5 + 70*x^4 + 56*x^3 + 28*x^2 + 8*x + 1
}}}

{{{id=36|
sum( x^p.length() for p in Permutations(3) )
///
}}}

{{{id=37|
factor(sum( x^p.length() for p in Permutations(3) ))
///
}}}

{{{id=38|
P = Permutations(5)
all( p in P for p in P )
///
True
}}}

{{{id=39|
for p in GL(2, 2): print p; print
///
}}}

{{{id=40|
for p in Partitions(3): print p
///
}}}

{{{id=41|
for p in Partitions(): print p
///
}}}

{{{id=42|
for p in Primes(): print p
///
}}}

{{{id=43|
exists( Primes(), lambda p: not is_prime(mersenne(p)) )
///
(True, 11)
}}}

{{{id=44|
contre_exemples = (p for p in Primes() if not is_prime(mersenne(p)))
contre_exemples.next()
///
11
}}}

