Python lists are one of the most versatile and widely used data structures in the language. They are ordered collections of items that are defined by enclosing elements in square brackets, like this: [ ]. The primary features of Python lists include their mutability and dynamic nature. This means that the contents of a list can be changed after its creation—elements can be added, removed, or modified. Lists can store items of any data type, including other lists, making them incredibly flexible for handling a variety of data structures.

The purposes of Python lists are broad and include storing sequences of items, such as a collection of numbers, strings, objects, or even mixed types. They are particularly useful for implementing stacks, queues, and other collections. Lists are also essential for iterating over elements using loops, applying operations to each element, and comprehending operations that produce new lists based on existing ones.

One of the standout features of Python lists compared to lists in other programming languages is their dynamic sizing. In languages like C++ or Java, arrays have a fixed size defined at the time of their creation. In contrast, Python lists automatically resize as elements are added or removed, managed internally by the Python runtime. This flexibility removes the need for manual memory management, simplifying development.

Python lists have the following characteristics:

• Lists are used to store multiple items in a single variable.
• Lists are created using square brackets.

 

Example:

fruits = ["apple", "banana", "cherry"] print(fruits) # Output: ['apple', 'banana', 'cherry']

 

• Lists are one of the four built-in data types in Python for storing collections of data. The other three are Tuples, Sets, and Dictionaries, each with its own unique properties and uses.
• List items are indexed, with the first item having an index of [0], the second item an index of [1], and so on.

 

Example:

fruits = ["apple", "banana", "cherry"] print(fruits[1]) # Output: banana

 

• List items are ordered, changeable, and allow duplicate values.
• When we say that Python lists are ordered, it means that the items in a list have a defined sequence, and that sequence will remain consistent unless explicitly changed.

For example, in the fruits list, "apple" is always the first item, "banana" is the second, and "cherry" is the third.

If you add new items to a list, they will be placed at the end. For instance:

fruits = ["apple", "banana", "cherry"] fruits = ["apple", "banana", "cherry"] fruits.append("orange") # Add ‘orange’ at the end print(fruits) # Output: ['apple', 'banana', 'cherry', 'orange']

The list is changeable, which means you can modify it after creation. You can change, add, or remove items as needed. Here are some examples:

Changing an item:

fruits = ["apple", "banana", "cherry", "orange"] fruits[1] = "blueberry" # Update ‘banana’ with ‘blueberry’ print(fruits) # Output: ['apple', 'blueberry', 'cherry', 'orange']

Adding an item:

fruits = ["apple", "blueberry", "cherry", "orange"] fruits.append("graph") print(fruits) # Output: ['apple', 'blueberry', 'cherry', 'orange', 'grape']

Removing an item:

fruits = ["apple", "blueberry", "cherry", "orange", "graph"] fruits.remove("cherry") print(fruits) # Output: ['apple', 'blueberry', 'orange', 'grape']

Since lists are indexed, you can have items with the same value. Lists allow duplicate values, which can be useful in many scenarios. For example:

fruits = ["apple", "banana", "cherry", "apple", "cherry"] print(fruits)

This will output:

['apple', 'banana', 'cherry', 'apple', 'cherry']

   

In this list, "apple" and "cherry" appear twice. Each occurrence is considered a separate item in the list, maintaining their positions and order.

 

The len() function

You can use the len() function to determine how many items a list contains.

fruits = ["apple", "banana", "cherry", "apple", "cherry"] print(len(fruits)) # Output: 5

Data Types of List Items

Python lists are very flexible and can contain items of any data type, even within the same list. This makes them incredibly versatile for various programming tasks.

Here are some examples to illustrate this concept:

List of Integers:

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

List of Strings:

fruits = ["apple", "banana", "cherry"] print(fruits) # Output: ['apple', 'banana', 'cherry']

List of Mixed Data Types:

mixed = [1, "apple", 3.14, True] print(mixed) # Output: [1, 'apple', 3.14, True]

In the above example, the list contains an integer (1), a string ("apple"), a float (3.14), and a boolean (True).

 

The list() Constructor

The list() constructor in Python is a built-in function that creates a new list. It can be used to create an empty list or to convert other iterable types (such as strings, tuples, or sets) into a list.

Here are some examples to illustrate how the list() constructor works:

Creating an empty list:

empty_list = list() print(empty_list) # Output: []

Converting a String to a List:

string_to_list = list("hello") print(string_to_list) # Output: ['h', 'e', 'l', 'l', 'o']

Indexing

In Python, lists are indexed, which means each item in the list has a specific position, known as an index. The index is used to access individual items within the list.

Here are some key points and examples to help you understand list indexing in Python:

(Zero-Based Indexing)

Python lists use zero-based indexing, meaning the first item in the list has an index of 0, the second item has an index of 1, and so on.

fruits = ["apple", "banana", "cherry"] print(fruits[0]) # Output: apple print(fruits[1]) # Output: banana print(fruits[2]) # Output: cherry

(Negative Indexing)

Python also supports negative indexing, where -1 refers to the last item, -2 refers to the second-last item, and so on.

fruits = ["apple", "banana", "cherry"] print(fruits[-1]) # Output: cherry print(fruits[-2]) # Output: banana print(fruits[-3]) # Output: apple

(Accessing and Modifying List Items)

You can access individual items in a list using their index.

animals = ["cat", "dog", "rabbit"] print(animals[1]) # Output: dog animals[1] = "hamster" print(animals) # Output: ['cat', 'hamster', 'rabbit']

(IndexError)

Attempting to access an index that is out of the range of the list will result in an IndexError.

animals = ["cat", "dog", "rabbit"] print(animals[3]) # This will raise an IndexError

(Finding the Index of an Item)

You can find the index of the first occurrence of an item using the index() method. If the item is not found, it raises a ValueError.

animals = ["cat", "dog", "rabbit", "dog"] print(animals.index("dog")) # Output: 1 print(animals.index("elephant")) # This will raise a ValueError

Slicing

Slicing in Python allows you to access a subset of items from a list. This is done by specifying a start, stop, and step index within square brackets. The syntax for slicing is list[start:stop:step].

Here are some key points and examples to help you understand list slicing:

(Slicing with Start and Stop)

numbers = [0, 1, 2, 3, 4, 5, 6] print(numbers[1:4]) # Output: [1, 2, 3]

This slice starts at index 1 and stops before index 4, so it includes items at indexes 1, 2, and 3.

(Omitting Start or Stop)

numbers = [0, 1, 2, 3, 4, 5, 6] print(numbers[:4]) # Output: [0, 1, 2, 3] print(numbers[3:]) # Output: [3, 4, 5, 6]

• numbers[:4] starts from the beginning of the list and stops before index 4.
• numbers[3:] starts from index 3 and goes to the end of the list.

(Specifying a Step)

numbers = [0, 1, 2, 3, 4, 5, 6] print(numbers[1:6:2]) # Output: [1, 3, 5]

This slice starts at index 1, stops before index 6, and includes every second item.

(Using a Negative Step)

numbers = [0, 1, 2, 3, 4, 5, 6] print(numbers[::-1]) # Output: [6, 5, 4, 3, 2, 1, 0]

This slice reverses the list by starting from the end and stepping backwards.

(Using Negative Indices)

numbers = [0, 1, 2, 3, 4, 5, 6] print(numbers[-5:-2]) # Output: [2, 3, 4]

This slice starts at the fifth last item and stops before the second last item.

The in Keyword

The in keyword in Python is used to check if a specific item exists in a list (or any other iterable, like a string or tuple). It returns True if the item is found and False otherwise. This is a very convenient and readable way to perform membership tests.

Here are some examples to illustrate how it works:

(Checking for an item in a List)

fruits = ["apple", "banana", "cherry"] print("banana" in fruits) # Output: True print("orange" in fruits) # Output: False

In this example, "banana" is in the list fruits, so the first check returns True. "orange" is not in the list, so the second check returns False.

(Using in in an if statement)

fruits = ["apple", "banana", "cherry"] if "cherry" in fruits: print("Cherry is in the list!") else: print("Cherry is not in the list!")

This example shows how you can use the in keyword in an if statement to perform different actions based on whether an item is in the list.

The insert() Function

The insert() function in Python lists is used to add an item at a specified index. Unlike the append() function, which adds an item to the end of the list, insert() allows you to place the item at any position within the list. The syntax for insert() is list.insert(index, item), where index is the position at which the item will be inserted, and item is the element you want to add to the list.

Here are some examples to illustrate how insert() works:

(Inserting at a Specific Index)

fruits = ["apple", "banana", "cherry"] fruits.insert(1, "orange") print(fruits)

 

The output will be:

['apple', 'orange', 'banana', 'cherry']

In this example, "orange" is inserted at index 1, shifting "banana" and "cherry" one position to the right.

(Inserting with Negative Indices)

animals = ["cat", "dog", "rabbit"] animals.insert(-1, "hamster") print(animals)

The output will be:

 

['cat', 'dog', 'hamster', 'rabbit']

Using a negative index -1 inserts "hamster" just before the last item.

List Comprehension

List comprehensions in Python provide a concise way to create lists. They are often more readable and faster than using traditional for-loops and append() calls to construct lists. A list comprehension consists of brackets containing an expression followed by a for clause, and optionally additional for or if clauses.

The syntax can be written as:

                [expression for item in iterable if condition]

(Creating a list of squares)

squares = [x**2 for x in range(10)] print(squares)

The output will be:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

This list comprehension generates a list of squares of numbers from 0 to 9.

(Filtering with a Condition)

even_numbers = [x for x in range(10) if x % 2 == 0] print(even_numbers)

 

The output will be:

[0, 2, 4, 6, 8]

This creates a list of even numbers from 0 to 9 by including only those numbers that satisfy the condition x % 2 == 0.

The sort() function

The sort() method in Python is used to sort the elements of a list in place, meaning it modifies the original list. By default, it sorts the list in ascending order, but you can customize the sorting order by providing additional parameters.

Here are some key points and examples to illustrate how the sort() function works:

(Sorting a List of Numbers)

numbers = [5, 2, 9, 1, 5, 6] numbers.sort() print(numbers)

 

The output will be:

[1, 2, 5, 5, 6, 9]

This sorts the list of numbers in ascending order.

(Sorting a List of Strings)

fruits = ["apple", "banana", "cherry", "date"] fruits.sort() print(fruits)

 

The output will be:

['apple', 'banana', 'cherry', 'date']

This sorts the list of strings alphabetically.

(Sorting in Descending Order)

numbers = [5, 2, 9, 1, 5, 6] numbers.sort(reverse=True) print(numbers)

The output will be:

[9, 6, 5, 5, 2, 1]

Setting the reverse parameter to True sorts the list in descending order. 

 

Example Use Case - Total Sales Calculation

Write a program that asks the user to enter a store’s sales for each day of the week. The amounts should be stored in a list. Use a loop to calculate the total sales for the week and display the result.

Detailed Instructions

• Input Sales Data:
  • Prompt the user to enter sales amounts for each day of the week (Monday to Sunday).
  • Store each day's sales in a list.
• Calculate Total Sales:
  • Use a loop to iterate through the list and calculate the total sales for the week.
• Display Total Sales:
  • Print the total sales amount.

# Step 1: Input sales data sales = [] days_of_week = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] for day in days_of_week:     sale = float(input(f"Enter sales for {day}: "))     sales.append(sale) # Step 2: Calculate total sales total_sales = 0 for sale in sales:     total_sales += sale # Step 3: Display total sales print(f"\nTotal sales for the week: ${total_sales:.2f}")

Example Output:

Enter sales for Monday: 150.75 Enter sales for Tuesday: 200.50 Enter sales for Wednesday: 175.00 Enter sales for Thursday: 225.25 Enter sales for Friday: 300.00 Enter sales for Saturday: 400.50 Enter sales for Sunday: 350.00   Total sales for the week: $1802.00