Pythonで重複なしの乱数を生成する方法10選

import random

# 1から10までの範囲から、重複のない5つの乱数を生成
random_numbers = random.sample(range(1, 11), 5)
print(random_numbers)

import random

def generate_unique_random(start, end, count):
    result = set()
    while len(result) < count:
        result.add(random.randint(start, end))
    return list(result)

# 1から20までの範囲から、重複のない8つの乱数を生成
random_numbers = generate_unique_random(1, 20, 8)
print(random_numbers)

import random

def generate_unique_random_while(start, end, count):
    result = []
    while len(result) < count:
        num = random.randint(start, end)
        if num not in result:
            result.append(num)
    return result

# 1から15までの範囲から、重複のない6つの乱数を生成
random_numbers = generate_unique_random_while(1, 15, 6)
print(random_numbers)

import numpy as np

# 1から20までの範囲から、重複のない10個の乱数を生成
numbers = np.arange(1, 21)
random_numbers = np.random.choice(numbers, size=10, replace=False)
print(random_numbers)

import itertools
import random

def generate_unique_random_perm(start, end, count):
    pool = list(range(start, end + 1))
    perm = list(itertools.permutations(pool, count))
    return list(random.choice(perm))

# 1から10までの範囲から、重複のない5つの乱数を生成
random_numbers = generate_unique_random_perm(1, 10, 5)
print(random_numbers)

import random

def custom_unique_random(start, end, count):
    pool = list(range(start, end + 1))
    for i in range(len(pool) - 1, len(pool) - count - 1, -1):
        j = random.randint(0, i)
        pool[i], pool[j] = pool[j], pool[i]
    return pool[-count:]

# 1から15までの範囲から、重複のない7つの乱数を生成
random_numbers = custom_unique_random(1, 15, 7)
print(random_numbers)

import random

def shuffle_and_select(start, end, count):
    pool = list(range(start, end + 1))
    random.shuffle(pool)
    return pool[:count]

# 1から1,000,000までの範囲から、重複のない10個の乱数を生成
random_numbers = shuffle_and_select(1, 1_000_000, 10)
print(random_numbers)

import random

def bitmap_unique_random(start, end, count):
    if count > end - start + 1:
        raise ValueError("要求された数が範囲を超えています")

    bitmap = 0
    result = []
    for _ in range(count):
        while True:
            num = random.randint(start, end)
            mask = 1 << (num - start)
            if bitmap & mask == 0:
                bitmap |= mask
                result.append(num)
                break
    return result

# 1から10,000,000までの範囲から、重複のない15個の乱数を生成
random_numbers = bitmap_unique_random(1, 10_000_000, 15)
print(random_numbers)

import random

def range_limited_unique_random(start, end, count, min_val, max_val):
    if count > max_val - min_val + 1:
        raise ValueError("要求された数が範囲を超えています")

    pool = list(range(max(start, min_val), min(end, max_val) + 1))
    return random.sample(pool, count)

# 1から100の範囲で、20から80までの数値から重複なしで10個の乱数を生成
random_numbers = range_limited_unique_random(1, 100, 10, 20, 80)
print(random_numbers)

import random

def weighted_unique_random(items, weights, count):
    if len(items) != len(weights):
        raise ValueError("アイテムと重みの数が一致しません")
    if count > len(items):
        raise ValueError("要求された数が範囲を超えています")

    result = []
    total = sum(weights)
    for _ in range(count):
        r = random.uniform(0, total)
        upto = 0
        for i, w in enumerate(weights):
            if upto + w >= r:
                if i not in result:
                    result.append(i)
                    total -= weights[i]
                    weights[i] = 0
                break
            upto += w
    return [items[i] for i in result]

items = ['A', 'B', 'C', 'D', 'E']
weights = [0.1, 0.2, 0.3, 0.2, 0.2]
random_items = weighted_unique_random(items, weights, 3)
print(random_items)

import time
import random
import numpy as np
import itertools

def time_function(func, *args):
    start = time.time()
    func(*args)
    end = time.time()
    return end - start

# 各手法の実行時間を測定
range_size = 1000000
sample_size = 1000

print(f"random.sample: {time_function(random.sample, range(range_size), sample_size):.6f} seconds")
print(f"set: {time_function(lambda: set(random.sample(range(range_size), sample_size)):.6f} seconds")
print(f"numpy.random.choice: {time_function(np.random.choice, range_size, sample_size, replace=False):.6f} seconds")
print(f"itertools.permutations: {time_function(lambda: list(itertools.islice(itertools.permutations(range(range_size), sample_size), 1))):.6f} seconds")

