{"id":5153,"date":"2022-03-12T15:36:44","date_gmt":"2022-03-12T14:36:44","guid":{"rendered":"http:\/\/miro.borodziuk.eu\/?p=5153"},"modified":"2025-05-05T17:12:17","modified_gmt":"2025-05-05T15:12:17","slug":"lists","status":"publish","type":"post","link":"http:\/\/miro.borodziuk.eu\/index.php\/2022\/03\/12\/lists\/","title":{"rendered":"Lists"},"content":{"rendered":"
\n

1. The list is a type of data<\/strong> in Python used to store multiple objects<\/strong>. It is an ordered and mutable collection<\/strong> of comma-separated items between square brackets, e.g.:<\/p>\n<\/div>\n

<\/p>\n

\n
\n
\n
\n
my_list = [1, None, True, \"I am a string\", 256, 0]<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
 <\/p>\n
2. Lists can be indexed and updated<\/strong>, e.g.:<\/p>\n
\n
\n
my_list = [1, None, True, 'I am a string', 256, 0]\r\nprint(my_list[3]) # outputs: I am a string\r\nprint(my_list[-1]) # outputs: 0\r\n\r\nmy_list[1] = '?'\r\nprint(my_list) # outputs: [1, '?', True, 'I am a string', 256, 0]\r\n\r\nmy_list.insert(0, \"first\")\r\nmy_list.append(\"last\")\r\nprint(my_list) # outputs: ['first', 1, '?', True, 'I am a string', 256, 0, 'last']<\/pre>\n
 <\/p>\n
3. Lists can be nested<\/strong>, e.g.:<\/p>\n<\/div>\n<\/div>\n
\n
\n
\n
my_list = [1, 'a', [\"list\", 64, [0, 1], False]]<\/pre>\n
 <\/p>\n
4. List elements and lists can be deleted<\/strong>, e.g.:<\/p>\n<\/div>\n<\/div>\n<\/div>\n
\n
\n
my_list = [1, 2, 3, 4]\r\ndel my_list[2]\r\nprint(my_list) # outputs: [1, 2, 4]\r\n\r\ndel my_list # deletes the whole list<\/pre>\n
 <\/p>\n
5. Lists can be iterated<\/strong> through using the for<\/code> loop, e.g.:<\/p>\n<\/div>\n<\/div>\n
\n
\n
my_list = [\"white\", \"purple\", \"blue\", \"yellow\", \"green\"]\r\n\r\nfor color in my_list:\r\n  print(color)<\/pre>\n
 <\/p>\n
6. The len()<\/code> function may be used to check the list’s length<\/strong>, e.g.:<\/p>\n<\/div>\n<\/div>\n
\n
\n
my_list = [\"white\", \"purple\", \"blue\", \"yellow\", \"green\"]\r\nprint(len(my_list)) # outputs 5\r\n\r\ndel my_list[2]\r\nprint(len(my_list)) # outputs 4<\/pre>\n
 <\/p>\n
7. A typical function<\/strong> invocation looks as follows: result = function(arg)<\/code>, while a typical method<\/strong> invocation looks like this:result = data.method(arg)<\/code>.<\/p>\n<\/div>\n<\/div>\n<\/div>\n
 <\/p>\n
8. You can use the sort() method to sort elements of a list, e.g.:<\/p>\n
lst = [5, 3, 1, 2, 4]\r\nprint(lst)\r\n\r\nlst.sort()\r\nprint(lst) # outputs: [1, 2, 3, 4, 5]<\/pre>\n
    \n
  • Both sort()<\/strong><\/code> and sorted()<\/strong><\/code> sort a list in ascending order.<\/li>\n
  • sort()<\/strong><\/code> is a method and sorted()<\/strong><\/code> is a built-in<\/strong> function.<\/li>\n
  • sort()<\/strong><\/code> changes the list in place, while sorted()<\/strong><\/code> creates a new list<\/li>\n
  • sort()<\/strong><\/code> is defined only for lists, while sorted()<\/strong><\/code> accepts any iterable (such as strings and tuples)<\/li>\n<\/ul>\n
     <\/p>\n
    9. There is also a list method called reverse(), which you can use to reverse the list, e.g.:<\/p>\n
    lst = [5, 3, 1, 2, 4]\r\nprint(lst)\r\n\r\nlst.reverse()\r\nprint(lst) # outputs: [4, 2, 1, 3, 5]<\/pre>\n
    or<\/p>\n
    lst = [2, 3, 7, 11, 26]\r\nprint(lst[::-1]) # outputs: [26, 11, 7, 3, 2] \r\n<\/pre>\n
    In Python, the slice<\/strong> notation [::-1]<\/strong><\/code> returns the elements of a data collection, such as a list, in reverse<\/strong> order.<\/p>\n
     <\/p>\n
    10. If you have a list list1<\/code>, then the following assignment: list2 = list1<\/code> does not make a copy of the list1<\/code> list, but makes the variables list1<\/code> and list2<\/code> point to one and the same list in memory<\/strong>. For example:<\/p>\n
    vehicles_one = ['car', 'bicycle', 'motor']\r\nprint(vehicles_one) # outputs: ['car', 'bicycle', 'motor']\r\n\r\nvehicles_two = vehicles_one\r\ndel vehicles_one[0] # deletes 'car'\r\nprint(vehicles_two) # outputs: ['bicycle', 'motor']<\/pre>\n
     <\/p>\n
    11. If you want to copy a list or part of the list, you can do it by performing slicing<\/strong>:<\/code><\/p>\n
    \n
    \n
    colors = ['red', 'green', 'orange']\r\n\r\ncopy_whole_colors = colors[:] # copy the entire list\r\ncopy_part_colors = colors[0:2] # copy part of the list<\/pre>\n
     <\/p>\n
    12. You can use negative indices<\/strong> to perform slices, too. For example:<\/p>\n<\/div>\n<\/div>\n
    \n
    \n
    sample_list = [\"A\", \"B\", \"C\", \"D\", \"E\"]\r\nnew_list = sample_list[2:-1]\r\nprint(new_list) # outputs: ['C', 'D']<\/pre>\n
     <\/p>\n
    13. The start<\/code> and end<\/code> parameters are optional<\/strong> when performing a slice: list[start:end]<\/code>, e.g.:<\/p>\n<\/div>\n<\/div>\n
    \n
    \n
    my_list = [1, 2, 3, 4, 5]\r\nslice_one = my_list[2: ]\r\nslice_two = my_list[ :2]\r\nslice_three = my_list[-2: ]\r\n\r\nprint(slice_one) # outputs: [3, 4, 5]\r\nprint(slice_two) # outputs: [1, 2]\r\nprint(slice_three) # outputs: [4, 5]<\/pre>\n
     <\/p>\n
    14. You can delete slices<\/strong> using the del<\/code> instruction:<\/p>\n<\/div>\n<\/div>\n
    \n
    \n
    my_list = [1, 2, 3, 4, 5]\r\ndel my_list[0:2]\r\nprint(my_list) # outputs: [3, 4, 5]\r\n\r\ndel my_list[:]\r\nprint(my_list) # deletes the list content, outputs: []<\/pre>\n
     <\/p>\n
    15. You can test if some items exist in a list or not<\/strong> using the keywords in<\/code> and not in<\/code>, e.g.:<\/p>\n<\/div>\n<\/div>\n
    \n
    \n
    my_list = [\"A\", \"B\", 1, 2]\r\n\r\nprint(\"A\" in my_list) # outputs: True\r\nprint(\"C\" not in my_list) # outputs: True\r\nprint(2 not in my_list) # outputs: False<\/pre>\n<\/div>\n<\/div>\n
     <\/p>\n
    16. List comprehension<\/strong> allows you to create new lists from existing ones in a concise and elegant way. The syntax of a list comprehension looks as follows:<\/p>\n
    \n
    [expression for element in list if conditional]<\/pre>\n
    which is actually an equivalent of the following code:<\/p>\n
    for element in list:\r\n   if conditional:\r\n      expression<\/pre>\n
    Let’s assume that we’re able to use the selected numbers to represent any chess piece. We can also assume that every row on the chessboard is a list.<\/p>\n
    Look at the code below:<\/p>\n
    row = []\r\nfor i in range(8):\r\n   row.append(WHITE_PAWN)<\/pre>\n
    It builds a list containing eight elements representing the second row of the chessboard – the one filled with pawns (assume that WHITE_PAWN is a predefined symbol representing a white pawn).<\/p>\n
    The same effect may be achieved by means of a list comprehension, the special syntax used by Python in order to fill massive lists.<\/p>\n
    row = [WHITE_PAWN for i in range(8)]<\/pre>\n
    The part of the code placed inside the brackets specifies:<\/p>\n
    the data to be used to fill the list (WHITE_PAWN)
    \nthe clause specifying how many times the data occurs inside the list (for i in range(8))<\/p>\n
    Here’s an example of a list comprehension \u2012 the code creates a five-element list filled with the first five natural numbers raised to the power of 3:<\/p>\n
    \n
    \n
    cubed = [num ** 3 for num in range(5)]\r\nprint(cubed) # outputs: [0, 1, 8, 27, 64]<\/pre>\n
     <\/p>\n
    17. Swapping the lists’s elements.<\/p>\n
    you can easily swap<\/strong> the list’s elements to reverse their order<\/strong>:<\/code><\/p>\n
    \n
    \n
    my_list = [10, 1, 8, 3, 5]\r\nmy_list[0], my_list[4] = my_list[4], my_list[0]\r\nmy_list[1], my_list[3] = my_list[3], my_list[1]\r\n\r\nprint(my_list)<\/pre>\n
    Run the snippet. Its output should look like this:<\/p>\n<\/div>\n<\/div>\n
    [5, 3, 8, 1, 10]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n
    Will it still be acceptable with a list containing 100 elements? No, it won’t. You use the for<\/code> loop to do the same thing automatically, irrespective of the list’s length.<\/p>\n
    \n
    This is how we’ve done it:<\/p>\n
    my_list = [10, 1, 8, 3, 5] \r\nlength = len(my_list) \r\nfor i in range(length \/\/ 2): \r\n   my_list[i], my_list[length - i - 1] = my_list[length - i - 1], my_list[i] \r\nprint(my_list)<\/pre>\n
     <\/p>\n
    \n
    \n
     <\/p>\n
    Let us show you some other list comprehension examples<\/strong>:<\/div>\n<\/div>\n<\/div>\n
    \n
    \n
    \n
    Example #1:<\/em><\/p>\n
    \n
    \n
    \n
    squares = [x ** 2 for x in range(10)]<\/pre>\n
    The snippet produces a ten-element list filled with squares of ten integer numbers starting from zero (0, 1, 4, 9, 16, 25, 36, 49, 64, 81)<\/p>\n<\/div>\n<\/div>\n<\/div>\n
    Example #2:<\/em><\/p>\n
    twos = [2 ** i for i in range(8)]<\/pre>\n
    The snippet creates an eight-element array containing the first eight powers of two (1, 2, 4, 8, 16, 32, 64, 128)<\/p>\n
    Example #3:<\/em><\/p>\n
    \n
    \n
    \n
    odds = [x for x in squares if x % 2 != 0 ]<\/pre>\n
    The snippet makes a list with only the odd elements of the squares<\/code> list.<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
    <\/div>\n
    18. You can use nested lists<\/strong> in Python to create matrices<\/strong> (i.e., two-dimensional lists). For example:<\/div>\n<\/div>\n
    \"Table<\/p>\n
    \n
    \n
    # A four-column\/four-row table \u2012 a two dimensional array (4x4)\r\ntable = [[\":(\", \":)\", \":(\", \":)\"],\r\n         [\":)\", \":(\", \":)\", \":)\"],\r\n         [\":(\", \":)\", \":)\", \":(\"],\r\n         [\":)\", \":)\", \":)\", \":(\"]]\r\n\r\nprint(table)\r\nprint(table[0][0]) # outputs: ':('\r\nprint(table[0][3]) # outputs: ':)'<\/pre>\n
     <\/p>\n
    18. You can nest as many lists in lists as you want, thereby creating n-dimensional lists, e.g., three-, four- or even sixty-four-dimensional arrays. For example:<\/p>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    \"Cube<\/p>\n
    <\/code><\/p>\n
    \n
    \n
    # Cube - a three-dimensional array (3x3x3)\r\n\r\ncube = [[[':(', 'x', 'x'],\r\n[':)', 'x', 'x'],\r\n[':(', 'x', 'x']],\r\n\r\n[[':)', 'x', 'x'],\r\n[':(', 'x', 'x'],\r\n[':)', 'x', 'x']],\r\n\r\n[[':(', 'x', 'x'],\r\n[':)', 'x', 'x'],\r\n[':)', 'x', 'x']]]\r\n\r\nprint(cube)\r\nprint(cube[0][0][0]) # outputs: ':('\r\nprint(cube[2][2][0]) # outputs: ':)'<\/pre>\n
     <\/p>\n
    Exercise 1<\/strong><\/div>\n<\/div>\n<\/div>\n<\/div>\n
    \n
    What is the output of the following snippet?<\/p>\n
    lst = [1, 2, 3, 4, 5]\r\nlst.insert(1, 6)\r\ndel lst[0]\r\nlst.append(1)\r\n\r\nprint(lst)\r\n\r\n# Output: [6, 2, 3, 4, 5, 1]<\/pre>\n
     <\/p>\n<\/div>\n
    Exercise 2<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    lst = [1, 2, 3, 4, 5]\r\nlst_2 = []\r\nadd = 0\r\n\r\nfor number in lst:\r\n    add += number\r\n    lst_2.append(add)\r\n\r\nprint(lst_2)\r\n\r\n# Output: [1, 3, 6, 10, 15]\r\n\r\n<\/pre>\n
     <\/p>\n
    Exercise 3<\/strong><\/p>\n
    What happens when you run the following snippet?<\/code><\/p>\n
    lst = []\r\ndel lst\r\nprint(lst)\r\n\r\n# Output: NameError: name 'lst' is not defined<\/code><\/pre>\n
    <\/div>\n
    Exercise 4<\/strong><\/p>\n
    What is the output of the following snippet?<\/code><\/p>\n
    lst = [1, [2, 3], 4]\r\nprint(lst[1])\r\nprint(len(lst))\r\n\r\n# Output:\r\n# [2, 3]\r\n# 3<\/code><\/pre>\n
     <\/p>\n
    Exercise 5
    \n<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    list_1 = [\"A\", \"B\", \"C\"]\r\nlist_2 = list_1\r\nlist_3 = list_2\r\n\r\ndel list_1[0]\r\ndel list_2[0]\r\nprint(list_3)\r\n\r\n# Output: ['C']<\/pre>\n
     <\/p>\n
    Exercise 6
    \n<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    list_1 = [\"A\", \"B\", \"C\"]\r\nlist_2 = list_1\r\nlist_3 = list_2\r\n\r\ndel list_1[0]\r\ndel list_2\r\nprint(list_3)\r\n\r\n['B', 'C']<\/pre>\n
     <\/p>\n
    Exercise 7<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    list_1 = [\"A\", \"B\", \"C\"]\r\nlist_2 = list_1\r\nlist_3 = list_2\r\n\r\ndel list_1[0]\r\ndel list_2[:]\r\n\r\nprint(list_3)\r\n\r\n[]<\/pre>\n
     <\/p>\n
    Exercise 8<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    list_1 = [\"A\", \"B\", \"C\"]\r\nlist_2 = list_1[:]\r\nlist_3 = list_2[:]\r\n\r\ndel list_1[0]\r\ndel list_2[0]\r\n\r\nprint(list_3)\r\n\r\n['A', 'B', 'C']<\/pre>\n
     <\/p>\n
    Exercise 9<\/strong><\/p>\n
    Insert in or not in instead of ??? so that the code outputs the expected result.<\/p>\n
    my_list = [1, 2, \"in\", True, \"ABC\"]\r\n\r\nprint(1 ??? my_list) # outputs True\r\nprint(\"A\" ??? my_list) # outputs True\r\nprint(3 ??? my_list) # outputs True\r\nprint(False ??? my_list) # outputs False\r\n\r\nmy_list = [1, 2, \"in\", True, \"ABC\"]\r\n\r\nprint(1 in my_list) # outputs True\r\nprint(\"A\" not in my_list) # outputs True\r\nprint(3 not in my_list) # outputs True\r\nprint(False in my_list) # outputs False<\/pre>\n
     <\/p>\n
    Exercise 10<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    lst = [\"D\", \"F\", \"A\", \"Z\"]\r\nlst.sort()\r\n\r\nprint(lst)<\/pre>\n
     <\/p>\n
    ['A', 'D', 'F', 'Z']<\/code><\/strong><\/p>\n
     <\/p>\n
    Exercise 11
    \n<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    a = 3\r\nb = 1\r\nc = 2\r\n\r\nlst = [a, c, b]\r\nlst.sort()\r\n\r\nprint(lst)<\/pre>\n
     <\/p>\n
    [1, 2, 3]<\/code><\/strong><\/p>\n
     <\/p>\n
    Exercise 12<\/strong><\/p>\n
    What is the output of the following snippet?<\/p>\n
    a = \"A\"\r\nb = \"B\"\r\nc = \"C\"\r\nd = \" \"\r\n\r\nlst = [a, b, c, d]\r\nlst.reverse()\r\n\r\nprint(lst)<\/pre>\n
     <\/p>\n
    [' ', 'C', 'B', 'A']<\/code><\/strong><\/p>\n
     <\/p>\n
    Ex. 13<\/p>\n
    What is the output of the following code snippet?<\/p>\n
    d1 = {1: 'one', 2: 'two', 3: 'three'}\r\n\r\nd2 = d1\r\ndel d1\r\n\r\nprint(d2)<\/pre>\n
     <\/p>\n
    {1: 'one', 2: 'two', 3: 'three'}<\/code><\/p>\n
      \n
    • After line 3<\/strong> of the code, d1<\/strong><\/code> and d2<\/strong><\/code> refer to the same dictionary. In other words, d1<\/strong><\/code> and d2<\/strong><\/code> are two variables that point to the same dictionary in memory and not two separate copies of it.<\/li>\n<\/ul>\n
        \n
      • The instruction in line 4<\/strong> removes the reference d1<\/strong><\/code>, but the variable d2<\/strong><\/code> will continue to point to the starting dictionary. Therefore, in line 6<\/strong>, the print()<\/strong><\/code>function will print the entire dictionary.<\/li>\n<\/ul>\n
         <\/p>\n
        Ex. 14<\/p>\n
        What is the output of the following code snippet?<\/p>\n
        lst = [3, 2, 0, 4]\r\n\r\nfor n in lst:\r\n  if n != 2 and n != 4:\r\n    print(lst[n], end=\" \")<\/pre>\n
         <\/p>\n
        4 3<\/code><\/p>\n
          \n
        • The program executes the for<\/strong><\/code> loop 4<\/strong><\/code> times, according to the four elements of the lst<\/strong><\/code> list. Due to the if<\/strong><\/code> condition, the program will execute the print<\/strong><\/code> statement only for the values 3<\/strong><\/code> and 0<\/strong><\/code> in the list.<\/li>\n
        • In the print<\/strong><\/code> statement, n<\/strong><\/code> is used as an index to get the corresponding value in lst<\/strong><\/code>.<\/li>\n
        • Due to the presence of the end=\" \"<\/strong><\/code> parameter the numbers are printed on a single line separated by a space.<\/li>\n
        • Here’s how the for loop works:\n
            \n
          • First iteration<\/strong>: n = 3<\/strong><\/code>.
            \nThe if<\/strong><\/code> condition is True<\/strong><\/code> because 3<\/strong><\/code> is different from 2<\/strong><\/code> and 4<\/strong><\/code>.
            \nThe print<\/strong><\/code> statement outputs 4<\/strong><\/code> to the screen:print(lst[3], end=\" \")<\/strong><\/code> -><\/strong> print(4, end=\" \")<\/strong><\/code> -><\/strong> 4<\/strong><\/code>.(The list index starts with 0<\/strong><\/code>).<\/li>\n
          • Second iteration<\/strong>: n = 2<\/strong><\/code>.
            \nThe if<\/strong><\/code> condition is False<\/strong><\/code>.<\/li>\n
          • Third iteration<\/strong>: n = 3<\/strong><\/code>.
            \nThe if<\/strong><\/code> condition is True<\/strong><\/code> because 0<\/strong><\/code> is different from 2<\/strong><\/code> and 4<\/strong><\/code>.
            \nThe print<\/strong><\/code> statement outputs 3<\/strong><\/code> to the screen:print(lst[0], end=\" \")<\/strong><\/code> -><\/strong> print(3, end=\" \")<\/strong><\/code> -><\/strong> 3<\/strong><\/code>.<\/li>\n
          • Fourth iteration<\/strong>: n = 4<\/strong><\/code>.
            \nThe if<\/strong><\/code> condition is False<\/strong><\/code> and the program ends.<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
             <\/p>\n
            Ex.15<\/p>\n
            \n
            \n
            \n
            What is the output of the following code snippet?<\/p>\n<\/div>\n<\/div>\n<\/div>\n
            lst = ['a', 'C', \" \", 'b', 'Z']\r\nlst.sort()\r\nprint(lst)<\/pre>\n
            \n
            \n
            \n
            \n
            \n
            ['a', 'b', 'C', 'Z', ' ']<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
            \n
            \n
            \n
            \n
            [' ', 'a', 'b', 'C', 'Z']<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
            \n
            \n
            \n
            \n
            [' ', 'C', 'Z', 'a', 'b']<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
            \n
            \n
            \n
            \n
            ['C', 'Z', 'a', 'b', ' ']<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
            \n
            <\/div>\n
            <\/div>\n
            \n
            \n
            \n
            \n
            Correct answer<\/span><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
            \n
            \n
            \n
            \n
            \n
            [' ', 'C', 'Z', 'a', 'b']<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
            \n
            \n
              \n
            • The sort()<\/strong><\/code> method changes the order of the elements of the original list. It sorts a list in ascending<\/strong> order by default. Alphabetical sorting is based on the ASCII <\/strong>value of the elements. The space (\" \"<\/strong><\/code>) has the lowest ASCII<\/strong> value and is listed first.<\/li>\n
            • Uppercase<\/strong> letters have a lower ASCII<\/strong> value than lowercase<\/strong> letters and are listed first.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
               <\/p>\n
              Ex. 16<\/p>\n
              \n
              \n
              \n
              What is the output of the following code snippet?<\/p>\n
              lst = [1, 2, 3, 4, 5]\r\n\u00a0\r\nlst.append([6, 7])\r\nlst.extend(['a', 'b'])\r\nlst.pop()\r\n\u00a0\r\nprint(lst)<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
              \n
              \n
              \n
              \n
              \n
              [1, 2, 3, 4, 5, ['a', 'b']]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
              \n
              \n
              \n
              \n
              [1, 2, 3, 4, 5, [6, 7]]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
              \n
              \n
              \n
              \n
              [1, 2, 3, 4, 5, [6, 7], 'a']<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
              \n
              \n
              \n
              \n
              [1, 2, 3, 4, 5, 6, 7]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
              \n
              <\/div>\n
              \n
              Correct answer<\/span><\/div>\n
              \n
              \n
              [1, 2, 3, 4, 5, [6, 7], 'a']<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n
              \n
                \n
              • The append(element)<\/strong><\/code> method adds an element, of any type, to the end of the list. append()<\/strong><\/code> adds the element as a single item. In our code, the element is the list [6, 7]<\/strong><\/code>.\u00a0 Thus, we have:lst.append([6, 7])<\/strong><\/code> -><\/strong> [1, 2, 3, 4, 5, [6, 7]]<\/strong><\/code>.<\/li>\n<\/ul>\n
                  \n
                • The extend()<\/strong><\/code> method also adds elements to the end of a list, but the argument must be an iterable object (list, tuple, range, …). Also, extend()<\/strong><\/code> appends each item generated by the iterable as a single entry to the end of the list:lst.extend(['a', 'b'])<\/strong><\/code> -><\/strong> [1, 2, 3, 4, 5, [6, 7], 'a', 'b']<\/strong><\/code>.<\/li>\n<\/ul>\n
                    \n
                  • The pop(position)<\/strong><\/code> method removes the element at the specified position. The default is -1<\/strong><\/code>, so pop()<\/strong><\/code> removes the last item in a list:lst.pop()<\/strong><\/code> -><\/strong> lst.pop(-1)<\/strong><\/code> -><\/strong> [1, 2, 3, 4, 5, [6, 7], 'a']<\/strong><\/code>.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                     <\/p>\n
                    Ex.17<\/p>\n
                    \n
                    \n
                    \n
                    What is the output of the following code snippet?<\/p>\n
                    \n
                    \n
                    str = \"\"\"\r\nPython\"\"\"\r\n\r\nprint(len(str))<\/pre>\n
                     <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                    <\/div>\n
                    Correct answer<\/span><\/div>\n
                    \n
                    \n
                    7<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                    \n
                    \n
                    \n
                      \n
                    • The code is correct and does not generate any errors. In Python, multiline<\/strong> strings enclosed in triple quote<\/strong>s are allowed.<\/li>\n<\/ul>\n
                        \n
                      • The len()<\/strong><\/code> function counts 7<\/strong><\/code> characters from str<\/strong><\/code> because it also adds the hidden newline<\/strong> character \\n<\/strong><\/code> to the total.<\/li>\n<\/ul>\n
                          \n
                        • In other words, the contents of the string str<\/strong><\/code> is equivalent to \"\"\"\\nPython\"\"\"<\/strong><\/code>, where the escape<\/strong> character \\n<\/strong><\/code> is counted as 1<\/strong><\/code>.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                           <\/p>\n
                          Ex. 18<\/p>\n
                          \n
                          \n
                          \n
                          What is the output of the following code snippet?<\/p>\n
                          \n
                          \n
                          print(list(range(-3)))<\/pre>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                          \n
                          \n
                          \n
                          \n
                          \n
                          [0, -1, -2]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                          \n
                          \n
                          \n
                          \n
                          A ValueError<\/code> exception<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                          \n
                          \n
                          \n
                          \n
                          []<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                          \n
                          \n
                          \n
                          \n
                          [-1, -2, -3] <\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                          \n
                          <\/div>\n
                          <\/div>\n
                          \n
                          Correct answer<\/span><\/div>\n
                          \n
                          \n
                          []<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n
                          \n
                            \n
                          • The syntax of the range()<\/strong><\/code> function is range(start, stop, step)<\/strong><\/code>.<\/li>\n
                          • range()<\/strong><\/code> returns a sequence of numbers containing all values from start<\/strong> to stop<\/strong> (excluded), where step<\/strong> specifies the increment<\/strong>.<\/li>\n
                          • The start, stop and step values must be integers<\/strong>.<\/li>\n
                          • start and step are optional<\/strong>.<\/li>\n
                          • 0<\/strong><\/code> and 1<\/strong><\/code> are the default<\/strong> values of start and step parameters, respectively.<\/li>\n<\/ul>\n
                              \n
                            • Based on the above, range(-3)<\/strong><\/code> is equal to range(0, -3, 1)<\/strong><\/code>.<\/li>\n
                            • When the start<\/strong> parameter (0<\/strong><\/code>) is greater than the stop<\/strong> parameter (-3<\/strong><\/code>), and the step<\/strong> parameter (1<\/strong><\/code>) is positive, the range()<\/strong><\/code> function cannot generate any values.<\/li>\n
                            • Therefore, the list()<\/strong><\/code> function returns an empty<\/strong> list.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                               <\/p>\n
                              Ex. 19<\/p>\n
                              \n
                              \n
                              \n
                              What is the output of the following code snippet?<\/p>\n
                              def fun():\r\n  lst[0] = 8\r\n\u00a0\r\nlst = [3, 7, 1, 5, 9]\r\nfun()\r\n\u00a0\r\nprint(lst)<\/pre>\n<\/div>\n<\/div>\n<\/div>\n
                              \n
                              \n
                              \n
                              \n
                              \n
                              [8, 7, 1, 5, 9]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                              \n
                              \n
                              \n
                              \n
                              [0, 8, 7, 1, 5, 9]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                              \n
                              \n
                              \n
                              \n
                              [3, 7, 1, 5, 9]<\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                              \n
                              \n
                              \n
                              \n
                              A SyntaxError<\/code> exception<\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                              \n
                              \n
                              \n
                              \n
                              \n
                              Correct answer<\/span><\/div>\n
                              \n
                              \n
                              [8, 7, 1, 5, 9]<\/strong><\/code><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                \n
                              • The lst<\/strong><\/code> list is defined in the global<\/strong> scope and is accessible from anywhere in the code, even within the fun()<\/strong><\/code> function. Therefore, the function changes lst<\/strong><\/code> by replacing the first<\/strong> element 3<\/strong><\/code> (index 0<\/strong><\/code>) with the new value 8<\/strong><\/code>.<\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                 <\/p>\n
                                Ex. 20<\/p>\n
                                \n
                                \n
                                \n
                                What is the output of the following code snippet?<\/p>\n
                                \n
                                \n
                                l3d = [[['A','B','C'],\r\n        ['X','Y','Z'],\r\n        ['J','K','L']],\r\n\r\n       [[100,200,300],\r\n        [400,500,600],\r\n        [700,800,900]],\r\n\r\n       [['@','$','\u00a7'],\r\n        ['?','#','&'],\r\n        ['*','!','=']]]\r\n\r\nprint(l3d[2][1])\r\nprint(l3d[2][1][1])<\/pre>\n
                                 <\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                \n
                                \n
                                \n
                                \n
                                \n
                                \n
                                <\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                \n
                                \n
                                Correct answer<\/span><\/div>\n
                                \n
                                \n
                                \n
                                \n
                                [<\/span>'?'<\/span>,<\/span> '#'<\/span>,<\/span> '&'<\/span>]<\/span><\/code><\/strong><\/p>\n
                                #<\/span><\/code><\/strong><\/p>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                \n
                                \n
                                \n
                                  \n
                                • This is an example of a 3-dimensional list. It is composed of a series of nested lists that create a 3x3x3 ‘cube’ with 27 elements in total.<\/li>\n<\/ul>\n
                                    \n
                                  • To locate an element in the 3d<\/code> list, three ‘coordinates’ are needed: l3d[x][y][z]<\/code>.The x<\/code> coordinate identifies one of the main 3×3 matrixes that make up the list.\n
                                    The y<\/code> coordinate locates one of the lists that form the rows of the matrix.<\/p>\n
                                    The last coordinate, z<\/code>, specifies the single element of a row.<\/li>\n<\/ul>\n
                                      \n
                                    • Here’s how the code works.ls[2][1]<\/code> – It locates the row of index 1 in the matrix of index 2.\n
                                      Step by step:<\/p>\n
                                      Step 1 –\u00a0 print(l3d[2][1])<\/code><\/p>\n
                                      Step 2 – print([['@','$','\u00a7'], ['?','#','&'], ['*','!','=']][1])<\/code><\/p>\n
                                      Output –['?','#','&']<\/code><\/p>\n
                                      ls[2][1][1]<\/code> – It locates the element of index 1, in row 1, of matrix 2.<\/p>\n
                                      Step by step:<\/p>\n
                                      Step 1 – print(l3d[2][1][1])<\/code><\/p>\n
                                      Step 2 – print([['@','$','\u00a7'], ['?','#','&'], ['*','!','=']][1][1])<\/code><\/p>\n
                                      Step 3 – print(['?','#','&'][1])<\/code><\/p>\n
                                      Output – #<\/code><\/li>\n<\/ul>\n<\/div>\n<\/div>\n<\/div>\n<\/div>\n
                                       <\/p>\n
                                      <\/div>\n
                                      \n
                                      Scenario<\/strong><\/h2>\n
                                      Imagine a list – not very long, not very complicated, just a simple list containing some integer numbers. Some of these numbers may be repeated, and this is the clue. We don’t want any repetitions. We want them to be removed.<\/p>\n
                                      Your task is to write a program which removes all the number repetitions from the list. The goal is to have a list in which all the numbers appear not more than once.<\/p>\n
                                      Note: assume that the source list is hard-coded inside the code – you don’t have to enter it from the keyboard. Of course, you can improve the code and add a part that can carry out a conversation with the user and obtain all the data from her\/him.<\/p>\n
                                      Hint: we encourage you to create a new list as a temporary work area – you don’t need to update the list in situ.<\/p>\n<\/div>\n
                                      my_list = [1, 2, 4, 4, 1, 4, 2, 6, 2, 9]\r\nnew_list = []\r\n\r\nfor number in my_list:\r\n    if number not in new_list:\r\n        new_list.append(number)\r\n    \r\nprint(\"The list with unique elements only:\")\r\nprint(new_list)<\/pre>\n
                                       <\/p>\n","protected":false},"excerpt":{"rendered":"
                                      1. The list is a type of data in Python used to store multiple objects. It is an ordered and mutable collection of comma-separated items between square brackets, e.g.:<\/p>\n","protected":false},"author":2,"featured_media":5928,"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\/5153"}],"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=5153"}],"version-history":[{"count":36,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5153\/revisions"}],"predecessor-version":[{"id":5929,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/posts\/5153\/revisions\/5929"}],"wp:featuredmedia":[{"embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media\/5928"}],"wp:attachment":[{"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/media?parent=5153"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/categories?post=5153"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/miro.borodziuk.eu\/index.php\/wp-json\/wp\/v2\/tags?post=5153"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}