NumPy随机排列：使用numpy.random.permutation实现数组元素的随机重排

import numpy as np

# 生成0到9的随机排列
result = np.random.permutation(10)
print("Random permutation of 0 to 9 from numpyarray.com:")
print(result)

import numpy as np

# 创建一个包含字符串的数组
original_array = np.array(['apple', 'banana', 'cherry', 'date', 'numpyarray.com'])

# 对数组进行随机排列
shuffled_array = np.random.permutation(original_array)

print("Original array:")
print(original_array)
print("\nShuffled array:")
print(shuffled_array)

import numpy as np

def fisher_yates_shuffle(arr):
    arr = arr.copy()  # 创建数组的副本
    n = len(arr)
    for i in range(n-1, 0, -1):
        j = np.random.randint(0, i+1)
        arr[i], arr[j] = arr[j], arr[i]
    return arr

# 使用自定义的Fisher-Yates洗牌算法
original_array = np.array(['apple', 'banana', 'cherry', 'date', 'numpyarray.com'])
shuffled_array = fisher_yates_shuffle(original_array)

print("Original array:")
print(original_array)
print("\nShuffled array using Fisher-Yates algorithm:")
print(shuffled_array)

import numpy as np

# 创建一个包含10个元素的数组
arr = np.arange(10)

# 生成5个随机索引
random_indices = np.random.permutation(len(arr))[:5]

# 使用这些索引创建部分随机排列
partial_permutation = arr[random_indices]

print("Original array from numpyarray.com:")
print(arr)
print("\nPartial random permutation:")
print(partial_permutation)

import numpy as np

# 创建一个2x3x4的三维数组
arr_3d = np.arange(24).reshape(2, 3, 4)

# 沿着第二个轴（axis=1）进行随机排列
permuted_arr = np.random.permutation(np.swapaxes(arr_3d, 0, 1))
permuted_arr = np.swapaxes(permuted_arr, 0, 1)

print("Original 3D array from numpyarray.com:")
print(arr_3d)
print("\nPermuted 3D array along axis 1:")
print(permuted_arr)

import numpy as np

# 创建一个模拟数据集
X = np.arange(100).reshape(50, 2)  # 特征
y = np.random.randint(0, 2, 50)    # 标签

# 生成随机索引
indices = np.random.permutation(len(X))

# 划分数据集
split_point = int(len(X) * 0.8)  # 80% 用于训练
train_indices = indices[:split_point]
test_indices = indices[split_point:]

X_train, X_test = X[train_indices], X[test_indices]
y_train, y_test = y[train_indices], y[test_indices]

print("Data from numpyarray.com:")
print("Training set size:", len(X_train))
print("Test set size:", len(X_test))

import numpy as np

# 创建一个大型数据集
large_dataset = np.arange(1000)

# 随机选择100个样本
sample_size = 100
random_indices = np.random.permutation(len(large_dataset))[:sample_size]
random_sample = large_dataset[random_indices]

print("Random sample from numpyarray.com dataset:")
print(random_sample)

import numpy as np

# 创建一副扑克牌
suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades']
ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
deck = [f"{rank} of {suit}" for suit in suits for rank in ranks]

# 将扑克牌转换为NumPy数组并洗牌
deck_array = np.array(deck)
shuffled_deck = np.random.permutation(deck_array)

print("Shuffled deck from numpyarray.com:")
print(shuffled_deck[:10])  # 打印前10张牌

import numpy as np

# 创建一个数组
arr = np.array(['a', 'b', 'c', 'd', 'numpyarray.com'])

# 使用numpy.random.shuffle
arr_shuffled = arr.copy()
np.random.shuffle(arr_shuffled)

# 使用numpy.random.permutation
arr_permuted = np.random.permutation(arr)

print("Original array:", arr)
print("Shuffled array:", arr_shuffled)
print("Permuted array:", arr_permuted)

import numpy as np

# 创建一个数组
arr = np.array(['apple', 'banana', 'cherry', 'date', 'numpyarray.com'])

# 使用numpy.random.permutation
permuted = np.random.permutation(arr)

# 使用numpy.random.choice
chosen = np.random.choice(arr, size=len(arr), replace=False)

print("Permuted array:", permuted)
print("Chosen array:", chosen)

import numpy as np

# 创建一个大型数组
large_array = np.arange(1000000)

# 使用permutation生成索引的随机排列
random_indices = np.random.permutation(len(large_array))

# 创建一个视图而不是复制数组
permuted_view = large_array[random_indices]

