Python function that identifies if the numbers in a list or array are closer to 0 or 1











up vote
8
down vote

favorite
1












I have a numpy array of numbers. Below is an example:



[[-2.10044520e-04  1.72314372e-04  1.77235336e-04 -1.06613465e-04

6.76617611e-07  2.71623057e-03 -3.32789944e-05  1.44899758e-05

5.79249863e-05  4.06502549e-04 -1.35823707e-05 -4.13955189e-04

5.29862793e-05 -1.98286005e-04 -2.22829175e-04 -8.88758230e-04

5.62228710e-05  1.36249752e-05 -2.00474996e-05 -2.10090068e-05

1.00007518e+00  1.00007569e+00 -4.44597417e-05 -2.93724453e-04

1.00007513e+00  1.00007496e+00  1.00007532e+00 -1.22357142e-03

3.27903892e-06  1.00007592e+00  1.00007468e+00  1.00007558e+00

2.09869172e-05 -1.97610235e-05  1.00007529e+00  1.00007530e+00

1.00007503e+00 -2.68725642e-05 -3.00372853e-03  1.00007386e+00

1.00007443e+00  1.00007388e+00  5.86993822e-05 -8.69989983e-06

1.00007590e+00  1.00007488e+00  1.00007515e+00  8.81850779e-04

2.03875532e-05  1.00007480e+00  1.00007425e+00  1.00007517e+00

-2.44678912e-05 -4.36556267e-08  1.00007436e+00  1.00007558e+00

1.00007571e+00 -5.42990711e-04  1.45517859e-04  1.00007522e+00

1.00007469e+00  1.00007575e+00 -2.52271817e-05 -7.46339417e-05

1.00007427e+00]]


I want to know if each of the numbers is closer to 0 or 1. Is there a function in Python that could do it or do I have to do it manually?






python arrays list function numpy







share|improve this question




















  • 1




    You may want to take a look at numpy.rint. Although it returns floats and not ints, for whatever reason, but you can cast the result to int after applying this function.
    – ForceBru
    2 days ago












  • @ForceBru: It returns floats because float to int conversion can overflow.
    – Kevin
    2 days ago






  • 5




    What behaviour do you want for 0.5?
    – Eric Towers
    2 days ago






  • 3




    @ForceBru or even just (x >= 0.5).
    – The Great Duck
    2 days ago















up vote
8
down vote

favorite
1












I have a numpy array of numbers. Below is an example:



[[-2.10044520e-04  1.72314372e-04  1.77235336e-04 -1.06613465e-04

6.76617611e-07  2.71623057e-03 -3.32789944e-05  1.44899758e-05

5.79249863e-05  4.06502549e-04 -1.35823707e-05 -4.13955189e-04

5.29862793e-05 -1.98286005e-04 -2.22829175e-04 -8.88758230e-04

5.62228710e-05  1.36249752e-05 -2.00474996e-05 -2.10090068e-05

1.00007518e+00  1.00007569e+00 -4.44597417e-05 -2.93724453e-04

1.00007513e+00  1.00007496e+00  1.00007532e+00 -1.22357142e-03

3.27903892e-06  1.00007592e+00  1.00007468e+00  1.00007558e+00

2.09869172e-05 -1.97610235e-05  1.00007529e+00  1.00007530e+00

1.00007503e+00 -2.68725642e-05 -3.00372853e-03  1.00007386e+00

1.00007443e+00  1.00007388e+00  5.86993822e-05 -8.69989983e-06

1.00007590e+00  1.00007488e+00  1.00007515e+00  8.81850779e-04

2.03875532e-05  1.00007480e+00  1.00007425e+00  1.00007517e+00

-2.44678912e-05 -4.36556267e-08  1.00007436e+00  1.00007558e+00

1.00007571e+00 -5.42990711e-04  1.45517859e-04  1.00007522e+00

1.00007469e+00  1.00007575e+00 -2.52271817e-05 -7.46339417e-05

1.00007427e+00]]


I want to know if each of the numbers is closer to 0 or 1. Is there a function in Python that could do it or do I have to do it manually?






python arrays list function numpy







share|improve this question




















  • 1




    You may want to take a look at numpy.rint. Although it returns floats and not ints, for whatever reason, but you can cast the result to int after applying this function.
    – ForceBru
    2 days ago












  • @ForceBru: It returns floats because float to int conversion can overflow.
    – Kevin
    2 days ago






  • 5




    What behaviour do you want for 0.5?
    – Eric Towers
    2 days ago






  • 3




    @ForceBru or even just (x >= 0.5).
    – The Great Duck
    2 days ago













up vote
8
down vote

favorite
1









up vote
8
down vote

favorite
1






1





I have a numpy array of numbers. Below is an example:



[[-2.10044520e-04  1.72314372e-04  1.77235336e-04 -1.06613465e-04

6.76617611e-07  2.71623057e-03 -3.32789944e-05  1.44899758e-05

5.79249863e-05  4.06502549e-04 -1.35823707e-05 -4.13955189e-04

5.29862793e-05 -1.98286005e-04 -2.22829175e-04 -8.88758230e-04

5.62228710e-05  1.36249752e-05 -2.00474996e-05 -2.10090068e-05

1.00007518e+00  1.00007569e+00 -4.44597417e-05 -2.93724453e-04

1.00007513e+00  1.00007496e+00  1.00007532e+00 -1.22357142e-03

3.27903892e-06  1.00007592e+00  1.00007468e+00  1.00007558e+00

2.09869172e-05 -1.97610235e-05  1.00007529e+00  1.00007530e+00

1.00007503e+00 -2.68725642e-05 -3.00372853e-03  1.00007386e+00

1.00007443e+00  1.00007388e+00  5.86993822e-05 -8.69989983e-06

1.00007590e+00  1.00007488e+00  1.00007515e+00  8.81850779e-04

2.03875532e-05  1.00007480e+00  1.00007425e+00  1.00007517e+00

-2.44678912e-05 -4.36556267e-08  1.00007436e+00  1.00007558e+00

1.00007571e+00 -5.42990711e-04  1.45517859e-04  1.00007522e+00

1.00007469e+00  1.00007575e+00 -2.52271817e-05 -7.46339417e-05

1.00007427e+00]]


I want to know if each of the numbers is closer to 0 or 1. Is there a function in Python that could do it or do I have to do it manually?






python arrays list function numpy







share|improve this question















I have a numpy array of numbers. Below is an example:



[[-2.10044520e-04  1.72314372e-04  1.77235336e-04 -1.06613465e-04

6.76617611e-07  2.71623057e-03 -3.32789944e-05  1.44899758e-05

5.79249863e-05  4.06502549e-04 -1.35823707e-05 -4.13955189e-04

5.29862793e-05 -1.98286005e-04 -2.22829175e-04 -8.88758230e-04

5.62228710e-05  1.36249752e-05 -2.00474996e-05 -2.10090068e-05

1.00007518e+00  1.00007569e+00 -4.44597417e-05 -2.93724453e-04

1.00007513e+00  1.00007496e+00  1.00007532e+00 -1.22357142e-03

3.27903892e-06  1.00007592e+00  1.00007468e+00  1.00007558e+00

2.09869172e-05 -1.97610235e-05  1.00007529e+00  1.00007530e+00

1.00007503e+00 -2.68725642e-05 -3.00372853e-03  1.00007386e+00

1.00007443e+00  1.00007388e+00  5.86993822e-05 -8.69989983e-06

1.00007590e+00  1.00007488e+00  1.00007515e+00  8.81850779e-04

2.03875532e-05  1.00007480e+00  1.00007425e+00  1.00007517e+00

-2.44678912e-05 -4.36556267e-08  1.00007436e+00  1.00007558e+00

1.00007571e+00 -5.42990711e-04  1.45517859e-04  1.00007522e+00

1.00007469e+00  1.00007575e+00 -2.52271817e-05 -7.46339417e-05

1.00007427e+00]]


