Générer des nombres premiers dans Python

Vous apprendrez à générer et à obtenir des nombres premiers en utilisant Python dans ce tutoriel en identifiant tous les nombres premiers dans une plage de valeurs spécifiée. Les nombres premiers sont ceux qui n'ont que le nombre lui-même et le numéro 1 comme facteurs. En d'autres termes, seul le numéro 1 et le nombre lui-même peuvent diviser un nombre premier. Ils ne sont pas complètement divisibles par aucun autre numéro. Travailler avec des nombres premiers est une compétence fréquemment utilisée dans des domaines comme la cybersécurité.

Après avoir terminé ce tutoriel, vous saurez:

• Quels sont les nombres premiers?
• Plusieurs méthodes Python pour obtenir des nombres premiers.
• Optimisation de l'algorithme Python pour obtenir des nombres premiers.
• En utilisant Python, trouvez tous les nombres premiers dans une plage de valeurs spécifiée.

Quels sont les nombres premiers?

Dans Python, les nombres premiers sont un nombre de types int qui sont supérieurs à 1 et n'ont pas d'autres facteurs mais eux-mêmes et 1. Un nombre privilégié est un comme 5, tandis qu'un nombre non prison est de quatre (puisque 2 x 2 est égal à 4). Les nombres 2, 11, 23 et 43 sont parmi les quelques nombres premiers.

Comment les nombres premiers peuvent être générés dans Python?

Une série de nombres premiers peut ressembler à 2, 3, 5, 7, 9, 11, 13, etc. La logique peut être implémentée dans Python pour recréer cette séquence de nombres premiers et déterminer si un numéro donné est premier ou non. L'utilisation de bibliothèques Python, de boucles, de conditions et de la fonction lambda est quelques techniques pour effectuer cette tâche.

Il existe diverses approches pour implémenter des nombres premiers dans Python; Nous en avons expliqué quelques-uns dans les exemples ci-dessous.

Exemple # 1: Génération de séquence de nombres premiers à l'aide de la fonction lambda

Les nombres premiers peuvent être générés en utilisant la fonction lambda comme on peut le voir dans l'exemple ci-dessous.

Code:

def prime_seq (num):
pour i à portée (2, num):
Si prime (i) == true:
imprimer (i, end = "")
autre:
passer
num = int (entrée ("Entrez la plage:"))
prime = Lambda Num: Tous (num% x != 0 pour x dans la plage (2, int (num **.5) +1))
Prime_seq (num)

Sortir:

Nous entrons la valeur clé 30 afin que la fonction ait imprimé tous les nombres premiers de 2 à 30. L'utilisation d'une fonction lambda qui est une fonction orpheline ou une fonction anonyme est utilisée dans le programme ci-dessus pour déterminer la plage de nombres premiers. Nous avons conçu le programme de telle manière que lorsque nous exécutons le script, le programme demandera à l'utilisateur de saisir une valeur clé. Ensuite, le programme générera la séquence ou la série de nombres premiers à partir de 2 à la valeur de clé spécifiée.

Le flux du programme:

L'utilisateur entre dans la plage d'entrée et la méthode d'entrée Python est utilisée pour prendre cette entrée. L'entrée est explicitement transformée en type de données numérique int. Dans le processus d'invoquer la fonction, le casting int est fourni comme argument. La fonction lambda est invoquée par la fonction définie. En conséquence, la fonction lambda est invoquée pour chaque nombre ou valeur entière de 2 à une valeur de clé spécifiée et un chèque de choix est effectué. Pour faire ce chèque de choix, le numéro de logique% 2! = 0 est utilisé.

Exemple n ° 2: générer des nombres premiers en utilisant pour Loop

Nous avons vu comment obtenir une séquence de nombres premiers en utilisant la fonction lambda. Maintenant, nous utiliserons la boucle pour et une condition pour générer une séquence de nombres premiers.

Code:

num = int (entrée ("Entrée la plage:"))
pour i à portée (2, num):
pour x dans la gamme (2, i):
if (i% x == 0):
casser
autre:
Imprimer (i)

Sortir:

Notre programme a obtenu une série de nombres premiers de 2 à 13 avec succès alors que nous entrions la valeur 15. Ce programme utilise des boucles et des conditions pour obtenir une série de nombres premiers. Il s'exécute de telle manière qu'après que l'utilisateur entre un entier spécifique, tous les nombres premiers entre la plage commençant de 2 au numéro d'entrée spécifié, seront générés et imprimés.

Le flux du programme:

L'utilisateur entre dans la plage d'entrée et la fonction d'entrée () prend cette entrée. L'entrée spécifiée est ensuite explicitement transformée en type int. Dans cet exemple, deux entiers sont déterminés par boucle imbriquée; La première boucle s'assure d'obtenir tous les nombres ou entiers se trouvant dans la plage à clé. La vérification du nombre premier est déterminée par la deuxième boucle pour. L'entier manipulé s'affiche / imprimé sur la console si le résultat du processus pour chaque valeur entière libellé n'est pas 0. Chaque nombre dans la plage spécifiée de deux à la valeur d'entrée est soumis à une boucle qui répète ce processus.

