How to Create a Subarray From an Array in Python?

How to Fix Tuple Does Not Support Item Assignment in Python?

Are you looking for solutions on how to create a subarray from an array in python? Don’t worry we are here to provide you with a variety of solutions 😉.

An array is one of the simplest and most commonly used data structures in computer programming. Basically, arrays are containers that are used to store more than one data item in a single variable, and to access the data items of the defined array we’ll need their index to locate them. The index is the location of the data items of an array, and it starts with 0 and ends at ArraySize – 1.

Whereas SubArray is known as contiguous parts of the array, in simple words, it is an array inside another array.

Creating a subarray, or a subset of an array, is a common operation in Python. There are several ways to create a subarray, and the method you choose will depend on your specific needs and the structure of your array.

In this article, we’ll discuss how to create a subarray from an array in Python, but first, let’s see how to create a simple array in Python.



How to Create an Array in Python?

In Python, an array is an ordered collection of elements where each data items are of homogeneous data type. The data items of the array are stored in sequential order and each individual data item is accessed using an index.

To create an array in Python we need to import an array, let’s see an example of how to create an array.

Syntax of creating an array in Python.

array(data_type, value_list)



# import array 

import array as arr

# create integer data type array

b = arr.array('i', [1, 2, 3, 4, 5])

# let's print the original array

print ("The newly created array is: ", end =" ")

# start the loop from the first index and stop at the last index

for i in range (0, 5):

    print (b[i], end =" ")




The newly created array is:  1 2 3 4 5



How to Create a Subarray From an Array in Python?

In Python, we can create a subarray from an array using the following approaches:

  1. Slicing
  2. Recursion
  3. List Comprehension
  4. Append
  5. Built-In Python Array Functions


Method 1: Using Slicing

In python, slicing means obtaining a subset of the array element after completing the iteration of the indices. Slicing allows you to specify a range of indices to include in your subarray. It is used for various purposes but here we will create subarrays from an array by using this approach. The following example This allows you to specify a starting and ending index, as well as a step size:



Object [starting: ending: step]



# created an array

array = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]

# apply slicing

test1 = array[1 : 3]

test2 = array[0 : 7]

test3 = array[5 : ]

test4 = array[ : 6]

# print the results







[20, 30]

[10, 20, 30, 40, 50, 60, 70]

[60, 70, 80, 90, 100]

[10, 20, 30, 40, 50, 60]



Method 2: Using Recursion

In Python, we can create a subarray from an array using recursion. Recursion basically refers to a function calling itself. It is a well-known programming and mathematical concept. The advantage of using recursion is that one can loop the data element to reach the end result. 

Let’s understand with the below example how it is helpful in creating subarrays from an array.



def SubArrays(array, beginning, ending):


    # stop when reached at the end of the array

    if ending == len(array):



    # begin from 0 and Increment the ending point

    elif beginning > ending:

     return SubArrays(array, 0, ending + 1)


    # display the subarray and increment from the beginning point


     print(array[beginning:ending + 1])

     return SubArrays(array, beginning + 1, ending)


# set array values

array = [1, 2, 3, 4, 5]

SubArrays(array, 0, 0)




[1, 2]


[1, 2, 3]

[2, 3]


[1, 2, 3, 4]

[2, 3, 4]

[3, 4]


[1, 2, 3, 4, 5]

[2, 3, 4, 5]

[3, 4, 5]

[4, 5]




Method 3: Using List Comprehension

This is similar to the previous step, where another way to create a subarray in Python is to use a list comprehension. A list comprehension is a concise way to create a new list based on elements from an existing list.

For example, suppose you have an array of integers and you want to create a new array that contains only the even numbers. You can use a list comprehension to do this in a single line of code:

my_array = [1, 2, 3, 4, 5]

even_numbers = [x for x in my_array if x % 2 == 0]


This will create a new array called even_numbers that contains only the even elements of my_array. The x for x in my_array if x % 2 == 0 syntax specifies that the new list should include all elements x from my_array that are even (i.e., have a remainder of 0 when divided by 2).

You can also use list comprehension to create a subarray that includes only a certain number of elements. For example, to create a subarray that includes the first three elements of an array, you can use the following code:

my_array = [1, 2, 3, 4, 5]

first_three = [x for x in my_array[:3]]


This will create a new array called first_three that contains the first three elements of my_array.

List comprehensions are a powerful and concise way to create subarrays in Python, and they are often used in combination with other techniques like slicing and the array[start:stop:step] syntax.



Method 4: Using Append and Slicing

We can create a subArray from an array using the following steps:

  1. Run the loop till the end of the given array.
  2. Use an iterative loop from i+1 to the end(length) of the array for getting all the subarrays. 
  3. Slice the subarrays from i to j.
  4. Append the subarray to store it in another array.
  5. In the end, print the array to see the result.

Let’s understand the above steps using an example below:



# define sub arrays

def generate_sub_arrays(array):

# use for storing sub array

sub_array = [[]]


     # initial loop

for i in range(len(array) + 1):

    # second loop  

    for j in range(i + 1, len(array) + 1):


         # slice subarray

         s = array[i:j]


         # append sub array


return sub_array

# make an array

array = [1, 2, 3, 4, 5]

# print the result




[[], [1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [2], [2, 3], [2, 3, 4], [2, 3, 4, 5], [3], [3, 4], [3, 4, 5], [4], [4, 5], [5]]



Method 5: Using Built-In Python Array Functions

In addition to these methods, there are also several built-in functions in Python that can be used to create subarrays. For example, the filter() function can be used to create a new array that contains only elements that meet a certain condition. The map() function can be used to apply a specific function to each element of an array and create a new array with the resulting values.




To summarise the article, we have explained arrays and subarrays. Moreover, we have discussed how to create a subarray from an array in python. For creating subarrays from an array, we have used a recursion, list comprehension, append, slicing, and with built-in Python array function approaches. 

Hope this guide helps you, feel free to share with your friends and mates 🧑‍🤝‍🧑 and let us know in the comments below 👇 which solution you find more feasible 🥰

Happy Coding 😇

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts