20. LIST – Python Data Structures

A list is a collection of items enclosed in square brackets [ ], separated by commas.

my_list = [10, 20, 30, 40, 50]

Key features of lists: • Lists can store different data types: integers, floats, strings, even other lists. • Lists are indexed, starting from 0. • Lists are mutable (can be changed after creation).

A list in Python is a versatile data structure that can hold multiple items. It's enclosed in square brackets, with items separated by commas. Lists can contain various data types such as numbers, strings, or even other lists. Each item in a list is assigned an index, starting from 0, which means the first item is at index 0, the second at index 1, and so on. Another important feature is that lists are mutable, meaning their content can be changed after they have been created, unlike strings which are immutable.

Think of a list like a box of different colored marbles. Each marble represents an item that can be unique, like a red marble (a string), a blue one (an integer), or even a green marble (another mini box of marbles, i.e., another list). You can always change the marbles in the box (mutability), and you can find each marble by its position in the box (indexing).

Creating lists

numbers = [1, 2, 3, 4, 5] fruits = ["apple", "banana", "mango"] mixed = [1, "apple", 3.14, True] empty = [] # empty list

To create a list in Python, you can define it by placing the items inside square brackets. The items can be of the same type, like 'numbers' which holds integers, or varied types, like 'mixed' that includes an integer, a string, a float, and a boolean. You can also create an empty list, which can be filled later as needed. This flexibility allows you to store data efficiently based on your program's requirements.

Imagine a shopping cart where you can put different items. You can have a cart full of just fruits (like the 'fruits' list), or you can mix categories like fruits, clothes, and electronics (like the 'mixed' list). You can even start with an empty cart when shopping and add items as you find them (the 'empty' list).

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

Negative Indexing: print(fruits[-1]) # Output: mango print(fruits[-2]) # Output: banana

You can access any element in a list using its index. In the example, 'fruits[0]' gives you the first item that is 'apple', and 'fruits[2]' gives you 'mango' as it is the third item. Python also allows negative indexing, where 'fruits[-1]' retrieves the last item in the list, and 'fruits[-2]' retrieves the second last item. This feature makes it easier to fetch items from the end of a list without knowing its exact length.

Think about a bookshelf with books lined up. The first book on the shelf is like the first item in your list. If you want the last book easily, instead of counting all the way down the shelf, you can just say 'give me the last book', which is similar to negative indexing in lists.

fruits = ["apple", "banana", "mango"] fruits[1] = "kiwi" print(fruits) # Output: ['apple', 'kiwi', 'mango']

Lists in Python are mutable, which means you can change their contents even after they are created. In this example, we change 'banana' (at index 1) to 'kiwi'. After this modification, the list now reflects the updated content. This capability allows you to efficiently manage and update your data as required.

Consider a fashion closet where you may have to change the outfit hangers. If one day you want to replace a blue shirt (like 'banana') with a green one ('kiwi'), you simply take the blue one off the hanger and put the green one in its place. The closet still holds clothes, just like the list still holds elements; but now one is different.

Using append() Adds an element at the end. fruits.append("orange")

Using insert() Adds an element at a specific index. fruits.insert(1, "grapes")

Adding elements to a list can be done using methods like 'append()' or 'insert()'. The 'append()' method adds an item to the end of the list. For instance, using 'fruits.append("orange")' adds 'orange' at the last position of the list. The 'insert()' method allows you to add an item at a specific index (like 'fruits.insert(1, "grapes")'), pushing subsequent elements one position down.

Imagine filling a jar with candies. When you add candies using 'append()', you simply drop more candies in at the top (the end of the jar). If you want to add a special candy between others, you can carefully place it at a certain position (using 'insert()'), jostling the other candies to make room.

Using remove() Removes the first occurrence of the value. fruits.remove("banana")

Using pop() Removes and returns the element at the specified index. fruits.pop(2)

Using del Deletes the element by index. del fruits[0]

When you need to remove items from a list, Python provides several methods. The 'remove()' method eliminates the first instance of the specified value (like removing 'banana'). The 'pop()' method not only removes an element but also returns it, which is useful if you want to use the removed item (like popping the fruit at index 2). The 'del' statement can remove an item at any specified index without returning it.

