小编Sha*_*Han的帖子

众所周知，pythonic 的方式来交换两个项目的值，a并且b是

a, b = b, a

它应该相当于

b, a = a, b

但是，今天在写代码的时候，无意中发现下面的两个swap给出了不同的结果：

nums = [1, 2, 4, 3]
i = 2
nums[i], nums[nums[i]-1] = nums[nums[i]-1], nums[i]
print(nums)
# [1, 2, 4, 3]

nums = [1, 2, 4, 3]
i = 2
nums[nums[i]-1], nums[i] = nums[i], nums[nums[i]-1]
print(nums)
# [1, 2, 3, 4]

这对我来说令人难以置信。有人可以向我解释这里发生了什么吗？我认为在 Python 交换中，这两个任务同时且独立地发生。

我正在尝试顺时针（按升序）对 numpy ndarray 进行排序。您可以将其理解为获取数组中的所有值，对它们进行排序，然后将它们按顺时针螺旋排列成具有相同形状的新数组。顺时针螺旋的方向如下图所示：

例如，假设我有一个数组

import numpy as np
a1 = np.array(([2, 4, 6],
               [1, 5, 3],
               [7, 9, 8]))

预期的输出是

np.array([[1, 2, 3],
          [8, 9, 4],
          [7, 6, 5]])

如果我有一个数组

a2 = np.array(([2, 4, 6],
               [1, 5, 3],
               [7, 9, 8],
               [12, 11, 10]))

预期的输出是

np.array([[1, 2, 3],
          [10, 11, 4],
          [9, 12, 5],
          [8, 7, 6]])

到目前为止我尝试过的

我的想法是跟踪移动迭代器的行索引x和列索引y以及cur排序后的扁平列表的当前索引sa。移动迭代器水平通过行和垂直lenr通过列时，将通过 ( lenc)的行数和通过 ( ) 的列数减去。这是我设法编写的函数：1lenrlenc

def …

给定一个包含 20 个浮点数的列表，我想找到一个最大的子集，其中任意两个候选者彼此不同且大于 a mindiff = 1.。现在我正在使用蛮力方法使用itertools.combinations. 如下图，代码在 4 s 后为 20 个数字的列表找到了一个子集。

from itertools import combinations
import random
from time import time

mindiff = 1.
length = 20
random.seed(99)
lst = [random.uniform(1., 10.) for _ in range(length)]

t0 = time()
n = len(lst)
sample = []
found = False
while not found:
    # get all subsets with size n
    subsets = list(combinations(lst, n))
    # shuffle to ensure randomness
    random.shuffle(subsets)
    for subset in subsets:
        # sort the …

我有一个 3D 晶格，其单位单元（即最小重复单位）为 16 个点。由于它是 3D 晶格，因此它在所有 3 个维度（x、y、z）上都是周期性的。详细来说，单位单元如下所示：\n

3 个晶格向量 a ₁、a ₂、a ₃为

