{"id":5136,"date":"2022-03-05T10:45:14","date_gmt":"2022-03-05T09:45:14","guid":{"rendered":"http:\/\/miro.borodziuk.eu\/?p=5136"},"modified":"2025-05-05T17:34:47","modified_gmt":"2025-05-05T15:34:47","slug":"loops","status":"publish","type":"post","link":"http:\/\/miro.borodziuk.eu\/index.php\/2022\/03\/05\/loops\/","title":{"rendered":"Loops"},"content":{"rendered":"
\n

1. There are two types of loops in Python: while<\/code> and for<\/code>:<\/p>\n<\/div>\n

<\/p>\n

\n
    \n
  • \n
      \n
    • the while<\/code> loop executes a statement or a set of statements as long as a specified boolean condition is true, e.g.:<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
      \n
      \n
      # Example 1\r\nwhile True:\r\n   print(\"Stuck in an infinite loop.\")\r\n\r\n\r\n# Example 2\r\ncounter = 5\r\nwhile counter > 2:\r\n   print(counter)\r\n   counter -= 1<\/pre>\n<\/div>\n<\/div>\n
        \n
      • \n
          \n
        • the for<\/code> loop executes a set of statements many times; it’s used to iterate over a sequence (e.g., a list, a dictionary, a tuple, or a set – you will learn about them soon) or other objects that are iterable (e.g., strings). You can use the for<\/code> loop to iterate over a sequence of numbers using the built-in range<\/code> function. Look at the examples below:<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
          \n
          \n
          # Example 1\r\nword = \"Python\"\r\nfor letter in word:\r\n   print(letter, end=\"*\")\r\n\r\n\r\n# Example 2\r\nfor i in range(1, 10):\r\n   if i % 2 == 0:\r\n      print(i)<\/pre>\n<\/div>\n<\/div>\n
          2. You can use the break<\/code> and continue<\/code> statements to change the flow of a loop:<\/p>\n
            \n
          • \n
              \n
            • You use break<\/code> to exit a loop, e.g.:<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
              \n
              \n
              text = \"Coding in  Python\"\r\nfor letter in text:\r\n   if letter == \"P\":\r\n      break\r\n   print(letter, end=\"\")<\/pre>\n<\/div>\n<\/div>\n
                \n
              • \n
                  \n
                • You use continue<\/code> to skip the current iteration, and continue with the next iteration, e.g.:<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                  \n
                  \n
                  text = \"pyxpyxpyx\"\r\nfor letter in text:\r\n   if letter == \"x\":\r\n      continue\r\n   print(letter, end=\"\")<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                   <\/p>\n
                  \n
                  3. The while<\/code> and for<\/code> loops can also have an else<\/code> clause in Python. The else<\/code> clause executes after the loop finishes its execution as long as it has not been terminated by break<\/code>, e.g.:<\/p>\n
                  \n
                  \n
                  n = 0\r\nwhile n != 3:\r\n   print(n)\r\n   n += 1\r\nelse:\r\n   print(n, \"else\")\r\n<\/pre>\n<\/div>\n<\/div>\n
                  0<\/p>\n
                  1<\/p>\n
                  2<\/p>\n
                  3 else<\/p>\n
                   <\/p>\n
                  for i in range(0, 3): \r\n  print(i) \r\nelse: \r\n  print(i, \"else\")<\/pre>\n<\/div>\n
                  0<\/p>\n
                  1<\/p>\n
                  2<\/p>\n
                  2 else<\/p>\n
                   <\/p>\n
                  \n
                  for i in range(5):\r\n    print(i)\r\nelse:\r\n    print(\"else:\", i)\r\n\r\n0\r\n1\r\n2\r\n3\r\n4\r\nelse: 4\r\n<\/pre>\n
                  The i<\/code> variable retains its last value.<\/p>\n<\/div>\n
                  i = 111\r\nfor i in range(2, 1):\r\n    print(i)\r\nelse:\r\n    print(\"else:\", i)\r\n\r\nelse: 111\r\n<\/pre>\n
                  The loop’s body won’t be executed here at all. Note: we’ve assigned the i<\/code> variable before the loop. When the loop’s body isn’t executed, the control variable retains the value it had before the loop.<\/p>\n
                  Note: if the control variable doesn’t exist before the loop starts, it won’t exist when the execution reaches the else<\/code> branch<\/strong>.<\/p>\n
                   <\/p>\n
                  \n
                  4. The range()<\/code> function generates a sequence of numbers. It accepts integers and returns range objects. The syntax of range()<\/code> looks as follows: range(start, stop, step)<\/code>, where:<\/p>\n
                    \n
                  • start<\/code> is an optional parameter specifying the starting number of the sequence (0<\/span> by default)<\/li>\n
                  • stop<\/code> is an optional parameter specifying the end of the sequence generated (it is not included),<\/li>\n
                  • and step<\/code> is an optional parameter specifying the difference between the numbers in the sequence (1<\/span> by default.)<\/li>\n<\/ul>\n
                    Example code:<\/p>\n
                    \n
                    \n
                    for i in range(3):\r\n   print(i, end=\" \") # Outputs: 0 1 2\r\n\r\nfor i in range(6, 1, -2):\r\n   print(i, end=\" \") # Outputs: 6, 4, 2<\/pre>\n
                     <\/p>\n<\/div>\n<\/div>\n<\/div>\n
                     <\/p>\n
                    Scenario 1<\/p>\n
                    In 1937, a German mathematician named Lothar Collatz formulated an intriguing hypothesis (it still remains unproven) which can be described in the following way:<\/p>\n
                    take any non-negative and non-zero integer number and name it c0;
                    \nif it’s even, evaluate a new c0 as c0 \u00f7 2;
                    \notherwise, if it’s odd, evaluate a new c0 as 3 \u00d7 c0 + 1;
                    \nif c0 \u2260 1, skip to point 2.<\/p>\n
                     <\/p>\n
                    The hypothesis says that regardless of the initial value of c0, it will always go to 1.<\/p>\n
                    Of course, it’s an extremely complex task to use a computer in order to prove the hypothesis for any natural number (it may even require artificial intelligence), but you can use Python to check some individual numbers. Maybe you’ll even find the one which would disprove the hypothesis.<\/p>\n
                    Write a program which reads one natural number and executes the above steps as long as c0 remains different from 1. We also want you to count the steps needed to achieve the goal. Your code should output all the intermediate values of c0, too.<\/p>\n
                    Hint: the most important part of the problem is how to transform Collatz’s idea into a while loop – this is the key to success.<\/p>\n
                    Test your code using the data we’ve provided.
                    \nTest Data<\/p>\n
                    Sample input: 15<\/p>\n
                    Expected output:
                    \n46
                    \n23
                    \n70
                    \n35
                    \n106
                    \n53
                    \n160
                    \n80
                    \n40
                    \n20
                    \n10
                    \n5
                    \n16
                    \n8
                    \n4
                    \n2
                    \n1
                    \nsteps = 17<\/p>\n
                    Sample input: 16<\/p>\n
                    Expected output:
                    \n8
                    \n4
                    \n2
                    \n1
                    \nsteps = 4<\/p>\n
                    Sample input: 1023<\/p>\n
                    Expected output:
                    \n3070
                    \n1535
                    \n4606
                    \n2303
                    \n6910
                    \n3455
                    \n10366
                    \n5183
                    \n15550
                    \n7775
                    \n23326
                    \n11663
                    \n34990
                    \n17495
                    \n52486
                    \n26243
                    \n78730
                    \n39365
                    \n118096
                    \n59048
                    \n29524
                    \n14762
                    \n7381
                    \n22144
                    \n11072
                    \n5536
                    \n2768
                    \n1384
                    \n692
                    \n346
                    \n173
                    \n520
                    \n260
                    \n130
                    \n65
                    \n196
                    \n98
                    \n49
                    \n148
                    \n74
                    \n37
                    \n112
                    \n56
                    \n28
                    \n14
                    \n7
                    \n22
                    \n11
                    \n34
                    \n17
                    \n52
                    \n26
                    \n13
                    \n40
                    \n20
                    \n10
                    \n5
                    \n16
                    \n8
                    \n4
                    \n2
                    \n1
                    \nsteps = 62<\/p>\n
                     <\/p>\n
                    Scenario 2<\/h2>\n
                    Listen to this story: a boy and his father, a computer programmer, are playing with wooden blocks. They are building a pyramid.<\/p>\n
                    Their pyramid is a bit weird, as it is actually a pyramid-shaped wall – it’s flat. The pyramid is stacked according to one simple principle: each lower layer contains one block more than the layer above.<\/p>\n
                    The figure illustrates the rule used by the builders:<\/p>\n
                    <\/p>\n
                    Your task is to write a program which reads the number of blocks the builders have, and outputs the height of the pyramid that can be built using these blocks.<\/p>\n
                    Note: the height is measured by the number of fully completed layers<\/strong> – if the builders don’t have a sufficient number of blocks and cannot complete the next layer, they finish their work immediately.<\/p>\n
                    Test your code using the data we’ve provided.<\/p>\n
                     <\/p>\n
                    Test Data<\/h2>\n
                     <\/p>\n
                    Sample input: 6<\/code><\/p>\n
                    Expected output: The height of the pyramid: 3<\/code><\/p>\n
                    \n
                    Sample input: 20<\/code><\/p>\n
                    Expected output: The height of the pyramid: 5<\/code><\/p>\n
                    \n
                    Sample input: 1000<\/code><\/p>\n
                    Expected output: The height of the pyramid: 44<\/code><\/p>\n
                    \n
                    Sample input: 2<\/code><\/p>\n
                    Expected output: The height of the pyramid: 1<\/code><\/p>\n
                     <\/p>\n
                     <\/p>\n
                    Exercise 3<\/p>\n
                    Create a program with a for<\/code> loop and a break<\/code> statement. The program should iterate over characters in an email address, exit the loop when it reaches the @<\/code> symbol, and print the part before @<\/code> on one line. Use the skeleton below:<\/p>\n
                     <\/p>\n
                    Solutions 1<\/p>\n
                    c0=int(input(\"c0= \"))\r\ni=0\r\nwhile c0 != 1:\r\n    if c0%2==0:\r\n        c0\/=2\r\n    else:\r\n        c0=3*c0 + 1\r\n    c0=int(c0)\r\n    print(c0)\r\n    i+=1\r\nprint(\"steps = \", i)<\/pre>\n
                    Solution 2<\/p>\n
                    blocks = int(input(\"Enter the number of blocks: \"))\r\n\r\nheight=0\r\ni=0\r\n\r\nwhile blocks>0:\r\n    height+=1\r\n    blocks-=height\r\n    print (height, blocks)\r\n    if height+1 > blocks: \r\n        break\r\n    \r\nprint(\"The height of the pyramid:\", height)<\/pre>\n
                    Solution 3<\/p>\n
                    for ch in \"john.smith@pythoninstitute.org\":\r\n    if ch == \"@\":\r\n        break\r\n    print(ch, end=\"\")<\/pre>\n
                     <\/p>\n
                    Exercise 5<\/p>\n
                    What is the output of the following code?<\/p>\n
                    n = 3\r\n\r\nwhile n > 0:\r\n  print(n + 1)\r\n  n -= 1\r\nelse:\r\n  print(n)<\/pre>\n
                     <\/p>\n
                    4
                    \n3
                    \n2
                    \n0<\/code><\/p>\n
                     <\/p>\n
                    Exercise 6<\/p>\n
                    What is the output of the following code?<\/p>\n
                    n = range(4)\r\n\r\nfor num in n:\r\n  print(num - 1)\r\nelse:\r\n  print(num)<\/pre>\n
                     <\/p>\n
                    -1
                    \n0
                    \n1
                    \n2
                    \n3<\/code><\/p>\n
                     <\/p>\n
                    Exercise 7<\/p>\n
                    What is the output of the following code?<\/p>\n
                    for i in range(0, 6, 3):\r\n  print(i)<\/pre>\n
                     <\/p>\n
                    0
                    \n3<\/code><\/p>\n
                     <\/p>\n
                    Ex. 8<\/p>\n
                    \n
                    \n
                    \n
                    \n
                    \n
                    Which of the following Python keywords<\/strong> is used as an empty statement<\/strong> that does nothing?<\/p>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    \n
                    pass<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    None<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    return<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    \n
                    continue<\/strong><\/code><\/p>\n
                    <\/div>\n
                    Correct answer<\/span><\/div>\n
                    \n
                    \n
                    pass<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                     <\/p>\n
                    \n
                      \n
                    • pass<\/strong><\/code> is a null<\/strong> statement and can be used as a placeholder where Python’s syntax requires an instruction, even if it doesn’t have to perform any action. For example, you can use pass<\/strong><\/code> as a temporary placeholder for the body of a newly defined function:\n
                      \n
                      \n
                      def fun():\r\n  pass<\/pre>\n
                       <\/p>\n<\/div>\n<\/div>\n<\/li>\n<\/ul>\n<\/div>\n<\/div>\n
                      Ex. 9<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      Which of the following statements about the arguments<\/strong> of a function<\/strong> are true<\/strong>?(Select two answers)<\/p>\n<\/div>\n<\/div>\n<\/div>\n
                      \n
                      \n
                      \n
                      \n
                      \n
                        \n
                      • The default value of a parameter cannot be overridden by a new argument when the function is invoked<\/em><\/li>\n
                      • Positional arguments must be passed according to the order of the function parameters<\/em><\/li>\n
                      • You cannot pass a mix of positional and keyword arguments to a function<\/em><\/li>\n
                      • Keyword arguments must be passed to functions after any required positional arguments<\/em><\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                        \n
                        <\/div>\n
                        Correct selection<\/span><\/div>\n
                        \n
                        \n
                        \n
                        \n
                        \n
                        Positional arguments must be passed according to the order of the function parameters<\/em><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                        \n
                        \n
                        \n
                        \n
                        Keyword arguments must be passed to functions after any required positional arguments<\/em><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                        \n
                        \n
                          \n
                        • It is true <\/strong>that positional<\/strong> arguments can be passed to a function along with keyword<\/strong> arguments. You can combine positional<\/strong> and keyword<\/strong> arguments as long as they are passed to the function in the correct order: keyword<\/strong> arguments must follow positional<\/strong> arguments.<\/li>\n
                        • It is true<\/strong> that the default<\/strong> value of a parameter can\u00a0 be overridden. A default<\/strong> parameter<\/strong> can be overridden by a new argument when a function is invoked.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                           <\/p>\n
                          Ex. 10<\/p>\n
                          \n
                          \n
                          \n
                          What is the output of the following code snippet?<\/p>\n<\/div>\n<\/div>\n<\/div>\n
                          str = \"Monty\"\r\n\u00a0\r\nfor i in str:\r\n  print(i)\r\n  break\r\nelse:\r\n  print(\"Python\")\r\n<\/pre>\n
                           <\/p>\n
                          \n
                          Python\r\n\r\nM\r\n\r\nM\r\nPython\r\n\r\nMonty\r\nPython<\/pre>\n
                           <\/p>\n<\/div>\n
                          Correct answer<\/span><\/div>\n
                          \n
                          \n
                          \n
                          \n
                          M<\/code> <\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                          \n
                          \n
                          \n
                          \n
                            \n
                          • The break<\/strong><\/code> statement unconditionally terminates the program during the first<\/strong> iteration of the for<\/strong><\/code> loop, after the letter M<\/strong><\/code> is printed on the console. The else<\/strong><\/code> statement\u00a0 is not executed because the loop is terminated by a break<\/strong><\/code>.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                             <\/p>\n
                            Ex. 11<\/p>\n
                            \n
                            \n
                            \n
                            What is the output of the following code snippet?<\/p>\n
                            \n
                            \n
                            str = \"XyZ\"\r\nc = \"x\"\r\n\r\n\r\nwhile c not in str:\r\n  print(\"A\")\r\n  break\r\nelse:\r\n  print(\"B\")<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                            \n
                            AB<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                            \n
                            B<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                            \n
                            A<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                            \n
                            The code has no output<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            <\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                            <\/div>\n
                            Correct answer<\/span><\/div>\n
                            \n
                            \n
                            A<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                            <\/div>\n<\/div>\n<\/div>\n<\/div>\n
                            \n
                            \n
                            \n
                              \n
                            • The \"x<\/strong>\"<\/code> (lowercase) character is not present in the string str<\/strong><\/code>. Consequently, the condition of the while<\/strong><\/code> statement is True<\/strong><\/code>:
                              \nstep by step<\/strong>Step 1 –\u00a0 while c not in str:<\/strong><\/code>Step 2 – while \"x\" not in \"XyZ\":<\/strong><\/code><\/p>\n
                              Result – while True:<\/strong><\/code><\/li>\n<\/ul>\n
                                \n
                              • The loop prints the letter A<\/strong><\/code> and then terminates due to the break<\/strong><\/code> statement. Also, executing break<\/strong><\/code> prevents the program from executing the else<\/strong><\/code> clause as well.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                <\/div>\n
                                Ex. 12<\/div>\n
                                \n
                                \n
                                \n
                                \n
                                What is the output of the following code snippet?<\/p>\n
                                \n
                                \n
                                for ch in \"Python\":\r\n  pass\r\n\r\nprint(ch)<\/pre>\n
                                 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                \n
                                \n
                                \n
                                Correct answer<\/span><\/div>\n
                                \n
                                \n
                                n<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                \n
                                \n
                                \n
                                  \n
                                • The pass<\/strong><\/code> statement does nothing. While the interpreter ignores the comments, it does not ignore the pass<\/strong><\/code> statement, but nothing happens when pass is executed. It serves as a NOP<\/strong> (N<\/strong>o OP<\/strong>eration) placeholder.<\/li>\n<\/ul>\n
                                    \n
                                  • In this code snippet, the only effect of the for<\/strong><\/code> loop is to assign a letter of the string \"Python<\/strong>\"<\/code> to the variable ch<\/strong><\/code> at each iteration. The loop is executed six<\/strong> times, once for each letter of \"Python<\/strong>\"<\/code>. During the last iteration, the variable ch<\/strong><\/code> receives the letter n<\/strong><\/code>, which is then output to the console by the print<\/strong><\/code> statement.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                    \n
                                    \n
                                    \n
                                    \n
                                    \n
                                    \n
                                    \n
                                    \n
                                    \n
                                     <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                     <\/p>\n<\/div>\n<\/div>\n<\/div>\n
                                    <\/div>\n","protected":false},"excerpt":{"rendered":"
                                    1. There are two types of loops in Python: while and for:<\/p>\n","protected":false},"author":2,"featured_media":5930,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[100],"tags":[],"_links":{"self":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5136"}],"collection":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/comments?post=5136"}],"version-history":[{"count":30,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5136\/revisions"}],"predecessor-version":[{"id":5138,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5136\/revisions\/5138"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media\/5930"}],"wp:attachment":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media?parent=5136"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/categories?post=5136"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/tags?post=5136"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}