Think about decluttering a toolbox. If you want to remove a wrench (like removing 'banana'), you simply take it out with 'remove()'. If you want to take out the last tool you used and need it back for once (like using 'pop()'), you can pull it out and it also tells you what it was. Finally, if you want to clear away the first tool on your table without caring to use it again (using 'del'), you just set that aside.

for fruit in fruits: print(fruit)

Using index

for i in range(len(fruits)): print(fruits[i])

Traversing, or looping through a list, allows you to access each item sequentially. You can do this either by directly iterating over the items using 'for fruit in fruits:' or by using a range with indices, 'for i in range(len(fruits)):', which provides the index of each item as you loop through. This is essential for performing operations or extracting information from all elements in a list.

Imagine going through a lineup of people at an event. You can either speak with each person directly as you go down the line (the first method), or you can count your way along the line (the second method), asking each person to introduce themselves by number. Both methods let you get to know each individual.

Function/Method Description len(list) Returns number of elements in list min(list) Returns smallest item max(list) Returns largest item sum(list) Returns sum of all numeric values list.sort() Sorts the list (ascending) list.reverse() Reverses the order of the list list.index(value) Returns index of first occurrence of value list.count(value) Returns count of a value list.copy() Returns a shallow copy of the list list.clear() Removes all elements

Python lists come with various built-in functions and methods that perform specific operations. For example, 'len(list)' gives you the total number of items, while 'min()' and 'max()' help find the smallest and largest items respectively. You can aggregate values with 'sum()', and manipulate the order of items using 'sort()' or 'reverse()'. 'index()' provides the position of a specific value, and 'count()' tells you how many times a value appears in the list. The 'copy()' method makes a duplicate of the list, while 'clear()' removes everything from it.

These functions are like having specialized tools in your toolbox for specific tasks. You have a ruler (for 'len()' to measure how many items); a scale for finding the lightest (min) and heaviest (max) items; calculators for adding up values ('sum()'). It’s all about quickly finding or organizing your tools without having to sift through the entire box.

A list within a list. matrix = [ [1, 2, 3], [4, 5, 6], [7, 8, 9] ] print(matrix[0][1]) # Output: 2

A nested list is essentially a list that contains other lists as its items. This structure allows the creation of complex data formats, such as matrices or grids. Accessing values within nested lists requires two indices, the first for the outer list and the second for the inner list. In the example, 'matrix[0][1]' accesses the second item of the first inner list, yielding the value 2.

Think of a bookshelf organized into rows (outer list) where each row contains a set of books (inner lists). To find a specific book, you first identify the row (or the first index), and then you look at the specific book's position (the second index) within that row to get your book.

A concise way to create lists. squares = [x*x for x in range(1, 6)] print(squares) # Output: [1, 4, 9, 16, 25]

List comprehension is an advanced feature in Python that allows you to create lists quickly and concisely in a single line of code. It follows the structure '[expression for item in iterable]'. In the example, it generates a list of squares from 1 to 5. This technique is efficient and readable, making it easier to write and understand code that creates new lists based on existing ones.

Imagine you have a machine that automatically processes a list of numbers and produces another list of their squares. Instead of doing each calculation manually, you could just place the original numbers in and let it spit out the squared numbers in one go—this is the beauty of list comprehension.

• Storing datasets. • Managing input-output values in machine learning models. • Creating feature vectors. • Holding data from sensors, user inputs, or text processing. • Managing results of image pixels, audio samples, or word embeddings.

Lists play a crucial role in the field of AI across various applications. They can be used to store datasets for training models, where each element could represent a sample of data. In machine learning, lists manage input and output values during model training and inference. Lists help create feature vectors, which are essential for representing data points in a mathematical form. Additionally, lists can hold data collected from sensors or user inputs, and they manage outcomes from processes such as image processing and audio analysis.

Consider a library filled with books, where each book represents data. You can organize the bookshelves to help a librarian find the right one quickly. Similarly, lists in AI help organize, access, and process vast amounts of information, just like a librarian manages the knowledge inside a library.

--