I want to know if each of the numbers is closer to 0 or 1. Is there a function in Python that could do it or do I have to do it manually?






python arrays list function numpy




python arrays list function numpy






share|improve this question















share|improve this question













share|improve this question




share|improve this question








edited yesterday









timgeb

45.8k106286




45.8k106286










asked 2 days ago









Eliyah

2841524




2841524








  • 1




    You may want to take a look at numpy.rint. Although it returns floats and not ints, for whatever reason, but you can cast the result to int after applying this function.
    – ForceBru
    2 days ago












  • @ForceBru: It returns floats because float to int conversion can overflow.
    – Kevin
    2 days ago






  • 5




    What behaviour do you want for 0.5?
    – Eric Towers
    2 days ago






  • 3




    @ForceBru or even just (x >= 0.5).
    – The Great Duck
    2 days ago














  • 1




    You may want to take a look at numpy.rint. Although it returns floats and not ints, for whatever reason, but you can cast the result to int after applying this function.
    – ForceBru
    2 days ago












  • @ForceBru: It returns floats because float to int conversion can overflow.
    – Kevin
    2 days ago






  • 5




    What behaviour do you want for 0.5?
    – Eric Towers
    2 days ago






  • 3




    @ForceBru or even just (x >= 0.5).
    – The Great Duck
    2 days ago








1




1




You may want to take a look at numpy.rint. Although it returns floats and not ints, for whatever reason, but you can cast the result to int after applying this function.
– ForceBru
2 days ago






You may want to take a look at numpy.rint. Although it returns floats and not ints, for whatever reason, but you can cast the result to int after applying this function.
– ForceBru
2 days ago














@ForceBru: It returns floats because float to int conversion can overflow.
– Kevin
2 days ago




@ForceBru: It returns floats because float to int conversion can overflow.
– Kevin
2 days ago




5




5




What behaviour do you want for 0.5?
– Eric Towers
2 days ago




What behaviour do you want for 0.5?
– Eric Towers
2 days ago




3




3




@ForceBru or even just (x >= 0.5).
– The Great Duck
2 days ago




@ForceBru or even just (x >= 0.5).
– The Great Duck
2 days ago












10 Answers
10






active

oldest

votes

















up vote
9
down vote



accepted










numpy.rint is a ufunc that will round the elements of an array to the nearest integer.



>>> a = np.arange(0, 1.1, 0.1)

>>> a

array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])

>>> np.rint(a)

array([0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.])



What if the numbers don't have to be between 0 and 1?




In that case, I'd use numpy.where.



>>> a = np.arange(-2, 2.1, 0.1)

>>> a

array([-2.00000000e+00, -1.90000000e+00, -1.80000000e+00, -1.70000000e+00,

       -1.60000000e+00, -1.50000000e+00, -1.40000000e+00, -1.30000000e+00,

       -1.20000000e+00, -1.10000000e+00, -1.00000000e+00, -9.00000000e-01,

       -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01,

       -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01,

        1.77635684e-15,  1.00000000e-01,  2.00000000e-01,  3.00000000e-01,

        4.00000000e-01,  5.00000000e-01,  6.00000000e-01,  7.00000000e-01,

        8.00000000e-01,  9.00000000e-01,  1.00000000e+00,  1.10000000e+00,

        1.20000000e+00,  1.30000000e+00,  1.40000000e+00,  1.50000000e+00,

        1.60000000e+00,  1.70000000e+00,  1.80000000e+00,  1.90000000e+00,

        2.00000000e+00])

>>> np.where(a <= 0.5, 0, 1)

array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

   0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])





share|improve this answer



















  • 1




    What if my numbers is above 2?
    – Eliyah
    2 days ago






  • 2




    @Eliyah then np.where!
    – timgeb
    2 days ago










  • np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
    – Tls Chris
    2 days ago










  • @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
    – timgeb
    2 days ago








  • 1




    @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
    – Tls Chris
    2 days ago


















up vote
19
down vote













A straightforward way:



lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]



closerTo1 = [x >= 0.5 for x in lst]


Or you can use np:



import numpy as np

lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]



arr = np.array(lst)

closerTo1 = arr >= 0.5


Note that >= 0.5 can be changed to > 0.5, however you choose to treat it.






share|improve this answer

















  • 3




    Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
    – jpp
    2 days ago








  • 1




    Did not mention rounding solutions, as no range was defined.
    – Or Dinari
    2 days ago


















up vote
4
down vote













You could use numpy.where:



import numpy as np



arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 2.0])

result = np.where(arr >= 0.5, 1, 0)

print(result)


Output



[0 0 0 0 1 1 1 1 1 1]


Note that this will return 1 for numbers above 1 (for instance 2).






share|improve this answer




























    up vote
    3
    down vote













    You could use abs() to measure distances between your number and 0 and 1 and check which on is shorter.



    x = [[-2.10044520e-04,  1.72314372e-04,  1.77235336e-04, -1.06613465e-04,
    
6.76617611e-07,  2.71623057e-03, -3.32789944e-05,  1.44899758e-05,
    
5.79249863e-05,  4.06502549e-04, -1.35823707e-05, -4.13955189e-04,
    
5.29862793e-05, -1.98286005e-04, -2.22829175e-04, -8.88758230e-04,
    
5.62228710e-05,  1.36249752e-05, -2.00474996e-05, -2.10090068e-05,
    
1.00007518e+00,  1.00007569e+00, -4.44597417e-05, -2.93724453e-04,
    
1.00007513e+00,  1.00007496e+00,  1.00007532e+00, -1.22357142e-03,
    
3.27903892e-06,  1.00007592e+00,  1.00007468e+00,  1.00007558e+00,
    
2.09869172e-05, -1.97610235e-05,  1.00007529e+00,  1.00007530e+00,
    
1.00007503e+00, -2.68725642e-05, -3.00372853e-03,  1.00007386e+00,
    
1.00007443e+00,  1.00007388e+00,  5.86993822e-05, -8.69989983e-06,
    
1.00007590e+00,  1.00007488e+00,  1.00007515e+00,  8.81850779e-04,
    
2.03875532e-05,  1.00007480e+00,  1.00007425e+00,  1.00007517e+00,
    
-2.44678912e-05, -4.36556267e-08,  1.00007436e+00,  1.00007558e+00,
    
1.00007571e+00, -5.42990711e-04,  1.45517859e-04,  1.00007522e+00,
    
1.00007469e+00,  1.00007575e+00, -2.52271817e-05, -7.46339417e-05,
    
1.00007427e+00]]
    

    
rounded_x = [0 if abs(i) < abs(1-i) else 1 for i in x[0]]
    
print(rounded_x)


    Output:



    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1]





    share|improve this answer




























      up vote
      3
      down vote













      Here's a simple generalization for any arbitrary numbers a and b, instead of just 0 and 1:



      def closerab(l, a=0, b=1):
      
    l = np.asarray(l)
      
    boolarr = (np.abs(l - b) > np.abs(l - a))
      

      
    # returns two lists of indices, one for numbers closer to a and one for numbers closer to b
      
    return boolarr.nonzero()[0], (boolarr==0).nonzero()[0]


      This'll return two lists, one with the indices of the numbers closer to a, and one with the indices of the numbers closer to b.



      Testing it out:



      l = [
      
-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
      
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
      
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
      
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
      
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
      
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
      
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
      
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
      
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
      
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
      
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
      
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
      
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
      
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
      
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
      
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
      
1.00007427e+00
      
]
      

      
print(closerab(l, 0, 1))


      This outputs:



      (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
      
        17, 18, 19, 22, 23, 27, 28, 32, 33, 37, 38, 42, 43, 47, 48, 52, 53,
      
        57, 58, 62, 63]),
      
 array([20, 21, 24, 25, 26, 29, 30, 31, 34, 35, 36, 39, 40, 41, 44, 45, 46,
      
        49, 50, 51, 54, 55, 56, 59, 60, 61, 64]))





      share|improve this answer




























        up vote
        2
        down vote













        Here is one simple way to do this:



        >>> a = np.arange(-2, 2.1, 0.1)
        
