Iterating wieder, Primfaktoren Schleife, Python

Question

Ich habe vor kurzem eine Funktion in Python, die mir alle Faktoren einer beliebigen Zahl geben Sie in Python wählen. Ich möchte es jetzt ändern, um nur die Primfaktoren zu zeigen. Die Funktion, die ich zur Zeit habe, ist:

def prime_factors(n): 
L = [] 
i = range(1, n+1) 
for x in i: 
    if n % x == 0: 
     L.append(x) 
return L 

, nun die Primfaktoren zu finden, wollte ich durch L, erneut auf, und entfernen Sie alle Zahlen von L, der bei bis zu sich selbst durch irgendwelche Zahlen geteilt, der Rest wäre 0.

Also, im Wesentlichen, ich möchte nur die Liste, die ich jetzt habe, nachdem ich es angehängt habe, dann teilen Sie jeden Wert in der Liste von jeder Zahl bis zu dieser Nummer, um sicherzustellen, dass es nicht ' teilbar t durch irgendetwas mit einem Rest von 0.

ich habe versucht:

def prime_factors(n): 
    L = [] 
    i = range(1, n+1) 
    for x in i: 
     if n % x == 0: 
      L.append(x) 
    for y in L: 
     for x in i: 
      if y % x == 0: 
       L.remove(y) 
    return L 

Außerdem habe ich Splitting es in 2 verschiedenen Funktionen versucht ...

def prime_factors(n): 
    L = [] 
    i = range(2, n) 
     for x in i: 
      if n % x == 0: 
       L.append(x) 
    return L 

def prime(n): 
    L = prime_factors(n) 
    i = range(2, n) 
     for y in L: 
      for x in i: 
       if x % y == 0: 
        L.remove(x) 
    return L 

Ich habe versucht, die Rückkehr an verschiedenen Orten platzieren, ich habe versucht, die Reihenfolge der Schleifen Spiegeln, egal was, ich kann nicht herausfinden, wie die Liste L durch eine weitere Überprüfung ausgeführt, um zu sehen, ob die Werte in ihnen teilbar sind durch 0 ...

Answer 1

Modif y Ihre prime_factors Funktion wie folgt:

def prime_factors(n): 
    L = [] 
    i = range(2, n+1) # start from 2 as it is the first prime 
    for x in i: 
     if n % x == 0: 
      L.append(x) 
      # loop added 
      while n%x == 0: 
       n = n/x 
     # break as no further factors are possible 
     if n == 1: 
      break 
    return L 

Nun, was die während n% x == 0 ist, ist es Kräfte von einem Faktor von der ursprünglichen Zahl entfernt.

Zum Beispiel
n = 24 = 2 * 2 * 2 * 3 n% 2 == 0, so L = [2] und n 3 wird [Das stellt sicher, 4 oder 8, die nicht sind Primzahlen werden nicht an L angehängt]

Answer 2

können Sie verwenden einfach eine Funktion, die Wahr/Falsch für Primzahlen Rückkehr

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)) 

def prime_factors(n): 
    L = [] 
    i = range(1, n+1) 
    for x in i: 
     if n % x == 0: 
      if is_prime(x): 
       L.append(x) 
    return L