Bagaimana cara menghentikan pengulangan dalam python acak?

Klaster Masalah Teknis Dijawab Pertama Kali Pada 2 Desember 2020 Popularitas 9/10 Bermanfaat 3/10

Table of Contents Show

generator nomor acak python tidak ada duplikat
generator nomor acak python tidak ada duplikat
Fungsi pembukuan
Fungsi untuk byte
Fungsi untuk bilangan bulat
Fungsi untuk urutan
Distribusi bernilai riil
Generator Alternatif
Catatan tentang Reproduksibilitas
Bagaimana Anda membuat angka acak tidak berulang dengan Python?
Bagaimana Anda mendapatkan Randint acak untuk tidak mengulang?
Bagaimana Anda menghasilkan angka acak tanpa pengulangan?
Bagaimana cara Python menghasilkan angka acak dengan pengulangan?

generator nomor acak python tidak ada duplikat

Popularitas 9/10 Bermanfaat 3/10 Bahasa python

generator nomor acak python tidak ada duplikat

Popularitas 9/10 Kegunaan 1/10 Bahasa python

Untuk bilangan bulat, ada pemilihan yang seragam dari suatu rentang. Untuk urutan, ada pemilihan elemen acak yang seragam, fungsi untuk menghasilkan permutasi acak dari daftar di tempat, dan fungsi untuk pengambilan sampel acak tanpa penggantian

Pada garis real, terdapat fungsi untuk menghitung distribusi seragam, normal (Gaussian), lognormal, eksponensial negatif, gamma, dan beta. Untuk menghasilkan distribusi sudut, tersedia distribusi von Mises

Hampir semua fungsi modul bergantung pada fungsi dasar, yang menghasilkan pelampung acak secara seragam dalam rentang setengah terbuka

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

1. Python menggunakan Mersenne Twister sebagai generator inti. Ini menghasilkan pelampung presisi 53-bit dan memiliki periode 2**19937-1. Implementasi yang mendasari di C adalah cepat dan threadsafe. Mersenne Twister adalah salah satu generator nomor acak yang paling banyak diuji. Namun, karena sepenuhnya deterministik, ini tidak cocok untuk semua tujuan, dan sama sekali tidak cocok untuk tujuan kriptografi

Fungsi yang disediakan oleh modul ini sebenarnya adalah metode terikat dari instance kelas yang tersembunyi. Anda dapat membuat instance Anda sendiri untuk mendapatkan generator yang tidak berbagi status

Kelas juga dapat dijadikan subkelas jika Anda ingin menggunakan generator dasar yang berbeda dari rancangan Anda sendiri. dalam hal ini, ganti metode

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

_0,

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

7, dan

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

8. Opsional, generator baru dapat menyediakan metode

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

9 — ini memungkinkan untuk menghasilkan pilihan pada rentang besar yang sewenang-wenang

Modul ini juga menyediakan kelas yang menggunakan fungsi sistem untuk menghasilkan angka acak dari sumber yang disediakan oleh sistem operasi

Peringatan

Generator acak semu dari modul ini tidak boleh digunakan untuk tujuan keamanan. Untuk penggunaan keamanan atau kriptografi, lihat modul

Lihat juga

M. Matsumoto dan T. Nishimura, “Mersenne Twister. Generator nomor pseudorandom seragam 623-dimensi yang merata”, Transaksi ACM pada Pemodelan dan Simulasi Komputer Vol. 8, Tidak. 1 Januari hal. 3–30 1998

Resep Komplementer-Kalikan-dengan-Carry untuk generator nomor acak alternatif yang kompatibel dengan jangka waktu lama dan operasi pembaruan yang relatif sederhana

Fungsi pembukuan

acak. benih(a=Tidak ada, version=2)

Inisialisasi generator nomor acak

Jika a dihilangkan atau

>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> dealt = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> dealt.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial():
..     return choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
..     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958

_5, waktu sistem saat ini akan digunakan. Jika sumber keacakan disediakan oleh sistem operasi, sumber tersebut digunakan sebagai pengganti waktu sistem (lihat fungsi untuk perincian tentang ketersediaan)

Jika a adalah int, maka digunakan secara langsung

Dengan versi 2 (default), a , , atau objek dikonversi menjadi an dan semua bitnya digunakan

Dengan versi 1 (disediakan untuk mereproduksi urutan acak dari versi Python yang lebih lama), algoritme untuk dan menghasilkan rentang seed yang lebih sempit

