Incrément python de 1
Lorsque vous connaissez Python, vous êtes probablement conscient que l'incrément et les expressions de décréments (avant et après) ne sont pas prises en charge. Python a été créé pour être compréhensible et cohérent. En linguistique ayant des expressions ++ et -, un programmeur débutant fait souvent l'erreur de confondre les distinctions entre les expressions d'incrément / décrément, le post et le pré (à la fois en priorité et en valeur de retour). Par rapport à de nombreux autres langages de programmation, l'incrément de base et les expressions de décréments ne sont pas tout à fait nécessaires. Dans ce tutoriel, nous découvrirons l'incrément de 1 opérateur dans Python Code. Assurez-vous que vous devez avoir un outil Python installé et configuré sur votre système. Par conséquent, nous avons installé l'outil Spyder Python sur notre système.
Exemple 01:
Notre premier exemple serait de regarder comment ajouter l'incrément de 1 dans n'importe quel code python. Ouvrez d'abord l'outil Spyder et nommez le fichier de code comme test.py. Dans la zone de code, écrivez le code Python ci-dessous pour incrémenter 1 dans une variable de type entier. Nous avons d'abord ajouté le support Python dans notre page Spyder. Vous pouvez voir que nous avons défini un entier X ayant une valeur de 0. Après cela, nous avons incrémenté cette variable X avec 1 en utilisant l'opérateur «+ =» à l'intérieur. Après cela, nous avons imprimé la variable X pour voir si l'incrément de 1 fonctionne correctement ou non. Enregistrez le code et cliquez sur le bouton «Exécuter» pour exécuter le code Python.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = 0
x + = 1
Imprimer (x)
Les fenêtres de sortie nous montrent que la valeur de la variable x a été incrémentée de 1 car elle était initialement 0. Cela signifie que la syntaxe utilisée ci-dessus pour incrémenter toute variable par 1 est réalisable et fiable.
Exemple 02:
Jetons un coup d'œil à différentes façons d'augmenter une variable de 1. Dans ce cas, nous avons à nouveau ajouté le support Python dans la fenêtre Spyder. Après cela, nous avons déclaré une variable X avec une valeur de 2. Sur la 4e ligne, nous avons utilisé l'incrément «+» signe pour ajouter 1 dans la valeur précédente de x, et le résultat a à nouveau été enregistré dans la variable x. Cela signifie que la dernière valeur a été remplacée ici. Après cela, la déclaration d'impression imprimera la nouvelle valeur remplacée. Enregistrez votre code pour voir les résultats. Appuyez sur le bouton "Exécuter" pour interpréter le code.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = 2
x = x + 1
Imprimer (x)
La sortie montre que la valeur 2 de la variable x a été incrémentée de 1 et devient 3. Ensuite, cette valeur a de nouveau été enregistrée dans la variable X et imprimée.
Exemple 03:
Comme nous l'avons mentionné ci-dessus, l'incrément et les opérateurs de décréments ne peuvent pas être utilisés dans le langage de programmation Python car ils ne sont aucun usage ici. Vérifions si c'est vrai ou ne pas effacer la compréhension. Par conséquent, nous avons mis à jour le code et initialisé une variable «n» ayant une valeur de 2. Ensuite, nous avons utilisé l'opérateur de pré-incrément pour augmenter sa valeur et enregistré cette valeur en variable «n» à nouveau. Après l'instruction IMPREST, nous avons enregistré le code et l'avons exécuté via le panneau «Exécuter».
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
n = 2
n = ++ n
Imprimer (n)
Lorsque nous avons exécuté le code, nous savons que la valeur d'origine n'a pas été incrémentée et que la sortie montre la même valeur d'origine dans son résultat. Cela signifie que l'opérateur de pré-incrément ne fonctionne pas ici et n'est d'aucune utilité lorsqu'il est utilisé dans la programmation.
Vérifions l'opérateur post-Incement maintenant. Nous avons à nouveau utilisé le même code tout en remplaçant l'opérateur de pré-incitation par un opérateur post-imprécision, comme indiqué dans le code ci-dessous.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
n = 2
n = n++
Imprimer (n)
La sortie du code ci-dessus renvoie une erreur de syntaxe disant que la syntaxe n'est pas valide. Cela prouve que le poste et les opérateurs de pré-incitation ou de décrément ne sont pas utiles dans Python.
Exemple 04:
Jetons un coup d'œil à un exemple simple pour incrémenter une variable avec 1. Nous avons utilisé une variable ayant une valeur de 0 au début. La valeur d'origine a été imprimée, puis la valeur a été incrémentée de 1 en utilisant le signe «+ =». Alors la nouvelle valeur devrait être 1 maintenant. La nouvelle valeur sera imprimée. Ensuite, nous avons à nouveau utilisé l'opérateur «+ =» pour incrémenter la valeur de 30 cette fois et l'a imprimé. Enregistrez le code et exécutez-le via le bouton "Exécuter".
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = 0
Imprimer (x)
x + = 1
Imprimer (x)
x + = 30
Imprimer (x)
La sortie ci-dessous montre les résultats attendus. Il affiche d'abord la valeur d'origine 0, et après l'augmentation de 1, il imprime 1. En fin de compte, la valeur 1 a été augmentée de 30, et elle devient 31.
Exemple 05:
Utilisons l'incrément par 1 opérateur sur n'importe quelle valeur de type de chaîne et voyons ses résultats. Tout d'abord, nous avons pris une variable entière «X» comme nous l'avons fait dans l'exemple ci-dessus. La variable x a une valeur d'origine de 0. Sa valeur a été augmentée de 1 et après cela de 31. C'est le même cas que nous avons discuté ci-dessus. Voici une autre variable, «y» ayant la valeur «aqsa» dedans. Ensuite, nous avons utilisé le signe «+ =» pour incrémenter la valeur de la variable «y» avec 1. Logiquement, c'est mal parce que la valeur entière ne peut pas être incrément dans la valeur de la chaîne. Donc, nous devons obtenir une erreur lors de l'exécution de ce code. Alors, enregistrez votre code et exécutez-le.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = 0
Imprimer (x)
x + = 1
Imprimer (x)
x + = 30
Imprimer (x)
y = 'aqsa'
y + -1
imprimer (y)
Lorsque nous avons imprimé le code, l'incrément effectué sur la variable de type entier «X» a réussi et a affiché la valeur incrémentée à chaque fois. Mais dans le cas de la variable «Y», il lance une exception de «type EERROR» disant que les données de type de chaîne ne peuvent être concaténées qu'avec une chaîne au lieu des données de type entier.
Modifions le code et incmenmentons la valeur «y» entière par une valeur de type de chaîne, comme indiqué dans le code ci-dessous. Enregistrez votre code et exécutez le fichier pour les voir fonctionner.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = 0
Imprimer (x)
x + = 1
Imprimer (x)
x + -30
Imprimer (x)
y = 'aqsa'
y + = 'yasin'
imprimer (y)
Cette fois, il a affiché toutes les valeurs incrémentées, y compris la valeur d'incrément de type de chaîne dans la sortie. En effet.
Exemple 06:
Comprenez que nous ne pouvons pas utiliser également des opérateurs pré et post-incidence ou décrément dans des boucles «pour». Par conséquent, nous utilisons l'opérateur «+ =» dans une boucle de temps pour imprimer les valeurs d'une liste.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
liste = [12, 14, 16, 18, 20]
x = 0
tandis que (x
x + = 1
Lors de l'exécution du code, nous avons les valeurs de la liste une après l'autre dans une séquence.
Exemple 07:
Voyons l'effet de l'incrément de 1 dans un «ID» variable cette fois. Nous avons initialisé une variable «x» avec la valeur 2 et vérifié d'abord son «ID». Après cela, nous devons l'incrémenter de 1 et vérifier à nouveau son «ID». Enregistrer et exécuter le code.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = 2 imprimer (x)
imprimer (id (x))
x + = 1
Imprimer (x)
imprimer (id (x))
Alors que l'exécution du code, la sortie affiche deux «ID» différents avant et après l'incrément de 1. Cela signifie que chaque fois que nous incrémenons ou changeons une variable, sa dynamique change également.
# - * - CODING: UTF-8 - *-#!/ utilisateur / bin / python
x = y = z = 2
imprimer (id (x))
imprimer (id (y))
imprimer (id (z))
x + = 1
imprimer (id (x))
imprimer (id (y))
imprimer (id (z))
Conclusion:
Ce tutoriel a discuté et vu comment le post et les opérateurs de pré-incitation ou de décrément échouent en python. Nous avons également vu comment utiliser différentes façons pour incrémenter toute variable de 1. J'espère que cet article vous sera utile lors de l'utilisation de Python.