>>> (a >= .5).astype(np.float)
        
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
        
        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,
        
        1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,
        
        1.,  1.])


        (Change np.float to np.int if you want integers.)






        share|improve this answer





















        • Cleanest and probably fastest solution. Pity it did not attract many votes so far.
          – Luca Citi
          2 days ago










        • You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
          – Rob
          yesterday


















        up vote
        1
        down vote













        From the Python built-in function docs round(number[, ndigits]):




        Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so, for example, round(0.5) is 1.0 and round(-0.5) is -1.0).




        For numpy arrays in particular, you can use the numpy.round_ function.






        share|improve this answer








        New contributor




        Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
        Check out our Code of Conduct.


















        • What about numbers that are not in range of 0 and 1?
          – Filip Młynarski
          2 days ago






        • 1




          Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
          – Andrew Fiorillo
          2 days ago










        • @AndrewFiorillo But I just wanted an output 0 and 1 :)
          – Eliyah
          2 days ago












        • Then @FilipMłynarski 's answer above is probably the most robust.
          – Andrew Fiorillo
          2 days ago


















        up vote
        1
        down vote













        your_list=[[-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
        
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
        
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
        
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
        
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
        
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
        
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
        
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
        
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
        
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
        
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
        
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
        
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
        
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
        
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
        
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
        
1.00007427e+00]]
        

        
close_to_one_or_zero=[1 if x > 0.5 else 0 for x in your_list[0]]
        
close_to_one_or_zero
        
    [0, 0, 0, 0, 0,....... 1, 1, 1, 0, 0, 1]





        share|improve this answer




























          up vote
          1
          down vote













          You can use round: 



          [round(i) for i in [0.1,0.2,0.3,0.8,0.9]]





          share|improve this answer






























            up vote
            1
            down vote













            Alternatively, you can use a ternary operator.



            x = [-0.2, 0.1, 1.1, 0.75, 0.4, 0.2, 1.5, 0.9]
            

            
a = 0
            
b = 1
            

            
[a if i <= (a+b)/2 else b for i in x]





            share|improve this answer





















              Your Answer






              StackExchange.ifUsing("editor", function () {
              StackExchange.using("externalEditor", function () {
              StackExchange.using("snippets", function () {
              StackExchange.snippets.init();
              });
              });
              }, "code-snippets");

              StackExchange.ready(function() {
              var channelOptions = {
              tags: "".split(" "),
              id: "1"
              };
              initTagRenderer("".split(" "), "".split(" "), channelOptions);

              StackExchange.using("externalEditor", function() {
              // Have to fire editor after snippets, if snippets enabled
              if (StackExchange.settings.snippets.snippetsEnabled) {
              StackExchange.using("snippets", function() {
              createEditor();
              });
              }
              else {
              createEditor();
              }
              });

              function createEditor() {
              StackExchange.prepareEditor({
              heartbeatType: 'answer',
              convertImagesToLinks: true,
              noModals: true,
              showLowRepImageUploadWarning: true,
              reputationToPostImages: 10,
              bindNavPrevention: true,
              postfix: "",
              imageUploader: {
              brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
              contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
              allowUrls: true
              },
              onDemand: true,
              discardSelector: ".discard-answer"
              ,immediatelyShowMarkdownHelp:true
              });


              }
              });














               

              draft saved


              draft discarded


















              StackExchange.ready(
              function () {
              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53467807%2fpython-function-that-identifies-if-the-numbers-in-a-list-or-array-are-closer-to%23new-answer', 'question_page');
              }
              );

              Post as a guest















              Required, but never shown

























              10 Answers
              10






              active

              oldest

              votes








              10 Answers
              10






              active

              oldest

              votes









              active

              oldest

              votes






              active

              oldest

              votes








              up vote
              9
              down vote



              accepted










              numpy.rint is a ufunc that will round the elements of an array to the nearest integer.



              >>> a = np.arange(0, 1.1, 0.1)
              
>>> a
              
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
              
>>> np.rint(a)
              
array([0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.])



              What if the numbers don't have to be between 0 and 1?




              In that case, I'd use numpy.where.



              >>> a = np.arange(-2, 2.1, 0.1)
              
>>> a
              
array([-2.00000000e+00, -1.90000000e+00, -1.80000000e+00, -1.70000000e+00,
              
       -1.60000000e+00, -1.50000000e+00, -1.40000000e+00, -1.30000000e+00,
              
       -1.20000000e+00, -1.10000000e+00, -1.00000000e+00, -9.00000000e-01,
              
       -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01,
              
       -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01,
              
        1.77635684e-15,  1.00000000e-01,  2.00000000e-01,  3.00000000e-01,
              
        4.00000000e-01,  5.00000000e-01,  6.00000000e-01,  7.00000000e-01,
              
        8.00000000e-01,  9.00000000e-01,  1.00000000e+00,  1.10000000e+00,
              
        1.20000000e+00,  1.30000000e+00,  1.40000000e+00,  1.50000000e+00,
              
        1.60000000e+00,  1.70000000e+00,  1.80000000e+00,  1.90000000e+00,
              
        2.00000000e+00])
              
>>> np.where(a <= 0.5, 0, 1)
              
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              
   0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])





              share|improve this answer



















              • 1




                What if my numbers is above 2?
                – Eliyah
                2 days ago






              • 2




                @Eliyah then np.where!
                – timgeb
                2 days ago










              • np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
                – Tls Chris
                2 days ago










              • @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
                – timgeb
                2 days ago








              • 1




                @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
                – Tls Chris
                2 days ago















              up vote
              9
              down vote



              accepted










              numpy.rint is a ufunc that will round the elements of an array to the nearest integer.



              >>> a = np.arange(0, 1.1, 0.1)
              
>>> a
              
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
              
>>> np.rint(a)
              
array([0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.])



              What if the numbers don't have to be between 0 and 1?




              In that case, I'd use numpy.where.



              >>> a = np.arange(-2, 2.1, 0.1)
              
>>> a
              
array([-2.00000000e+00, -1.90000000e+00, -1.80000000e+00, -1.70000000e+00,
              
       -1.60000000e+00, -1.50000000e+00, -1.40000000e+00, -1.30000000e+00,
              
       -1.20000000e+00, -1.10000000e+00, -1.00000000e+00, -9.00000000e-01,
              
       -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01,
              
       -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01,
              
        1.77635684e-15,  1.00000000e-01,  2.00000000e-01,  3.00000000e-01,
              
        4.00000000e-01,  5.00000000e-01,  6.00000000e-01,  7.00000000e-01,
              
        8.00000000e-01,  9.00000000e-01,  1.00000000e+00,  1.10000000e+00,
              
        1.20000000e+00,  1.30000000e+00,  1.40000000e+00,  1.50000000e+00,
              
        1.60000000e+00,  1.70000000e+00,  1.80000000e+00,  1.90000000e+00,
              
        2.00000000e+00])
              
>>> np.where(a <= 0.5, 0, 1)
              
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              
   0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])





              share|improve this answer



















              • 1




                What if my numbers is above 2?
                – Eliyah
                2 days ago






              • 2




                @Eliyah then np.where!
                – timgeb
                2 days ago










              • np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
                – Tls Chris
                2 days ago










              • @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
                – timgeb
                2 days ago








              • 1




                @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
                – Tls Chris
                2 days ago













              up vote
              9
              down vote



              accepted







              up vote
              9
              down vote



              accepted






              numpy.rint is a ufunc that will round the elements of an array to the nearest integer.



              >>> a = np.arange(0, 1.1, 0.1)
              
>>> a
              
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
              
>>> np.rint(a)
              
array([0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.])



              What if the numbers don't have to be between 0 and 1?




              In that case, I'd use numpy.where.



              >>> a = np.arange(-2, 2.1, 0.1)
              
>>> a
              
