da lista de números inteiros, obtenha o número mais próximo de um determinado valor

Dada uma lista de números inteiros, quero descobrir qual número é o mais próximo de um número que eu forneço na entrada:

>>> myList = [4, 1, 88, 44, 3]
>>> myNumber = 5
>>> takeClosest(myList, myNumber)
...
4

Existe alguma maneira rápida de fazer isso?

Se não tiver certeza de que a lista é ordenada, poderíamos usar o built-in min()função , para encontrar o elemento que tem a distância mínima entre o número especificado.

>>> min(myList, key=lambda x:abs(x-myNumber))
4

Observe que ele também funciona com dict com chaves int, como {1: "a", 2: "b"}. Este método leva O (n) tempo.

Se a lista já estiver classificada, ou você pode pagar o preço de classificar a matriz apenas uma vez, use o método de bissecção ilustrado na resposta de @ Lauritz, que leva apenas tempo O (log n) (observe, porém, verificar se uma lista já está classificada é O (n) e a classificação é O (n log n).)

Renomearei a função take_closestpara estar em conformidade com as convenções de nomenclatura do PEP8.

Se você quer dizer execução rápida, em vez de gravação rápida, nãomin deve ser sua arma preferida, exceto em um caso de uso muito restrito. A solução precisa examinar todos os números da lista e fazer um cálculo para cada número. O uso é quase sempre mais rápido.minbisect.bisect_left

O "quase" vem do fato de bisect_leftexigir que a lista seja classificada para funcionar. Felizmente, seu caso de uso é tal que você pode classificar a lista uma vez e depois deixá-la em paz. Mesmo se não, contanto que você não precise classificar antes de cada vez que ligar take_closest, o bisectmódulo provavelmente sairá por cima. Se você estiver em dúvida, tente os dois e veja a diferença no mundo real.

from bisect import bisect_left

def take_closest(myList, myNumber):
    """
    Assumes myList is sorted. Returns closest value to myNumber.

    If two numbers are equally close, return the smallest number.
    """
    pos = bisect_left(myList, myNumber)
    if pos == 0:
        return myList[0]
    if pos == len(myList):
        return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
       return after
    else:
       return before

O Bisect trabalha repetidamente pela metade uma lista e descobre em que metade myNumberdeve constar, olhando o valor médio. Isso significa que ele tem um tempo de execução de O (log n) em oposição ao tempo de execução de O (n) da resposta mais votada . Se compararmos os dois métodos e fornecermos ambos com uma ordenada myList, estes são os resultados:

$ python -m timeit -s "
da importação mais próxima take_closest
de importação aleatória aleatória
a = intervalo (-1000, 1000, 10) "" take_closest (a, randint (-1100, 1100)) ""

100000 loops, o melhor de 3: 2,22 usec por loop

$ python -m timeit -s "
da importação mais próxima com_min
de importação aleatória aleatória
a = intervalo (-1000, 1000, 10) "" com_min (a, randint (-1100, 1100)) ""

10000 loops, o melhor de 3: 43,9 usec por loop

Portanto, neste teste em particular, bisecté quase 20 vezes mais rápido. Para listas mais longas, a diferença será maior.

E se nivelarmos o campo de jogo removendo a pré-condição que myListdeve ser classificada? Digamos que classifiquemos uma cópia da lista sempre que take_closest for chamada, deixando a minsolução inalterada. Usando a lista de 200 itens no teste acima, a bisectsolução ainda é a mais rápida, embora apenas em cerca de 30%.

Esse é um resultado estranho, considerando que a etapa de classificação é O (n log (n)) ! O único motivo que minainda está perdendo é que a classificação é feita em código c altamente otimizado, enquanto miné necessário chamar uma função lambda para cada item. À medida que myListcresce em tamanho, a minsolução será eventualmente mais rápida. Observe que tivemos que empilhar tudo a seu favor para a minsolução vencer.

>>> takeClosest = lambda num,collection:min(collection,key=lambda x:abs(x-num))
>>> takeClosest(5,[4,1,88,44,3])
4

Um lambda é uma maneira especial de escrever uma função "anônima" (uma função que não tem nome). Você pode atribuir a ele qualquer nome que desejar, porque um lambda é uma expressão.

A maneira "longa" de escrever o texto acima seria:

def takeClosest(num,collection):
   return min(collection,key=lambda x:abs(x-num))

def closest(list, Number):
    aux = []
    for valor in list:
        aux.append(abs(Number-valor))

    return aux.index(min(aux))

Este código fornecerá o índice do número mais próximo de número na lista.

A solução dada pelo KennyTM é a melhor em geral, mas nos casos em que você não pode usá-la (como brython), essa função fará o trabalho

Itere a lista e compare o número mais próximo atual com abs(currentNumber - myNumber):

def takeClosest(myList, myNumber):
    closest = myList[0]
    for i in range(1, len(myList)):
        if abs(i - myNumber) < closest:
            closest = i
    return closest

É importante observar que a ideia de Lauritz de usar o bisect não encontra o valor mais próximo em MyList ao MyNumber. Em vez disso, o bisect encontra o próximo valor em ordem após MyNumber em MyList. Portanto, no caso do OP, você realmente retornaria a posição de 44 em vez da posição de 4.

>>> myList = [1, 3, 4, 44, 88] 
>>> myNumber = 5
>>> pos = (bisect_left(myList, myNumber))
>>> myList[pos]
...
44

Para obter o valor mais próximo de 5, você pode tentar converter a lista em uma matriz e usar argmin de numpy dessa maneira.

>>> import numpy as np
>>> myNumber = 5   
>>> myList = [1, 3, 4, 44, 88] 
>>> myArray = np.array(myList)
>>> pos = (np.abs(myArray-myNumber)).argmin()
>>> myArray[pos]
...
4

Eu não sei o quão rápido isso seria, meu palpite seria "não muito".

Expandindo a resposta de Gustavo Lima. O mesmo pode ser feito sem criar uma lista totalmente nova. Os valores na lista podem ser substituídos pelos diferenciais à medida que o FORloop avança.

def f_ClosestVal(v_List, v_Number):
"""Takes an unsorted LIST of INTs and RETURNS INDEX of value closest to an INT"""
for _index, i in enumerate(v_List):
    v_List[_index] = abs(v_Number - i)
return v_List.index(min(v_List))

myList = [1, 88, 44, 4, 4, -2, 3]
v_Num = 5
print(f_ClosestVal(myList, v_Num)) ## Gives "3," the index of the first "4" in the list.

Se eu puder adicionar à resposta de @ Lauritz

Para não ter um erro de execução, não se esqueça de adicionar uma condição antes da bisect_leftlinha:

if (myNumber > myList[-1] or myNumber < myList[0]):
    return False

então o código completo terá a seguinte aparência:

from bisect import bisect_left

def takeClosest(myList, myNumber):
    """
    Assumes myList is sorted. Returns closest value to myNumber.
    If two numbers are equally close, return the smallest number.
    If number is outside of min or max return False
    """
    if (myNumber > myList[-1] or myNumber < myList[0]):
        return False
    pos = bisect_left(myList, myNumber)
    if pos == 0:
            return myList[0]
    if pos == len(myList):
            return myList[-1]
    before = myList[pos - 1]
    after = myList[pos]
    if after - myNumber < myNumber - before:
       return after
    else:
       return before