python how to pad numpy array with zeros

Question

I want to know how I can pad a 2D numpy array with zeros using python 2 6 6 with numpy version 1 5 0  Sorry  But these are my limitations  Therefore I cannot use np pad  For example  I want to pad a with zeros such that its shape matches b  The reason why I want to do this is so I can do   b-a   such that   gt  gt  gt  a array    1    1    1    1    1             1    1    1    1    1             1    1    1    1    1      gt  gt  gt  b array    3    3    3    3    3    3             3    3    3    3    3    3             3    3    3    3    3    3             3    3    3    3    3    3      gt  gt  gt  c array   1  1  1  1  1  0           1  1  1  1  1  0           1  1  1  1  1  0           0  0  0  0  0  0      The only way I can think of doing this is appending  however this seems pretty ugly  is there a cleaner solution possibly using b shape   Edit  Thank you to  MSeiferts  answer  I had to clean it up a bit  and this is what I got   def pad array  reference shape  offsets               array  Array to be padded     reference shape  tuple of size of ndarray to create     offsets  list of offsets  number of elements must be equal to the dimension of the array      will throw a ValueError if offsets is too big and the reference shape cannot handle the offsets                Create an array of zeros with the reference shape     result   np zeros reference shape        Create a list of slices from offset to offset   shape in each dimension     insertHere    slice offsets dim   offsets dim    array shape dim   for dim in range array ndim         Insert the array in the result at the specified offsets     result insertHere    array     return result

User · Answer

Tensorflow also implemented functions for resizing/padding images tf.image.pad tf.pad.

padded_image = tf.image.pad_to_bounding_box(image, top_padding, left_padding, target_height, target_width)

padded_image = tf.pad(image, paddings, "CONSTANT")

These functions work just like other input-pipeline features of tensorflow and will work much better for machine learning applications.

User · Answer

In case you need to add a fence of 1s to an array    gt  gt  gt  mat   np zeros  4 4   np int32   gt  gt  gt  mat array   0  0  0  0           0  0  0  0           0  0  0  0           0  0  0  0     gt  gt  gt  mat 0      mat   0    mat   -1     mat -1      1  gt  gt  gt  mat array   1  1  1  1           1  0  0  1           1  0  0  1           1  1  1  1

User · Answer

I understand that your main problem is that you need to calculate d b-a but your arrays have different sizes  There is no need for an intermediate padded c  You can solve this without padding   import numpy as np  a   np array    1    1    1    1    1                    1    1    1    1    1                    1    1    1    1    1      b   np array    3    3    3    3    3    3                    3    3    3    3    3    3                    3    3    3    3    3    3                    3    3    3    3    3    3      d   b copy   d  a shape 0   a shape 1   -   a  print d   Output      2   2   2   2   2   3      2   2   2   2   2   3      2   2   2   2   2   3      3   3   3   3   3   3

User · Answer

Very simple  you create an array containing zeros using the reference shape   result   np zeros b shape    actually you can also use result   np zeros like b     but that also copies the dtype not only the shape   and then insert the array where you need it   result  a shape 0   a shape 1     a   and voila you have padded it   print result  array    1    1    1    1    1    0             1    1    1    1    1    0             1    1    1    1    1    0             0    0    0    0    0    0         You can also make it a bit more general if you define where your upper left element should be inserted  result   np zeros like b  x offset   1    0 would be what you wanted y offset   1    0 in your case result x offset a shape 0  x offset y offset a shape 1  y offset    a result  array    0    0    0    0    0    0             0    1    1    1    1    1             0    1    1    1    1    1             0    1    1    1    1    1       but then be careful that you don t have offsets bigger than allowed  For x offset   2 for example this will fail     If you have an arbitary number of dimensions you can define a list of slices to insert the original array  I ve found it interesting to play around a bit and created a padding function that can pad  with offset  an arbitary shaped array as long as the array and reference have the same number of dimensions and the offsets are not too big   def pad array  reference  offsets               array  Array to be padded     reference  Reference array with the desired shape     offsets  list of offsets  number of elements must be equal to the dimension of the array                Create an array of zeros with the reference shape     result   np zeros reference shape        Create a list of slices from offset to offset   shape in each dimension     insertHere    slice offset dim   offset dim    array shape dim   for dim in range a ndim         Insert the array in the result at the specified offsets     result insertHere    a     return result   And some test cases   import numpy as np    1 Dimension a   np ones 2  b   np ones 5  offset    3  pad a  b  offset     3 Dimensions  a   np ones  3 3 3   b   np ones  5 4 3   offset    1 0 0  pad a  b  offset

User · Answer

