In [ ]:

    

# recursion or looping
# for,do..while,while..do,foreach,until - for other languages
# for,while
# for is a finite loop and while is infinite.
# for/while both work on a sequence.


    

In [1]:

    

# my_string
my_string = "python"

for value in my_string:
    print value


    

    




p
y
t
h
o
n

In [2]:

    

# a list/tuple of trainings
my_trainings = ['perl','shell','linux','python']

for training in my_trainings:
    print training


    

    




perl
shell
linux
python

In [3]:

    

# numbers
print help(range)


    

    




Help on built-in function range in module __builtin__:

range(...)
    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers
    
    Return a list containing an arithmetic progression of integers.
    range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
    When step is given, it specifies the increment (or decrement).
    For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
    These are exactly the valid indices for a list of 4 elements.

None

In [8]:

    

print range(5) # 0 till 5
print range(1,5) # 1 till 5
# for((i=1;i<=10;i++))
print range(1,11,1) # 1 til 11 with a step of 1.
# for((i=1;i<=10;i+2))
print range(1,11,2) # 1 til 11 with a step of 2.


    

    




[0, 1, 2, 3, 4]
[1, 2, 3, 4]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 3, 5, 7, 9]

In [9]:

    

for value in range(1,11,1):
    print value


    

    




1
2
3
4
5
6
7
8
9
10

In [10]:

    

# how for loop works
print help(iter)


    

    




Help on built-in function iter in module __builtin__:

iter(...)
    iter(collection) -> iterator
    iter(callable, sentinel) -> iterator
    
    Get an iterator from an object.  In the first form, the argument must
    supply its own iterator, or be a sequence.
    In the second form, the callable is called until it returns the sentinel.

None

In [11]:

    

m = iter(range(5))
print m,type(m)


    

    




<listiterator object at 0x7ff60f7f78d0> <type 'listiterator'>

In [12]:

    

print m.next()


    

    




0

In [13]:

    

print m.next()


    

    




1

In [14]:

    

print m.next()


    

    




2

In [15]:

    

print m.next()


    

    




3

In [16]:

    

print m.next()


    

    




4

In [17]:

    

print m.next()


    

    




---------------------------------------------------------------------------
StopIteration                             Traceback (most recent call last)
<ipython-input-17-6ecd064bb0a6> in <module>()
----> 1 print m.next()

StopIteration: 

In [18]:

    

# iterator and generator
# iterator - range
# generator - xrange

print help(range)
print help(xrange)


    

    




Help on built-in function range in module __builtin__:

range(...)
    range(stop) -> list of integers
    range(start, stop[, step]) -> list of integers
    
    Return a list containing an arithmetic progression of integers.
    range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
    When step is given, it specifies the increment (or decrement).
    For example, range(4) returns [0, 1, 2, 3].  The end point is omitted!
    These are exactly the valid indices for a list of 4 elements.

None
Help on class xrange in module __builtin__:

class xrange(object)
 |  xrange(stop) -> xrange object
 |  xrange(start, stop[, step]) -> xrange object
 |  
 |  Like range(), but instead of returning a list, returns an object that
 |  generates the numbers in the range on demand.  For looping, this is 
 |  slightly faster than range() and more memory efficient.
 |  
 |  Methods defined here:
 |  
 |  __getattribute__(...)
 |      x.__getattribute__('name') <==> x.name
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __iter__(...)
 |      x.__iter__() <==> iter(x)
 |  
 |  __len__(...)
 |      x.__len__() <==> len(x)
 |  
 |  __reduce__(...)
 |  
 |  __repr__(...)
 |      x.__repr__() <==> repr(x)
 |  
 |  __reversed__(...)
 |      Returns a reverse iterator.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __new__ = <built-in method __new__ of type object>
 |      T.__new__(S, ...) -> a new object with type S, a subtype of T

None

In [20]:

    

print range(5),type(range(5))
print xrange(5),type(xrange(5))


    

    




[0, 1, 2, 3, 4] <type 'list'>
xrange(5) <type 'xrange'>

In [21]:

    

for value in xrange(5):
    print value


    

    




0
1
2
3
4

In [ ]:

    

# range(1000000) # you will run oout of memory.
# xrange(1000000) # you will run out of time.