即使我返回了所有内容，我的代码的递归似乎也不起作用

Question

I am making code to check if a number is a prime or not, but I want the argument to be both list and integer. For that I'm using recursion but the recursion doesn't seem to work.

 def prime_checker(suspected_prime):
    if type(suspected_prime) == type(list()):
        result_list = list()
        for x in range(len(suspected_prime)):
            result_list.append(prime_checker(suspected_prime[x]))
        return(result_list)
    else:
        prime_factor, factors, suspected_prime = 2, 0, abs(suspected_prime)
        while factors < 1:
            if suspected_prime % prime_factor == 0:
                factors += 1
            if math.ceil(suspected_prime**0.5) == prime_factor:
                if factors == 0:
                    return True
                else:
                    return False
            prime_factor += 1 

Answer 1

I think this should work for your code:

def prime(suspected_prime):
if type(suspected_prime) == list:
    result_list = list()
    for x in suspected_prime:
        result_list.append(prime(x))
    return(result_list)
else:
    factors,suspected_prime = 0,abs(suspected_prime)
    root = int(suspected_prime**0.5)
    for x in range (2,(root+1)):
        if(factors == 1):
            break
        elif(suspected_prime%x == 0):
            factors = 1  
            return False

    if (factors == 0):
        return True

You can change the if-else statement according to your requirement if you want.

Answer 2

Both your list case and int case are too complicated if not broken, let's see what we can do. First, use isinstance to test types. Next, you don't need to loop over the indexes, you can more easily loop over the content.

As far as the int clause, you continue doing math after the answer is already known -- don't waste time this way when it comes to primes. Also, this style of prime testing is always simpler if we treat numbers 2 and less, and evens, as special cases and focus on testing odd divisors only:

def prime_checker(suspected_primes):
    if isinstance(suspected_primes, list):
        return [prime_checker(entity) for entity in suspected_primes]

    suspected_prime = abs(suspected_primes)

    if suspected_prime < 2:
        return False

    if suspected_prime % 2 == 0:
        return suspected_prime == 2

    for divisor in range(3, int(suspected_prime**0.5) + 1, 2):
        if suspected_prime % divisor == 0:
            return False

    return True

print(prime_checker([1, [2, 3], 4, [5, 6, [7, 8], 9]]))
print(prime_checker(13))

OUTPUT

> python3 test.py
[False, [True, True], False, [True, False, [True, False], False]]
True
>

Answer 3

Currently you have :

def prime-checker (input could be scalar or a list)

Strategy 1 : (Remove the looping inside prime-checker, always deal with a scalar, ie non-list). so you have :

def prime_checker (scalar, ie. non-list input arg) :

To handle this, change your implementation to always handle a scalar. Do your looping externally, outside the prime-checker function. With this your prime-checker will only have the math calculation part, so it will be simpler and easier to understand.

Strategy 2: Alternately, if you insist on keeping the list looping inside prime-checker.

Case 1 : if your input is just a number , say 45. Then send the input arg as [45] So , the external invocation of prime-checker (from the external caller) would become

results = prime_checker( [45])

Case 2: If your input is a list, say list1, then your invocation is

results = prime_checker (list1).

So, now your implementation always expects and deals with a list.

# we always get input as a list (hence I changed the arg name)
 def prime_checker(suspected_list):
    # this branch *looks* recursive, but actually only handles a list
    if (len(suspected_list) > 1) :
        result_list = []
        for prime_candidate in suspected_list:
            result_list.append(prime_checker([prime_candidate]) # recur, as a list
        return(result_list)
    else: (when suspected list has only 1 entry)
        # this branch does the actual prime calculation for a single input
        suspected_prime = suspected_list[0]
        prime_factor, factors, suspected_prime = 2, 0, abs(suspected_prime)
        while factors < 1:
            if suspected_prime % prime_factor == 0:
                factors += 1
            if math.ceil(suspected_prime**0.5) == prime_factor:
                if factors == 0:
                    return True
                else:
                    return False
            prime_factor += 1