{"id":2640,"date":"2026-10-19T10:09:48","date_gmt":"2026-10-19T10:09:48","guid":{"rendered":"https:\/\/prwatech.in\/blog\/?p=2640"},"modified":"2026-10-20T05:34:06","modified_gmt":"2026-10-20T05:34:06","slug":"python-list-tutorial","status":"publish","type":"post","link":"https:\/\/prwatech.in\/blog\/python\/python-data-types\/python-list-tutorial\/","title":{"rendered":"Python Lists Tutorial"},"content":{"rendered":"

Python Lists Tutorial With Examples<\/b><\/strong><\/h1>\n

Think of a shopping list on your phone. You add items as you remember them, strike off the ones you have bought, move things around, and sometimes sort the list to match the shop aisles. It can hold anything you like, and it grows and shrinks as you go. A Python list is the same idea, and it is the most used data type in the language.<\/p>\n

A list is an ordered collection of items, written in square brackets, that you can change after creating it. It can hold numbers, text, other lists, or a mix. Lists hold the rows of a dataset, the results of a search, the names in a class, or the steps in a recipe. Almost every Python program you write will use at least one.<\/p>\n

In this tutorial, we explain how to create a list, read items by position, change them and cut out slices. We then go through the list methods one by one, with the real output of every example: append, insert, extend, remove, pop, del, clear, copy, index, count, reverse and sort. We cover the places beginners get stuck, such as reverse and sort returning None, the copy trap, and extend against append. We finish with list comprehension, nested lists, a quick reference table and the full program.<\/p>\n

What is a Python List?<\/h2>\n

A list is an ordered, changeable collection of items written inside square brackets, with commas between the items.<\/p>\n

    \n
  • Ordered.<\/strong> Items stay in the order you put them, and each has a position.<\/li>\n
  • Mutable.<\/strong> You can change, add and remove items after the list is created.<\/li>\n
  • Allows duplicates.<\/strong> The same value can appear many times.<\/li>\n
  • Can mix types.<\/strong> Numbers, text, true or false values and other lists can share one list.<\/li>\n<\/ul>\n

    Every example below was run on Python 3.13, and the output is real.<\/p>\n

    How to Create a List in Python?<\/h2>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 33, 44]\r\nmixed = [1, \"two\", 3.5, True]\r\nprint(L1, mixed, [], list(\"abc\"))<\/pre>\n
    output<\/div>\n
    [11, 22, 33, 44] [1, 'two', 3.5, True] [] ['a', 'b', 'c']<\/pre>\n<\/div>\n
    The third item shows an empty list, and the fourth shows list()<\/code> turning a string into a list of its letters.<\/p>\n
    Reading Items by Index<\/h2>\n
    Each item has a position, called an index, counted from 0. A negative index counts from the end, so minus 1 is the last item.<\/p>\n
    \n\n\n\n\n\n\n
    How L1 is numbered<\/caption>\n
    Value<\/th>\n11<\/th>\n22<\/th>\n33<\/th>\n44<\/th>\n<\/tr>\n<\/thead>\n
    Index<\/th>\n0<\/td>\n1<\/td>\n2<\/td>\n3<\/td>\n<\/tr>\n
    Negative index<\/th>\n-4<\/td>\n-3<\/td>\n-2<\/td>\n-1<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 33, 44]\r\nprint(L1[2], L1[-1])<\/pre>\n
    output<\/div>\n
    33 44<\/pre>\n<\/div>\n
    Asking for a position that does not exist raises an error:<\/p>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 33, 44]\r\ntry:\r\n    L1[10]\r\nexcept IndexError as error:\r\n    print(\"IndexError:\", error)<\/pre>\n
    output<\/div>\n
    IndexError: list index out of range<\/pre>\n<\/div>\n
    Changing an Item<\/h2>\n
    Because lists are mutable, you can assign a new value to a position.<\/p>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 33, 44]\r\nL1[2] = 55\r\nprint(L1)<\/pre>\n
    output<\/div>\n
    [11, 22, 55, 44]<\/pre>\n<\/div>\n
    Slicing a List<\/h2>\n
    A slice takes a section of a list. The pattern is list[start:end:step]<\/code>. The start is included and the end is not. A step of minus 1 reverses the list.<\/p>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 55, 44]\r\nprint(L1[1:3], L1[::-1])<\/pre>\n
    output<\/div>\n
    [22, 55] [44, 55, 22, 11]<\/pre>\n<\/div>\n
    Looping Through a List<\/h2>\n
    A for<\/code> loop visits each item in turn. Print the loop variable, and indent the line inside the loop.<\/p>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 55, 44]\r\nfor x in L1:\r\n    print(x, end=\" \")<\/pre>\n
    output<\/div>\n
    11 22 55 44<\/pre>\n<\/div>\n
    When you need the position as well, use enumerate<\/code>:<\/p>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 55, 44]\r\nfor position, value in enumerate(L1):\r\n    print(position, value)<\/pre>\n
    output<\/div>\n
    0 11\r\n1 22\r\n2 55\r\n3 44<\/pre>\n<\/div>\n
    Checking Membership and Length<\/h2>\n
    The in<\/code> word tells you whether a value is in the list. len<\/code> counts the items.<\/p>\n
    \n
    python<\/div>\n
    L1 = [11, 22, 55, 44]\r\nprint(22 in L1, 99 in L1, len(L1))<\/pre>\n
    output<\/div>\n
    True False 4<\/pre>\n<\/div>\n
    List Methods in Python<\/h2>\n
    \n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n
    List methods at a glance<\/caption>\n
    Method<\/th>\nWhat it does<\/th>\nReturns<\/th>\n<\/tr>\n<\/thead>\n
    append(item)<\/th>\nAdds one item at the end<\/td>\nNone<\/td>\n<\/tr>\n
    insert(index, item)<\/th>\nAdds an item at a position<\/td>\nNone<\/td>\n<\/tr>\n
    extend(iterable)<\/th>\nAdds every item of another collection<\/td>\nNone<\/td>\n<\/tr>\n
    remove(item)<\/th>\nRemoves the first matching item<\/td>\nNone<\/td>\n<\/tr>\n
    pop(index)<\/th>\nRemoves and returns the item at a position, the last by default<\/td>\nThe item<\/td>\n<\/tr>\n
    clear()<\/th>\nRemoves every item<\/td>\nNone<\/td>\n<\/tr>\n
    copy()<\/th>\nMakes a shallow copy<\/td>\nA new list<\/td>\n<\/tr>\n
    index(item)<\/th>\nPosition of the first match<\/td>\nA number<\/td>\n<\/tr>\n
    count(item)<\/th>\nHow many times an item appears<\/td>\nA number<\/td>\n<\/tr>\n
    reverse()<\/th>\nReverses the list in place<\/td>\nNone<\/td>\n<\/tr>\n
    sort()<\/th>\nSorts the list in place<\/td>\nNone<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    append()<\/h3>\n
    append<\/code> adds a single item at the end.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.append(\"hg\")\r\nprint(L)<\/pre>\n
    output<\/div>\n
    ['a', 'ab', 'aaa', 'cc', 'hg']<\/pre>\n<\/div>\n
    If you append a list, it goes in as one item, and the list becomes nested:<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\", \"hg\"]\r\nL.append([\"x\", \"y\"])\r\nprint(L)<\/pre>\n
    output<\/div>\n
    ['a', 'ab', 'aaa', 'cc', 'hg', ['x', 'y']]<\/pre>\n<\/div>\n
    insert()<\/h3>\n
    insert<\/code> puts an item at the position you choose, and pushes the rest along.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.insert(3, \"hg\")\r\nprint(L)<\/pre>\n
    output<\/div>\n
    ['a', 'ab', 'aaa', 'hg', 'cc']<\/pre>\n<\/div>\n
    extend()<\/h3>\n
    extend<\/code> adds every item of another collection, one by one. A string counts as a collection of letters, which surprises many beginners.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.extend([\"qw\"])\r\nprint(L)\r\nL.extend(\"qw\")\r\nprint(L)<\/pre>\n
    output<\/div>\n
    ['a', 'ab', 'aaa', 'cc', 'qw']\r\n['a', 'ab', 'aaa', 'cc', 'qw', 'q', 'w']<\/pre>\n<\/div>\n
    Use a list, as in the first call, to add a whole word as one item.<\/p>\n
    \n\n\n\n\n\n\n\n
    append compared with extend<\/caption>\n
    Point<\/th>\nappend<\/th>\nextend<\/th>\n<\/tr>\n<\/thead>\n
    Adds<\/th>\nOne item, as it is<\/td>\nEach item of a collection<\/td>\n<\/tr>\n
    append([1, 2])<\/th>\nAdds one list, so the list is nested<\/td>\nAdds 1 and 2 as separate items<\/td>\n<\/tr>\n
    Use when<\/th>\nYou have one thing to add<\/td>\nYou have many things to add<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    remove()<\/h3>\n
    remove<\/code> deletes the first item that matches a value. It raises a ValueError if the value is not there.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.remove(\"ab\")\r\nprint(L)\r\ntry:\r\n    L.remove(\"zzz\")\r\nexcept ValueError as error:\r\n    print(\"ValueError:\", error)<\/pre>\n
    output<\/div>\n
    ['a', 'aaa', 'cc']\r\nValueError: list.remove(x): x not in list<\/pre>\n<\/div>\n
    pop()<\/h3>\n
    pop<\/code> removes an item by position and gives it back. With no position, it takes the last one. It also returns the item, so you can use it.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nprint(L.pop(2), L)\r\nprint(L.pop(), L)<\/pre>\n
    output<\/div>\n
    aaa ['a', 'ab', 'cc']\r\ncc ['a', 'ab']<\/pre>\n<\/div>\n
    del<\/h3>\n
    del<\/code> is a statement, not a method. It removes an item or a slice by position, or the whole list.<\/p>\n
    \n
    python<\/div>\n
    L = [10, 20, 30, 40, 50]\r\ndel L[1]\r\nprint(L)\r\ndel L[1:3]\r\nprint(L)<\/pre>\n
    output<\/div>\n
    [10, 30, 40, 50]\r\n[10, 50]<\/pre>\n<\/div>\n
    Writing del L<\/code> with no position removes the name itself, and using the list after that raises a NameError.<\/p>\n
    \n
    python<\/div>\n
    gone = [1, 2]\r\ndel gone\r\ntry:\r\n    print(gone)\r\nexcept NameError as error:\r\n    print(\"NameError:\", error)<\/pre>\n
    output<\/div>\n
    NameError: name 'gone' is not defined<\/pre>\n<\/div>\n
    clear()<\/h3>\n
    clear<\/code> empties the list but keeps it. The list still exists and prints as empty brackets.<\/p>\n
    \n
    python<\/div>\n
    L = [10, 50]\r\nL.clear()\r\nprint(L)<\/pre>\n
    output<\/div>\n
    []<\/pre>\n<\/div>\n
    copy()<\/h3>\n
    Writing alias = a<\/code> does not copy a list. Both names point to the same list, so a change through one shows up in the other. copy<\/code> makes a separate list.<\/p>\n
    \n
    python<\/div>\n
    a = [1, 2, 3]\r\nalias = a\r\ncopy_of = a.copy()\r\na.append(4)\r\nprint(\"alias:\", alias, \"copy:\", copy_of)<\/pre>\n
    output<\/div>\n
    alias: [1, 2, 3, 4] copy: [1, 2, 3]<\/pre>\n<\/div>\n
    But copy<\/code> is shallow. If the list holds other lists, those inner lists are still shared. Use copy.deepcopy<\/code> from the copy<\/code> module when you need a fully independent copy.<\/p>\n
    \n
    python<\/div>\n
    nested = [[1, 2], [3]]\r\nshallow = nested.copy()\r\nnested[0].append(99)\r\nprint(\"shallow:\", shallow)<\/pre>\n
    output<\/div>\n
    shallow: [[1, 2, 99], [3]]<\/pre>\n<\/div>\n
    index() and count()<\/h3>\n
    index<\/code> is a method, so call it on the list, as in L.index(\"a\")<\/code>.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\", \"a\"]\r\nprint(L.index(\"a\"), L.count(\"a\"))\r\nprint(L.index(\"a\", 1))<\/pre>\n
    output<\/div>\n
    0 2\r\n4<\/pre>\n<\/div>\n
    The first line shows that a first appears at position 0, and that it appears twice. The second index<\/code> call starts looking from position 1, so it finds the later a at position 4.<\/p>\n
    reverse()<\/h3>\n
    reverse<\/code> flips the list in place. It returns None, so printing the call itself shows None. It is a method, and it gives nothing back.<\/p>\n
    \n
    python<\/div>\n
    L = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nprint(L.reverse())\r\nprint(L)<\/pre>\n
    output<\/div>\n
    None\r\n['cc', 'aaa', 'ab', 'a']<\/pre>\n<\/div>\n
    sort()<\/h3>\n
    sort<\/code> puts the list in order, in place, and also returns None. Use reverse=True<\/code> for a descending order, and key<\/code> to choose what to sort by.<\/p>\n
    \n
    python<\/div>\n
    L = [\"cc\", \"a\", \"aaa\", \"ab\"]\r\nprint(L.sort())\r\nprint(L)\r\nL.sort(reverse=True)\r\nprint(L)\r\nL.sort(key=len)\r\nprint(L)<\/pre>\n
    output<\/div>\n
    None\r\n['a', 'aaa', 'ab', 'cc']\r\n['cc', 'ab', 'aaa', 'a']\r\n['a', 'cc', 'ab', 'aaa']<\/pre>\n<\/div>\n
    The last sort is by length. Items with the same length keep their earlier order, which is why cc stays before ab.<\/p>\n
    sort() Against sorted()<\/h3>\n
    If you want a sorted copy and want to keep the original, use the sorted<\/code> function. It works on any collection and returns a new list.<\/p>\n
    \n
    python<\/div>\n
    data = [3, 1, 2]\r\nprint(sorted(data), data)\r\nprint(sorted(\"hello\"))<\/pre>\n
    output<\/div>\n
    [1, 2, 3] [3, 1, 2]\r\n['e', 'h', 'l', 'l', 'o']<\/pre>\n<\/div>\n
    Joining, Repeating and Summarising Lists<\/h2>\n
    \n
    python<\/div>\n
    print([1, 2] + [3], [0] * 3)\r\nnums = [4, 8, 15, 16, 23, 42]\r\nprint(min(nums), max(nums), sum(nums), sum(nums) \/ len(nums))<\/pre>\n
    output<\/div>\n
    [1, 2, 3] [0, 0, 0]\r\n4 42 108 18.0<\/pre>\n<\/div>\n
    Plus joins two lists into a new one, and star repeats a list. min<\/code>, max<\/code> and sum<\/code> work on lists of numbers.<\/p>\n
    List Comprehension<\/h2>\n
    A list comprehension builds a new list in one line. Read it as: give me this, for each item in that, if the condition holds.<\/p>\n
    \n
    python<\/div>\n
    nums = [4, 8, 15, 16, 23, 42]\r\nprint([n * n for n in nums if n % 2 == 0])<\/pre>\n
    output<\/div>\n
    [16, 64, 256, 1764]<\/pre>\n<\/div>\n
    It took the even numbers from nums<\/code>, which are 4, 8, 16 and 42, and squared each one.<\/p>\n
    Nested Lists<\/h2>\n
    A list can hold other lists, which is how you store rows and columns. Use one index for each level, the row first.<\/p>\n
    \n
    python<\/div>\n
    grid = [[1, 2, 3], [4, 5, 6]]\r\nprint(grid[1][2])<\/pre>\n
    output<\/div>\n
    6<\/pre>\n<\/div>\n
    A Classic Mistake: append Returns None<\/h2>\n
    Methods like append<\/code>, sort<\/code> and reverse<\/code> change the list and return None. If you write the result into a variable, you lose your list:<\/p>\n
    \n
    python<\/div>\n
    result = [1, 2].append(3)\r\nprint(result)<\/pre>\n
    output<\/div>\n
    None<\/pre>\n<\/div>\n
    Call the method on its own line, and then use the list.<\/p>\n
    Quick Reference: List, Tuple, Set and Dictionary<\/h2>\n
    \n\n\n\n\n\n\n\n\n
    Four collection types compared<\/caption>\n
    Type<\/th>\nWritten as<\/th>\nOrdered<\/th>\nChangeable<\/th>\nDuplicates<\/th>\n<\/tr>\n<\/thead>\n
    List<\/th>\n[1, 2, 3]<\/td>\nYes<\/td>\nYes<\/td>\nAllowed<\/td>\n<\/tr>\n
    Tuple<\/th>\n(1, 2, 3)<\/td>\nYes<\/td>\nNo<\/td>\nAllowed<\/td>\n<\/tr>\n
    Set<\/th>\n{1, 2, 3}<\/td>\nNo<\/td>\nYes<\/td>\nNot allowed<\/td>\n<\/tr>\n
    Dictionary<\/th>\n{“a”: 1}<\/td>\nYes<\/td>\nYes<\/td>\nKeys must be unique<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
    Common Mistakes to Avoid<\/h2>\n
      \n
    • Printing the result of sort or reverse.<\/strong> They return None. Call them, then print the list.<\/li>\n
    • Writing index or sort as a plain function.<\/strong> They are methods, so write L.index<\/code> and L.sort<\/code>. The built in sorted<\/code> is a function, and it works as sorted(L)<\/code>.<\/li>\n
    • Using extend with a string.<\/strong> It adds each letter. Use append<\/code>, or extend<\/code> with a list.<\/li>\n
    • Thinking b = a makes a copy.<\/strong> It makes a second name for the same list. Use a.copy()<\/code>.<\/li>\n
    • Asking for an index past the end.<\/strong> It raises an IndexError. The last index is len<\/code> minus 1.<\/li>\n
    • Removing a value that is not there.<\/strong> remove<\/code> raises a ValueError. Check with in<\/code> first.<\/li>\n
    • Changing a list while looping over it.<\/strong> Items can be skipped. Loop over a copy or build a new list.<\/li>\n
    • Forgetting that append adds one item.<\/strong> Appending a list nests it.<\/li>\n<\/ul>\n
      Try It Yourself: The Full Program<\/h2>\n
      The program below holds every example in this tutorial. Copy it into a file, run it, and compare the output with what you see above.<\/p>\n
      \n
      python<\/div>\n
      import sys\r\nprint(\"Python\", sys.version_info.major, sys.version_info.minor)\r\n\r\n# Creating lists\r\nL1 = [11, 22, 33, 44]\r\nmixed = [1, \"two\", 3.5, True]\r\nprint(L1, mixed, [], list(\"abc\"))\r\n\r\n# Indexing, changing and slicing\r\nprint(L1[2], L1[-1])\r\nL1[2] = 55\r\nprint(L1)\r\nprint(L1[1:3], L1[::-1])\r\ntry:\r\n    L1[10]\r\nexcept IndexError as error:\r\n    print(\"IndexError:\", error)\r\n\r\n# Looping and membership\r\nfor x in L1:\r\n    print(x, end=\" \")\r\nprint()\r\nfor position, value in enumerate(L1):\r\n    print(position, value)\r\nprint(22 in L1, 99 in L1, len(L1))\r\n\r\n# Adding\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.append(\"hg\")\r\nprint(L)\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.insert(3, \"hg\")\r\nprint(L)\r\nL.append([\"x\", \"y\"])\r\nprint(L)\r\n\r\n# extend with a list and with a string\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.extend([\"qw\"])\r\nprint(L)\r\nL.extend(\"qw\")\r\nprint(L)\r\n\r\n# Removing\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nL.remove(\"ab\")\r\nprint(L)\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nprint(L.pop(2), L)\r\nprint(L.pop(), L)\r\ntry:\r\n    L.remove(\"zzz\")\r\nexcept ValueError as error:\r\n    print(\"ValueError:\", error)\r\nL = [10, 20, 30, 40, 50]\r\ndel L[1]\r\nprint(L)\r\ndel L[1:3]\r\nprint(L)\r\nL.clear()\r\nprint(L)\r\ngone = [1, 2]\r\ndel gone\r\ntry:\r\n    print(gone)\r\nexcept NameError as error:\r\n    print(\"NameError:\", error)\r\n\r\n# Copy against alias\r\na = [1, 2, 3]\r\nalias = a\r\ncopy_of = a.copy()\r\na.append(4)\r\nprint(\"alias:\", alias, \"copy:\", copy_of)\r\nnested = [[1, 2], [3]]\r\nshallow = nested.copy()\r\nnested[0].append(99)\r\nprint(\"shallow:\", shallow)\r\n\r\n# Searching and counting\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\", \"a\"]\r\nprint(L.index(\"a\"), L.count(\"a\"))\r\nprint(L.index(\"a\", 1))\r\n\r\n# Reverse and sort work in place and return None\r\nL = [\"a\", \"ab\", \"aaa\", \"cc\"]\r\nprint(L.reverse())\r\nprint(L)\r\nL = [\"cc\", \"a\", \"aaa\", \"ab\"]\r\nprint(L.sort())\r\nprint(L)\r\nL.sort(reverse=True)\r\nprint(L)\r\nL.sort(key=len)\r\nprint(L)\r\nprint(sorted([3, 1, 2]), sorted(\"hello\"))\r\ndata = [3, 1, 2]\r\nprint(sorted(data), data)\r\n\r\n# Joining, repeating and summary functions\r\nprint([1, 2] + [3], [0] * 3)\r\nnums = [4, 8, 15, 16, 23, 42]\r\nprint(min(nums), max(nums), sum(nums), sum(nums) \/ len(nums))\r\n\r\n# Comprehension and nested lists\r\nprint([n * n for n in nums if n % 2 == 0])\r\ngrid = [[1, 2, 3], [4, 5, 6]]\r\nprint(grid[1][2])\r\n\r\n# A classic mistake: append returns None\r\nresult = [1, 2].append(3)\r\nprint(result)<\/pre>\n<\/div>\n