Как сгенерировать список уникальных случайных чисел в Python

Ответ 1

Ответ

Одним из простых способов является сохранение набора всех случайных значений, видимых до сих пор, и повторного выбора, если есть повторение:

import random

def sample_floats(low, high, k=1):
    """ Return a k-length list of unique random floats
        in the range of low <= x <= high
    """
    result = []
    seen = set()
    for i in range(k):
        x = random.uniform(low, high)
        while x in seen:
            x = random.uniform(low, high)
        seen.add(x)
        result.append(x)
    return result

Примечания

• Этот метод реализуется как собственный метод Python random.sample().

• Функция использует set для отслеживания предыдущих выборов, поскольку поиск набора - это O (1) при поиске списка O (n).

• Вычисление вероятности повторного выбора эквивалентно знаменитой проблеме с днем ​​рождения.

• Учитывая 2 ** 53 различных возможных значения из random(), дубликаты нечасты. В среднем вы можете ожидать дублирования поплавка около 120 000 000 образцов.

Вариант: Ограниченный диапазон поплавка

Если население ограничено только диапазоном равномерно расположенных поплавков, то можно напрямую использовать random.sample(). Единственное требование состоит в том, чтобы население было Sequence:

from __future__ import division
from collections import Sequence

class FRange(Sequence):
    """ Lazily evaluated floating point range of evenly spaced floats
        (inclusive at both ends)

        >>> list(FRange(low=10, high=20, num_points=5))
        [10.0, 12.5, 15.0, 17.5, 20.0]

    """
    def __init__(self, low, high, num_points):
        self.low = low
        self.high = high
        self.num_points = num_points

    def __len__(self):
        return self.num_points

    def __getitem__(self, index):
        if index < 0:
            index += len(self)
        if index < 0 or index >= len(self):
            raise IndexError('Out of range')
        p = index / (self.num_points - 1)
        return self.low * (1.0 - p) + self.high * p

Ниже приведен пример выбора десяти случайных выборок без замены из диапазона из 41 равномерно расположенных поплавков с 10.0 до 20.0.

>>> import random
>>> random.sample(FRange(low=10.0, high=20.0, num_points=41), k=10)
[13.25, 12.0, 15.25, 18.5, 19.75, 12.25, 15.75, 18.75, 13.0, 17.75]

Ответ 2

Вы можете легко использовать свой список целых чисел для создания float:

int_list = random.sample(range(1, 100), 10)
float_list = [x/10 for x in int_list]

Откажитесь от этого вопроса о переполнении Stack   о создании случайных поплавков.

Если вы хотите, чтобы он работал с python2, добавьте этот импорт:

from __future__ import division

Ответ 3

Если вам нужно гарантировать уникальность, это может быть более эффективным для

• Попробуйте создать n случайные поплавки в [lo, hi] сразу.
• Если длина уникальных поплавков не равна n, попробуйте и сгенерируйте, однако по-прежнему нужно много поплавков.

и продолжайте соответственно до тех пор, пока у вас не будет достаточно, в отличие от генерации их 1 на 1 в цикле уровня Python, проверяющих набор.

Если вы можете позволить NumPy делать это с помощью np.random.uniform, это может быть огромным ускорением.

import numpy as np

def gen_uniq_floats(lo, hi, n):
    out = np.empty(n)
    needed = n
    while needed != 0:
        arr = np.random.uniform(lo, hi, needed)
        uniqs = np.setdiff1d(np.unique(arr), out[:n-needed])
        out[n-needed: n-needed+uniqs.size] = uniqs
        needed -= uniqs.size
    np.random.shuffle(out)
    return out.tolist()

Если вы не можете использовать NumPy, он по-прежнему может быть более эффективным, в зависимости от ваших данных, чтобы применить ту же концепцию проверки дубликатов, поддерживая набор.

def no_depend_gen_uniq_floats(lo, hi, n):
    seen = set()
    needed = n
    while needed != 0:
        uniqs = {random.uniform(lo, hi) for _ in range(needed)}
        seen.update(uniqs)
        needed -= len(uniqs)
    return list(seen)

Грубая оценка

Экстремальный вырожденный случай

# Mitch NumPy solution
%timeit gen_uniq_floats(0, 2**-50, 1000)
153 µs ± 3.71 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

# Mitch Python-only solution
%timeit no_depend_gen_uniq_floats(0, 2**-50, 1000)
495 µs ± 43.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

# Raymond Hettinger solution (single number generation)
%timeit sample_floats(0, 2**-50, 1000)
618 µs ± 13 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

Более "нормальный" случай (с большим образцом)

# Mitch NumPy solution
%timeit gen_uniq_floats(0, 1, 10**5)
15.6 ms ± 1.12 ms per loop (mean ± std. dev. of 7 runs, 100 loops each)

# Mitch Python-only solution
%timeit no_depend_gen_uniq_floats(0, 1, 10**5)
65.7 ms ± 2.31 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

# Raymond Hettinger solution (single number generation)
%timeit sample_floats(0, 1, 10**5)
78.8 ms ± 4.22 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

Ответ 4

Вы можете просто использовать random.uniform(start, stop). С плавающей точкой с двойной точностью вы можете быть уверены, что они уникальны, если ваш набор невелик. Если вы хотите сгенерировать большое количество случайных поплавков и вам нужно избегать того, что у вас есть номер дважды, проверьте, прежде чем добавлять их в список.

Однако, если вы ищете выбор конкретных номеров, это не решение.

Ответ 5

min_val=-5
max_val=15

numpy.random.random_sample(15)*(max_val-min_val) + min_val

или используйте единый

numpy.random.uniform(min_val,max_val,size=15)

Ответ 6

Как указано в документации Python имеет функцию random.random():

import random
random.random()

Затем вы получите float val как: 0.672807098390448

Итак, все, что вам нужно сделать, это сделать цикл for и распечатать random.random():

>>> for i in range(10):
print(random.random())

Ответ 7

more_itertools имеет общий numeric_range, который обрабатывает как целые числа, так и float.

import random

import more_itertools as mit

random.sample(list(mit.numeric_range(0, 2, 0.2)), 3)
# [0.8, 1.0, 0.4]

random.sample(list(mit.numeric_range(10.0, 20.0, 0.25)), 10)
# [17.25, 12.0, 19.75, 14.25, 15.25, 12.75, 14.5, 15.75, 13.5, 18.25]