Question

我有一个numpy数组，

nums = np.array([17, 18, 19, 20, 21, 22, 23])

如何以pythonic方式过滤掉此数组中的素数？我知道做一个简单的过滤，比如，

nums[nums > 20]   #array([21, 22, 23])

有没有办法传递lambda函数进行过滤？

预期输出：数组（[17,19,23]）

Answer 1

我这样做的方式是使用gmpy或第三方库开发了一个很好的素性测试算法。 Miller-Rabin素性测试通常是一种非常安全（快速！）的投注。如果您只想慢点，可以这样做：

import numpy as np
import math

def is_prime(n):
    if n % 2 == 0 and n > 2: 
        return False
    return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))

a = np.arange(1, 10**3)
foo = np.vectorize(is_prime)
pbools = foo(a)
primes = np.extract(pbools, a)
primes  # => Output below
array([  1,   2,   3,   5,   7,  11,  13,  17,  19,  23,  29,  31,  37,
        41,  43,  47,  53,  59,  61,  67,  71,  73,  79,  83,  89,  97,
       101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163,
       167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233,
       239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311,
       313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389,
       397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
       467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563,
       569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641,
       643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727,
       733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821,
       823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907,
       911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997])

如果要过滤素数，只需在pbools变量上调用np.invert。对于任何谓词都是如此。您还可以将lambda传递给vectorize。例如，假设我们只想要素数也可以被5整除（无论出于何种原因）。

import numpy as np
import math

def is_prime(n):
    if n % 2 == 0 and n > 2: 
        return False
    return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2))

a = np.arange(1, 10**3)
foo = np.vectorize(lambda x: (not (x + 1) % 5 or not (x - 1) % 5) and is_prime(x))
primes = a[foo(a)]  # => Shorthand.... Output below
array([  1,  11,  19,  29,  31,  41,  59,  61,  71,  79,  89, 101, 109,
   131, 139, 149, 151, 179, 181, 191, 199, 211, 229, 239, 241, 251,
   269, 271, 281, 311, 331, 349, 359, 379, 389, 401, 409, 419, 421,
   431, 439, 449, 461, 479, 491, 499, 509, 521, 541, 569, 571, 599,
   601, 619, 631, 641, 659, 661, 691, 701, 709, 719, 739, 751, 761,
   769, 809, 811, 821, 829, 839, 859, 881, 911, 919, 929, 941, 971, 991])

Answer 2

有这样的设置：

import numpy as np
import math
nums = np.array([17, 18, 19, 20, 21, 22, 23])

现在我们创建一个包含所有可能的整数候选项的数组：

divisors = np.arange(2,int(math.sqrt(np.max(nums)))+1) # Numbers from 2 to sqrt(max(nums))
print(divisors)
# [2 3 4]

现在对数组应用模运算但具有不同的维度，因此我们使用每个除数检查每个数字：

print(nums[:,None] % divisors[None,:]) # Modulo operation on each element (0 means divisible)

[[1 2 1]
 [0 0 2]
 [1 1 3]
 [0 2 0]
 [1 0 1]
 [0 1 2]
 [1 2 3]]

现在我们如何获得素数......我们检查线路中是否有零结果：

print(np.min(nums[:,None] % divisors[None,:], axis=1)) # Minimum of the modulo for that element
# [1 0 1 0 0 0 1]

然后创建一个掩码来索引它们：

print(nums[np.min(nums[:,None] % divisors[None,:], axis=1) > 0]) # So index them
# [17 19 23]

所以你最终需要的是：

nums = np.array([17, 18, 19, 20, 21, 22, 23])
divisors = np.arange(2,int(math.sqrt(np.max(nums)))+1)
nums[np.min(nums[:,None] % divisors[None,:], axis=1) > 0]

所有其他内容仅用于说明每个步骤的作用。

这不是微不足道的，因为它使用1D阵列广播到2D阵列中，但方法应该是清楚的。如果您有任何问题，请告诉我。

如果你想优化它，还有另一种可能性：除数当前是2和sqrt(max(array))之间的每个数字，但你不需要测试所有这些数字。如果你有一个函数返回该范围内的所有素数就足够了。例如，使用@ MaxU答案的primesfrom2to，更快的可能性是：

nums = np.array([17, 18, 19, 20, 21, 22, 23])
# All prime numbers in the range from 2 to sqrt(max(nums))
divisors = primesfrom2to(int(math.sqrt(np.max(nums)))+1)
nums[np.min(nums[:,None] % divisors[None,:], axis=1) > 0]

但它使用与以前相同的机制但速度稍快。： - ）

Answer 3

如果您关心速度和效率，我建议您使用fastest prime sieves和numpy.intersect1d()功能之一：

import numpy as np

def primesfrom2to(n):
    # http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    """ Input n>=6, Returns a array of primes, 2 <= p < n """
    sieve = np.ones(n//3 + (n%6==2), dtype=np.bool)
    sieve[0] = False
    for i in range(int(n**0.5)//3+1):
        if sieve[i]:
            k=3*i+1|1
            sieve[      ((k*k)//3)      ::2*k] = False
            sieve[(k*k+4*k-2*k*(i&1))//3::2*k] = False
    return np.r_[2,3,((3*np.nonzero(sieve)[0]+1)|1)]

# generate 100.000 random integers from 1 to 1.000.000.000
a1 = np.random.randint(1, 10**9, 100000)
# generate all primes that are equal or less than a1.max() 
primes = primesfrom2to(a1.max())

# print result    
print(np.intersect1d(primes, a1))

Answer 4

看来你的问题根本不是素数，而是关于如何将函数应用于numpy数组。我使用了简单的is_odd示例。也许np.vectorize正是您所寻找的：

In [34]: nums = np.array([17, 18, 19, 20, 21, 22, 23])

In [35]: def is_odd(n):
    if n % 2 == 1:
        return True
    return False
   ....: 

In [36]: is_odd_v = np.vectorize(is_odd)

In [37]: nums[is_odd_v(nums)]
Out[37]: array([17, 19, 21, 23]

如果我没记错的话，np.vectorize主要是为了方便而使用，并且没有很好的表现。

Answer 5

如果您真的想使用过滤器，可以使用：

nums[[i for i in range(len(nums)) if sum([nums[i]%val==0 for val in range(2,nums[i]-1)])==0]]

这是做什么的？

我们使用

搜索所有带素数的索引

[i for i in range(len(nums)) if sum([nums[i]%val==0 for val in range(2,nums[i]-1)])==0]

这基本上遍历每个值并检查它是否不能被任何小于其自身的值整除（忽略1）

[i for i in range(len(nums)) #for every index

if sum(#calculate sum of booleans

[nums[i]%val==0 for val in range(2,nums[i]-1)] # check if it is divisble by any value smaller than itself

)==0 #check if the number of divisors is zero

从numpy数组中获取素数

5 个答案: