Generere primtall i Python
Etter å ha fullført denne opplæringen, vil du vite:
- Hva er primtallene?
- Flere Python -metoder for å få primtall.
- Python -algoritmeoptimalisering for å få primtall.
- Ved å bruke Python, finn alle primtall i et spesifisert verdierområde.
Hva er primtall?
I Python er primtall antall INT -type som er større enn 1 og ikke har noen andre faktorer, men seg selv og 1. Et primtall er ett som 5, mens et ikke-prime-nummer er fire (siden 2 x 2 er lik 4). Tallene 2, 11, 23 og 43 er blant de få primtallene.
Hvordan primtall kan genereres i Python?
En serie med primtall kan se ut som 2, 3, 5, 7, 9, 11, 13 og så videre. Logikken kan implementeres i Python for å gjenskape denne sekvensen av primtall og bestemme om et gitt antall er førsteklasses eller ikke. Bruke Python -biblioteker, løkker, forhold og lambda -funksjonen er noen få teknikker for å utføre denne oppgaven.
Det er forskjellige tilnærminger til å implementere primtall i Python; Vi forklarte noen få i eksemplene nedenfor.
Eksempel 1: Generering av sekvens av primtall ved bruk av lambda -funksjon
Primtall kan genereres ved hjelp av lambda -funksjonen som kan sees i eksemplet nedenfor.
Kode:
def prime_seq (num):for jeg i rekkevidde (2, num):
Hvis prime (i) == true:
trykk (i, slutt = "")
ellers:
sende
num = int (input ("Angi rekkevidden:"))
prime = lambda num: alle (num%x != 0 for x i rekkevidde (2, int (num **.5) +1))
Prime_seq (num)
Produksjon:
Vi legger inn nøkkelverdi 30 slik at funksjonen har skrevet ut alle primtall fra 2 opp til 30. Bruke en lambda -funksjon som er en foreldreløs funksjon eller en anonym funksjon brukes i programmet ovenfor for å bestemme utvalget av primtall. Vi designet programmet på en slik måte at når vi utfører skriptet, vil programmet be brukeren legge inn en nøkkelverdi. Deretter vil programmet generere sekvensen eller serien med primtall som starter fra 2 opp til den spesifiserte nøkkelverdien.
Flyten av programmet:
Brukeren går inn i inngangsområdet og Python -inngangsmetoden brukes til å ta den inngangen. Inngangen blir eksplisitt transformert til den numeriske datatypen Int. I prosessen med å påkalle funksjonen, blir rollebesetningen gitt som et argument. Lambda -funksjonen påberopes av den definerte funksjonen. Som et resultat blir lambda -funksjonen påkalt for hvert tall eller heltallverdi fra 2 til en spesifisert nøkkelverdi og en primkontroll utføres. For å gjøre denne prime -sjekken, logikknummeret%2! = 0 brukes.
Eksempel nr. 2: Generere primtall som bruker for loop
Vi så hvordan vi kan få en sekvens av primtall ved å bruke lambda -funksjonen. Nå vil vi bruke for -sløyfen og en tilstand for å generere en sekvens av primtall.
Kode:
num = int (input ("input serien:"))for jeg i rekkevidde (2, num):
for x i rekkevidde (2, i):
if (i%x == 0):
gå i stykker
ellers:
trykk (i)
Produksjon:
Vårt program har fått en serie med primtall fra 2 til 13 med hell da vi skrev inn verdi 15. Dette programmet bruker for løkker og forhold for å få en serie med primtall. Den kjøres på en slik måte at etter at brukeren har gått inn i et spesifikt heltall, vil alle primtallene mellom området som starter fra 2 til det spesifiserte inngangsnummeret, bli generert og skrevet ut.
Flyten av programmet:
Brukeren går inn i inngangsområdet og input () -funksjonen tar den inngangen. Den spesifiserte inngangen blir deretter eksplisitt omgjort til en INT -type. I dette eksemplet bestemmes to heltall via nestet looping; Den første sløyfen sørger for å skaffe alle tall eller heltall som ligger innenfor nøkkelområdet. Primtallverifiseringen bestemmes av den andre for-loop. Heltallet som håndteres vises/trykt på konsollen hvis prosessens utfall for hvert heltallsverdi denominert ikke er 0. Hvert tall i det spesifiserte området for to til inngangsverdi blir utsatt for en sløyfe som gjentar denne prosessen.
Eksempel nr. 3: Genererer primtall ved å bruke mens løkker
Nå vil vi bruke mens løkker for å få primtall under et spesifisert område.
Kode:
rekkevidde = int (input ('Angi rekkevidden:'))num = 1
mens (num <= range):
telling = 0
x = 2
mens (x <= num//2):
if (num % x == 0):
telling = telling + 1
gå i stykker
x = x + 1
if (count == 0 og num!= 1):
print (" %d" %num, slutt = ")
num = num + 1
Produksjon:
Vi spesifiserte inngangsverdien på 45 og programmet hentet ut alle primtallene opp til tallet '45'. I koden over brukes mens løkker og forhold brukes til å bestemme området for primtall. Når brukeren kommer inn i et heltall, blir alle primtallene som faller mellom området 2 og den spesifiserte inngangen genereres og vises.
Flyten av programmet:
Brukeren går inn i inngangsområdet og Python -inngangsmetoden brukes til å ta den inngangen. Inngangen ble deretter støpt inn i datatype int. Her utføres prime -sjekken med en stund loop. Loop -kontrollen er basert på en betinget sjekk, og sykkelprosessen vil fortsette til den inngitte verdien overstiger løkke -kontrollvariabelen. Variabelen for sløyfekontroll initialiseres med 1 og øker med 1 etter hver sløyfe. Igjen, hvis utfallet fra prosessen for hvert heltallsverdi i denominert ikke er null, vil heltallet som håndteres skrives ut. For hver heltallverdi fra 1 til den spesifiserte nøkkelverdien, vil denne prosessen bli gjentatt og utført.
Eksempel 4: Generere primtall ved hjelp av Sympy -biblioteket i Python
Bruke sympyen.Primerange () -funksjonen i Sympy -biblioteket, vi kan få en liste som inneholder primtall innenfor et spesifisert område ved å bruke denne funksjonen.
Kode:
Import Sympyl_limit = int (input ("Nedre grense:"))
h_limit = int (input ("høyere grense:"))
prime_numbers = liste (sympy.Primerange (l_limit, h_limit+1))
Print ("Prime Numbers:", prime_numbers)
Produksjon:
Dette programmet brukte et forhåndsdefinert bibliotek for å finne utvalget av primtall. I dette eksemplet brukes Sympy -modulen til å utføre Prime Check, og funksjonen har generert en liste med primtall som ligger innenfor de nedre og høyere grensene, spesifisert av oss.
Flyten av programmet:
Brukeren kommer inn i det nedre og høyere området. Brukerens inngang blir deretter behandlet av Python -inngangsfunksjonen. Innspillet som ble oppnådd blir støpt i en INT -type. Primerange () -metoden til Sympy -modulen tar verdien av lavere og høyere rekkevidde som inngang. Funksjonens utgang skrives ut etter å ha blitt støpt i en listevariabel.
Bekreftelse av primtall
Vi har sett forskjellige tilnærminger til å generere primtall. Nå skal du også kunne bekrefte om et nummer er førsteklasses eller ikke. For dette kan du sjekke programmet gitt nedenfor. Den enkleste og mest grunnleggende tilnærmingen er å iterere gjennom rekkevidden av positive heltall fra to til inngangsnummeret og sjekke om området og modulen til tallet er lik null. Hvis det skjer, er ikke tallet et primtall fordi det har en annen divisor enn 'en' og selve tallet.
Kode:
def checkprime (n):Hvis n> 1:
for i i rekkevidde (2, n):
Hvis n % i == 0:
return falsk
Returner sann
return falsk
Print (CheckPrime (13)))
Print (CheckPrime (12)))
Produksjon:
For nummer 13 har funksjonen returnert sann og usant for nummer 12. Vi definerte funksjonen 'CheckPrime', som bare aksepterer et enkelt heltall som et argument fordi primtall må være større enn 1, hvis inngangsnummeret ikke er større enn ett, returnerer funksjonen falsk. Så iterer det over området fra to til det angitte nummeret. Funksjonen vil returnere falsk hvis moduloen (%) av det angitte nummeret 'num' og iterasjonen 'i' er lik null. Hvis ikke, returnerer metoden sann.
Konklusjon
I denne opplæringen så vi først introduksjonen til primtall og diskuterte deretter hvordan vi kan generere tilfeldige tall i Python. Vi brukte forskjellige tilnærminger for å generere en serie/utvalg av primtall. Først brukte vi lambda -funksjonen, for det andre brukte vi til løkker og forhold, deretter brukte vi mens Loop, og til slutt brukte vi Primerange () -metoden til Sympy -modulen for å generere tilfeldige tall innenfor et spesifisert område. Vi implementerte også ett eksempel for å bekrefte om et nummer er førsteklasses eller ikke.