array([-2.00000000e+00, -1.90000000e+00, -1.80000000e+00, -1.70000000e+00,
              
       -1.60000000e+00, -1.50000000e+00, -1.40000000e+00, -1.30000000e+00,
              
       -1.20000000e+00, -1.10000000e+00, -1.00000000e+00, -9.00000000e-01,
              
       -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01,
              
       -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01,
              
        1.77635684e-15,  1.00000000e-01,  2.00000000e-01,  3.00000000e-01,
              
        4.00000000e-01,  5.00000000e-01,  6.00000000e-01,  7.00000000e-01,
              
        8.00000000e-01,  9.00000000e-01,  1.00000000e+00,  1.10000000e+00,
              
        1.20000000e+00,  1.30000000e+00,  1.40000000e+00,  1.50000000e+00,
              
        1.60000000e+00,  1.70000000e+00,  1.80000000e+00,  1.90000000e+00,
              
        2.00000000e+00])
              
>>> np.where(a <= 0.5, 0, 1)
              
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              
   0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])





              share|improve this answer














              numpy.rint is a ufunc that will round the elements of an array to the nearest integer.



              >>> a = np.arange(0, 1.1, 0.1)
              
>>> a
              
array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ])
              
>>> np.rint(a)
              
array([0., 0., 0., 0., 0., 0., 1., 1., 1., 1., 1.])



              What if the numbers don't have to be between 0 and 1?




              In that case, I'd use numpy.where.



              >>> a = np.arange(-2, 2.1, 0.1)
              
>>> a
              
array([-2.00000000e+00, -1.90000000e+00, -1.80000000e+00, -1.70000000e+00,
              
       -1.60000000e+00, -1.50000000e+00, -1.40000000e+00, -1.30000000e+00,
              
       -1.20000000e+00, -1.10000000e+00, -1.00000000e+00, -9.00000000e-01,
              
       -8.00000000e-01, -7.00000000e-01, -6.00000000e-01, -5.00000000e-01,
              
       -4.00000000e-01, -3.00000000e-01, -2.00000000e-01, -1.00000000e-01,
              
        1.77635684e-15,  1.00000000e-01,  2.00000000e-01,  3.00000000e-01,
              
        4.00000000e-01,  5.00000000e-01,  6.00000000e-01,  7.00000000e-01,
              
        8.00000000e-01,  9.00000000e-01,  1.00000000e+00,  1.10000000e+00,
              
        1.20000000e+00,  1.30000000e+00,  1.40000000e+00,  1.50000000e+00,
              
        1.60000000e+00,  1.70000000e+00,  1.80000000e+00,  1.90000000e+00,
              
        2.00000000e+00])
              
>>> np.where(a <= 0.5, 0, 1)
              
array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
              
   0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])






              share|improve this answer














              share|improve this answer



              share|improve this answer








              edited 2 days ago

























              answered 2 days ago









              timgeb

              45.8k106286




              45.8k106286








              • 1




                What if my numbers is above 2?
                – Eliyah
                2 days ago






              • 2




                @Eliyah then np.where!
                – timgeb
                2 days ago










              • np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
                – Tls Chris
                2 days ago










              • @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
                – timgeb
                2 days ago








              • 1




                @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
                – Tls Chris
                2 days ago














              • 1




                What if my numbers is above 2?
                – Eliyah
                2 days ago






              • 2




                @Eliyah then np.where!
                – timgeb
                2 days ago










              • np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
                – Tls Chris
                2 days ago










              • @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
                – timgeb
                2 days ago








              • 1




                @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
                – Tls Chris
                2 days ago








              1




              1




              What if my numbers is above 2?
              – Eliyah
              2 days ago




              What if my numbers is above 2?
              – Eliyah
              2 days ago




              2




              2




              @Eliyah then np.where!
              – timgeb
              2 days ago




              @Eliyah then np.where!
              – timgeb
              2 days ago












              np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
              – Tls Chris
              2 days ago




              np.minimum(np.rint(a),1) returns 0 for a<0.5 and 1 for a>=0.5.
              – Tls Chris
              2 days ago












              @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
              – timgeb
              2 days ago






              @TlsChris On my machine: np.minimum(np.rint(0.5),1) -> 0 because np.rint(0.5) -> 0.
              – timgeb
              2 days ago






              1




              1




              @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
              – Tls Chris
              2 days ago




              @timgeb. np.rint(0.5) rounds down on my machine too. I shouldn't make assumptions :-).
              – Tls Chris
              2 days ago












              up vote
              19
              down vote













              A straightforward way:



              lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
closerTo1 = [x >= 0.5 for x in lst]


              Or you can use np:



              import numpy as np
              
lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
arr = np.array(lst)
              
closerTo1 = arr >= 0.5


              Note that >= 0.5 can be changed to > 0.5, however you choose to treat it.






              share|improve this answer

















              • 3




                Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
                – jpp
                2 days ago








              • 1




                Did not mention rounding solutions, as no range was defined.
                – Or Dinari
                2 days ago















              up vote
              19
              down vote













              A straightforward way:



              lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
closerTo1 = [x >= 0.5 for x in lst]


              Or you can use np:



              import numpy as np
              
lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
arr = np.array(lst)
              
closerTo1 = arr >= 0.5


              Note that >= 0.5 can be changed to > 0.5, however you choose to treat it.






              share|improve this answer

















              • 3




                Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
                – jpp
                2 days ago








              • 1




                Did not mention rounding solutions, as no range was defined.
                – Or Dinari
                2 days ago













              up vote
              19
              down vote










              up vote
              19
              down vote









              A straightforward way:



              lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
closerTo1 = [x >= 0.5 for x in lst]


              Or you can use np:



              import numpy as np
              
lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
arr = np.array(lst)
              
closerTo1 = arr >= 0.5


              Note that >= 0.5 can be changed to > 0.5, however you choose to treat it.






              share|improve this answer












              A straightforward way:



              lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
closerTo1 = [x >= 0.5 for x in lst]


              Or you can use np:



              import numpy as np
              
lst=[0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9]
              

              
arr = np.array(lst)
              
closerTo1 = arr >= 0.5


              Note that >= 0.5 can be changed to > 0.5, however you choose to treat it.







              share|improve this answer












              share|improve this answer



              share|improve this answer










              answered 2 days ago









              Or Dinari

              1,069321




              1,069321








              • 3




                Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
                – jpp
                2 days ago








              • 1




                Did not mention rounding solutions, as no range was defined.
                – Or Dinari
                2 days ago














              • 3




                Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
                – jpp
                2 days ago








              • 1




                Did not mention rounding solutions, as no range was defined.
                – Or Dinari
                2 days ago








              3




              3




              Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
              – jpp
              2 days ago






              Best to use NumPy for NumPy arrays, +1. Also worth mentioning other options if performance is an issue.
              – jpp
              2 days ago






              1




              1




              Did not mention rounding solutions, as no range was defined.
              – Or Dinari
              2 days ago




              Did not mention rounding solutions, as no range was defined.
              – Or Dinari
              2 days ago










              up vote
              4
              down vote













              You could use numpy.where:



              import numpy as np
              

              
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 2.0])
              
result = np.where(arr >= 0.5, 1, 0)
              
print(result)


              Output



              [0 0 0 0 1 1 1 1 1 1]


              Note that this will return 1 for numbers above 1 (for instance 2).






              share|improve this answer

























                up vote
                4
                down vote













                You could use numpy.where:



                import numpy as np
                

                
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 2.0])
                
result = np.where(arr >= 0.5, 1, 0)
                
print(result)


                Output



                [0 0 0 0 1 1 1 1 1 1]


                Note that this will return 1 for numbers above 1 (for instance 2).






                share|improve this answer























                  up vote
                  4
                  down vote










                  up vote
                  4
                  down vote









                  You could use numpy.where:



                  import numpy as np
                  

                  
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 2.0])
                  
result = np.where(arr >= 0.5, 1, 0)
                  