bulk_vecs = [[14.56578026795, 0.0,            0.0          ], # a1\n             [0.0,            8.919682340494, 0.0          ], # a2\n             [7.282890133975, 2.973227446831, 4.20477857933]] # a3\n

16个点的笛卡尔坐标为

bulk_coords = [[ 0.00000000,  0.00000000,  0.00000000],\n               [ 10.9243352,  6.34420137,  2.66488775],\n               [ 18.2072253,  6.34420137,  2.66488775],\n               [ 12.7450577,  3.17210068,  1.33244387],\n               [ 10.6807662,  8.91968234,  0.42187384],\n               [ 16.1429338,  3.37097392,  1.19181926],\n               [ 19.7843789,  9.31742882,  3.29420855],\n               [ 9.34718165,  2.97322745, …

我正在处理一些需要不断从迭代中获取元素的代码，只要基于（或与之相关）前一个元素的条件为真。例如，假设我有一个数字列表：

lst = [0.1, 0.4, 0.2, 0.8, 0.7, 1.1, 2.2, 4.1, 4.9, 5.2, 4.3, 3.2]

让我们使用一个简单的条件：该数字与前一个数字的差异不超过 1。因此预期输出将是

[0.1, 0.4, 0.2, 0.8, 0.7, 1.1]

通常，itertools.takewhile这是一个不错的选择，但在这种情况下它有点烦人，因为第一个元素没有要查询的前一个元素。以下代码返回一个空列表，因为对于第一个元素，代码会查询最后一个元素。

from itertools import takewhile
res1 = list(takewhile(lambda x: abs(lst[lst.index(x)-1] - x) <= 1., lst))
print(res1)
# []

我设法编写了一些“丑陋”的代码来解决：

res2 = []
for i, x in enumerate(lst):
    res2.append(x)
    # Make sure index is not out of range
    if i < len(lst) - 1:
        if not abs(lst[i+1] - x) <= 1.:
            break
print(res2)
# [0.1, 0.4, …

我有一个列表列表。我想找到所有保持每个子列表顺序的平面列表。举个例子，假设我有一个这样的列表：

ll = [['D', 'O', 'G'], ['C', 'A', 'T'], ['F', 'I', 'S', 'H']]

获得一个解决方案是微不足道的。我设法编写了以下代码，它可以生成一个随机的平面列表，该列表保持每个子列表的顺序。

import random

# Flatten the list of lists
flat = [x for l in ll for x in l]
# Shuffle to gain randomness
random.shuffle(flat)

for l in ll:
    # Find the idxs in the flat list that belongs to the sublist
    idxs = [i for i, x in enumerate(flat) if x in l]
    # Change the order to match the order in the sublist
    for …

我n在 3D 空间中有点。我想对所有最近邻距离都大于 的点的子集进行随机采样r。子集的大小m未知，但我希望采样点尽可能密集，即最大化m。

有类似的问题，但它们都是关于生成点，而不是从给定点采样。
以最小最近邻距离在 3D 空间中生成随机点

生成 3-d 随机点，每个点之间的距离最小？

假设我有 300 个随机 3D 点，

import numpy as np
n = 300
points = np.random.uniform(0, 10, size=(n, 3))

在最大化 的同时获得m具有最小最近邻距离的点子集的最快方法是什么？r = 1m

假设我有一个从 0 到 9 的 20 个随机整数列表。我想将列表划分为N子集，以便子集总和的比率等于给定值，并且我想找到所有可能的分区。我编写了以下代码并使其适用于该N = 2案例。

import random
import itertools

#lst = [random.randrange(10) for _ in range(20)]
lst = [2, 0, 1, 7, 2, 4, 9, 7, 6, 0, 5, 4, 7, 4, 5, 0, 4, 5, 2, 3]

def partition_sum_with_ratio(numbers, ratios):
    target1 = round(int(sum(numbers) * ratios[0] / (ratios[0] + ratios[1])))
    target2 = sum(numbers) - target1
    p1 = [seq for i in range(len(numbers), 0, -1) for seq in
          itertools.combinations(numbers, i) if sum(seq) == …

假设我有一个Y从 0 到 10 的随机浮点数矩阵，形状为(10, 3)：

import numpy as np
np.random.seed(99)
Y = np.random.uniform(0, 10, (10, 3))
print(Y)

输出：

[[6.72278559 4.88078399 8.25495174]
 [0.31446388 8.08049963 5.6561742 ]
 [2.97622499 0.46695721 9.90627399]
 [0.06825733 7.69793028 7.46767101]
 [3.77438936 4.94147452 9.28948392]
 [3.95454044 9.73956297 5.24414715]
 [0.93613093 8.13308413 2.11686786]
 [5.54345785 2.92269116 8.1614236 ]
 [8.28042566 2.21577372 6.44834702]
 [0.95181622 4.11663239 0.96865261]]

现在，我得到了一个X具有相同形状的矩阵，可以将其视为通过添加小噪声Y然后打乱行而获得的：

X = np.random.normal(Y, scale=0.1)
np.random.shuffle(X)
print(X)

输出：

[[ 4.04067271  9.90959141  5.19126867]
 [ 5.59873104  2.84109306  8.11175891]
 [ 0.10743952  7.74620162  7.51100441]
 [ …

假设我有一个带有重复项的数字列表。

import random
lst = [0, 0, 1, 2, 2, 2, 3, 3, 4, 4, 4, 4, 5, 6, 7, 7, 8, 8, 8, 9]
random.shuffle(lst)

我想将列表拆分为最少数量的子“集”，其中包含所有唯一数字，而不丢弃任何数字。我设法编写了以下代码，但我觉得这是硬编码的，因此应该有更快更通用的解决方案。

from collections import Counter

counter = Counter(lst)
maxcount = counter.most_common(1)[0][1]
res = []
while maxcount > 0:
    res.append(set(x for x in lst if counter[x] >= maxcount))
    maxcount -= 1
assert len([x for st in res for x in st]) == len(lst)
print(res)

输出：

[{4}, {8, 2, 4}, {0, 2, 3, 4, …