Berubah di versi 3. 2. Pindah ke skema versi 2 yang menggunakan semua bit dalam string seed.

Berubah di versi 3. 11. Benih harus salah satu dari jenis berikut. Tidak adaJenis, , , , , atau.

acak. dapatkan()

Mengembalikan objek yang menangkap keadaan internal generator saat ini. Objek ini dapat diteruskan ke untuk memulihkan keadaan

acak. setstat(status)

keadaan seharusnya diperoleh dari pemanggilan sebelumnya ke , dan memulihkan keadaan internal generator ke keadaan semula pada saat dipanggil

Fungsi untuk byte

acak. randbyte(n)

Hasilkan n byte acak

Metode ini tidak boleh digunakan untuk menghasilkan token keamanan. Gunakan sebagai gantinya

Baru di versi 3. 9

Fungsi untuk bilangan bulat

acak. rangkaian(berhenti)acak. rangkaian(mulai , berhenti[, step])

Kembalikan elemen yang dipilih secara acak dari

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

3. Ini setara dengan

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

_4, tetapi tidak benar-benar membangun objek jangkauan

Pola argumen posisi cocok dengan. Argumen kata kunci tidak boleh digunakan karena fungsi dapat menggunakannya dengan cara yang tidak terduga

Berubah di versi 3. 2. lebih canggih dalam menghasilkan nilai yang terdistribusi secara merata. Sebelumnya menggunakan gaya seperti

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

_7 yang dapat menghasilkan distribusi yang sedikit tidak merata.

Tidak digunakan lagi sejak versi 3. 10. Konversi otomatis tipe non-bilangan bulat ke bilangan bulat setara tidak digunakan lagi. Saat ini

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

_8 dikonversi secara lossless menjadi

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

9. Ke depan, hal ini akan meningkatkan a.

Tidak digunakan lagi sejak versi 3. 10. Pengecualian yang diajukan untuk nilai non-integral seperti

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

1 atau

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

2 akan diubah dari menjadi.

acak. randint(a , b)

Mengembalikan bilangan bulat acak N sehingga

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

5. Alias untuk

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

acak. getrandbits(k)

Mengembalikan integer Python non-negatif dengan k bit acak. Metode ini disertakan dengan generator MersenneTwister dan beberapa generator lain mungkin juga menyediakannya sebagai bagian opsional dari API. Jika tersedia, memungkinkan untuk menangani rentang besar yang sewenang-wenang

Berubah di versi 3. 9. Metode ini sekarang menerima nol untuk k.

Fungsi untuk urutan

acak. pilihan(seq)

Kembalikan elemen acak dari seq urutan yang tidak kosong. Jika seq kosong, naikkan

acak. pilihan(populasi , bobot=None, *, cum_weights=None, k=1)

Kembalikan daftar elemen berukuran k yang dipilih dari populasi dengan penggantian. Jika populasinya kosong, naikkan

Jika urutan bobot ditentukan, pemilihan dibuat sesuai dengan bobot relatif. Alternatifnya, jika urutan cum_weights diberikan, pilihan dibuat sesuai dengan bobot kumulatif (mungkin dihitung menggunakan ). Misalnya, bobot relatif

def random_product(*args, repeat=1):
    "Random selection from itertools.product(*args, **kwds)"
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(map(random.choice, pools))

def random_permutation(iterable, r=None):
    "Random selection from itertools.permutations(iterable, r)"
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(random.sample(pool, r))

def random_combination(iterable, r):
    "Random selection from itertools.combinations(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.sample(range(n), r))
    return tuple(pool[i] for i in indices)

def random_combination_with_replacement(iterable, r):
    "Random selection from itertools.combinations_with_replacement(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.choices(range(n), k=r))
    return tuple(pool[i] for i in indices)

_2 setara dengan bobot kumulatif

def random_product(*args, repeat=1):
    "Random selection from itertools.product(*args, **kwds)"
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(map(random.choice, pools))

def random_permutation(iterable, r=None):
    "Random selection from itertools.permutations(iterable, r)"
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(random.sample(pool, r))

def random_combination(iterable, r):
    "Random selection from itertools.combinations(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.sample(range(n), r))
    return tuple(pool[i] for i in indices)

def random_combination_with_replacement(iterable, r):
    "Random selection from itertools.combinations_with_replacement(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.choices(range(n), k=r))
    return tuple(pool[i] for i in indices)

3. Secara internal, bobot relatif diubah menjadi bobot kumulatif sebelum membuat pilihan, sehingga menyediakan bobot kumulatif menghemat pekerjaan

Jika tidak ada bobot atau cum_weight yang ditentukan, pilihan dibuat dengan probabilitas yang sama. Jika urutan bobot disediakan, itu harus sama panjangnya dengan urutan populasi. Ini adalah untuk menentukan bobot dan cum_weights

Bobot atau cum_weights dapat menggunakan tipe numerik apa pun yang beroperasi dengan nilai yang dikembalikan oleh (termasuk bilangan bulat, float, dan pecahan tetapi tidak termasuk desimal). Bobot diasumsikan non-negatif dan terbatas. A dinaikkan jika semua bobotnya nol

Untuk seed tertentu, fungsi dengan bobot yang sama biasanya menghasilkan urutan yang berbeda dari pemanggilan berulang. Algoritma yang digunakan menggunakan aritmatika floating point untuk konsistensi internal dan kecepatan. Algoritme yang digunakan secara default ke aritmatika bilangan bulat dengan pemilihan berulang untuk menghindari bias kecil dari kesalahan pembulatan

Baru di versi 3. 6

Berubah di versi 3. 9. Menaikkan a jika semua bobotnya nol.

acak. acak(x)

Kocok urutan x pada tempatnya

Untuk mengocok urutan yang tidak dapat diubah dan mengembalikan daftar acak baru, gunakan

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

3 sebagai gantinya

Perhatikan bahwa bahkan untuk

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

_4 kecil, jumlah total permutasi dari x dapat dengan cepat tumbuh lebih besar daripada periode kebanyakan generator bilangan acak. Ini menyiratkan bahwa sebagian besar permutasi dari urutan panjang tidak pernah dapat dihasilkan. Misalnya, urutan panjang 2080 adalah yang terbesar yang dapat ditampung dalam periode generator angka acak Mersenne Twister

Tidak digunakan lagi sejak versi 3. 9, dihapus di versi 3. 11. Parameter opsional acak.

acak. sampel(populasi , k, *, counts=None)

Mengembalikan k daftar panjang elemen unik yang dipilih dari urutan populasi. Digunakan untuk pengambilan sampel acak tanpa penggantian

Mengembalikan daftar baru yang berisi elemen dari populasi sambil membiarkan populasi asli tidak berubah. Daftar yang dihasilkan dalam urutan pemilihan sehingga semua sub-irisan juga akan menjadi sampel acak yang valid. Hal ini memungkinkan pemenang undian (sampel) untuk dipartisi menjadi hadiah utama dan juara kedua (subbagian)

Anggota populasi tidak perlu atau unik. Jika populasi mengandung pengulangan, maka setiap kejadian merupakan pilihan yang mungkin dalam sampel

Elemen berulang dapat ditentukan satu per satu atau dengan parameter jumlah hanya kata kunci opsional. Misalnya,

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

_5 setara dengan

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

Untuk memilih sampel dari rentang bilangan bulat, gunakan objek sebagai argumen. Ini sangat cepat dan hemat ruang untuk pengambilan sampel dari populasi besar.

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

Jika ukuran sampel lebih besar dari ukuran populasi, a dinaikkan

Berubah di versi 3. 9. Menambahkan parameter hitungan.

Berubah di versi 3. 11. Populasi harus berurutan. Konversi otomatis set ke daftar tidak lagi didukung.

Distribusi bernilai riil

Fungsi berikut menghasilkan distribusi bernilai nyata tertentu. Parameter fungsi diberi nama setelah variabel terkait dalam persamaan distribusi, seperti yang digunakan dalam praktik matematika umum;

acak. acak()

Kembalikan angka floating point acak berikutnya dalam rentang

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

acak. seragam(a , b)

Kembalikan angka floating point acak N sehingga

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

5 untuk

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

2 dan

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

3 untuk

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

Nilai titik akhir

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

5 mungkin termasuk atau tidak termasuk dalam rentang tergantung pada pembulatan titik-mengambang dalam persamaan

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

acak. segitiga(rendah , tinggi, mode)

Kembalikan angka floating point acak N sehingga

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

7 dan dengan mode yang ditentukan di antara batas tersebut. Batas rendah dan tinggi default ke nol dan satu. Argumen mode default ke titik tengah antara batas, memberikan distribusi simetris

acak. variasi beta(alpha , beta)

Distribusi beta. Ketentuan pada parameter adalah

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

_8 dan

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

9. Nilai yang dikembalikan berkisar antara 0 dan 1

acak. eksplorasi(lambd)

Distribusi eksponensial. lambda adalah 1. 0 dibagi dengan rata-rata yang diinginkan. Seharusnya bukan nol. (Parameter akan disebut "lambda", tapi itu adalah kata yang dicadangkan di Python. ) Nilai yang dikembalikan berkisar dari 0 hingga tak terhingga positif jika lambda positif, dan dari tak terhingga negatif hingga 0 jika lambda negatif

acak. variasi gama(alfa , beta)

Distribusi gama. (Bukan fungsi gamma. ) Kondisi pada parameter adalah

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

8 dan

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

Fungsi distribusi probabilitas adalah

          x ** (alpha - 1) * math.exp(-x / beta)
pdf(x) =  --------------------------------------
            math.gamma(alpha) * beta ** alpha

acak. gauss(mu=0. 0 , sigma=1. 0)

Distribusi normal, juga disebut distribusi Gaussian. mu adalah rata-rata, dan sigma adalah standar deviasi. Ini sedikit lebih cepat daripada fungsi yang didefinisikan di bawah ini

Catatan multithreading. Ketika dua utas memanggil fungsi ini secara bersamaan, ada kemungkinan mereka akan menerima nilai pengembalian yang sama. Ini dapat dihindari dengan tiga cara. 1) Mintalah setiap utas menggunakan contoh generator nomor acak yang berbeda. 2) Letakkan kunci di sekitar semua panggilan. 3) Gunakan fungsi yang lebih lambat, tetapi aman untuk thread

Berubah di versi 3. 11. mu dan sigma sekarang memiliki argumen default.

acak. variasi lognorm(mu , sigma)

Log distribusi normal. Jika Anda mengambil logaritma natural dari distribusi ini, Anda akan mendapatkan distribusi normal dengan rata-rata mu dan sigma standar deviasi. mu dapat memiliki nilai apapun, dan sigma harus lebih besar dari nol

acak. variasi normal(mu=0. 0 , sigma=1. 0)

Distribusi normal. mu adalah rata-rata, dan sigma adalah standar deviasi

Berubah di versi 3. 11. mu dan sigma sekarang memiliki argumen default.

acak. vonmisesvariate(mu , kappa)

mu adalah sudut rata-rata, dinyatakan dalam radian antara 0 dan 2*pi, dan kappa adalah parameter konsentrasi, yang harus lebih besar atau sama dengan nol. Jika kappa sama dengan nol, distribusi ini direduksi menjadi sudut acak seragam pada rentang 0 hingga 2*pi

acak. variasi pareto(alpha)

Distribusi Pareto. alpha adalah parameter bentuk

acak. variasi weibull(alpha , beta)

Distribusi Weibull. alpha adalah parameter skala dan beta adalah parameter bentuk

Generator Alternatif

kelas acak. Acak([benih])

Kelas yang mengimplementasikan generator bilangan acak semu default yang digunakan oleh modul

Tidak digunakan lagi sejak versi 3. 9. Di masa mendatang, benih harus salah satu dari jenis berikut. random5, , , , , atau.

kelas acak. SystemRandom([seed])

Kelas yang menggunakan fungsi untuk menghasilkan bilangan acak dari sumber yang disediakan oleh sistem operasi. Tidak tersedia di semua sistem. Tidak bergantung pada status perangkat lunak, dan urutan tidak dapat direproduksi. Dengan demikian, metode tersebut tidak berpengaruh dan diabaikan. Metode dan menaikkan jika dipanggil

Catatan tentang Reproduksibilitas

Terkadang berguna untuk dapat mereproduksi urutan yang diberikan oleh generator bilangan acak semu. Dengan menggunakan kembali nilai benih, urutan yang sama harus dapat direproduksi dari proses ke proses selama beberapa utas tidak berjalan

Sebagian besar algoritme modul acak dan fungsi penyemaian dapat berubah di seluruh versi Python, tetapi dua aspek dijamin tidak akan berubah

Jika metode penyemaian baru ditambahkan, maka penyemai yang kompatibel ke belakang akan ditawarkan

Metode

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

0 generator akan terus menghasilkan urutan yang sama ketika seeder yang kompatibel diberi seed yang sama