I know I m a bit late to this  but in case you wanted to perform relative padding  aka edge padding   here s how you can implement it  Note that the very first instance of assignment results in zero-padding  so you can use this for both zero-padding and relative padding  this is where you copy the edge values of the original array into the padded array   def replicate padding arr        quot  quot  quot Perform replicate padding on a numpy array  quot  quot  quot      new pad shape   tuple np array arr shape    2    2 indicates the width   height to change  a  512  512  image -- gt   514  514  padded image      padded array   np zeros new pad shape   create an array of zeros with new dimensions            perform replication     padded array 1 -1 1 -1    arr          result will be zero-pad     padded array 0 1 -1    arr 0           perform edge pad for top row     padded array -1  1 -1    arr -1        edge pad for bottom row     padded array T 0  1 -1    arr T 0      edge pad for first column     padded array T -1  1 -1    arr T -1    edge pad for last column           at this point  all values except for the 4 corners should have been replicated     padded array 0  0    arr 0  0        top left corner     padded array -1  0    arr -1  0      bottom left corner     padded array 0  -1    arr 0  -1      top right corner      padded array -1  -1    arr -1  -1    bottom right corner      return padded array  Complexity Analysis  The optimal solution for this is numpy s pad method  After averaging for 5 runs  np pad with relative padding is only 8  better than the function defined above  This shows that this is fairly an optimal method for relative and zero-padding padding    My method  replicate padding start   time time   padded   replicate padding input image  end   time time   delta0   end - start   np pad with edge padding start   time time   padded   np pad input image  1  mode  edge   end   time time   delta   end - start   print delta0    np Output  0 0008790493011474609  print delta     My Output  0 0008130073547363281 print 100   delta0-delta  delta     Percent difference  8 12316715542522

User · Answer

NumPy 1 7 0  when numpy pad was added  is pretty old now  it was released in 2013  so even though the question asked for a way without using that function I thought it could be useful to know how that could be achieved using numpy pad   It s actually pretty simple    gt  gt  gt  import numpy as np  gt  gt  gt  a   np array    1    1    1    1    1                        1    1    1    1    1                        1    1    1    1    1      gt  gt  gt  np pad a    0  1    0  1    mode  constant   array    1    1    1    1    1    0             1    1    1    1    1    0             1    1    1    1    1    0             0    0    0    0    0    0       In this case I used that 0 is the default value for mode  constant   But it could also be specified by passing it in explicitly    gt  gt  gt  np pad a    0  1    0  1    mode  constant   constant values 0  array    1    1    1    1    1    0             1    1    1    1    1    0             1    1    1    1    1    0             0    0    0    0    0    0       Just in case the second argument    0  1    0  1    seems confusing  Each list item  in this case tuple  corresponds to a dimension and item therein represents the padding before  first element  and after  second element   So     0  1    0  1                  ------ padding for second dimension        -------------- padding for first dimension     ------------------ no padding at the beginning of the first axis       --------------- pad with one  value  at the end of the first axis    In this case the padding for the first and second axis are identical  so one could also just pass in the 2-tuple    gt  gt  gt  np pad a   0  1   mode  constant   array    1    1    1    1    1    0             1    1    1    1    1    0             1    1    1    1    1    0             0    0    0    0    0    0       In case the padding before and after is identical one could even omit the tuple  not applicable in this case though     gt  gt  gt  np pad a  1  mode  constant   array    0    0    0    0    0    0    0             0    1    1    1    1    1    0             0    1    1    1    1    1    0             0    1    1    1    1    1    0             0    0    0    0    0    0    0       Or if the padding before and after is identical but different for the axis  you could also omit the second argument in the inner tuples    gt  gt  gt  np pad a    1      2      mode  constant   array    0    0    0    0    0    0    0    0    0             0    0    1    1    1    1    1    0    0             0    0    1    1    1    1    1    0    0             0    0    1    1    1    1    1    0    0             0    0    0    0    0    0    0    0    0       However I tend to prefer to always use the explicit one  because it s just to easy to make mistakes  when NumPys expectations differ from your intentions     gt  gt  gt  np pad a   1  2   mode  constant   array    0    0    0    0    0    0    0    0             0    1    1    1    1    1    0    0             0    1    1    1    1    1    0    0             0    1    1    1    1    1    0    0             0    0    0    0    0    0    0    0             0    0    0    0    0    0    0    0       Here NumPy thinks you wanted to pad all axis with 1 element before and 2 elements after each axis  Even if you intended it to pad with 1 element in axis 1 and 2 elements for axis 2   I used lists of tuples for the padding  note that this is just  my convention   you could also use lists of lists or tuples of tuples  or even tuples of arrays  NumPy just checks the length of the argument  or if it doesn t have a length  and the length of each item  or if it has a length

[python] python how to pad numpy array with zeros

Examples related to python

Examples related to arrays

Examples related to numpy

Examples related to pad