Having said that, the behavior of NumPy repeat is a little hard to understand sometimes. It’s a little un-intuitive.<\/p>\n
To help explain how this function works, I’m going to explain everything step by step. I’ll review the basics of NumPy arrays and how they are structured. Then I’ll explain the NumPy repeat function. Next, I’ll explain the actual syntax of np.repeat, before moving on to some examples and questions.<\/p>\n
Table of Contents:<\/strong><\/p>\n You can click on any of the above links and it will take you to the appropriate section in the tutorial.<\/p>\n But if you really want to understand how this works, I recommend that you read the full tutorial.<\/p>\n Ok. Onward.<\/p>\n <\/a><\/p>\n First, let’s just review NumPy arrays.<\/p>\n A NumPy array is just an array of numbers that we create with the NumPy package. It’s basically a special kind of object in Python<\/a> that we use to store and manipulate numeric data.<\/p>\n NumPy arrays can be 1-dimensional:<\/p>\n … 2-dimensional:<\/p>\n Or even have 3 or more dimensions.<\/p>\n The real constraint with NumPy arrays is that they essentially can only hold numbers. <\/p>\n You can think of NumPy arrays like vectors, matrices, and tensors in mathematics.<\/p>\n Importantly, NumPy arrays have “axes.”<\/p>\n What are axes?<\/p>\n You can think of axes like directions.<\/p>\n A 1-dimensional array only has one axis, called axis-0:<\/p>\n And 2-dimensional arrays have two axes, called axis-0 and axis-1:<\/p>\n As it turns out, NumPy axes are important because they are often used when we manipulate arrays.<\/p>\n We’ll actually use NumPy axes when we manipulate our NumPy arrays with NumPy repeat.<\/p>\n <\/a><\/p>\n Now that we’ve reviewed NumPy arrays, let’s talk more specifically about the NumPy repeat function.<\/p>\n Essentially, the NumPy repeat function repeats the elements of an array.<\/p>\n That’s basically all it does!<\/p>\n It can get a little more complicated though in more complicated cases.<\/p>\n One important thing to understand is that by default, NumPy repeat will flatten out an array.<\/p>\n That might not make sense, so let me give you an example. Let’s say that you have a 2-dimensional array with some numbers.<\/p>\n If you apply the np.repeat function on the 2-dimensional input array, then by default, it will repeat the values and put those repeated values into a 1-dimensional array. <\/p>\n By default, the output will be 1-dimensional.<\/p>\n It’s possible to change that behavior, but to do so, you need to understand the syntax of np.repeat.<\/p>\n That being said, let’s take a look at the syntax.<\/p>\n <\/a><\/p>\n The syntax of the np.repeat function is fairly straightforward.<\/p>\n First of all, you will typically call the function with the name However, it’s important to note that how exactly you call the function depends on how you’ve imported NumPy.<\/p>\n Remember that before you use<\/em> NumPy in a Python program, you need to import<\/em> NumPy. <\/p>\n The common way to do this is with the code When you import NumPy with the alias “ So if you import NumPy with the code On the other hand, if you instead import NumPy with the code Essentially, how you call the function depends on how you import NumPy.<\/p>\n Having said that, I’ll mostly refer to the function as Let’s finally take a close look at the syntax of np.repeat.<\/p>\n First, you’ll typically call the function with the name Then inside of the function are a set of parameters that you can use to specify exactly how the function will work.<\/p>\n The parameters are important, so let’s take a look at them.<\/p>\n The np.repeat function has 3 parameters:<\/p>\n Let’s examine each of these individually.<\/p>\n The Keep in mind that although the np.repeat function is primarily designed to operate on NumPy arrays<\/a>, it will also work on any array-like object. That includes Python lists and Python tuples. Technically, it will even operate on a string (although it will treat it like a Python list). The important thing to understand is that np.repeat is flexible concerning what inputs it will work on.<\/p>\n Also keep in mind that the The The argument to this parameter will be an integer …<\/p>\n … so if you want to repeat each item twice, you’ll type ‘ … if you want to repeat each item three times, you’ll type ‘ … etcetera.<\/p>\n This is fairly self explanatory, but you’ll be able to see how this works in practice in the examples section of the tutorial<\/a>.<\/p>\n Finally, the This is a little confusing to NumPy beginners, because most people don’t really understand what axes are.<\/p>\n Remember, NumPy arrays have axes. A 1D NumPy array has one axis, and a 2D array has two axes.<\/p>\n These “axes” are essentially like directions<\/em>.<\/p>\n When we use the So for example, if we have a 2-dimensional NumPy array and we want to repeat the items downwards down the columns, we will set If we want to repeat the items horizontally across the rows, we will set (Although, keep in mind that the axis specifications will be different for a 1-dimensional array.)<\/p>\n Again, this might not make a lot of sense. If you’re confused about NumPy axes, make sure to read our tutorial that explains what a NumPy axis is<\/a>.<\/p>\n You should also pay close attention to example 4<\/a> and example 5<\/a> in this tutorial which explain how to repeat elements down the columns or across the rows of a 2D array.<\/p>\n Finally, let’s talk about the output of np.repeat.<\/p>\n This is simple. <\/p>\n The output of NumPy repeat is a NumPy array. <\/p>\n But keep in mind that the size and exact shape of the output will depend on how we use the np.repeat function.<\/p>\n <\/a><\/p>\n Now that I’ve explained the syntax, let’s look at some examples of how to use NumPy repeat.<\/p>\n Examples:<\/strong><\/p>\n One quick note before you run any code:<\/p>\n You need to import NumPy properly.<\/p>\n I’m assuming here that you have NumPy already installed<\/em> on your machine (if you don’t, you should install Anaconda<\/a>, which will include NumPy).<\/p>\n But even if you have NumPy installed on your computer, you will need to import it into your working environment by using the following code:<\/p>\n This essentially makes the NumPy functions available in our code by typing the prefix “np.” followed by the name of the function.<\/p>\n Ok. With that out of the way, let’s look at some examples.<\/p>\n <\/a><\/p>\n First, let’s start veeeery simple.<\/p>\n Here, we’re just going to repeat a single number several times.<\/p>\n To do this, we’ll call the np.repeat function. Inside of the parenthesis, we’ll provide the value that we want to repeat with the Essentially, we’re going to repeat the number “7” four times.<\/p>\n Here’s the code:<\/p>\n Which produces the following output:<\/p>\n This is really easy to understand. <\/p>\n We indicate that we will repeat the number ‘7’ with the Notice also that the output is a NumPy array. If you want, you could check that with the code Very quickly, let’s redo the above examples without<\/em> explicitly referencing the parameter names.<\/p>\n For better or for worse, many Python programmers write their code without explicitly showing the parameter names. <\/p>\n Personally, I think this is a bad habit (one that I’ve been guilty of myself). It’s much more clear to explicitly show the parameter names.<\/p>\n But just so you can see it, let’s run the code without the parameter names. We’ll just pass arguments to the function by position.<\/p>\n OUT:<\/p>\n The output is still the same. <\/p>\n The only difference is that we’ve removed the actual parameters. Python knows that the argument in the first position refers to the “ The code looks a little different, but it’s essentially the same and the output is the same.<\/p>\n Again, I want you to see this so you understand what’s going on when the parameter names are removed.<\/p>\n <\/a><\/p>\n Now, we’re going to move on to a slightly more complicated example.<\/p>\n Instead of repeating a single number, we’re going to repeat multiple<\/em> numbers.<\/p>\n This example is almost exactly the same as the first example<\/a>, except we’re going to make one small modification to our code. <\/p>\n … we’re going to provide a list<\/em> of numbers to the Let’s take a look. <\/p>\n Here, we’re going to repeat the numbers 6 and 7 two times each. We specify the two numbers to repeat with the code OUT:<\/p>\n Notice what happened here. <\/p>\n Our input numbers, 6 and 7, are repeated two times each. <\/p>\n And notice how<\/em> it repeats the numbers. It repeats the first number two times and then repeats the second number two times.<\/p>\n The output is a NumPy array, as we should expect, but it’s a 1-dimensional NumPy array.<\/p>\n This is important! <\/p>\n By default, the output of numpy.repeat is a flat, 1-dimensional array that simply repeats all of the elements of the input.<\/p>\n We’ll see this behavior in the next example as well, and we’ll only be able to change it when we finally start to use the <\/a><\/p>\n In this example, we’re going to use a 2-d array as the input to NumPy repeat.<\/p>\n First, let’s create a NumPy array.<\/p>\n Here, we’re going to use the NumPy array function to create a 2-dimensional array with four numbers. <\/p>\n We can print this out with the code The resulting NumPy array, Now, we’re going to use np.repeat to repeat the elements of the array.<\/p>\n Here’s the code: <\/p>\n OUT:<\/p>\n This example is actually easy to understand if you understood example 1<\/a> and example 2<\/a>.<\/p>\n The array When it executes, the np.array function simply takes every individual element of the input, repeats it 2 times, and puts it into a 1-dimensional output array.<\/p>\n <\/a><\/p>\n Now, let’s make things more complicated.<\/p>\n We’re going to work with a 2-dimensional NumPy array again.<\/p>\n But we’re now going to use numpy.repeat to repeat the values downward down each column. <\/p>\n This is a little more complicated and more difficult to understand, so let’s take it step by step.<\/p>\n First let’s just create a 2-d NumPy array.<\/p>\n This is the same as the array in the previous example, so if you already ran that code, you don’t need to run this again.<\/p>\n If we print this out with the code Now, we’re going to repeat the values of each column downward<\/em> down each column.<\/p>\n Let’s first run the code and then let me explain.<\/p>\n Here, we’re going to run np.repeat with 2 repeats. But we’re now going to use the OUT:<\/p>\n So look at what happened …<\/p>\n The np.repeat function repeated the values of each column downward<\/em>. <\/p>\n Why?<\/p>\n To understand this, you need to understand NumPy axes<\/a>.<\/p>\n Remember that NumPy arrays have axes. The axes of an array are like directions<\/em>. For a 2-dimensional array, axis-0 is the axis that points downwards down the columns and axis-1 is the axis that points horizontally across the rows.<\/p>\n When we use numpy.repeat with So when we set The behavior of np.repeat actually makes sense, but to really understand this, you really need to understand NumPy array axes first. So if you’re a little confused by this example, you might want to read our tutorial about NumPy axes<\/a>.<\/p>\n <\/a><\/p>\n Next, let’s do something similar to the last example. In the previous example, we repeated elements down the columns.<\/p>\n In this example, we will repeat elements horizontally across the rows<\/em>.<\/p>\n This is very easy to do and it will make sense if you read the previous example<\/a>.<\/p>\n We’re essentially going to set Again, let’s create a 2-d NumPy array.<\/p>\n This is the same as the array in the last example, so if you already ran that code, you don’t need to run this again.<\/p>\n If we print this out with the code Now, let’s repeat those values horizontally.<\/p>\n To do this, we’ll use np.repeat with And here’s the output:<\/p>\n This is very similar to the previous example where we repeated values downward.<\/p>\n But here, by setting So essentially, this code will take each element in the input array and repeat it horizontally across axis-1.<\/p>\n Again, this is fairly easy to understand once you really understand NumPy axes. To learn more about axes, read our tutorial that explains what a NumPy axis is<\/a> and how we use them.<\/p>\n <\/a><\/p>\n Now let’s address some frequently asked questions about NumPy repeat.<\/p>\n Frequently asked questions:<\/strong><\/p>\n <\/a><\/p>\n If you already have a 2-dimensional NumPy array, then it’s relatively easy to duplicate all of the rows.<\/p>\n To do this, we’re simply going to use np.repeat with Let me show you.<\/p>\n First, we’ll just create a 2D numpy array:<\/p>\n Now, let’s duplicate the rows with NumPy repeat:<\/p>\n OUT:<\/p>\n As you can see, np.repeat has produced an output array that repeats every row of the input.<\/p>\n Note that this is essentially the same as example 4<\/a> in the examples section of this tutorial.<\/p>\n <\/a><\/p>\n Duplicating a 1D array is a little harder because a 1-dimensional array only has one axis (axis 0).<\/p>\n This is a problem, because when we duplicate the rows, there needs to be another dimension in which to copy the rows.<\/p>\n So essentially, to do this, we actually need to increase the number of dimensions of the array first, and then copy the row.<\/p>\n Let’s take a look.<\/p>\n First, let’s just create a 1-dimensional NumPy array.<\/p>\n If you were to use np.repeat on this with So before we run that code, we need to expand the number of dimensions.<\/p>\n And let’s print this out so you can see it.<\/p>\n OUT:<\/p>\n Now, let’s duplicate the row.<\/p>\n OUT:<\/p>\n As you can see, the output of np.repeat in this case is a new array with the row duplicated two times.<\/p>\n <\/a><\/p>\n The np.repeat function repeats the individual elements<\/em> of an input array.<\/p>\n But np.tile will take the entire array \u2013 including the order of the individual elements \u2013 and copy it in a particular direction.<\/p>\n So the difference is between copying the individual numbers verses copying the whole array all at once.<\/p>\n To learn more about np.tile, check out our tutorial about NumPy tile<\/a>.<\/p>\n In this tutorial, we’ve strictly focused on the NumPy repeat function.<\/p>\n But if you’re serious about doing data manipulation in Python (i.e., for machine learning and deep learning), you really need to know more.<\/p>\n I recommend that you learn about:<\/p>\n You’ll also want to learn about summary functions like np.sum<\/a>, np.median<\/a>, etc.<\/p>\n Moreover, even after you learn NumPy, you will probably need to learn a little about Pandas and matplotlib.<\/p>\n If you’re serious about learning NumPy (and Pandas, and matplotlib), then we can help.<\/p>\n Here at Sharp Sight, we teach data science.<\/p>\n We can show you how to do data manipulation, data visualization, data analysis, and machine learning in Python.<\/p>\n Want to learn more?<\/p>\n Sign up right now for our email list.<\/p>\n Members of our email list get immediate access to our free tutorials.<\/p>\n When you sign up, you\u2019ll get free tutorials on:<\/p>\n\n
A quick review of NumPy arrays<\/h2>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/07\/example-of-1D-numpy-array_0-to-3.png\")
<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/07\/example-of-2D-numpy-array_0-to-7.png\")
<\/p>\nNumPy arrays have axes<\/h5>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/numpy-axes-example_1D.png\")
<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/numpy-axes-example_2D.png\")
<\/p>\nA quick introduction to NumPy repeat<\/h2>\n
NumPy repeat “repeats” elements of an array<\/h4>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/simple-example-of-numpy-repeat.png\")
<\/p>\nNumPy repeat creates flat 1-dimensional arrays by default<\/h4>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/numpy-repeat-flattens-arrays.png\")
<\/p>\nThe syntax of np.repeat<\/h2>\n
np.repeat()<\/code>.<\/p>\nHow you call the function depends on how you import NumPy<\/h6>\n
import numpy as np<\/code>. That’s a very common convention used by many programmers. <\/p>\nnp<\/code>,” it allows you to refer to the NumPy package with the prefix “np.<\/code>” in your syntax. <\/p>\nimport numpy as np<\/code>, then you will call the repeat function as np.repeat()<\/code>.<\/p>\nimport numpy<\/code>, you’ll have to use the prefix “numpy.<\/code>” in your syntax, which means that you’d have to call the function as numpy.repeat()<\/code>.<\/p>\nnp.repeat()<\/code>, but you might see me use the term numpy.repeat()<\/code> as well.<\/p>\nnp.repeat syntax<\/h3>\n
np.repeat()<\/code>.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/np-repeat-syntax.png\")
<\/p>\nThe parameters of np.repeat<\/h4>\n
\n
a<\/code><\/li>\nrepeats<\/code><\/li>\naxis<\/code><\/li>\n<\/ul>\na<\/code> (required)<\/h6>\na<\/code> parameter enables you to specify the “array” that you will use as the input to np.repeat.<\/p>\na<\/code> parameter is required. This means that you must<\/em> provide some sort of input to the function.<\/p>\nrepeats<\/code> (required)<\/h6>\nrepeats<\/code> parameter enables you to specify how many times to repeat the items in the input array.<\/p>\n2<\/code>‘.<\/p>\n3<\/code>‘.<\/p>\naxis<\/code><\/h6>\naxis<\/code> parameter enables you to specify the axis along which you will repeat the elements.<\/p>\n<\/p>\naxis<\/code> parameter, we are specifying the direction along which we will repeat the items. <\/p>\naxis = 0<\/code>.<\/p>\naxis = 1<\/code>.<\/p>\nThe output of np.repeat<\/h4>\n
NumPy repeat examples<\/h2>\n
\n
Run this code first<\/h4>\n
\r\nimport numpy as np\r\n<\/pre>\n
Example 1: Repeat a single number<\/h3>\n
a =<\/code> parameter, and specify the number of repeats with the repeats =<\/code> parameter.<\/p>\n\r\nnp.repeat(a = 7, repeats = 4)\r\n<\/pre>\n
\r\narray([7, 7, 7, 7])\r\n<\/pre>\n
a<\/code> parameter, and indicate that we will repeat it four times with the repeats<\/code> parameter.<\/p>\n![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/simple-example-of-np-repeat_v3.png\")
<\/p>\ntype(np.repeat(a = 7, repeats = 4))<\/code>.<\/p>\nRedo the example without the parameter names<\/h5>\n
\r\nnp.repeat(7, 4)\r\n<\/pre>\n
\r\narray([7, 7, 7, 7])\r\n<\/pre>\n
a<\/code>” parameter and the item in the second position refers to the “repeats<\/code>” parameter.<\/p>\nExample 2: Repeat a 1-d list of numbers multiple times<\/h3>\n
a<\/code> parameter.<\/p>\na = [6,7]<\/code>. Then the parameter repeats = 2<\/code> indicates that we’ll repeat those numbers two times.<\/p>\n\r\nnp.repeat(a = [6,7], repeats = 2)\r\n<\/pre>\n
\r\narray([6, 6, 7, 7])\r\n<\/pre>\n
axis<\/code> parameter.<\/p>\nExample 3: Repeat the values of a 2-d array<\/h3>\n
Create numpy array<\/h6>\n
\r\nnp_array_2d = np.array([[6,7],[8,9]])\r\n<\/pre>\n
print(np_array_2d)<\/code> which produces the following output:<\/p>\n\r\n[[6 7]\r\n [8 9]]\r\n<\/pre>\n
np_array_2d<\/code>, is basically an array with 2 rows and two columns.<\/p>\nRepeat values with np.repeat<\/h6>\n
\r\nnp.repeat(a = np_array_2d, repeats = 2)\r\n<\/pre>\n
\r\narray([6, 6, 7, 7, 8, 8, 9, 9])\r\n<\/pre>\n
np_array_2d<\/code> is the input to the function. We’re using the repeats<\/code> parameter to specify that we want to repeat every element of the input two times.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/np-repeat-with-2D-input.png\")
<\/p>\nExample 4: Repeat values down the columns<\/h3>\n
Create numpy array<\/h6>\n
\r\nnp_array_2d = np.array([[6,7],[8,9]])\r\n<\/pre>\n
print(np_array_2d)<\/code>, you can see that it’s a 2×2 array with four values:<\/p>\n\r\n[[6 7]\r\n [8 9]]\r\n<\/pre>\n
Repeat values downward using axis = 0<\/h6>\n
axis<\/code> parameter. <\/p>\n\r\nnp.repeat(a = np_array_2d, repeats = 2, axis = 0)\r\n<\/pre>\n
\r\narray([[6, 7],\r\n [6, 7],\r\n [8, 9],\r\n [8, 9]])\r\n<\/pre>\n
Explanation<\/h6>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/11\/numpy-arrays-have-axes.png\")
<\/p>\naxis = 0<\/code>, we’re telling numpy.repeat to operate in the axis-0 direction.<\/p>\naxis = 0<\/code>, it takes the values of the array and it repeats them in that direction<\/em>. Remember, axis-0 points downwards down the columns. So in this case, it repeats the values downwards down the columns.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/np-repeat-axis-0_example.png\")
<\/p>\nExample 5: Repeat elements across the rows<\/h3>\n
axis = 1<\/code> which indicates that we want np.repeat to operate in the axis-1 direction. <\/p>\nCreate numpy array<\/h6>\n
\r\nnp_array_2d = np.array([[6,7],[8,9]])\r\n<\/pre>\n
print(np_array_2d)<\/code>, you can see the contents. It’s a 2-dimensional NumPy array:<\/p>\n\r\n[[6 7]\r\n [8 9]]\r\n<\/pre>\n
Repeat values across using axis = 1<\/h6>\n
axis = 1<\/code>.<\/p>\n\r\nnp.repeat(a = np_array_2d, repeats = 2, axis = 1)\r\n<\/pre>\n
\r\narray([[6, 6, 7, 7],\r\n [8, 8, 9, 9]])\r\n<\/pre>\n
Explanation<\/h6>\n
axis = 1<\/code>, we’re telling np.repeat that we want to repeat the values in the axis-1 direction. Remember, for a 2-dimensional array, axis-1 is the direction that points horizontally across the rows.<\/p>\n![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2019\/08\/np-repeat-axis-1_example.png\")
<\/p>\nFrequently asked questions about NumPy repeat<\/h2>\n
\n
How can I duplicate the rows of a 2-D array?<\/h3>\n
axis = 0<\/code>.<\/p>\n\r\nnp_array_2d = np.array([[1,2,3],[4,5,6]])\r\n<\/pre>\n
\r\nnp.repeat(a = np_array_2d, repeats = 2, axis = 0)\r\n<\/pre>\n
\r\narray([[1, 2, 3],\r\n [1, 2, 3],\r\n [4, 5, 6],\r\n [4, 5, 6]])\r\n<\/pre>\n
How can I duplicate a 1-dimensional array?<\/h3>\n
\r\nnp_array_1d = np.array([1,2,3,4])\r\n<\/pre>\n
axis = 1<\/code>, then you’d get an error.<\/p>\n\r\nnp_array_2d = np.expand_dims(np_array_1d, axis = 0)\r\n<\/pre>\n
\r\nprint(np_array_2d)\r\n<\/pre>\n
\r\n[[1 2 3 4]]\r\n<\/pre>\n
\r\nnp.repeat(a = np_array_2d, repeats = 2, axis = 0)\r\n<\/pre>\n
\r\narray([[1, 2, 3, 4],\r\n [1, 2, 3, 4]])\r\n<\/pre>\n
What is the difference between np.repeat and np.tile?<\/h3>\n
There’s a lot more to learn about NumPy<\/h2>\n
\n
For more
\n