Contoh

Contoh dasar

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

Simulasi

>>> # Six roulette wheel spins (weighted sampling with replacement)
>>> choices(['red', 'black', 'green'], [18, 18, 2], k=6)
['red', 'green', 'black', 'black', 'red', 'black']

>>> # Deal 20 cards without replacement from a deck
>>> # of 52 playing cards, and determine the proportion of cards
>>> # with a ten-value:  ten, jack, queen, or king.
>>> dealt = sample(['tens', 'low cards'], counts=[16, 36], k=20)
>>> dealt.count('tens') / 20
0.15

>>> # Estimate the probability of getting 5 or more heads from 7 spins
>>> # of a biased coin that settles on heads 60% of the time.
>>> def trial():
..     return choices('HT', cum_weights=(0.60, 1.00), k=7).count('H') >= 5
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.4169

>>> # Probability of the median of 5 samples being in middle two quartiles
>>> def trial():
..     return 2_500 <= sorted(choices(range(10_000), k=5))[2] < 7_500
...
>>> sum(trial() for i in range(10_000)) / 10_000
0.7958

Contoh bootstrapping statistik menggunakan resampling dengan penggantian untuk memperkirakan interval kepercayaan rata-rata sampel

# https://www.thoughtco.com/example-of-bootstrapping-3126155
from statistics import fmean as mean
from random import choices

data = [41, 50, 29, 37, 81, 30, 73, 63, 20, 35, 68, 22, 60, 31, 95]
means = sorted(mean(choices(data, k=len(data))) for i in range(100))
print(f'The sample mean of {mean(data):.1f} has a 90% confidence '
      f'interval from {means[5]:.1f} to {means[94]:.1f}')

Contoh a untuk menentukan signifikansi statistik atau nilai p dari perbedaan yang diamati antara efek obat versus plasebo

# Example from "Statistics is Easy" by Dennis Shasha and Manda Wilson
from statistics import fmean as mean
from random import shuffle

drug = [54, 73, 53, 70, 73, 68, 52, 65, 65]
placebo = [54, 51, 58, 44, 55, 52, 42, 47, 58, 46]
observed_diff = mean(drug) - mean(placebo)

n = 10_000
count = 0
combined = drug + placebo
for i in range(n):
    shuffle(combined)
    new_diff = mean(combined[:len(drug)]) - mean(combined[len(drug):])
    count += (new_diff >= observed_diff)

print(f'{n} label reshufflings produced only {count} instances with a difference')
print(f'at least as extreme as the observed difference of {observed_diff:.1f}.')
print(f'The one-sided p-value of {count / n:.4f} leads us to reject the null')
print(f'hypothesis that there is no difference between the drug and the placebo.')

Simulasi waktu kedatangan dan pengiriman layanan untuk antrian multiserver

from heapq import heapify, heapreplace
from random import expovariate, gauss
from statistics import mean, quantiles

average_arrival_interval = 5.6
average_service_time = 15.0
stdev_service_time = 3.5
num_servers = 3

waits = []
arrival_time = 0.0
servers = [0.0] * num_servers  # time when each server becomes available
heapify(servers)
for i in range(1_000_000):
    arrival_time += expovariate(1.0 / average_arrival_interval)
    next_server_available = servers[0]
    wait = max(0.0, next_server_available - arrival_time)
    waits.append(wait)
    service_duration = max(0.0, gauss(average_service_time, stdev_service_time))
    service_completed = arrival_time + wait + service_duration
    heapreplace(servers, service_completed)

print(f'Mean wait: {mean(waits):.1f}   Max wait: {max(waits):.1f}')
print('Quartiles:', [round(q, 1) for q in quantiles(waits)])

Lihat juga

Statistik untuk Peretas video tutorial oleh Jake Vanderplas tentang analisis statistik hanya menggunakan beberapa konsep dasar termasuk simulasi, pengambilan sampel, pengocokan, dan validasi silang

Simulasi Ekonomi simulasi pasar oleh Peter Norvig yang menunjukkan penggunaan yang efektif dari banyak alat dan distribusi yang disediakan oleh modul ini (gauss, uniform, sample, betavariate, choice, triangular, dan randrange)

Pengantar Probabilitas Konkrit (menggunakan Python) tutorial oleh Peter Norvig yang mencakup dasar-dasar teori probabilitas, cara menulis simulasi, dan cara melakukan analisis data menggunakan Python