print(result)


                  Output



                  [0 0 0 0 1 1 1 1 1 1]


                  Note that this will return 1 for numbers above 1 (for instance 2).






                  share|improve this answer












                  You could use numpy.where:



                  import numpy as np
                  

                  
arr = np.array([0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 2.0])
                  
result = np.where(arr >= 0.5, 1, 0)
                  
print(result)


                  Output



                  [0 0 0 0 1 1 1 1 1 1]


                  Note that this will return 1 for numbers above 1 (for instance 2).







                  share|improve this answer












                  share|improve this answer



                  share|improve this answer










                  answered 2 days ago









                  Daniel Mesejo

                  8,4821923




                  8,4821923






















                      up vote
                      3
                      down vote













                      You could use abs() to measure distances between your number and 0 and 1 and check which on is shorter.



                      x = [[-2.10044520e-04,  1.72314372e-04,  1.77235336e-04, -1.06613465e-04,
                      
6.76617611e-07,  2.71623057e-03, -3.32789944e-05,  1.44899758e-05,
                      
5.79249863e-05,  4.06502549e-04, -1.35823707e-05, -4.13955189e-04,
                      
5.29862793e-05, -1.98286005e-04, -2.22829175e-04, -8.88758230e-04,
                      
5.62228710e-05,  1.36249752e-05, -2.00474996e-05, -2.10090068e-05,
                      
1.00007518e+00,  1.00007569e+00, -4.44597417e-05, -2.93724453e-04,
                      
1.00007513e+00,  1.00007496e+00,  1.00007532e+00, -1.22357142e-03,
                      
3.27903892e-06,  1.00007592e+00,  1.00007468e+00,  1.00007558e+00,
                      
2.09869172e-05, -1.97610235e-05,  1.00007529e+00,  1.00007530e+00,
                      
1.00007503e+00, -2.68725642e-05, -3.00372853e-03,  1.00007386e+00,
                      
1.00007443e+00,  1.00007388e+00,  5.86993822e-05, -8.69989983e-06,
                      
1.00007590e+00,  1.00007488e+00,  1.00007515e+00,  8.81850779e-04,
                      
2.03875532e-05,  1.00007480e+00,  1.00007425e+00,  1.00007517e+00,
                      
-2.44678912e-05, -4.36556267e-08,  1.00007436e+00,  1.00007558e+00,
                      
1.00007571e+00, -5.42990711e-04,  1.45517859e-04,  1.00007522e+00,
                      
1.00007469e+00,  1.00007575e+00, -2.52271817e-05, -7.46339417e-05,
                      
1.00007427e+00]]
                      

                      
rounded_x = [0 if abs(i) < abs(1-i) else 1 for i in x[0]]
                      
print(rounded_x)


                      Output:



                      [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1]





                      share|improve this answer

























                        up vote
                        3
                        down vote













                        You could use abs() to measure distances between your number and 0 and 1 and check which on is shorter.



                        x = [[-2.10044520e-04,  1.72314372e-04,  1.77235336e-04, -1.06613465e-04,
                        
6.76617611e-07,  2.71623057e-03, -3.32789944e-05,  1.44899758e-05,
                        
5.79249863e-05,  4.06502549e-04, -1.35823707e-05, -4.13955189e-04,
                        
5.29862793e-05, -1.98286005e-04, -2.22829175e-04, -8.88758230e-04,
                        
5.62228710e-05,  1.36249752e-05, -2.00474996e-05, -2.10090068e-05,
                        
1.00007518e+00,  1.00007569e+00, -4.44597417e-05, -2.93724453e-04,
                        
1.00007513e+00,  1.00007496e+00,  1.00007532e+00, -1.22357142e-03,
                        
3.27903892e-06,  1.00007592e+00,  1.00007468e+00,  1.00007558e+00,
                        
2.09869172e-05, -1.97610235e-05,  1.00007529e+00,  1.00007530e+00,
                        
1.00007503e+00, -2.68725642e-05, -3.00372853e-03,  1.00007386e+00,
                        
1.00007443e+00,  1.00007388e+00,  5.86993822e-05, -8.69989983e-06,
                        
1.00007590e+00,  1.00007488e+00,  1.00007515e+00,  8.81850779e-04,
                        
2.03875532e-05,  1.00007480e+00,  1.00007425e+00,  1.00007517e+00,
                        
-2.44678912e-05, -4.36556267e-08,  1.00007436e+00,  1.00007558e+00,
                        
1.00007571e+00, -5.42990711e-04,  1.45517859e-04,  1.00007522e+00,
                        
1.00007469e+00,  1.00007575e+00, -2.52271817e-05, -7.46339417e-05,
                        
1.00007427e+00]]
                        

                        
rounded_x = [0 if abs(i) < abs(1-i) else 1 for i in x[0]]
                        
print(rounded_x)


                        Output:



                        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1]





                        share|improve this answer























                          up vote
                          3
                          down vote










                          up vote
                          3
                          down vote









                          You could use abs() to measure distances between your number and 0 and 1 and check which on is shorter.



                          x = [[-2.10044520e-04,  1.72314372e-04,  1.77235336e-04, -1.06613465e-04,
                          
6.76617611e-07,  2.71623057e-03, -3.32789944e-05,  1.44899758e-05,
                          
5.79249863e-05,  4.06502549e-04, -1.35823707e-05, -4.13955189e-04,
                          
5.29862793e-05, -1.98286005e-04, -2.22829175e-04, -8.88758230e-04,
                          
5.62228710e-05,  1.36249752e-05, -2.00474996e-05, -2.10090068e-05,
                          
1.00007518e+00,  1.00007569e+00, -4.44597417e-05, -2.93724453e-04,
                          
1.00007513e+00,  1.00007496e+00,  1.00007532e+00, -1.22357142e-03,
                          
3.27903892e-06,  1.00007592e+00,  1.00007468e+00,  1.00007558e+00,
                          
2.09869172e-05, -1.97610235e-05,  1.00007529e+00,  1.00007530e+00,
                          
1.00007503e+00, -2.68725642e-05, -3.00372853e-03,  1.00007386e+00,
                          
1.00007443e+00,  1.00007388e+00,  5.86993822e-05, -8.69989983e-06,
                          
1.00007590e+00,  1.00007488e+00,  1.00007515e+00,  8.81850779e-04,
                          
2.03875532e-05,  1.00007480e+00,  1.00007425e+00,  1.00007517e+00,
                          
-2.44678912e-05, -4.36556267e-08,  1.00007436e+00,  1.00007558e+00,
                          
1.00007571e+00, -5.42990711e-04,  1.45517859e-04,  1.00007522e+00,
                          
1.00007469e+00,  1.00007575e+00, -2.52271817e-05, -7.46339417e-05,
                          
1.00007427e+00]]
                          

                          
rounded_x = [0 if abs(i) < abs(1-i) else 1 for i in x[0]]
                          
print(rounded_x)


                          Output:



                          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1]





                          share|improve this answer












                          You could use abs() to measure distances between your number and 0 and 1 and check which on is shorter.



                          x = [[-2.10044520e-04,  1.72314372e-04,  1.77235336e-04, -1.06613465e-04,
                          
6.76617611e-07,  2.71623057e-03, -3.32789944e-05,  1.44899758e-05,
                          
5.79249863e-05,  4.06502549e-04, -1.35823707e-05, -4.13955189e-04,
                          
5.29862793e-05, -1.98286005e-04, -2.22829175e-04, -8.88758230e-04,
                          
5.62228710e-05,  1.36249752e-05, -2.00474996e-05, -2.10090068e-05,
                          
1.00007518e+00,  1.00007569e+00, -4.44597417e-05, -2.93724453e-04,
                          
1.00007513e+00,  1.00007496e+00,  1.00007532e+00, -1.22357142e-03,
                          
3.27903892e-06,  1.00007592e+00,  1.00007468e+00,  1.00007558e+00,
                          
2.09869172e-05, -1.97610235e-05,  1.00007529e+00,  1.00007530e+00,
                          
1.00007503e+00, -2.68725642e-05, -3.00372853e-03,  1.00007386e+00,
                          
1.00007443e+00,  1.00007388e+00,  5.86993822e-05, -8.69989983e-06,
                          
1.00007590e+00,  1.00007488e+00,  1.00007515e+00,  8.81850779e-04,
                          
2.03875532e-05,  1.00007480e+00,  1.00007425e+00,  1.00007517e+00,
                          
-2.44678912e-05, -4.36556267e-08,  1.00007436e+00,  1.00007558e+00,
                          
1.00007571e+00, -5.42990711e-04,  1.45517859e-04,  1.00007522e+00,
                          
1.00007469e+00,  1.00007575e+00, -2.52271817e-05, -7.46339417e-05,
                          
1.00007427e+00]]
                          

                          
rounded_x = [0 if abs(i) < abs(1-i) else 1 for i in x[0]]
                          
print(rounded_x)


                          Output:



                          [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1]






                          share|improve this answer












                          share|improve this answer



                          share|improve this answer










                          answered 2 days ago









                          Filip Młynarski

                          1,107111




                          1,107111






















                              up vote
                              3
                              down vote













                              Here's a simple generalization for any arbitrary numbers a and b, instead of just 0 and 1:



                              def closerab(l, a=0, b=1):
                              
    l = np.asarray(l)
                              
    boolarr = (np.abs(l - b) > np.abs(l - a))
                              

                              
    # returns two lists of indices, one for numbers closer to a and one for numbers closer to b
                              
    return boolarr.nonzero()[0], (boolarr==0).nonzero()[0]


                              This'll return two lists, one with the indices of the numbers closer to a, and one with the indices of the numbers closer to b.



                              Testing it out:



                              l = [
                              
-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                              
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                              
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                              
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                              
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                              
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                              
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                              
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                              
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                              
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                              
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                              
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                              
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                              
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                              
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                              
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                              
1.00007427e+00
                              
]
                              

                              
print(closerab(l, 0, 1))


                              This outputs:



                              (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
                              
        17, 18, 19, 22, 23, 27, 28, 32, 33, 37, 38, 42, 43, 47, 48, 52, 53,
                              
        57, 58, 62, 63]),
                              
 array([20, 21, 24, 25, 26, 29, 30, 31, 34, 35, 36, 39, 40, 41, 44, 45, 46,
                              
        49, 50, 51, 54, 55, 56, 59, 60, 61, 64]))





                              share|improve this answer

























                                up vote
                                3
                                down vote













                                Here's a simple generalization for any arbitrary numbers a and b, instead of just 0 and 1:



                                def closerab(l, a=0, b=1):
                                
    l = np.asarray(l)
                                
    boolarr = (np.abs(l - b) > np.abs(l - a))
                                

                                
    # returns two lists of indices, one for numbers closer to a and one for numbers closer to b
                                
    return boolarr.nonzero()[0], (boolarr==0).nonzero()[0]


                                This'll return two lists, one with the indices of the numbers closer to a, and one with the indices of the numbers closer to b.



                                Testing it out:



                                l = [
                                
-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                
1.00007427e+00
                                
]
                                

                                
print(closerab(l, 0, 1))


                                This outputs:



                                (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
                                
        17, 18, 19, 22, 23, 27, 28, 32, 33, 37, 38, 42, 43, 47, 48, 52, 53,
                                
        57, 58, 62, 63]),
                                
 array([20, 21, 24, 25, 26, 29, 30, 31, 34, 35, 36, 39, 40, 41, 44, 45, 46,
                                
        49, 50, 51, 54, 55, 56, 59, 60, 61, 64]))





                                share|improve this answer























                                  up vote
                                  3
                                  down vote










                                  up vote
                                  3
                                  down vote









                                  Here's a simple generalization for any arbitrary numbers a and b, instead of just 0 and 1:



                                  def closerab(l, a=0, b=1):
                                  
    l = np.asarray(l)
                                  
    boolarr = (np.abs(l - b) > np.abs(l - a))
                                  

                                  
    # returns two lists of indices, one for numbers closer to a and one for numbers closer to b
                                  
    return boolarr.nonzero()[0], (boolarr==0).nonzero()[0]


                                  This'll return two lists, one with the indices of the numbers closer to a, and one with the indices of the numbers closer to b.



                                  Testing it out:



                                  l = [
                                  
-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                  
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                  
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                  
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                  
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                  
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                  
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                  
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                  
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                  
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                  
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                  
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                  
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                  
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                  
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                  
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                  
1.00007427e+00
                                  
]
                                  

                                  
print(closerab(l, 0, 1))


                                  This outputs:



                                  (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
                                  
        17, 18, 19, 22, 23, 27, 28, 32, 33, 37, 38, 42, 43, 47, 48, 52, 53,
                                  
        57, 58, 62, 63]),
                                  
 array([20, 21, 24, 25, 26, 29, 30, 31, 34, 35, 36, 39, 40, 41, 44, 45, 46,
                                  
        49, 50, 51, 54, 55, 56, 59, 60, 61, 64]))





                                  share|improve this answer












                                  Here's a simple generalization for any arbitrary numbers a and b, instead of just 0 and 1:



                                  def closerab(l, a=0, b=1):
                                  
    l = np.asarray(l)
                                  
    boolarr = (np.abs(l - b) > np.abs(l - a))
                                  

                                  
    # returns two lists of indices, one for numbers closer to a and one for numbers closer to b
                                  
    return boolarr.nonzero()[0], (boolarr==0).nonzero()[0]


                                  This'll return two lists, one with the indices of the numbers closer to a, and one with the indices of the numbers closer to b.



                                  Testing it out:



                                  l = [
                                  
-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                  
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                  
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                  
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                  
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                  
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                  
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                  
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                  
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                  
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                  
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                  
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                  
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                  
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                  
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                  
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                  
1.00007427e+00
                                  
]
                                  

                                  
print(closerab(l, 0, 1))


                                  This outputs:



                                  (array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
                                  
        17, 18, 19, 22, 23, 27, 28, 32, 33, 37, 38, 42, 43, 47, 48, 52, 53,
                                  
        57, 58, 62, 63]),
                                  
 array([20, 21, 24, 25, 26, 29, 30, 31, 34, 35, 36, 39, 40, 41, 44, 45, 46,
                                  
        49, 50, 51, 54, 55, 56, 59, 60, 61, 64]))






                                  share|improve this answer












                                  share|improve this answer



                                  share|improve this answer










                                  answered 2 days ago









                                  tel

                                  3,4911427




                                  3,4911427






















                                      up vote
                                      2
                                      down vote













                                      Here is one simple way to do this:



                                      >>> a = np.arange(-2, 2.1, 0.1)
                                      
>>> (a >= .5).astype(np.float)
                                      
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
                                      
        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,
                                      
        1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,
                                      
        1.,  1.])


                                      (Change np.float to np.int if you want integers.)






                                      share|improve this answer





















                                      • Cleanest and probably fastest solution. Pity it did not attract many votes so far.
                                        – Luca Citi
                                        2 days ago










                                      • You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
                                        – Rob
                                        yesterday















                                      up vote
                                      2
                                      down vote













                                      Here is one simple way to do this:



                                      >>> a = np.arange(-2, 2.1, 0.1)
                                      
>>> (a >= .5).astype(np.float)
                                      
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
                                      
        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,
                                      
        1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,
                                      
        1.,  1.])


                                      (Change np.float to np.int if you want integers.)






                                      share|improve this answer





















                                      • Cleanest and probably fastest solution. Pity it did not attract many votes so far.
                                        – Luca Citi
                                        2 days ago










                                      • You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
                                        – Rob
                                        yesterday













                                      up vote
                                      2
                                      down vote










                                      up vote
                                      2
                                      down vote









                                      Here is one simple way to do this:



                                      >>> a = np.arange(-2, 2.1, 0.1)
                                      
