In Python, lists are versatile mutable sequences with built-in methods for adding, removing, searching, sorting, and more—covering all common scenarios like dynamic data manipulation, queues, or stacks. Below is a complete breakdown of all list methods, each with syntax, an example, and output, plus key built-in functions for comprehensive use.

📚 Adding Elements
⦁ append(x): Adds a single element to the end.

  lst = [1, 2]
  lst.append(3)
  print(lst)  # Output: [1, 2, 3]
  

⦁ extend(iterable): Adds all elements from an iterable to the end.

  lst = [1, 2]
  lst.extend([3, 4])
  print(lst)  # Output: [1, 2, 3, 4]
  

⦁ insert(i, x): Inserts x at index i (shifts elements right).

  lst = [1, 3]
  lst.insert(1, 2)
  print(lst)  # Output: [1, 2, 3]
  

📚 Removing Elements
⦁ remove(x): Removes the first occurrence of x (raises ValueError if not found).

  lst = [1, 2, 2]
  lst.remove(2)
  print(lst)  # Output: [1, 2]
  

⦁ pop(i=-1): Removes and returns the element at index i (default: last).

  lst = [1, 2, 3]
  item = lst.pop(1)
  print(item, lst)  # Output: 2 [1, 3]
  

⦁ clear(): Removes all elements.

  lst = [1, 2, 3]
  lst.clear()
  print(lst)  # Output: []
  

📚 Searching and Counting
⦁ count(x): Returns the number of occurrences of x.

  lst = [1, 2, 2, 3]
  print(lst.count(2))  # Output: 2
  

⦁ index(x[, start[, end]]): Returns the lowest index of x in the slice (raises ValueError if not found).

  lst = [1, 2, 3, 2]
  print(lst.index(2))  # Output: 1
  

📚 Ordering and Copying
⦁ sort(key=None, reverse=False): Sorts the list in place (ascending by default; stable sort).

  lst = [3, 1, 2]
  lst.sort()
  print(lst)  # Output: [1, 2, 3]
  

⦁ reverse(): Reverses the elements in place.

  lst = [1, 2, 3]
  lst.reverse()
  print(lst)  # Output: [3, 2, 1]
  

⦁ copy(): Returns a shallow copy of the list.

  lst = [1, 2]
  new_lst = lst.copy()
  print(new_lst)  # Output: [1, 2]
  

📚 Built-in Functions for Lists (Common Cases)
⦁ len(lst): Returns the number of elements.

  lst = [1, 2, 3]
  print(len(lst))  # Output: 3
  

⦁ min(lst): Returns the smallest element (raises ValueError if empty).

  lst = [3, 1, 2]
  print(min(lst))  # Output: 1
  

⦁ max(lst): Returns the largest element.

  lst = [3, 1, 2]
  print(max(lst))  # Output: 3
  

⦁ sum(lst[, start=0]): Sums the elements (start adds an offset).

  lst = [1, 2, 3]
  print(sum(lst))  # Output: 6
  

⦁ sorted(lst, key=None, reverse=False): Returns a new sorted list (non-destructive).

  lst = [3, 1, 2]
  print(sorted(lst))  # Output: [1, 2, 3]
  

These cover all standard operations (O(1) for append/pop from end, O(n) for most others). Use slicing lst[start:end:step] for advanced extraction, like lst[1:3] outputs ``.

#python #lists #datastructures #methods #examples #programming

⭐ @DataScience4

💡 Python Lists Cheatsheet: Essential Operations

This lesson provides a quick reference for common Python list operations. Lists are ordered, mutable collections of items, and mastering their use is fundamental for Python programming. This cheatsheet covers creation, access, modification, and utility methods.

# 1. List Creation
my_list = [1, "hello", 3.14, True]
empty_list = []
numbers = list(range(5)) # [0, 1, 2, 3, 4]

# 2. Accessing Elements (Indexing & Slicing)
first_element = my_list[0]     # 1
last_element = my_list[-1]    # True
sub_list = my_list[1:3]       # ["hello", 3.14]
copy_all = my_list[:]         # [1, "hello", 3.14, True]

# 3. Modifying Elements
my_list[1] = "world"          # my_list is now [1, "world", 3.14, True]

# 4. Adding Elements
my_list.append(False)         # [1, "world", 3.14, True, False]
my_list.insert(1, "new item") # [1, "new item", "world", 3.14, True, False]
another_list = [5, 6]
my_list.extend(another_list)  # [1, "new item", "world", 3.14, True, False, 5, 6]

# 5. Removing Elements
removed_value = my_list.pop() # Removes and returns last item (6)
removed_at_index = my_list.pop(1) # Removes and returns "new item"
my_list.remove("world")       # Removes the first occurrence of "world"
del my_list[0]                # Deletes item at index 0 (1)
my_list.clear()               # Removes all items, list becomes []

# Re-create for other examples
numbers = [3, 1, 4, 1, 5, 9, 2]

# 6. List Information
list_length = len(numbers)    # 7
count_ones = numbers.count(1) # 2
index_of_five = numbers.index(5) # 4 (first occurrence)
is_present = 9 in numbers     # True
is_not_present = 10 not in numbers # True

# 7. Sorting
numbers_sorted_asc = sorted(numbers) # Returns new list: [1, 1, 2, 3, 4, 5, 9]
numbers.sort(reverse=True)          # Sorts in-place: [9, 5, 4, 3, 2, 1, 1]

# 8. Reversing
numbers.reverse()                   # Reverses in-place: [1, 1, 2, 3, 4, 5, 9]

# 9. Iteration
for item in numbers:
    # print(item)
    pass # Placeholder for loop body

# 10. List Comprehensions (Concise creation/transformation)
squares = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]
even_numbers = [x for x in numbers if x % 2 == 0] # [2, 4]

Code explanation: This script demonstrates fundamental list operations in Python. It covers creating lists, accessing elements using indexing and slicing, modifying existing elements, adding new items with append(), insert(), and extend(), and removing items using pop(), remove(), del, and clear(). It also shows how to get list information like length (len()), item counts (count()), and indices (index()), check for item existence (in), sort (sort(), sorted()), reverse (reverse()), and iterate through lists. Finally, it illustrates list comprehensions for concise list generation and filtering.

#Python #Lists #DataStructures #Programming #Cheatsheet

━━━━━━━━━━━━━━━
By: @DataScience4 ✨