How to Make a for Loop Python to Keep Doing Something Again and Again

Repeating Deportment with Loops

Overview

Educational activity: 30 min
Exercises: 0 min

Questions

• How can I practice the same operations on many unlike values?

Objectives

• Explicate what a for loop does.

• Correctly write for loops to echo simple calculations.

• Trace changes to a loop variable as the loop runs.

• Trace changes to other variables as they are updated by a for loop.

In the episode about visualizing data, we wrote Python code that plots values of interest from our first inflammation dataset (inflammation-01.csv), which revealed some suspicious features in it.

We have a dozen data sets right now and potentially more on the fashion if Dr. Bohemian can go on upwards their surprisingly fast clinical trial rate. Nosotros want to create plots for all of our data sets with a single argument. To do that, we'll have to teach the computer how to repeat things.

An case task that nosotros might want to repeat is accessing numbers in a list, which we will do by printing each number on a line of its own.

In Python, a list is basically an ordered collection of elements, and every element has a unique number associated with it — its index. This means that we can access elements in a listing using their indices. For example, we can become the first number in the list odds, by using odds[0]. One way to impress each number is to employ four print statements:

                          print              (              odds              [              0              ])              impress              (              odds              [              1              ])              print              (              odds              [              ii              ])              print              (              odds              [              three              ])                      

This is a bad arroyo for 3 reasons:

1. Not scalable. Imagine yous need to impress a list that has hundreds of elements. Information technology might exist easier to type them in manually.

2. Difficult to maintain. If nosotros want to decorate each printed element with an asterisk or any other character, we would have to modify 4 lines of lawmaking. While this might not be a trouble for small lists, information technology would definitely be a problem for longer ones.

3. Delicate. If we employ it with a list that has more elements than what nosotros initially envisioned, it volition but display part of the listing's elements. A shorter list, on the other hand, will cause an fault considering it will exist trying to display elements of the list that do non be.

                          odds              =              [              i              ,              three              ,              5              ]              print              (              odds              [              0              ])              print              (              odds              [              one              ])              print              (              odds              [              2              ])              print              (              odds              [              3              ])                      

            --------------------------------------------------------------------------- IndexError                                Traceback (nigh recent call last) <ipython-input-3-7974b6cdaf14> in <module>()       3 print(odds[one])       iv print(odds[2]) ----> 5 impress(odds[3])  IndexError: list alphabetize out of range                      

Here's a better arroyo: a for loop

                          odds              =              [              ane              ,              3              ,              five              ,              7              ]              for              num              in              odds              :              impress              (              num              )                      

This is shorter — certainly shorter than something that prints every number in a hundred-number list — and more robust as well:

                          odds              =              [              1              ,              iii              ,              5              ,              7              ,              9              ,              11              ]              for              num              in              odds              :              impress              (              num              )                      

The improved version uses a for loop to repeat an functioning — in this case, press — one time for each affair in a sequence. The general course of a loop is:

                          for              variable              in              drove              :              # do things using variable, such equally print                                    

Using the odds instance in a higher place, the loop might wait like this:

where each number (num) in the variable odds is looped through and printed one number after another. The other numbers in the diagram announce which loop cycle the number was printed in (i existence the showtime loop wheel, and 6 being the terminal loop wheel).

We tin telephone call the loop variable anything nosotros similar, only there must be a colon at the terminate of the line starting the loop, and we must indent anything nosotros want to run inside the loop. Unlike many other languages, there is no command to signify the cease of the loop trunk (due east.g. stop for); what is indented afterward the for statement belongs to the loop.

What's in a name?

In the example higher up, the loop variable was given the name num as a mnemonic; it is short for 'number'. We tin can choose whatever name we want for variables. Nosotros might but as easily have chosen the name banana for the loop variable, as long equally we use the same name when nosotros invoke the variable inside the loop:

                              odds                =                [                one                ,                3                ,                v                ,                7                ,                9                ,                11                ]                for                banana                in                odds                :                print                (                banana                )                          

Information technology is a proficient idea to choose variable names that are meaningful, otherwise it would be more than difficult to sympathise what the loop is doing.

Here'southward another loop that repeatedly updates a variable:

                          length              =              0              names              =              [              'Curie'              ,              'Darwin'              ,              'Turing'              ]              for              value              in              names              :              length              =              length              +              1              print              (              'There are'              ,              length              ,              'names in the listing.'              )                      

            There are three names in the list.                      

