Pythonで使う重複なしの乱数生成方法と活用10選

import random

# 1から10までの整数から、3つの重複しない乱数を生成
result = random.sample(range(1, 11), 3)
print(result)

import numpy as np

# 0から99までの整数から、10個の重複しない乱数を生成
result = np.random.choice(100, 10, replace=False)
print(result)

import random

# 1から20までの整数のリストを作成
numbers = list(range(1, 21))

# リストをシャッフル
random.shuffle(numbers)

# シャッフルしたリストから最初の5要素を取得
result = numbers[:5]
print(result)

import random

# 1000から9999までの整数から、100個の重複しない乱数を生成
result = random.sample(range(1000, 10000), 100)
print(result[:10])  # 最初の10個だけ表示

import numpy as np

# 0.0から1.0の範囲で、5個の重複しない浮動小数点数を生成
result = np.random.uniform(0, 1, 5)
print(result)

import random
import numpy as np

# シードを設定
seed_value = 42
random.seed(seed_value)
np.random.seed(seed_value)

# 乱数生成
result1 = random.sample(range(1, 100), 5)
result2 = np.random.choice(100, 5, replace=False)

print("Random結果:", result1)
print("NumPy結果:", result2)

Random結果: [37, 13, 95, 4, 68]
NumPy結果: [51 92 14 71 60]

import random

def efficient_sampling(population_size, sample_size):
    seen = set()
    for _ in range(sample_size):
        while True:
            random_num = random.randrange(population_size)
            if random_num not in seen:
                seen.add(random_num)
                yield random_num
                break

# 10億の範囲から100万個の重複なし乱数を生成
population_size = 1_000_000_000
sample_size = 1_000_000

sampled_numbers = list(efficient_sampling(population_size, sample_size))
print(f"生成された乱数の数: {len(sampled_numbers)}")
print(f"最初の10個の乱数: {sampled_numbers[:10]}")

生成された乱数の数: 1000000
最初の10個の乱数: [305308945, 823758598, 798563513, 84353286, 164228718, 656821772, 326491876, 489816769, 708986395, 320783500]

import random

def safe_sample(population, sample_size):
    try:
        return random.sample(population, sample_size)
    except ValueError as e:
        print(f"エラーが発生しました: {e}")
        return None

# 正常なケース
result1 = safe_sample(range(1, 11), 5)
print("正常なケース:", result1)

# エラーケース：サンプルサイズが母集団より大きい
result2 = safe_sample(range(1, 6), 10)
print("エラーケース:", result2)

正常なケース: [7, 2, 9, 3, 5]
エラーが発生しました: Sample larger than population or is negative
エラーケース: None

import random

items = ["剣", "盾", "弓", "魔法の杖", "回復薬", "毒消し", "爆弾", "鍵", "地図", "お守り"]

def generate_random_items(num_items):
    if num_items > len(items):
        raise ValueError("要求されたアイテム数が多すぎます")
    return random.sample(items, num_items)

# プレイヤーに3つのランダムアイテムを付与
player_items = generate_random_items(3)
print("プレイヤーが獲得したアイテム:", player_items)

import random
import math

def estimate_pi(num_points):
    inside_circle = 0
    total_points = num_points

    for _ in range(total_points):
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        if math.sqrt(x**2 + y**2) <= 1:
            inside_circle += 1

    pi_estimate = 4 * inside_circle / total_points
    return pi_estimate

# シミュレーション実行
num_simulations = 1000000
estimated_pi = estimate_pi(num_simulations)

print(f"推定されたπの値: {estimated_pi}")
print(f"実際のπとの差: {abs(math.pi - estimated_pi)}")

推定されたπの値: 3.141148
実際のπとの差: 0.0004062858163088319

import numpy as np

# サンプルデータセット
data = np.array([i for i in range(100)])

def split_data(data, train_ratio=0.8):
    data_size = len(data)
    train_size = int(data_size * train_ratio)

    # インデックスをシャッフル
    indices = np.random.permutation(data_size)

    train_indices = indices[:train_size]
    test_indices = indices[train_size:]

    train_data = data[train_indices]
    test_data = data[test_indices]

    return train_data, test_data

# データ分割の実行
train_set, test_set = split_data(data)

print(f"トレーニングセットのサイズ: {len(train_set)}")
print(f"テストセットのサイズ: {len(test_set)}")
print(f"トレーニングセットの最初の10要素: {train_set[:10]}")
print(f"テストセットの最初の10要素: {test_set[:10]}")

トレーニングセットのサイズ: 80
テストセットのサイズ: 20
トレーニングセットの最初の10要素: [42 90 60 17 95 25 22 80 72 62]
テストセットの最初の10要素: [70 39 19 85 40 27 35 75 43 11]

import numpy as np

def bootstrap_mean(data, num_bootstrap_samples=10000, confidence_level=0.95):
    bootstrap_means = []
    for _ in range(num_bootstrap_samples):
        sample = np.random.choice(data, size=len(data), replace=True)
        bootstrap_means.append(np.mean(sample))

    confidence_interval = np.percentile(bootstrap_means, [(1-confidence_level)/2*100, (1+confidence_level)/2*100])
    return np.mean(data), confidence_interval

# サンプルデータ
data = np.random.normal(loc=10, scale=2, size=100)

# ブートストラップ法による平均値と信頼区間の推定
sample_mean, (ci_lower, ci_upper) = bootstrap_mean(data)

print(f"サンプル平均: {sample_mean:.2f}")
print(f"95%信頼区間: ({ci_lower:.2f}, {ci_upper:.2f})")

サンプル平均: 9.91
95%信頼区間: (9.53, 10.28)

import multiprocessing
import random
import time

def generate_unique_random(start, end, count):
    return random.sample(range(start, end + 1), count)

def parallel_unique_random(total_range, total_count, num_processes):
    pool = multiprocessing.Pool(processes=num_processes)

    chunk_size = total_count // num_processes
    remaining = total_count % num_processes

    tasks = []
    start = 1
    for i in range(num_processes):
        count = chunk_size + (1 if i < remaining else 0)
        end = start + total_range // num_processes - 1
        tasks.append((start, end, count))
        start = end + 1

    results = pool.starmap(generate_unique_random, tasks)
    pool.close()
    pool.join()

    return [num for sublist in results for num in sublist]

if __name__ == "__main__":
    total_range = 1000000
    total_count = 100000
    num_processes = 4

    start_time = time.time()
    parallel_result = parallel_unique_random(total_range, total_count, num_processes)
    end_time = time.time()

    print(f"並列処理による生成時間: {end_time - start_time:.4f}秒")
    print(f"生成された乱数の数: {len(parallel_result)}")
    print(f"重複チェック: {len(set(parallel_result)) == len(parallel_result)}")

    start_time = time.time()
    sequential_result = random.sample(range(1, total_range + 1), total_count)
    end_time = time.time()

    print(f"\n逐次処理による生成時間: {end_time - start_time:.4f}秒")
    print(f"生成された乱数の数: {len(sequential_result)}")
    print(f"重複チェック: {len(set(sequential_result)) == len(sequential_result)}")

並列処理による生成時間: 0.2353秒
生成された乱数の数: 100000
重複チェック: True

逐次処理による生成時間: 0.3747秒
生成された乱数の数: 100000
重複チェック: True