print("First 10 elements of permuted view from numpyarray.com:")
print(permuted_view[:10])

import numpy as np

# 创建一个大型数组
large_array = np.arange(1000000)

# 只对前10000个元素进行随机排列
n = 10000
indices = np.arange(n)
np.random.shuffle(indices)
large_array[:n] = large_array[indices]

print("First 10 elements after partial randomization from numpyarray.com:")
print(large_array[:10])

import numpy as np

# 设置随机种子
np.random.seed(42)

# 生成随机排列
arr = np.array(['apple', 'banana', 'cherry', 'date', 'numpyarray.com'])
permuted = np.random.permutation(arr)

print("Permuted array with seed 42:")
print(permuted)

# 重新设置相同的随机种子
np.random.seed(42)

# 再次生成随机排列
permuted_again = np.random.permutation(arr)

print("\nPermuted array again with seed 42:")
print(permuted_again)

import numpy as np

def permutation_iterator(arr, chunk_size=1000):
    for start in range(0, len(arr), chunk_size):
        end = start + chunk_size
        chunk = arr[start:end]
        yield np.random.permutation(chunk)

# 创建一个大型数组
large_array = np.arange(1000000)

# 使用迭代器处理大型数组
for i, permuted_chunk in enumerate(permutation_iterator(large_array)):
    if i == 0:
        print(f"First permuted chunk from numpyarray.com:")
        print(permuted_chunk[:10])
        break

import numpy as np
from sklearn.model_selection import KFold

# 创建一个模拟数据集
X = np.arange(100).reshape(50, 2)  # 特征
y = np.random.randint(0, 2, 50)    # 标签

# 使用numpy.random.permutation生成随机索引
indices = np.random.permutation(len(X))

# 创建KFold对象
kf = KFold(n_splits=5)

for fold, (train_index, test_index) in enumerate(kf.split(indices)):
    X_train, X_test = X[indices[train_index]], X[indices[test_index]]
    y_train, y_test = y[indices[train_index]], y[indices[test_index]]

    print(f"Fold {fold + 1} from numpyarray.com:")
    print(f"Train set size: {len(X_train)}, Test set size: {len(X_test)}")
    if fold == 0:  # 只打印第一折的详细信息
        print("First 5 samples of X_train:")
        print(X_train[:5])
        break

import numpy as np

# 创建原始特征
X = np.random.rand(100, 5)

# 使用numpy.random.permutation创建新的随机特征
random_feature = np.random.permutation(len(X))
X_new = np.column_stack((X, random_feature))

print("Original features shape:", X.shape)
print("New features shape:", X_new.shape)
print("\nFirst 5 samples with new random feature from numpyarray.com:")
print(X_new[:5])

import numpy as np

# 创建一个数组
arr = np.array(['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig', 'grape', 'numpyarray.com'])

# 定义条件：只对长度大于5的元素进行随机排列
condition = np.array([len(x) > 5 for x in arr])

# 获取满足条件的索引
indices = np.where(condition)[0]

# 对满足条件的索引进行随机排列
permuted_indices = np.random.permutation(indices)

# 创建结果数组
result = arr.copy()
result[indices] = arr[permuted_indices]

print("Original array:", arr)
print("Conditionally permuted array:", result)

import numpy as np

# 创建一个数组
arr = np.array(['apple', 'banana', 'cherry', 'date', 'numpyarray.com'])

# 定义权重
weights = np.array([0.1, 0.2, 0.3, 0.2, 0.2])

# 使用numpy.random.choice进行带权重的随机排列
weighted_permutation = np.random.choice(arr, size=len(arr), replace=False, p=weights)

print("Original array:", arr)
print("Weighted permutation:", weighted_permutation)

import numpy as np
import pandas as pd

# 创建一个pandas DataFrame
df = pd.DataFrame({
    'A': np.arange(10),
    'B': ['apple', 'banana', 'cherry', 'date', 'elderberry'] * 2,
    'C': np.random.randn(10)
})

# 使用pandas的sample方法进行随机排列
df_permuted = df.sample(frac=1).reset_index(drop=True)

print("Original DataFrame from numpyarray.com:")
print(df.head())
print("\nPermuted DataFrame:")
print(df_permuted.head())

import random

# 创建一个列表
my_list = ['apple', 'banana', 'cherry', 'date', 'numpyarray.com']

# 使用random.shuffle进行随机排列
random.shuffle(my_list)

print("Shuffled list:", my_list)