It's worth tracing the execution of this little program step by stride. Since there are three names in names, the statement on line 4 will exist executed three times. The start time effectually, length is zero (the value assigned to it on line 1) and value is Curie. The statement adds 1 to the old value of length, producing 1, and updates length to refer to that new value. The side by side time around, value is Darwin and length is 1, then length is updated to exist 2. Later on one more update, length is iii; since there is nothing left in names for Python to process, the loop finishes and the print function on line five tells us our final answer.

Annotation that a loop variable is a variable that is being used to record progress in a loop. It still exists later on the loop is over, and we can re-use variables previously divers equally loop variables as well:

                          name              =              'Rosalind'              for              proper noun              in              [              'Curie'              ,              'Darwin'              ,              'Turing'              ]:              print              (              proper noun              )              print              (              'after the loop, proper name is'              ,              name              )                      

            Curie Darwin Turing after the loop, name is Turing                      

Annotation also that finding the length of an object is such a common operation that Python actually has a congenital-in role to exercise it called len:

len is much faster than any function we could write ourselves, and much easier to read than a ii-line loop; it volition also give us the length of many other things that we haven't met nonetheless, and so nosotros should e'er utilise it when we can.

From 1 to N

Python has a built-in function chosen range that generates a sequence of numbers. range can take one, 2, or 3 parameters.

• If i parameter is given, range generates a sequence of that length, starting at zippo and incrementing by 1. For example, range(3) produces the numbers 0, 1, two.
• If ii parameters are given, range starts at the first and ends only before the second, incrementing past 1. For example, range(2, 5) produces ii, 3, iv.
• If range is given 3 parameters, information technology starts at the first one, ends just before the second one, and increments past the 3rd one. For example, range(iii, 10, 2) produces three, 5, 7, 9.

Using range, write a loop that uses range to print the first 3 natural numbers:

Solution

                                  for                  number                  in                  range                  (                  1                  ,                  iv                  ):                  impress                  (                  number                  )                              

Agreement the loops

Given the post-obit loop:

                              word                =                'oxygen'                for                char                in                word                :                impress                (                char                )                          

How many times is the body of the loop executed?

• 3 times
• 4 times
• 5 times
• vi times

Solution

The body of the loop is executed six times.

Computing Powers With Loops

Exponentiation is built into Python:

Write a loop that calculates the same issue as 5 ** 3 using multiplication (and without exponentiation).

Solution

                                  issue                  =                  1                  for                  number                  in                  range                  (                  0                  ,                  3                  ):                  result                  =                  consequence                  *                  5                  impress                  (                  consequence                  )                              

Summing a list

Write a loop that calculates the sum of elements in a list past calculation each element and printing the final value, so [124, 402, 36] prints 562

Solution

                                  numbers                  =                  [                  124                  ,                  402                  ,                  36                  ]                  summed                  =                  0                  for                  num                  in                  numbers                  :                  summed                  =                  summed                  +                  num                  print                  (                  summed                  )                              

Computing the Value of a Polynomial

The congenital-in function enumerate takes a sequence (e.g. a listing) and generates a new sequence of the same length. Each element of the new sequence is a pair composed of the index (0, 1, ii,…) and the value from the original sequence:

                              for                idx                ,                val                in                enumerate                (                a_list                ):                # Do something using idx and val                                          

The code above loops through a_list, assigning the index to idx and the value to val.

Suppose you accept encoded a polynomial equally a list of coefficients in the following way: the outset element is the abiding term, the second element is the coefficient of the linear term, the third is the coefficient of the quadratic term, etc.

                              x                =                5                coefs                =                [                ii                ,                4                ,                3                ]                y                =                coefs                [                0                ]                *                x                **                0                +                coefs                [                i                ]                *                x                **                one                +                coefs                [                2                ]                *                ten                **                ii                print                (                y                )                          

Write a loop using enumerate(coefs) which computes the value y of any polynomial, given x and coefs.

Solution

                                  y                  =                  0                  for                  idx                  ,                  coef                  in                  enumerate                  (                  coefs                  ):                  y                  =                  y                  +                  coef                  *                  x                  **                  idx                              

Key Points

• Use for variable in sequence to process the elements of a sequence one at a time.

• The body of a for loop must be indented.

• Utilize len(affair) to determine the length of something that contains other values.

lyonsalis2000.blogspot.com

Source: https://swcarpentry.github.io/python-novice-inflammation/05-loop/index.html

Bagikan Artikel ini