Incremento Python em 1
Quando você está familiarizado com Python, você provavelmente está ciente de que as expressões de incremento e decrementação (antes e depois) não são suportadas. Python foi criado para ser compreensível e consistente. Na linguística com ++ e - expressões, um programador iniciante freqüentemente comete o erro de confundir as distinções entre expressões de incremento/decréscimo, pós e pré (tanto em valor prioritário quanto de retorno). Em comparação com muitas outras linguagens de programação, as expressões básicas de incremento e decréscimo não são tão necessárias. Neste tutorial, aprenderemos sobre o incremento por 1 operador no código Python. Verifique se você deve ter uma ferramenta Python instalada e configurada em seu sistema. Por isso, instalamos a ferramenta Spyder Python em nosso sistema.
Exemplo 01:
Nosso primeiro exemplo seria analisar como adicionar incremento por 1 em qualquer código Python. Abra a ferramenta Spyder primeiro e nomeie o arquivo de código como teste.py. Na área de código, escreva o código Python abaixo para incremento 1 em uma variável do tipo inteiro. Adicionamos o suporte do Python em nossa página do Spyder First. Você pode ver que definimos um número inteiro x com um valor de 0. Depois disso, incrementamos essa variável x com 1 usando o operador "+=" dentro. Depois disso, imprimimos a variável x para ver se o incremento em 1 trabalho corretamente ou não. Salve o código e clique no botão "Executar" para executar o código Python.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = 0
x += 1
impressão (x)
As janelas de saída nos mostram que o valor da variável x foi incrementado por 1, pois foi inicialmente 0. Isso significa que a sintaxe usada acima para incrementar qualquer variável por 1 é viável e confiável.
Exemplo 02:
Vamos dar uma olhada em diferentes maneiras de incrementar uma variável em 1. Nesse caso, adicionamos novamente o suporte do Python na janela do Spyder. Depois disso, declaramos uma variável x com um valor de 2. Na 4ª linha, usamos o sinal de incremento "+" para adicionar 1 no valor anterior de x, e o resultado foi novamente salvo na variável x. Isso significa que o último valor está substituindo aqui. Depois disso, a declaração de impressão imprimirá o novo valor substituído. Salve seu código para ver os resultados. Toque no botão "Executar" para interpretar o código.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = 2
x = x + 1
impressão (x)
A saída mostra que o valor 2 da variável x foi incrementado por 1 e se torna 3. Então esse valor foi novamente salvo na variável x e impresso.
Exemplo 03:
Como mencionamos acima, os operadores de incremento e decréscimos não podem ser usados na linguagem de programação Python, pois não são utidos aqui. Vamos verificar se é verdade ou não limpar o entendimento. Portanto, atualizamos o código e inicializamos uma variável "n" com um valor de 2. Em seguida, usamos o operador de pré-incremento para incrementar seu valor e salvamos esse valor na variável "n" novamente. Após a declaração de impressão, salvamos o código e o executamos através do sinal "Run".
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
n = 2
n = ++ n
impressão (n)
Quando executamos o código, sabemos que o valor original não foi incrementado e a saída mostra o mesmo valor original em seu resultado. Isso significa que o operador de pré-incremento não está funcionando aqui e não tem utilidade enquanto usado na programação.
Vamos verificar o operador pós-incremento agora. Usamos o mesmo código aqui novamente enquanto substituímos o operador de pré-incremento por um operador pós-incremento, como mostrado no código abaixo.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
n = 2
n = n++
impressão (n)
A saída do código acima retorna um erro de sintaxe dizendo que a sintaxe é inválida. Isso prova que o post e os operadores de pré-incremento ou decréscimo não são úteis no Python.
Exemplo 04:
Vamos dar uma olhada em um exemplo simples para incrementar uma variável com 1. Usamos uma variável com um valor de 0 no início. O valor original foi impresso e o valor foi incrementado por 1 usando o sinal "+=". Então o novo valor deve ser 1 agora. O novo valor será impresso. Em seguida, usamos novamente o operador "+=" para incrementar o valor em 30 desta vez e imprimi -lo. Salve o código e execute -o através do botão "Executar".
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = 0
impressão (x)
x += 1
impressão (x)
x += 30
impressão (x)
A saída abaixo está mostrando os resultados esperados. Primeiro exibe o valor original 0 e, após o incremento de 1, imprime 1. No final, o valor 1 foi incremento em 30 e se torna 31.
Exemplo 05:
Vamos usar o incremento por 1 operador em qualquer valor de tipo de string e ver seus resultados. Primeiro de tudo, pegamos uma variável inteira "x" como fizemos no exemplo acima. A variável x tem um valor original de 0. Seu valor foi incrementado em 1 e depois disso até 31. Este é o mesmo caso que discutimos acima. Aí vem outra variável, "y" tendo o valor "aqsa". Em seguida, usamos o sinal "+=" para incrementar o valor da variável "y" com 1. Logicamente, está errado porque o valor inteiro não pode ser incremento no valor da string. Então, devemos receber um erro ao executar este código. Então, salve seu código e execute -o.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = 0
impressão (x)
x += 1
impressão (x)
x += 30
impressão (x)
y = 'aqsa'
y +-1
impressão (y)
Quando imprimimos o código, o incremento realizado na variável do tipo inteiro "x" foi bem -sucedido e exibiu o valor incrementado sempre que. Mas, no caso de variável "y", ele lança uma exceção de "TypeError" dizendo que os dados do tipo de sequência só podem ser concatenados com string em vez de dados do tipo inteiro.
Vamos modificar o código e incrementar o valor inteiro "y" por um valor de tipo de string, como mostrado no código abaixo. Salve seu código e execute o arquivo para vê -los trabalhando.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = 0
impressão (x)
x += 1
impressão (x)
x +-30
impressão (x)
y = 'aqsa'
y += 'yasin'
impressão (y)
Esse tempo exibiu todos os valores incrementados, incluindo o valor de incremento do tipo de string na saída. Isso ocorre porque o sinal + pode ser tomado como concatenação para strings e não pode incrementar o valor inteiro em algum tipo de valor de string.
Exemplo 06:
Entenda que não podemos usar os operadores pré e pós-incremento ou decremento em loops "for" também. Portanto, estamos usando o operador "+=" em um tempo para imprimir os valores de uma lista.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
Lista = [12, 14, 16, 18, 20]
x = 0
enquanto (x
x += 1
Após a execução do código, temos os valores da lista um após o outro em uma sequência.
Exemplo 07:
Vamos ver o efeito do incremento em 1 em uma variável "id" desta vez. Inicializamos uma variável "x" com o valor 2 e verificamos seu "id" primeiro. Depois disso, temos que incrementá -lo em 1 e verificar seu "id" mais uma vez. Salvar e executar o código.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = 2 impressão (x)
Imprimir (id (x))
x += 1
impressão (x)
Imprimir (id (x))
Enquanto a execução do código, a saída mostra dois "IDs" diferentes antes e depois do incremento em 1. Isso significa que toda vez que aumentamos ou mudamos uma variável, sua dinâmica também muda.
# -* -Codificação: UTF -8 -*-#!/usuário/bin/python
x = y = z = 2
Imprimir (id (x))
Imprimir (id (y))
Imprimir (id (z))
x += 1
Imprimir (id (x))
Imprimir (id (y))
Imprimir (id (z))
Conclusão:
Este tutorial discutiu e viu como o post e os operadores de pré-incremento ou decréscimo falham no Python. Também vimos como usar maneiras diferentes de incrementar qualquer variável por 1. Espero que este artigo seja útil para você enquanto estiver usando Python.