Ho provato a usare random.randint(0, 100), ma alcuni numeri erano gli stessi. Esiste un metodo / modulo per creare un elenco di numeri casuali univoci?

Nota: il codice seguente si basa su una risposta ed è stato aggiunto dopo che la risposta è stata pubblicata. Non fa parte della domanda; è la soluzione.

def getScores():
    # open files to read and write
    f1 = open("page.txt", "r");
    p1 = open("pgRes.txt", "a");

    gScores = [];
    bScores = [];
    yScores = [];

    # run 50 tests of 40 random queries to implement "bootstrapping" method 
    for i in range(50):
        # get 40 random queries from the 50
        lines = random.sample(f1.readlines(), 40);

Ciò restituirà un elenco di 10 numeri selezionati nell'intervallo da 0 a 99, senza duplicati.

import random
random.sample(range(100), 10)

Con riferimento al tuo esempio di codice specifico, probabilmente vorrai leggere tutte le righe dal file una volta e quindi selezionare righe casuali dall'elenco salvato in memoria. Per esempio:

all_lines = f1.readlines()
for i in range(50):
    lines = random.sample(all_lines, 40)

In questo modo, è sufficiente leggere effettivamente dal file una volta, prima del ciclo. È molto più efficiente farlo che cercare di nuovo all'inizio del file e chiamare di f1.readlines()nuovo per ogni iterazione del ciclo.

Puoi usare la funzione shuffle dal modulo random in questo modo:

import random

my_list = list(xrange(1,100)) # list of integers from 1 to 99
                              # adjust this boundaries to fit your needs
random.shuffle(my_list)
print my_list # <- List of unique random numbers

Nota qui che il metodo shuffle non restituisce alcuna lista come ci si potrebbe aspettare, rimescola solo la lista passata per riferimento.

Puoi prima creare un elenco di numeri da aa b, dove ae bsono rispettivamente i numeri più piccoli e più grandi nella tua lista, quindi mescolarlo con l' algoritmo di Fisher-Yates o usando il random.shufflemetodo di Python .

La soluzione presentata in questa risposta funziona, ma potrebbe diventare problematica con la memoria se la dimensione del campione è piccola, ma la popolazione è enorme (ad esempio random.sample(insanelyLargeNumber, 10)).

Per risolvere questo problema, vorrei andare con questo:

answer = set()
sampleSize = 10
answerSize = 0

while answerSize < sampleSize:
    r = random.randint(0,100)
    if r not in answer:
        answerSize += 1
        answer.add(r)

# answer now contains 10 unique, random integers from 0.. 100

Generatore di numeri pseudocasuali congruenti lineari

O (1) Memoria

O (k) Operazioni

Questo problema può essere risolto con un semplice generatore congruenziale lineare . Ciò richiede un sovraccarico di memoria costante (8 numeri interi) e al massimo 2 * (lunghezza della sequenza) calcoli.

Tutte le altre soluzioni utilizzano più memoria e più elaborazione! Se hai bisogno solo di poche sequenze casuali, questo metodo sarà significativamente più economico. Per intervalli di dimensioni N, se si desidera generare in ordine di sequenze Nunivoche ko più, consiglio la soluzione accettata utilizzando i metodi incorporati random.sample(range(N),k)poiché è stata ottimizzata in Python per la velocità.

Codice

