‹ PREV

Learn Lists in python

 NEXT ›

Lists are another core data type in Python, highly useful for handling collections of items. Let’s break down lists from the ground up, looking at how they work and some practical examples.

What is a List in Python?

A list in Python is a dynamic, ordered collection of elements, which means:

  • • You can add, remove, or change elements in a list.
  • • Items in a list are stored in the order they are added.
  • • Lists can hold different data types, though they’re often used to store related items of the same type.

Basic List Creation

A list is created by enclosing elements in square brackets [ ] and separating them with commas. Creating a list of strings 

fruits = ["apple", "banana", "cherry"]

Examples on Lists in python

 Example 1: Tracking a Shopping Cart

Imagine an online shopping cart, where each item a user adds is stored in a list.

shopping_cart = ["laptop", "headphones", "notebook"]
print(shopping_cart)
Output: ["laptop", "headphones", "notebook"]

Here, each element in shopping_cart represents a product. This list can grow or shrink dynamically as the user adds or removes items.

Accessing and Modifying List Elements

Python lists allow you to access items by index (starting from 0), modify elements, and even add or remove items dynamically.

  • 1. Accessing Items - Use the index to access specific items.
    • print(shopping_list[1])  # Output: eggs
  • 2. Modifying Items - You can replace an item at a specific index.
    • shopping_list[2] = "butter"
print(shopping_list)  # Output: ['milk', 'eggs', 'butter']
  • 3. Adding Items - Use .append() to add an item at the end.
    • shopping_list.append("coffee")
print(shopping_list)  # Output: ['milk', 'eggs', 'butter', 'coffee']
  • 4. Removing Items - Use .remove() to remove a specific item or .pop() to remove by index.
    • shopping_list.remove("milk")
print(shopping_list)  # Output: ['eggs', 'butter', 'coffee']
    Example 2: Task Management System

    Imagine building a simple to-do list app that lets users add, update, and remove tasks.

    tasks = ["Finish report", "Call John", "Email client"]
tasks.append("Prepare slides")  # Adding a new task
tasks[0] = "Finish report and review"  # Updating a task
tasks.pop(1)  # Removing 'Call John' by index
    
print(tasks)
Output: ['Finish report and review', 'Email client', 'Prepare slides']

    List Methods for Efficient Data Handling

    Python lists come with a suite of built-in methods that make managing collections of data straightforward:

    1. sort() – Sorts the list in ascending order.

    numbers = [3, 1, 4, 1, 5]
numbers.sort()
print(numbers)  # Output: [1, 1, 3, 4, 5]

    2. reverse() – Reverses the list order.

    numbers.reverse()
print(numbers)  # Output: [5, 4, 3, 1, 1]

    3. len() – Gets the length (number of items) in the list.

    print(len(numbers))  # Output: 5

    4. count() – Counts the occurrences of an element.

    print(numbers.count(1))  # Output: 2
    Example 3: Tracking Monthly Expenses

    Imagine you’re creating an app to track monthly expenses. You can store each expense in a list and calculate total spending.

    expenses = [1200, 250, 800, 300, 150]
total_expenses = sum(expenses)
average_expense = total_expenses / len(expenses)
    
print(f"Total Expenses: {total_expenses}")
print(f"Average Expense: {average_expense}")
Output: Total Expenses: 2700
Average Expense: 540.0

    Working with Nested Lists

     A nested list is a list within a list. This is helpful for storing grid-like or hierarchical data. Real-Life Example 4: Storing a Matrix of Data

    In data processing, you might store tabular data or matrices. Here’s a simple 2x2 matrix:

    matrix = [[1, 2], [3, 4]]
print(matrix[1][0])  # Accesses the first item of the second row
Output:3

    Summary:

    • Lists are ordered, dynamic, and allow duplicates, which makes them suitable for most general-purpose data storage.

    • Common operations such as append, remove, and slicing is essential for handling dynamic data structures.

    • List methods like sort, reverse, and count add efficiency and flexibility to data processing tasks.