Python List

Python List

List data structure characteristics:

• List is a mutable object, this means that same instance of list can be modified to add, update and remove items.
• List can be empty or made up of either homogenous items(same datatype) or heterogenous items(different datatype or data structures).
• List are iterable object, this means that user can loop items in the list from 1st through last item or vice versa.
• As applicable for most Python objects, index in List objects also starts from Zero position. This means index of first element in the list will be Zero, below listed example is showing pictorial representation of List in Python.

  
  a_list = ['D', 'B', 'M', 'S', 'T', 'U', 'T', 'O', 'R', 'I', 'A', 'L', 'S']
  

  
  

  
  Examples:
  
  print(a_list[0])
  Output 1: D
  
  
  print(a_list[2])
  Output 2: M
  
  
  print(a_list[-2])
  Output 3: L
  

• Like array in many programming languages, List items can be replaced using positional index. 'M' character at index(position) 2 is replaced with 'Py' in the below example.

  
  a_list = ['D', 'B', 'M', 'S', 'T', 'U', 'T', 'O', 'R', 'I', 'A', 'L', 'S']
  a_list[2]='Py'
  print(a_list)
  
  Output:  ['D', 'B', 'Py', 'S', 'T', 'U', 'T', 'O', 'R', 'I', 'A', 'L', 'S']
  

• Keyword 'del' can be used to remove item from the specified position. 'Py' item present at index(position) 2 is removed in the below example.

  
  a_list = ['D', 'B', 'Py', 'S', 'T', 'U', 'T', 'O', 'R', 'I', 'A', 'L', 'S']
  del a_list[2]
  print(a_list)
  
  Output:  ['D', 'B', 'S', 'T', 'U', 'T', 'O', 'R', 'I', 'A', 'L', 'S']
  

• Like Python strings, 2 list objects can be joined using plus(+) operator to form 3rd list.

  
  list1 = ['a','b']
  list2 = ['cd','e']
  list3 = list1 + list2
  print(list3)
  
  Output:  ['a', 'b', 'cd', 'e']
  

• Available built-in Python functions helps to perform variety of operations on list objects, click on the required function to get more detail and sample examples.
  • Length
  • Append
  • Extend
  • Insert
  • Index
  • Count
  • Remove
  • Pop
  • Sort
  • Copy
  • Reverse
  • Clear
• Some of miscellaneous topics explained with examples
  • Extend Vs Append
  • Remove Vs Pop
  • List Comprehensions
  • List as Stacks
  • List as Queues
  • Create a copy of List (4 approaches)
  • Create a reference to a existing list
  • Slice List

➠ Append Vs Extend

• extend() function requires iterable object(such as list) as input otherwise it will throw error that 'object is not iterable'.
• append() function does not require iterable object as input but can be passed.
  
  
• extend() function will iterate through all the elements in the passed input and add them as individual item in the existing list.
• append() function will append the passed input as single element in the existing list.
  
  Extend Example:

  
  a_list = [1, 2, 3, 6, 'A']
  b_list = [4, 5, 7] 
  a_list.extend(b_list)   # Using extend() function here
  print(a_list)           # b_list elements got added as 6th 7th & 8th items in a_list
  
  Output: [1, 2, 3, 6, 'A', 4, 5, 7]
  

  
  Append Example:

  
  a_list = [1, 2, 3, 6, 'A']
  b_list = [4, 5, 7] 
  a_list.append(b_list)   # Using append() function here
  print(a_list)           # b_list got added as 6th item in a_list
  
  Output: [1, 2, 3, 6, 'A', [4, 5, 7]]
  

➠ Remove Vs Pop

• remove() function requires value of item as input which need to be removed.
• pop() function requires index of item as input which need to be removed, .
  
  
• remove() function will remove first occurence of input value(item) from the list.
• pop() function will remove specified index's item from the list. If index is not specified then by default it will remove last item from the list.
  
  
• remove() function will not return anything and it will just remove the item from the list.
• pop() function will return the item's value which was removed from the list.
  
  Remove Example:

  
  a_list = [1, 2, 3, 6, 'A']
  print(a_list.remove(2))    # remove() function returning None
  
  Output:  None
  

  
  Pop Example:

  
  a_list = [1, 2, 3, 6, 'A']
  print(a_list.pop(2))      # pop() function returning 3
  
  Output:  3
  

➠ List Comprehensions: Python provide a concise way to create lists without using map(), filter() or lambda functions. List comprehension statement consists of an expression followed by a for loop clause, then zero or more for loops or if clauses.

• Example 1: Statement will return 5 as there are 5 items present in the list.

  
  a_list = [i for i in range(0,5)]
  print(a_list)
  
  Output: [0, 1, 2, 3, 4]
  

• Example 2: Statement will return 5 as there are 5 items present in the list.

  
  a_list = [i for i in range(0,10) if i%3==0] 
  print(a_list)
  
  Output: [0, 3, 6, 9]
  

• Example 3: Statement will return 5 as there are 5 items present in the list.

  
  a_list = [i*j for i in range(1,3) for j in range(2,5)] 
  print(a_list)
  
  Output: [2, 3, 4, 4, 6, 8]
  