# Return a randomized "range" using a Linear Congruential Generator
# to produce the number sequence. Parameters are the same as for 
# python builtin "range".
#   Memory  -- storage for 8 integers, regardless of parameters.
#   Compute -- at most 2*"maximum" steps required to generate sequence.
#
def random_range(start, stop=None, step=None):
    import random, math
    # Set a default values the same way "range" does.
    if (stop == None): start, stop = 0, start
    if (step == None): step = 1
    # Use a mapping to convert a standard range into the desired range.
    mapping = lambda i: (i*step) + start
    # Compute the number of numbers in this range.
    maximum = (stop - start) // step
    # Seed range with a random integer.
    value = random.randint(0,maximum)
    # 
    # Construct an offset, multiplier, and modulus for a linear
    # congruential generator. These generators are cyclic and
    # non-repeating when they maintain the properties:
    # 
    #   1) "modulus" and "offset" are relatively prime.
    #   2) ["multiplier" - 1] is divisible by all prime factors of "modulus".
    #   3) ["multiplier" - 1] is divisible by 4 if "modulus" is divisible by 4.
    # 
    offset = random.randint(0,maximum) * 2 + 1      # Pick a random odd-valued offset.
    multiplier = 4*(maximum//4) + 1                 # Pick a multiplier 1 greater than a multiple of 4.
    modulus = int(2**math.ceil(math.log2(maximum))) # Pick a modulus just big enough to generate all numbers (power of 2).
    # Track how many random numbers have been returned.
    found = 0
    while found < maximum:
        # If this is a valid value, yield it in generator fashion.
        if value < maximum:
            found += 1
            yield mapping(value)
        # Calculate the next value in the sequence.
        value = (value*multiplier + offset) % modulus

uso

L'utilizzo di questa funzione "random_range" è lo stesso di qualsiasi generatore (come "range"). Un esempio:

# Show off random range.
print()
for v in range(3,6):
    v = 2**v
    l = list(random_range(v))
    print("Need",v,"found",len(set(l)),"(min,max)",(min(l),max(l)))
    print("",l)
    print()

Risultati del campione

Required 8 cycles to generate a sequence of 8 values.
Need 8 found 8 (min,max) (0, 7)
 [1, 0, 7, 6, 5, 4, 3, 2]

Required 16 cycles to generate a sequence of 9 values.
Need 9 found 9 (min,max) (0, 8)
 [3, 5, 8, 7, 2, 6, 0, 1, 4]

Required 16 cycles to generate a sequence of 16 values.
Need 16 found 16 (min,max) (0, 15)
 [5, 14, 11, 8, 3, 2, 13, 1, 0, 6, 9, 4, 7, 12, 10, 15]

Required 32 cycles to generate a sequence of 17 values.
Need 17 found 17 (min,max) (0, 16)
 [12, 6, 16, 15, 10, 3, 14, 5, 11, 13, 0, 1, 4, 8, 7, 2, ...]

Required 32 cycles to generate a sequence of 32 values.
Need 32 found 32 (min,max) (0, 31)
 [19, 15, 1, 6, 10, 7, 0, 28, 23, 24, 31, 17, 22, 20, 9, ...]

Required 64 cycles to generate a sequence of 33 values.
Need 33 found 33 (min,max) (0, 32)
 [11, 13, 0, 8, 2, 9, 27, 6, 29, 16, 15, 10, 3, 14, 5, 24, ...]

Se l'elenco di N numeri da 1 a N viene generato in modo casuale, allora sì, c'è la possibilità che alcuni numeri possano essere ripetuti.

Se vuoi un elenco di numeri da 1 a N in ordine casuale, riempi un array con numeri interi da 1 a N, quindi usa un shuffle di Fisher-Yates o di Python random.shuffle().

Se è necessario campionare numeri estremamente grandi, non è possibile utilizzare range

random.sample(range(10000000000000000000000000000000), 10)

perché lancia:

OverflowError: Python int too large to convert to C ssize_t

Inoltre, se random.samplenon è possibile produrre il numero di elementi desiderati a causa dell'intervallo troppo piccolo

 random.sample(range(2), 1000)

lancia:

 ValueError: Sample larger than population

Questa funzione risolve entrambi i problemi:

import random

def random_sample(count, start, stop, step=1):
    def gen_random():
        while True:
            yield random.randrange(start, stop, step)

    def gen_n_unique(source, n):
        seen = set()
        seenadd = seen.add
        for i in (i for i in source() if i not in seen and not seenadd(i)):
            yield i
            if len(seen) == n:
                break

    return [i for i in gen_n_unique(gen_random,
                                    min(count, int(abs(stop - start) / abs(step))))]

Utilizzo con numeri estremamente grandi:

print('\n'.join(map(str, random_sample(10, 2, 10000000000000000000000000000000))))

Risultato del campione:

7822019936001013053229712669368
6289033704329783896566642145909
2473484300603494430244265004275
5842266362922067540967510912174
6775107889200427514968714189847
9674137095837778645652621150351
9969632214348349234653730196586
1397846105816635294077965449171
3911263633583030536971422042360
9864578596169364050929858013943

Utilizzo in cui l'intervallo è inferiore al numero di articoli richiesti:

print(', '.join(map(str, random_sample(100000, 0, 3))))

Risultato del campione:

2, 0, 1

Funziona anche con intervalli e passaggi negativi:

print(', '.join(map(str, random_sample(10, 10, -10, -2))))
print(', '.join(map(str, random_sample(10, 5, -5, -2))))

Risultati del campione:

2, -8, 6, -2, -4, 0, 4, 10, -6, 8
-3, 1, 5, -1, 3

Puoi usare la libreria Numpy per una risposta rapida come mostrato di seguito -

Dato frammento di codice elenca 6 numeri univoci compresi tra 0 e 5. È possibile regolare i parametri per comodità.

import numpy as np
import random
a = np.linspace( 0, 5, 6 )
random.shuffle(a)
print(a)

Produzione

[ 2.  1.  5.  3.  4.  0.]

Non pone alcun vincolo come vediamo in random.sample come indicato qui .

Spero che questo aiuti un po '.

La risposta fornita qui funziona molto bene rispetto al tempo e alla memoria, ma un po 'più complicata in quanto utilizza costrutti python avanzati come yield. La risposta più semplice funziona bene nella pratica, ma il problema con quella risposta è che può generare molti numeri interi spuri prima di costruire effettivamente l'insieme richiesto. Provalo con PopulationSize = 1000, sampleSize = 999. In teoria, c'è la possibilità che non termini.

La risposta di seguito affronta entrambi i problemi, poiché è deterministica e in qualche modo efficiente sebbene attualmente non sia efficiente come le altre due.

def randomSample(populationSize, sampleSize):
  populationStr = str(populationSize)
  dTree, samples = {}, []
  for i in range(sampleSize):
    val, dTree = getElem(populationStr, dTree, '')
    samples.append(int(val))
  return samples, dTree

dove le funzioni getElem, percolateUp sono come definite di seguito

import random

def getElem(populationStr, dTree, key):
  msd  = int(populationStr[0])
  if not key in dTree.keys():
    dTree[key] = range(msd + 1)
  idx = random.randint(0, len(dTree[key]) - 1)
  key = key +  str(dTree[key][idx])
  if len(populationStr) == 1:
    dTree[key[:-1]].pop(idx)
    return key, (percolateUp(dTree, key[:-1]))
  newPopulation = populationStr[1:]
  if int(key[-1]) != msd:
    newPopulation = str(10**(len(newPopulation)) - 1)
  return getElem(newPopulation, dTree, key)

def percolateUp(dTree, key):
  while (dTree[key] == []):
    dTree[key[:-1]].remove( int(key[-1]) )
    key = key[:-1]
  return dTree

Infine, il tempo in media era di circa 15 ms per un valore elevato di n come mostrato di seguito,

In [3]: n = 10000000000000000000000000000000

In [4]: %time l,t = randomSample(n, 5)
Wall time: 15 ms

In [5]: l
Out[5]:
[10000000000000000000000000000000L,
 5731058186417515132221063394952L,
 85813091721736310254927217189L,
 6349042316505875821781301073204L,
 2356846126709988590164624736328L]

Per ottenere un programma che generi un elenco di valori casuali senza duplicati che sia deterministico, efficiente e costruito con costrutti di programmazione di base si consideri la funzione extractSamplesdefinita di seguito,

def extractSamples(populationSize, sampleSize, intervalLst) :
    import random
    if (sampleSize > populationSize) :
        raise ValueError("sampleSize = "+str(sampleSize) +" > populationSize (= " + str(populationSize) + ")")
    samples = []
    while (len(samples) < sampleSize) :
        i = random.randint(0, (len(intervalLst)-1))
        (a,b) = intervalLst[i]
        sample = random.randint(a,b)
        if (a==b) :
            intervalLst.pop(i)
        elif (a == sample) : # shorten beginning of interval                                                                                                                                           
            intervalLst[i] = (sample+1, b)
        elif ( sample == b) : # shorten interval end                                                                                                                                                   
            intervalLst[i] = (a, sample - 1)
        else :
            intervalLst[i] = (a, sample - 1)
            intervalLst.append((sample+1, b))
        samples.append(sample)
    return samples

L'idea di base è tenere traccia degli intervalli intervalLstper i possibili valori da cui selezionare gli elementi richiesti. Questo è deterministico nel senso che ci viene garantito di generare un campione entro un numero fisso di passaggi (dipendenti esclusivamente da populationSizee sampleSize).

Per utilizzare la funzione di cui sopra per generare il nostro elenco richiesto,

In [3]: populationSize, sampleSize = 10**17, 10**5

In [4]: %time lst1 = extractSamples(populationSize, sampleSize, [(0, populationSize-1)])
CPU times: user 289 ms, sys: 9.96 ms, total: 299 ms
Wall time: 293 ms

Possiamo anche confrontare con una soluzione precedente (per un valore inferiore di PopolazioneSize)

In [5]: populationSize, sampleSize = 10**8, 10**5

In [6]: %time lst = random.sample(range(populationSize), sampleSize)
CPU times: user 1.89 s, sys: 299 ms, total: 2.19 s
Wall time: 2.18 s

In [7]: %time lst1 = extractSamples(populationSize, sampleSize, [(0, populationSize-1)])
CPU times: user 449 ms, sys: 8.92 ms, total: 458 ms
Wall time: 442 ms

Nota che ho ridotto il populationSizevalore in quanto produce un errore di memoria per valori più alti quando si utilizza la random.samplesoluzione (menzionato anche nelle risposte precedenti qui e qui ). Per i valori di cui sopra, possiamo anche osservare che extractSamplessupera l' random.sampleapproccio.

PS: Sebbene l'approccio di base sia simile alla mia risposta precedente , ci sono modifiche sostanziali nell'implementazione e nell'approccio insieme al miglioramento della chiarezza.

Una funzione molto semplice che risolve anche il tuo problema

from random import randint

data = []

def unique_rand(inicial, limit, total):

        data = []

        i = 0

        while i < total:
            number = randint(inicial, limit)
            if number not in data:
                data.append(number)
                i += 1

        return data


data = unique_rand(1, 60, 6)

print(data)


"""

prints something like 

[34, 45, 2, 36, 25, 32]

"""

Il problema con gli approcci basati sugli insiemi ("se il valore casuale nei valori restituiti, riprova") è che il loro tempo di esecuzione non è determinato a causa delle collisioni (che richiedono un'altra iterazione "riprova"), specialmente quando viene restituita una grande quantità di valori casuali dalla gamma.

Un'alternativa che non è soggetta a questo runtime non deterministico è la seguente:

import bisect
import random

def fast_sample(low, high, num):
    """ Samples :param num: integer numbers in range of
        [:param low:, :param high:) without replacement
        by maintaining a list of ranges of values that
        are permitted.

        This list of ranges is used to map a random number
        of a contiguous a range (`r_n`) to a permissible
        number `r` (from `ranges`).
    """
    ranges = [high]
    high_ = high - 1
    while len(ranges) - 1 < num:
        # generate a random number from an ever decreasing
        # contiguous range (which we'll map to the true
        # random number).
        # consider an example with low=0, high=10,
        # part way through this loop with:
        #
        # ranges = [0, 2, 3, 7, 9, 10]
        #
        # r_n :-> r
        #   0 :-> 1
        #   1 :-> 4
        #   2 :-> 5
        #   3 :-> 6
        #   4 :-> 8
        r_n = random.randint(low, high_)
        range_index = bisect.bisect_left(ranges, r_n)
        r = r_n + range_index
        for i in xrange(range_index, len(ranges)):
            if ranges[i] <= r:
                # as many "gaps" we iterate over, as much
                # is the true random value (`r`) shifted.
                r = r_n + i + 1
            elif ranges[i] > r_n:
                break
        # mark `r` as another "gap" of the original
        # [low, high) range.
        ranges.insert(i, r)
        # Fewer values possible.
        high_ -= 1
    # `ranges` happens to contain the result.
    return ranges[:-1]

import random

sourcelist=[]
resultlist=[]

for x in range(100):
    sourcelist.append(x)

for y in sourcelist:
    resultlist.insert(random.randint(0,len(resultlist)),y)

print (resultlist)

Se desideri assicurarti che i numeri aggiunti siano univoci, puoi utilizzare un oggetto Set

se si utilizza 2.7 o versioni successive, oppure importare il modulo set in caso contrario.

Come altri hanno già detto, questo significa che i numeri non sono veramente casuali.

per campionare interi senza sostituzione tra minvale maxval:

import numpy as np

minval, maxval, n_samples = -50, 50, 10
generator = np.random.default_rng(seed=0)
samples = generator.permutation(np.arange(minval, maxval))[:n_samples]

# or, if minval is 0,
samples = generator.permutation(maxval)[:n_samples]

con jax:

import jax

minval, maxval, n_samples = -50, 50, 10
key = jax.random.PRNGKey(seed=0)
samples = jax.random.shuffle(key, jax.numpy.arange(minval, maxval))[:n_samples]

Dalla CLI in win xp:

python -c "import random; print(sorted(set([random.randint(6,49) for i in range(7)]))[:6])"

In Canada abbiamo il Lotto 6/49. Metto semplicemente il codice sopra in lotto.bat e corro C:\home\lotto.bato semplicemente C:\home\lotto.

Poiché random.randintspesso ripete un numero, lo uso setcon range(7)e poi lo accorcio a una lunghezza di 6.

Occasionalmente, se un numero si ripete più di 2 volte, la lunghezza dell'elenco risultante sarà inferiore a 6.

EDIT: Tuttavia, random.sample(range(6,49),6)è il modo corretto di procedere.

import random
result=[]
for i in range(1,50):
    rng=random.randint(1,20)
    result.append(rng)