>>> (a >= .5).astype(np.float)
                                      
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
                                      
        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,
                                      
        1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,
                                      
        1.,  1.])


                                      (Change np.float to np.int if you want integers.)






                                      share|improve this answer












                                      Here is one simple way to do this:



                                      >>> a = np.arange(-2, 2.1, 0.1)
                                      
>>> (a >= .5).astype(np.float)
                                      
array([ 0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,
                                      
        0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  0.,  1.,
                                      
        1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,  1.,
                                      
        1.,  1.])


                                      (Change np.float to np.int if you want integers.)







                                      share|improve this answer












                                      share|improve this answer



                                      share|improve this answer










                                      answered 2 days ago









                                      NPE

                                      344k59733866




                                      344k59733866












                                      • Cleanest and probably fastest solution. Pity it did not attract many votes so far.
                                        – Luca Citi
                                        2 days ago










                                      • You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
                                        – Rob
                                        yesterday


















                                      • Cleanest and probably fastest solution. Pity it did not attract many votes so far.
                                        – Luca Citi
                                        2 days ago










                                      • You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
                                        – Rob
                                        yesterday
















                                      Cleanest and probably fastest solution. Pity it did not attract many votes so far.
                                      – Luca Citi
                                      2 days ago




                                      Cleanest and probably fastest solution. Pity it did not attract many votes so far.
                                      – Luca Citi
                                      2 days ago












                                      You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
                                      – Rob
                                      yesterday




                                      You don't have to use np.float or np.int in .astype, a regular float or int will do just fine. Numpy will interpret it as the equivalent numpy variant.
                                      – Rob
                                      yesterday










                                      up vote
                                      1
                                      down vote













                                      From the Python built-in function docs round(number[, ndigits]):




                                      Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so, for example, round(0.5) is 1.0 and round(-0.5) is -1.0).




                                      For numpy arrays in particular, you can use the numpy.round_ function.






                                      share|improve this answer








                                      New contributor




                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.


















                                      • What about numbers that are not in range of 0 and 1?
                                        – Filip Młynarski
                                        2 days ago






                                      • 1




                                        Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
                                        – Andrew Fiorillo
                                        2 days ago










                                      • @AndrewFiorillo But I just wanted an output 0 and 1 :)
                                        – Eliyah
                                        2 days ago












                                      • Then @FilipMłynarski 's answer above is probably the most robust.
                                        – Andrew Fiorillo
                                        2 days ago















                                      up vote
                                      1
                                      down vote













                                      From the Python built-in function docs round(number[, ndigits]):




                                      Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so, for example, round(0.5) is 1.0 and round(-0.5) is -1.0).




                                      For numpy arrays in particular, you can use the numpy.round_ function.






                                      share|improve this answer








                                      New contributor




                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.


















                                      • What about numbers that are not in range of 0 and 1?
                                        – Filip Młynarski
                                        2 days ago






                                      • 1




                                        Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
                                        – Andrew Fiorillo
                                        2 days ago










                                      • @AndrewFiorillo But I just wanted an output 0 and 1 :)
                                        – Eliyah
                                        2 days ago












                                      • Then @FilipMłynarski 's answer above is probably the most robust.
                                        – Andrew Fiorillo
                                        2 days ago













                                      up vote
                                      1
                                      down vote










                                      up vote
                                      1
                                      down vote









                                      From the Python built-in function docs round(number[, ndigits]):




                                      Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so, for example, round(0.5) is 1.0 and round(-0.5) is -1.0).




                                      For numpy arrays in particular, you can use the numpy.round_ function.






                                      share|improve this answer








                                      New contributor




                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.









                                      From the Python built-in function docs round(number[, ndigits]):




                                      Return the floating point value number rounded to ndigits digits after the decimal point. If ndigits is omitted, it defaults to zero. The result is a floating point number. Values are rounded to the closest multiple of 10 to the power minus ndigits; if two multiples are equally close, rounding is done away from 0 (so, for example, round(0.5) is 1.0 and round(-0.5) is -1.0).




                                      For numpy arrays in particular, you can use the numpy.round_ function.







                                      share|improve this answer








                                      New contributor




                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.









                                      share|improve this answer



                                      share|improve this answer






                                      New contributor




                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.









                                      answered 2 days ago









                                      Andrew Fiorillo

                                      685




                                      685




                                      New contributor




                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.





                                      New contributor





                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.






                                      Andrew Fiorillo is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
                                      Check out our Code of Conduct.












                                      • What about numbers that are not in range of 0 and 1?
                                        – Filip Młynarski
                                        2 days ago






                                      • 1




                                        Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
                                        – Andrew Fiorillo
                                        2 days ago










                                      • @AndrewFiorillo But I just wanted an output 0 and 1 :)
                                        – Eliyah
                                        2 days ago












                                      • Then @FilipMłynarski 's answer above is probably the most robust.
                                        – Andrew Fiorillo
                                        2 days ago


















                                      • What about numbers that are not in range of 0 and 1?
                                        – Filip Młynarski
                                        2 days ago






                                      • 1




                                        Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
                                        – Andrew Fiorillo
                                        2 days ago










                                      • @AndrewFiorillo But I just wanted an output 0 and 1 :)
                                        – Eliyah
                                        2 days ago












                                      • Then @FilipMłynarski 's answer above is probably the most robust.
                                        – Andrew Fiorillo
                                        2 days ago
















                                      What about numbers that are not in range of 0 and 1?
                                      – Filip Młynarski
                                      2 days ago




                                      What about numbers that are not in range of 0 and 1?
                                      – Filip Młynarski
                                      2 days ago




                                      1




                                      1




                                      Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
                                      – Andrew Fiorillo
                                      2 days ago




                                      Round works outside of the [0, 1] range. So round(2.2) would be 2.0, round(-1.2) would be -1.0, and round(3.141, 2) would be 3.14.
                                      – Andrew Fiorillo
                                      2 days ago












                                      @AndrewFiorillo But I just wanted an output 0 and 1 :)
                                      – Eliyah
                                      2 days ago






                                      @AndrewFiorillo But I just wanted an output 0 and 1 :)
                                      – Eliyah
                                      2 days ago














                                      Then @FilipMłynarski 's answer above is probably the most robust.
                                      – Andrew Fiorillo
                                      2 days ago




                                      Then @FilipMłynarski 's answer above is probably the most robust.
                                      – Andrew Fiorillo
                                      2 days ago










                                      up vote
                                      1
                                      down vote













                                      your_list=[[-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                      
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                      
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                      
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                      
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                      
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                      
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                      
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                      
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                      
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                      
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                      
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                      
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                      
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                      
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                      
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                      
1.00007427e+00]]
                                      

                                      
close_to_one_or_zero=[1 if x > 0.5 else 0 for x in your_list[0]]
                                      
close_to_one_or_zero
                                      
    [0, 0, 0, 0, 0,....... 1, 1, 1, 0, 0, 1]





                                      share|improve this answer

























                                        up vote
                                        1
                                        down vote













                                        your_list=[[-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                        
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                        
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                        
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                        
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                        
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                        
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                        
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                        
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                        
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                        
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                        
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                        
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                        
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                        
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                        
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                        
1.00007427e+00]]
                                        

                                        
close_to_one_or_zero=[1 if x > 0.5 else 0 for x in your_list[0]]
                                        
close_to_one_or_zero
                                        
    [0, 0, 0, 0, 0,....... 1, 1, 1, 0, 0, 1]





                                        share|improve this answer























                                          up vote
                                          1
                                          down vote










                                          up vote
                                          1
                                          down vote









                                          your_list=[[-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                          
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                          
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                          
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                          
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                          
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                          
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                          
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                          
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                          
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                          
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                          
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                          
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                          
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                          
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                          
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                          
1.00007427e+00]]
                                          

                                          
close_to_one_or_zero=[1 if x > 0.5 else 0 for x in your_list[0]]
                                          