• Example 4: Statement will return 5 as there are 5 items present in the list.

  
  a_list = [i*j for i in range(1,3) for j in range(2,5) if i*j//4!=0] 
  print(a_list)
  
  Output: [4, 4, 6, 8]
  

➠ List as Stacks: Python list can be used as Stack i.e Last In First Out(LIFO) using pop() and append() functions.

• 
  stack = ['Oracle', 'Teradata', 'Hadoop']
  
  stack.append('Druid')      # Druid arrived
  print(stack)
  Output: ['Oracle', 'Teradata', 'Hadoop', 'Druid']
  
  
  stack.append('Snowflakes') # Snowflakes arrived
  print(stack)
  Output: ['Oracle', 'Teradata', 'Hadoop', 'Druid', 'Snowflakes']
  
  
  stack.pop()  # Snowflakes Leaving as it was last inserted
  print(stack)
  Output: ['Oracle', 'Teradata', 'Hadoop', 'Druid']
  
  
  stack.pop()  # Druid Leaving as it was second last inserted
  print(stack)
  Output: ['Oracle', 'Teradata', 'Hadoop']
  

➠ List as Queues: Python list can be used as Queue i.e First In First Out(FIFO) using pop() and append() functions.

• 
  queue = ['Oracle', 'Teradata', 'Hadoop']
  
  queue.append('Druid')    # Druid arrived
  print(queue)
  Output: ['Oracle', 'Teradata', 'Hadoop', 'Druid']
  
  
  queue.pop(0)  # Oracle Leaving as it was first inserted
  print(queue)
  Output: ['Teradata', 'Hadoop', 'Druid']
  
  
  queue.pop(0)  # Teradata Leaving as it was inserted second
  print(queue)
  Output: ['Hadoop', 'Druid']
  

➠ Create a Copy of List: List object can not be copied using assignment operator in Python. Assignment operator creates a reference to an existing list object. Copy of a list is sometimes needed so one list(copy) can be changed without changing the content of other list copy.

• Approach 1 : Using built-in 'list' class to create a copy of existing list.

  
  a_list = [1, 2, 3, 6, 'A']
  print(a_list)
  Output 1: [1, 2, 3, 6, 'A']
  
  
  b_list = list(a_list)  # Creating a copy here
  print(b_list)
  Output 2: [1, 2, 3, 6, 'A']
  
  
  b_list.pop()   # Removing last item from b_list
  Output 3: 'A'
  
  
  print(b_list)   # 'A' value not present in b_list
  Output 4: [1, 2, 3, 6]
  
  
  print(a_list)   # 'A' value is still present in a_list
  Output 5: [1, 2, 3, 6, 'A']
  

  
  
• Approach 2 : Using built-in copy() function to creating a copy of input list

  
  Syntax: list_object.copy()
  
  a_list = [1, 2, 3, 6, 'A']
  b_list = a_list.copy()
  print(a_list)
  Output 2: [1, 2, 3, 6, 'A']
  
  
  b_list.pop()   # Removing last item from b_list
  Output 3: 'A'
  
  
  print(b_list)   # 'A' value not present in b_list
  Output 4: [1, 2, 3, 6]
  
  
  print(a_list)   # 'A' value is still present in a_list
  Output 5: [1, 2, 3, 6, 'A']
  

  
  
• Approach 3 : Using list slicing to create a copy of existing list.

  
  a_list = [1, 2, 3, 6, 'A']
  print(a_list)
  Output 1: [1, 2, 3, 6, 'A']
  
  
  c_list = a_list[:]  # Creating a copy here
  print(c_list)
  Output 2: [1, 2, 3, 6, 'A']
  
  
  a_list.pop()   # Removing last item from a_list
  Output 3: 'A'
  
  
  print(a_list)   # 'A' value not present in a_list
  Output 4: [1, 2, 3, 6]
  
  
  print(c_list)   # 'A' value is still present in c_list
  Output 5: [1, 2, 3, 6, 'A']
  

  
  
• Approach 4 : Using built-in 'copy' module to creating a copy of existing list.

  
  a_list = [1, 2, 3, 6, 'A']
  print(a_list)
  Output 1: [1, 2, 3, 6, 'A']
  
  
  import copy
  d_list=copy.copy(a_list)  # Creating a copy here
  print(d_list)
  Output 2: [1, 2, 3, 6, 'A']
  
  
  d_list.pop()   # Removing last item from d_list
  Output 3: 'A'
  
  
  print(d_list)   # 'A' value not present in d_list
  Output 4: [1, 2, 3, 6]
  
  
  print(a_list)   # 'A' value is still present in a_list
  Output 5: [1, 2, 3, 6, 'A']
  

➠ Create a reference to a existing list : Assignment operator can be used create a reference to an existing list object. If list is referenced, then any change in either of list variable will result in changes in the content of other list(because it is just a reference) as well.

• 
  a_list = [1, 2, 3, 6, 'A']
  print(a_list)
  Output 1: [1, 2, 3, 6, 'A']
  
  
  e_list = a_list  # Creating a reference here
  print(e_list)
  Output 2: [1, 2, 3, 6, 'A']
  
  
  e_list.pop()   # Removing last item from e_list
  Output 3: 'A'
  
  
  print(e_list)   # 'A' value not present in e_list
  Output 4: [1, 2, 3, 6]
  
  
  print(a_list)   # 'A' value also not present in a_list
  Output 5: [1, 2, 3, 6]
  
  
  a_list.pop()   # Removing last item from a_list
  Output 6: 6
  
  
  print(a_list)   # '6' value not present in a_list
  Output 7: [1, 2, 3]
  
  
  print(e_list)   # '6' value also not present in e_list
  Output 8: [1, 2, 3]