Exemple n ° 3: générer des nombres premiers en utilisant les boucles While

Maintenant, nous allons utiliser des boucles pour obtenir des nombres premiers dans une plage spécifiée.

Code:

plage = int (entrée ('entrez la plage:'))
num = 1
pendant que (num <= range):
comte = 0
x = 2
tandis que (x <= num//2):
if (num% x == 0):
Count = Count + 1
casser
x = x + 1
if (count == 0 et num!= 1):
imprimer ("% d"% num, end = ")
num = num + 1

Sortir:

Nous avons spécifié la valeur d'entrée de 45 et le programme a extrait tous les nombres premiers jusqu'au nombre «45». Dans le code ci-dessus, les boucles et les conditions WHAL sont utilisées pour déterminer la plage de nombres premiers. Une fois que l'utilisateur entre dans un entier, tous les nombres premiers se situant entre la plage de 2 et l'entrée spécifiée sont générées et affichées.

Le flux du programme:

L'utilisateur entre dans la plage d'entrée et la méthode d'entrée Python est utilisée pour prendre cette entrée. L'entrée a ensuite été jetée dans DataType int. Ici, le chèque de premier ordre est effectué en utilisant une boucle de temps. Le contrôle de la boucle est basé sur une vérification conditionnelle et le processus de cycle se poursuivra jusqu'à ce que la valeur saisie dépasse la variable de contrôle de la boucle. La variable pour le contrôle de la boucle est initialisée avec 1 et augmente de 1 après chaque boucle. Encore une fois, si le résultat du processus pour chaque valeur entière libellée n'est pas nul, le manage entier sera imprimé. Pour chaque valeur entière de 1 à la valeur de clé spécifiée, ce processus sera répété et exécuté.

Exemple n ° 4: Génération de nombres premiers à l'aide de la bibliothèque Sympy en Python

En utilisant la sympathie.Fonction Primerange () Dans la bibliothèque Sympy, nous pouvons obtenir une liste contenant des nombres premiers dans une plage spécifiée en utilisant cette fonction.

Code:

Importer Sympy
l_limit = int (entrée ("Limite inférieure:"))
h_limit = int (entrée ("Limite supérieure:"))
prime_numbers = list (Sympy.Primerange (l_limit, h_limit + 1))
print ("Prime Numbers:", prime_numbers)

Sortir:

Ce programme a utilisé une bibliothèque prédéfinie pour trouver la gamme de nombres premiers. Dans cet exemple, le module Sympy est utilisé pour effectuer le contrôle principal et la fonction a généré une liste avec des nombres premiers qui se trouvent dans les limites inférieures et supérieures, spécifiées par nous.

Le flux du programme:

L'utilisateur entre dans la plage inférieure et supérieure. L'entrée de l'utilisateur est ensuite traitée par la fonction d'entrée Python. L'entrée obtenue est jetée dans un type int. La méthode Primerange () du module Sympy prend les valeurs de plage inférieure et supérieure comme entrée. La sortie de la fonction est imprimée après avoir été coulée dans une variable de liste.

Vérification des nombres premiers

Nous avons vu différentes approches pour générer des nombres premiers. Maintenant, vous devriez également être en mesure de vérifier si un nombre est premier ou non. Pour cela, vous pouvez vérifier le programme ci-dessous. L'approche la plus simple et la plus élémentaire consiste à itérer dans la gamme d'entiers positifs de deux au nombre d'entrée et à vérifier si la plage et le modulo du nombre sont égaux à zéro. Si cela se produit, le nombre n'est pas un nombre premier car il a un diviseur autre que «un» et le nombre lui-même.

Code:

Def CheckPrime (n):
Si n> 1:
pour i à portée (2, n):
Si n% i == 0:
retourner faux
Retour vrai
retourner faux
Imprimer (CheckPrime (13))
Imprimer (CheckPrime (12))
Sortir:

Pour le numéro 13, la fonction a renvoyé True et False pour le numéro 12. Nous avons défini la fonction «Checkprime», qui n'accepte qu'un seul entier comme un argument car les nombres premiers doivent être supérieurs à 1, si le nombre d'entrée n'est pas supérieur à un, la fonction renvoie faux. Puis il itère sur la plage de deux au nombre spécifié. La fonction renvoie false si le modulo (%) du nombre entré «num» et que l'itération «i» est égal à zéro. Sinon, la méthode renvoie true.

Conclusion

Dans ce tutoriel, nous avons d'abord vu l'introduction aux nombres premiers, puis nous avons discuté de la façon dont nous pouvons générer des nombres aléatoires dans Python. Nous avons utilisé différentes approches pour générer une série / plage de nombres premiers. Tout d'abord, nous avons utilisé la fonction lambda, deuxièmement, nous avons utilisé pour les boucles et les conditions, puis nous avons utilisé la boucle while, et enfin, nous avons utilisé la méthode Primerange () du module Sympy pour générer des nombres aléatoires dans une plage spécifiée. Nous avons également implémenté un exemple pour vérifier si un nombre est premier ou non.