# Python | Sliced Product in List

Last Updated : 22 Apr, 2023

Accessing elements in a list has many types and variations. These are an essential part of Python programming and one must know to perform the same. This article discusses ways to fetch the initial K elements and do its multiplication. Letâ€™s discuss a certain solution to perform this task.

Method #1 : Using list slicing + loop
This problem can be performed in 1 line rather than using a loop using the list slicing functionality provided by Python and then using a loop to perform the product.

## Python3

 `# Python3 code to demonstrate ` `# Sliced Product in List` `# using list slicing + loop`   `# getting Product` `def` `prod(val) :` `    ``res ``=` `1` `    ``for` `ele ``in` `val:` `        ``res ``*``=` `ele` `    ``return` `res `   `# initializing list ` `test_list ``=` `[``4``, ``5``, ``2``, ``6``, ``7``, ``8``, ``10``] `   `# printing original list ` `print``(``"The original list : "` `+` `str``(test_list)) `   `# initializing K ` `K ``=` `5`   `# Sliced Product in List` `# using list slicing + loop` `res ``=` `prod(test_list[:K])`   `# print result ` `print``(``"The first K elements product of list is : "` `+` `str``(res)) `

Output :

```The original list : [4, 5, 2, 6, 7, 8, 10]
The first K elements product of list is : 1680```

Time complexity: O(n), where n is the length of the test_list. The list slicing + loop  takes O(n) time
Auxiliary Space: O(1), constant extra space is required

Method #2 : Using islice() + loop
The inbuilt functions can also be used to perform this particular task. The islice function can be used to get the sliced list and then prod() can be employed to perform product.

## Python3

 `# Python3 code to demonstrate ` `# Sliced Product in List` `# using islice() + loop` `from` `itertools ``import` `islice `   `# getting Product` `def` `prod(val) :` `    ``res ``=` `1` `    ``for` `ele ``in` `val:` `        ``res ``*``=` `ele` `    ``return` `res `   `# initializing list ` `test_list ``=` `[``4``, ``5``, ``2``, ``6``, ``7``, ``8``, ``10``] `   `# printing original list ` `print``(``"The original list : "` `+` `str``(test_list)) `   `# initializing K ` `K ``=` `5`   `# Sliced Product in List` `# using islice() + loop` `res ``=` `list``(islice(test_list, ``0``, K)) ` `res ``=` `prod(res)`   `# print result ` `print``(``"The first K elements product of list is : "` `+` `str``(res)) `

Output :

```The original list : [4, 5, 2, 6, 7, 8, 10]
The first K elements product of list is : 1680```

Time Complexity: O(n), where n is the length of the input list. This is because weâ€™re using islice() + loop which has a time complexity of O(n) in the worst case.
Auxiliary Space: O(1), constant extra space is required

Method #3 : Using numpy()

## Python3

 `# Python3 code to demonstrate` `# Sliced Product in List` `# using numpy` `import` `numpy as np` ` `  `# initializing list` `test_list ``=` `[``4``, ``5``, ``2``, ``6``, ``7``, ``8``, ``10``]` ` `  `# printing original list` `print``(``"The original list : "` `+` `str``(test_list))` ` `  `# initializing K` `K ``=` `5` ` `  `# Sliced Product in List` `# using numpy` `res ``=` `np.prod(test_list[:K])` ` `  `# print result` `print``(``"The first K elements product of list is : "` `+` `str``(res))` `#This code is contributed by Edula Vinay Kumar Reddy`

Output:

The original list : [4, 5, 2, 6, 7, 8, 10]
The first K elements product of list is : 1680

Time complexity: O(n)

Auxiliary space: O(1)

Method #4 : Using operator.getitem(),slice() methods

Approach

1. Slice the given test_list using operator.getitem(),slice() and initialise a variable res=1
2. Initiate a for loop to traverse the sliced list and multiply each element to res using *= operator
3. Display res where product is stored

## Python3

 `# Python3 code to demonstrate ` `# Sliced Product in List` `# using list slicing + loop`   `# initializing list ` `test_list ``=` `[``4``, ``5``, ``2``, ``6``, ``7``, ``8``, ``10``] `   `# printing original list ` `print``(``"The original list : "` `+` `str``(test_list)) `   `# initializing K ` `K ``=` `5`   `# Sliced Product in List` `# using list slicing + loop` `res``=``1` `import` `operator` `x``=``operator.getitem(test_list,``slice``(``0``,K))` `for` `i ``in` `x:` `    ``res``*``=``i`   `# print result ` `print``(``"The first K elements product of list is : "` `+` `str``(res))`

Output

```The original list : [4, 5, 2, 6, 7, 8, 10]
The first K elements product of list is : 1680```

Time Complexity : O(K) K – length of sliced list

Auxiliary Space : O(1) since we used only one variable to store product.

Method5: Using Recursive method: The idea to use the recursive method is based on the following two conditions:

1. If K is 0, return 1 (base case)
2. Otherwise, return the product of the last element in the first K elements and the result of the function called with the first K-1 elements (recursive case)

## Python3

 `# Python program for the above approach`   `# Recursive function to find product` `# of first K elements in a list` `def` `sliced_product(lst, K):` `    ``if` `K ``=``=` `0``:` `        ``return` `1` `    ``else``:` `        ``return` `lst[K``-``1``] ``*` `sliced_product(lst, K``-``1``)`     `# Driver Code` `test_list ``=` `[``4``, ``5``, ``2``, ``6``, ``7``, ``8``, ``10``]` `K ``=` `5`   `print``(``"The original list : "` `+` `str``(test_list))`   `res ``=` `sliced_product(test_list[:K], K)` `print``(``"The first K elements product of list is : "` `+` `str``(res))`

Output

```The original list : [4, 5, 2, 6, 7, 8, 10]
The first K elements product of list is : 1680```

Time Complexity:
The recursive function calls itself K times, with each call reducing K by 1 until it reaches the base case where K equals 0. Therefore, the time complexity of the function is O(K).

Space Complexity:
The function uses recursion to solve the problem, so it creates a new stack frame for each recursive call. The maximum depth of the stack is K, so the space complexity of the function is also O(K).

Previous
Next