Resep

Resep ini menunjukkan cara membuat pilihan acak secara efisien dari iterator kombinatorik dalam modul

def random_product(*args, repeat=1):
    "Random selection from itertools.product(*args, **kwds)"
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(map(random.choice, pools))

def random_permutation(iterable, r=None):
    "Random selection from itertools.permutations(iterable, r)"
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(random.sample(pool, r))

def random_combination(iterable, r):
    "Random selection from itertools.combinations(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.sample(range(n), r))
    return tuple(pool[i] for i in indices)

def random_combination_with_replacement(iterable, r):
    "Random selection from itertools.combinations_with_replacement(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.choices(range(n), k=r))
    return tuple(pool[i] for i in indices)

Default mengembalikan kelipatan 2⁻⁵³ dalam rentang 0. 0 ≤ x < 1. 0. Semua angka seperti itu diberi jarak yang sama dan persis dapat direpresentasikan sebagai float Python. Namun, banyak pelampung lain yang dapat diwakili dalam interval tersebut bukanlah pilihan yang memungkinkan. Misalnya,

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

_09 bukan kelipatan bilangan bulat dari 2⁻⁵³

Resep berikut mengambil pendekatan yang berbeda. Semua pelampung dalam interval adalah pilihan yang memungkinkan. Mantissa berasal dari distribusi bilangan bulat yang seragam dalam rentang 2⁵² ≤ mantissa < 2⁵³. Eksponen berasal dari distribusi geometris di mana eksponen yang lebih kecil dari -53 terjadi setengah kali lebih sering dari eksponen berikutnya yang lebih besar

from random import Random
from math import ldexp

class FullRandom(Random):

    def random(self):
        mantissa = 0x10_0000_0000_0000 | self.getrandbits(52)
        exponent = -53
        x = 0
        while not x:
            x = self.getrandbits(32)
            exponent += x.bit_length() - 32
        return ldexp(mantissa, exponent)

Semua di kelas akan menggunakan metode baru

>>> fr = FullRandom()
>>> fr.random()
0.05954861408025609
>>> fr.expovariate(0.25)
8.87925541791544

Resepnya secara konseptual setara dengan algoritme yang memilih dari semua kelipatan 2⁻¹⁰⁷⁴ dalam rentang 0. 0 ≤ x < 1. 0. Semua angka tersebut memiliki jarak yang sama, tetapi sebagian besar harus dibulatkan ke bawah ke pelampung Python terdekat yang dapat diwakili. (Nilai 2⁻¹⁰⁷⁴ adalah float positif terkecil yang tidak dinormalisasi dan sama dengan

>>> random()                             # Random float:  0.0 <= x < 1.0
0.37444887175646646

>>> uniform(2.5, 10.0)                   # Random float:  2.5 <= x <= 10.0
3.1800146073117523

>>> expovariate(1 / 5)                   # Interval between arrivals averaging 5 seconds
5.148957571865031

>>> randrange(10)                        # Integer from 0 to 9 inclusive
7

>>> randrange(0, 101, 2)                 # Even integer from 0 to 100 inclusive
26

>>> choice(['win', 'lose', 'draw'])      # Single random element from a sequence
'draw'

>>> deck = 'ace two three four'.split()
>>> shuffle(deck)                        # Shuffle a list
>>> deck
['four', 'two', 'ace', 'three']

>>> sample([10, 20, 30, 40, 50], k=4)    # Four samples without replacement
[40, 10, 50, 30]

10. )

Lihat juga

Menghasilkan Pseudo-random Floating-Point Values makalah oleh Allen B. Downey menjelaskan cara untuk menghasilkan lebih banyak pelampung berbutir halus daripada yang biasanya dihasilkan oleh

Bagaimana Anda membuat angka acak tidak berulang dengan Python?

Gunakan kata kunci impor, untuk mengimpor modul acak. Buat variabel untuk menyimpan daftar input. Gunakan fungsi set() (mengembalikan semua item berbeda dari iterable dan mengonversi iterable menjadi set), untuk menghapus elemen berulang dari daftar input

Bagaimana Anda mendapatkan Randint acak untuk tidak mengulang?

dan gunakan dek. pop() untuk mendapatkan " randint tanpa pengulangan" berikutnya. Ini cukup banyak bagaimana Anda mendapatkan kartu acak tanpa pengulangan dari setumpuk (yang memang namanya acak.