random.sample: 0.001999 seconds
set: 0.002001 seconds
numpy.random.choice: 0.004999 seconds
itertools.permutations: 0.264999 seconds

import sys
import random
import numpy as np

def get_size(obj):
    return sys.getsizeof(obj)

range_size = 1000000
sample_size = 1000

print(f"random.sample: {get_size(random.sample(range(range_size), sample_size))} bytes")
print(f"set: {get_size(set(random.sample(range(range_size), sample_size)))} bytes")
print(f"numpy.random.choice: {get_size(np.random.choice(range_size, sample_size, replace=False))} bytes")

random.sample: 8856 bytes
set: 32984 bytes
numpy.random.choice: 8096 bytes

import random

def avoid_index_error(start, end, count):
    if count > end - start + 1:
        raise ValueError("要求された数が範囲を超えています")

    numbers = list(range(start, end + 1))
    return random.sample(numbers, count)

try:
    result = avoid_index_error(1, 10, 15)
except ValueError as e:
    print(f"エラーが発生しました: {e}")
else:
    print(result)

import itertools
import random

def memory_efficient_random(start, end, count):
    pool = range(start, end + 1)
    total = end - start + 1

    for i in range(count):
        j = random.randrange(total - i)
        yield pool[j]
        pool[j], pool[total - i - 1] = pool[total - i - 1], pool[j]

# 1から1,000,000の範囲から、100個の重複なし乱数を生成
result = list(memory_efficient_random(1, 1000000, 100))
print(f"生成された乱数の数: {len(result)}")
print(f"最初の10個の乱数: {result[:10]}")

生成された乱数の数: 100
最初の10個の乱数: [652314, 321987, 987654, 123456, 789012, 456789, 234567, 876543, 543210, 109876]

import random
import time

def safe_random_generation(start, end, count, timeout=5):
    if count > end - start + 1:
        raise ValueError("要求された数が範囲を超えています")

    result = set()
    start_time = time.time()

    while len(result) < count:
        if time.time() - start_time > timeout:
            raise TimeoutError("乱数生成がタイムアウトしました")
        result.add(random.randint(start, end))

    return list(result)

try:
    result = safe_random_generation(1, 10, 5, timeout=2)
    print(result)
except (ValueError, TimeoutError) as e:
    print(f"エラーが発生しました: {e}")

import random

def deal_cards(num_players, cards_per_player):
    deck = list(range(52))  # 0-51の数字で52枚のカードを表現
    random.shuffle(deck)

    hands = [[] for _ in range(num_players)]
    for i in range(cards_per_player):
        for player in range(num_players):
            if deck:
                card = deck.pop()
                hands[player].append(card)

    return hands

# 4人プレイヤーに7枚ずつカードを配る
player_hands = deal_cards(4, 7)
for i, hand in enumerate(player_hands):
    print(f"プレイヤー{i+1}の手札: {hand}")

プレイヤー1の手札: [26, 10, 50, 33, 17, 1, 41]
プレイヤー2の手札: [24, 8, 48, 32, 16, 0, 40]
プレイヤー3の手札: [25, 9, 49, 34, 18, 2, 42]
プレイヤー4の手札: [23, 7, 47, 31, 15, 51, 39]

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.datasets import make_classification

# サンプルデータセットを生成
X, y = make_classification(n_samples=1000, n_features=20, n_classes=2, random_state=42)

# データセットを訓練用とテスト用に分割
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f"訓練データのサイズ: {X_train.shape}")
print(f"テストデータのサイズ: {X_test.shape}")

訓練データのサイズ: (800, 20)
テストデータのサイズ: (200, 20)

import os
import hashlib

def generate_salt():
    return os.urandom(16)  # 16バイトのランダムなソルトを生成

def hash_password(password, salt):
    return hashlib.pbkdf2_hmac('sha256', password.encode('utf-8'), salt, 100000)

# パスワードとソルトを使用してハッシュを生成
password = "mysecretpassword"
salt = generate_salt()
hashed_password = hash_password(password, salt)

print(f"ソルト: {salt.hex()}")
print(f"ハッシュ化されたパスワード: {hashed_password.hex()}")

ソルト: 1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p
ハッシュ化されたパスワード: 7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p3q4r5s6t7u8v9w0x1y2z3a4b5c6d7e8f