close_to_one_or_zero
                                          
    [0, 0, 0, 0, 0,....... 1, 1, 1, 0, 0, 1]





                                          share|improve this answer












                                          your_list=[[-2.10044520e-04, 1.72314372e-04, 1.77235336e-04, 1.06613465e-04,
                                          
6.76617611e-07, 2.71623057e-03, 3.32789944e-05, 1.44899758e-05,
                                          
5.79249863e-05, 4.06502549e-04, 1.35823707e-05, 4.13955189e-04,
                                          
5.29862793e-05, 1.98286005e-04, 2.22829175e-04, 8.88758230e-04,
                                          
5.62228710e-05, 1.36249752e-05, 2.00474996e-05, 2.10090068e-05,
                                          
1.00007518e+00, 1.00007569e+00, 4.44597417e-05, 2.93724453e-04,
                                          
1.00007513e+00, 1.00007496e+00, 1.00007532e+00, 1.22357142e-03,
                                          
3.27903892e-06, 1.00007592e+00, 1.00007468e+00, 1.00007558e+00,
                                          
2.09869172e-05, 1.97610235e-05, 1.00007529e+00, 1.00007530e+00,
                                          
1.00007503e+00, 2.68725642e-05, 3.00372853e-03, 1.00007386e+00,
                                          
1.00007443e+00, 1.00007388e+00, 5.86993822e-05, 8.69989983e-06,
                                          
1.00007590e+00, 1.00007488e+00, 1.00007515e+00, 8.81850779e-04,
                                          
2.03875532e-05, 1.00007480e+00, 1.00007425e+00, 1.00007517e+00,
                                          
-2.44678912e-05, 4.36556267e-08, 1.00007436e+00, 1.00007558e+00,
                                          
1.00007571e+00, 5.42990711e-04, 1.45517859e-04, 1.00007522e+00,
                                          
1.00007469e+00, 1.00007575e+00, 2.52271817e-05, 7.46339417e-05,
                                          
1.00007427e+00]]
                                          

                                          
close_to_one_or_zero=[1 if x > 0.5 else 0 for x in your_list[0]]
                                          
close_to_one_or_zero
                                          
    [0, 0, 0, 0, 0,....... 1, 1, 1, 0, 0, 1]






                                          share|improve this answer












                                          share|improve this answer



                                          share|improve this answer










                                          answered 2 days ago









                                          cph_sto

                                          552214




                                          552214






















                                              up vote
                                              1
                                              down vote













                                              You can use round: 



                                              [round(i) for i in [0.1,0.2,0.3,0.8,0.9]]





                                              share|improve this answer



























                                                up vote
                                                1
                                                down vote













                                                You can use round: 



                                                [round(i) for i in [0.1,0.2,0.3,0.8,0.9]]





                                                share|improve this answer

























                                                  up vote
                                                  1
                                                  down vote










                                                  up vote
                                                  1
                                                  down vote









                                                  You can use round: 



                                                  [round(i) for i in [0.1,0.2,0.3,0.8,0.9]]





                                                  share|improve this answer














                                                  You can use round: 



                                                  [round(i) for i in [0.1,0.2,0.3,0.8,0.9]]






                                                  share|improve this answer














                                                  share|improve this answer



                                                  share|improve this answer








                                                  edited yesterday









                                                  davnicwil

                                                  8,10444962




                                                  8,10444962










                                                  answered 2 days ago









                                                  Rudolf Morkovskyi

                                                  692113




                                                  692113






















                                                      up vote
                                                      1
                                                      down vote













                                                      Alternatively, you can use a ternary operator.



                                                      x = [-0.2, 0.1, 1.1, 0.75, 0.4, 0.2, 1.5, 0.9]
                                                      

                                                      
a = 0
                                                      
b = 1
                                                      

                                                      
[a if i <= (a+b)/2 else b for i in x]





                                                      share|improve this answer

























                                                        up vote
                                                        1
                                                        down vote













                                                        Alternatively, you can use a ternary operator.



                                                        x = [-0.2, 0.1, 1.1, 0.75, 0.4, 0.2, 1.5, 0.9]
                                                        

                                                        
a = 0
                                                        
b = 1
                                                        

                                                        
[a if i <= (a+b)/2 else b for i in x]





                                                        share|improve this answer























                                                          up vote
                                                          1
                                                          down vote










                                                          up vote
                                                          1
                                                          down vote









                                                          Alternatively, you can use a ternary operator.



                                                          x = [-0.2, 0.1, 1.1, 0.75, 0.4, 0.2, 1.5, 0.9]
                                                          

                                                          
a = 0
                                                          
b = 1
                                                          

                                                          
[a if i <= (a+b)/2 else b for i in x]





                                                          share|improve this answer












                                                          Alternatively, you can use a ternary operator.



                                                          x = [-0.2, 0.1, 1.1, 0.75, 0.4, 0.2, 1.5, 0.9]
                                                          

                                                          
a = 0
                                                          
b = 1
                                                          

                                                          
[a if i <= (a+b)/2 else b for i in x]






                                                          share|improve this answer












                                                          share|improve this answer



                                                          share|improve this answer










                                                          answered yesterday









                                                          Anastasiya-Romanova 秀

                                                          1,9111230




                                                          1,9111230






























                                                               

                                                              draft saved


                                                              draft discarded



















































                                                               


                                                              draft saved


                                                              draft discarded














                                                              StackExchange.ready(
                                                              function () {
                                                              StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fstackoverflow.com%2fquestions%2f53467807%2fpython-function-that-identifies-if-the-numbers-in-a-list-or-array-are-closer-to%23new-answer', 'question_page');
                                                              }
                                                              );

                                                              Post as a guest















                                                              Required, but never shown





















































                                                              Required, but never shown














                                                              Required, but never shown












                                                              Required, but never shown







                                                              Required, but never shown

































                                                              Required, but never shown














                                                              Required, but never shown












                                                              Required, but never shown







                                                              Required, but never shown







                                                              -

                                                              Popular posts from this blog

                                                              If I really need a card on my start hand, how many mulligans make sense? [duplicate]

                                                              Image
                                                              5 This question already has an answer here: How do you calculate the likelihood of drawing certain cards in your opening hand? 3 answers There is a funny modern deck where you play Treasure Hunt, but you really need to have it on the starting hand. How many mulligans should I take, if my deck contains 60 cards and contains 4 copies of Treasure Hunt? magic-the-gathering probability share | improve this question asked Nov 23 '18 at 12:12 dan dan 152 4
                                                              Read more

                                                              Alcedinidae

                                                              Image
                                                              Alcedinidae Martin-pêcheur à dos bleu ( Alcedo azurea ) Classification (COI) Règne Animalia Embranchement Chordata Sous-embr. Vertebrata Classe Aves Ordre Coraciiformes Famille Alcedinidae Rafinesque, 1815 Les Alcédinidés ou Alcedinidae forment une famille d'oiseaux plus connus sous les noms de martins-pêcheurs et martins-chasseurs. Sommaire 1 Description 2 Répartition et habitat 3 Systématique 3.1 Liste alphabétique des genres 3.2 Liste des espèces 4 Chez les Anciens : l'alcyon 4.1 Étymologie (Littré) 4.2 Oiseau « fabuleux » ? 5 Notes 6 Articles connexes 7 Liens externes 7.1 Bibliographie Description | Ce sont des oiseaux compacts de taille petite à moyenne (10 à 46 cm), au bec droit et long, en forme de poignard. Leurs pattes sont courtes, et ils portent un plumage aux couleurs vives. Répartition et habitat | Cosmopolites, ils fréquentent surtout
                                                              Read more

                                                              Can an atomic nucleus contain both particles and antiparticles? [duplicate]

                                                              Image
                                                              9 $begingroup$ This question already has an answer here: What happens if we put together a proton and an antineutron? 2 answers Is it theoretically possible to make a "deuterium" atom containing a proton and an antineutron in its nucleus? Would the strong nuclear force cause attraction between a proton and an antineutron? Would such a nucleus be stable, or would the proton somehow annihilate the antineutron when close enough? nuclear-physics antimatter share | cite | improve this question asked yesterday
                                                              Read more