Noções básicas de Python: valores, variáveis e expressões

Um programa é uma sequência de instruções. O interpretador Python lê código Python e executa essas instruções. Use Python 3, em que uma chamada como print("Hello") tem parênteses.

Experimente uma linha no interpretador interativo

O interpretador interativo, ou REPL, mostra >>> quando está pronto para receber código Python. Digite uma instrução após o prompt e pressione Enter. Você não digita o >>>.

>>> 3 + 4
7
>>> "hi"
'hi'

O interpretador interativo mostra automaticamente o valor de uma expressão. Ele coloca aspas ao redor de uma string para identificá-la como texto. Um prompt ... significa que uma instrução está incompleta e o Python está esperando mais. Por exemplo, um parêntese de abertura pode ainda precisar do correspondente de fechamento. Digite exit() em um prompt pronto para sair do interpretador interativo.

O interpretador interativo é útil para testar uma expressão. Ele pode manter um histórico de comandos, mas esse histórico não é um programa salvo. Coloque em um script as instruções que você quer executar juntas novamente.

Salve e execute um script

Um script é um arquivo de texto simples com código e extensão .py. Use um editor de código como IDLE, Thonny ou VS Code. O IDLE acompanha a distribuição padrão do Python. Um processador de texto pode trocar aspas retas por aspas curvas; essas aspas curvas não podem delimitar strings em Python.

Digite estas linhas no editor e salve o script:

print("Hello, world!")
print("Welcome to Python.")

No IDLE, escolha Run → Run Module ou pressione F5. A saída é:

Hello, world!
Welcome to Python.

O Python executa essas instruções de cima para baixo. Cada print() exibe seu texto e passa para uma nova linha. Inverter as instruções inverte a saída.

Você também pode executar um script salvo em um terminal. Abra a pasta que contém seu script e digite o comando do interpretador seguido do nome do arquivo salvo. No macOS ou Linux, o comando geralmente é python3 seguido do nome do script; no Windows, costuma-se usar python ou py. O comando do terminal inicia o interpretador e informa qual script executar. Esse comando deve ser digitado no prompt do terminal, não depois do >>> do Python. Um editor on-line pode oferecer um botão de execução.

Decida o que precisa ser exibido

Um script que contém apenas 3 + 4 calcula um valor, mas não exibe nada. Escreva print(3 + 4) para mostrar 7. Da mesma forma, print("hi") exibe o texto sem as aspas ao redor. As aspas pertencem ao código; elas marcam o início e o fim do texto.

O Python distingue maiúsculas de minúsculas. print e Print são nomes diferentes, portanto Print("hi") produz um NameError, a menos que esse outro nome tenha sido definido. Mantenha a escrita e as maiúsculas e minúsculas dos nomes embutidos exatamente como aparecem.

Espaços no início da linha também têm significado. Para essas sequências simples de instruções, comece cada instrução na margem esquerda. Uma indentação indevida antes de print("hi") pode causar IndentationError: unexpected indent. Espaços dentro do texto entre aspas são diferentes: o Python os exibe como parte da mensagem.

Um erro em um programa é um defeito. Encontrá-lo e corrigi-lo é a depuração. Primeiro identifique o tipo de problema: código que o Python não consegue ler, uma operação que falha durante a execução ou um resultado que está simplesmente errado.

Três tipos de problema

O Python verifica a sintaxe do script inteiro antes de executá-lo. Um erro de sintaxe perto do fim impede até mesmo a execução da primeira linha. Um erro em tempo de execução é diferente: as instruções anteriores já foram executadas, e sua saída continua visível.

No cálculo da média, a divisão acontece antes da adição. O Python calcula 92 / 2 como 46.0 e depois soma 88 para obter 134.0. A expressão pretendida é (88 + 92) / 2, que fornece 90.0. Não há mensagem de erro porque ambas as expressões são válidas. Um cálculo à mão fornece um resultado para comparar com o programa.

Leia um rastreamento de exceção de baixo para cima

Suponha que o código seja:

name = "Ada"
print("Hello", nme)

O rastreamento de exceção termina com uma mensagem como NameError: name 'nme' is not defined. A última linha informa o erro e explica o que falhou. Acima dela, o Python mostra a localização, o número da linha e o código. Compare nme com o nome ao qual foi atribuído um valor antes: name. Corrigir essa escrita faz a saída ser Hello Ada.

A localização indicada é onde o Python percebeu o problema. Se uma linha parecer correta, verifique também a linha anterior. Uma aspa ou um parêntese ausente antes dela pode impedir o Python de entender o que vem depois. Versões recentes frequentemente apontam diretamente para o parêntese de abertura sem par.

Deixe o tipo de erro orientar sua busca

• NameError: o Python não encontra um nome, como em pirnt, Print ou uma variável usada antes da atribuição. Verifique a escrita, as maiúsculas e minúsculas e a ordem das linhas.
• TypeError: a operação não funciona com esses tipos. "5" + 5 tenta unir texto e um número.
• ValueError: uma conversão recebe conteúdo que não pode ser usado. int("abc") recebe texto, mas o texto não descreve um inteiro.
• ZeroDivisionError: um divisor é zero. Examine o valor usado após /, // ou %.

Para um SyntaxError, associe cada aspa e parêntese de abertura ao correspondente de fechamento. print('It's late') fecha a string no apóstrofo de “It's”; use print("It's late"). Código Python 2 como print "hi" precisa de parênteses no Python 3: print("hi"). Digite novamente as aspas curvas como aspas retas. Para uma indentação inesperada, remova os espaços indevidos no início da linha.

Corrija um problema e execute novamente. A primeira falha pode ter impedido o Python de chegar a uma segunda. Construa um programa algumas linhas por vez para que cada nova falha tenha uma pequena área a examinar.

O código informa ao Python o que fazer. Um comentário informa a uma pessoa por que o código faz isso ou o que um valor significa. O Python ignora um comentário ao executar o programa.

Marque o comentário claramente

Um comentário começa com # fora de uma string e continua até o fim da linha. Ele pode ficar sozinho ou vir após uma instrução:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = 68
celsius = (fahrenheit - 32) * 5 / 9
print(celsius)  # Show the converted temperature.

O comentário em linha inteira explica a finalidade do programa. O comentário na mesma linha vem depois do código. A PEP 8, guia de estilo do Python, recomenda pelo menos dois espaços antes de um # na mesma linha e um espaço depois dele. Esse espaçamento facilita a identificação do limite.

Um símbolo de cerquilha dentro de aspas é texto comum:

print("#1 is not a comment")  # This part is a comment.

A saída é #1 is not a comment. O Python lê toda a string entre aspas, incluindo seu símbolo de cerquilha, como dados. Ele ignora o texto após o # seguinte porque esse símbolo está fora das aspas.

Explique o significado, não etapas óbvias

Compare estes comentários:

count = count + 1  # Add 1 to count.
attempts = attempts + 1  # One more failed login.

O primeiro comentário repete uma operação já visível no código. O segundo acrescenta uma razão para a alteração. Agora o leitor sabe o que uma tentativa conta. Um nome claro como attempts também faz parte do trabalho que um nome vago deixaria para os comentários.

Comentários úteis explicam uma unidade, uma escolha ou uma finalidade que o código sozinho não deixa clara. Por exemplo, tax_rate = 0.08 # 8% sales tax relaciona uma taxa decimal ao seu significado. Se você alterar essa taxa depois, verifique também o comentário. Um comentário desatualizado pode levar o leitor na direção errada mesmo quando o código funciona.

Impeça temporariamente a execução de uma linha

Para comentar uma instrução, coloque # antes dela:

print("Start")
# print("Checking this step")
print("Finish")

Somente Start e Finish aparecem. Comentar uma linha mantém essa linha disponível enquanto você testa o programa sem ela. Remova código antigo desativado quando ele não ajudar mais; caso contrário, quem o ler depois terá de adivinhar se ele ainda é necessário.

Para uma anotação que ocupa várias linhas, comece cada linha com #:

# Read the temperature in degrees Fahrenheit.
# Keep the calculation in Celsius for the next step.

Texto entre aspas triplas é diferente. Uma linha como """Convert a temperature.""" é uma expressão de string, não um comentário. Em determinadas posições, essas strings podem servir como documentação, chamada de docstring. Use # quando quiser um comentário comum. Uma string que nada utiliza pode permanecer invisível em um script, o que pode fazê-la parecer um comentário, embora o Python a leia como um valor.

Um valor é um dado, como 42, 3.5 ou "Ada". Todo valor tem um tipo, que informa ao Python que espécie de dado ele é. Um literal é um valor escrito diretamente no código. A forma como é escrito importa: 7, 7.0 e "7" têm tipos diferentes.

Quatro tipos básicos

Um ponto decimal faz de 2.0 um float, embora seu valor numérico seja igual ao inteiro 2. As aspas fazem de "42" texto, embora os caracteres pareçam um número. O tipo depende do valor escrito, não de como uma pessoa poderia usá-lo.

Literais booleanos têm a primeira letra maiúscula e não têm aspas. True é um valor booleano; "True" é uma string. true em minúsculas é um nome, e usá-lo sem defini-lo gera NameError. Uma comparação pode produzir um valor booleano: 3 < 5 é avaliado como True.

Consulte o Python sobre o tipo

A função embutida type() informa o tipo de seu argumento. No interpretador interativo, estas chamadas mostram:

>>> type(7)
<class 'int'>
>>> type(7.0)
<class 'float'>
>>> type("7")
<class 'str'>
>>> type(True)
<class 'bool'>

Em um script, use print() para ver esses resultados:

print(type(42), type("42"))

Isso exibe <class 'int'> <class 'str'>. A palavra class faz parte da informação fornecida pelo Python; os nomes int e str identificam os tipos.

Os tipos mudam o significado dos operadores

Com números, + soma. Com duas strings, ele une textos:

print(5 + 3)
print("5" + "3")

A primeira linha exibe 8. A segunda exibe 53. A segunda expressão tem dois valores de texto, portanto o Python une seus caracteres. Ele não examina os caracteres de dígitos e decide somá-los.

"5" + 5 lança TypeError: um operando é texto e o outro é um inteiro. Verifique os tipos quando uma operação se comportar de modo diferente do esperado. Em particular, a aparência de dígitos na tela não estabelece que o valor armazenado seja numérico.

Escolha um tipo de acordo com o significado

Use um inteiro para uma contagem e um float para uma medida que possa incluir uma fração. Mantenha um identificador, como um código postal dos Estados Unidos, como texto. A string "02134" preserva o zero inicial; esse zero faz parte da identidade do código, não de um cálculo. Números de telefone também podem conter pontuação que vale a pena preservar.

O interpretador interativo pode mostrar 'Ada', enquanto print("Ada") mostra Ada. Ambos se referem ao mesmo texto. As aspas do interpretador identificam uma string; print() apresenta os caracteres para um leitor. Nenhuma das exibições altera o tipo armazenado.

O Python tem tipos separados para números inteiros e números de ponto flutuante. Escrevê-los claramente evita tanto erros de sintaxe quanto alterações menos óbvias nos dados.

Escreva contagens como inteiros

Um número inteiro não tem parte fracionária. Escreva um int sem ponto decimal, como em 42, 0 ou -7. Os inteiros do Python podem crescer até o limite da memória disponível, sem limite fixo de tamanho. Adição, subtração e multiplicação de inteiros são exatas. Por exemplo, 2 ** 100 fornece o inteiro exato 1267650600228229401496703205376.

Não use vírgulas para agrupar milhares. Escreva 1000000 ou use sublinhados para facilitar a leitura: 1_000_000. Os sublinhados não alteram o valor.

Um literal inteiro decimal diferente de zero não pode começar com zero. Escrever 02134 causa um erro de sintaxe. Se esses dígitos forem um identificador cujo zero inicial importa, escreva "02134" como texto.

Escreva quantidades fracionárias como floats

Um float usa ponto decimal ou notação com expoente. 3.5, 2.0 e -0.25 são floats. O Python também aceita .5 e 5., que significam 0.5 e 5.0; escrever o zero adicional muitas vezes facilita a leitura. Use floats para medidas como temperatura ou distância e para cálculos introdutórios com preços fracionários.

O código Python usa ponto decimal. Uma vírgula separa valores; ela nunca marca a parte fracionária. Por exemplo:

x = 3.5
print(x)

exibe 3.5, enquanto x = 3,5 cria um par de valores, exibido como (3, 5). Da mesma forma, x = 1,000 cria (1, 0), não mil. Essas instruções podem ser executadas, portanto a ausência de mensagem de erro não significa que o número foi escrito corretamente.

Use notação científica

A letra e significa “vezes dez elevado a” em um literal numérico:

Um literal com expoente é um float mesmo quando seu valor é um número inteiro. O sinal de menos após e indica um expoente negativo, portanto 2.5e-3 significa 2,5 dividido por 1.000.

Espere precisão limitada

Floats armazenam números em binário com precisão limitada, normalmente cerca de 15 a 17 dígitos decimais significativos. Muitas frações decimais, incluindo 0.1, não têm representação exata nesse armazenamento. Como resultado:

print(0.1 + 0.2)
print(round(0.1 + 0.2, 2))

exibe 0.30000000000000004 e depois 0.3. A pequena diferença vem das aproximações armazenadas. round(..., 2) arredonda o resultado para duas casas decimais para exibição; ele não muda a forma como floats armazenam valores. Mantenha o cálculo original até o fim e depois arredonde o resultado exibido.

Um sinal também pode ser um operador. O menos unário muda o sinal de um valor: -7 é menos sete. Em 5 - -3, o primeiro sinal de menos subtrai e o segundo produz menos três, portanto o resultado é 8. Distinga esse sinal do expoente negativo em um literal como 2.5e-3.

Uma string é uma sequência de caracteres: letras, dígitos, espaços, sinais de pontuação e outros símbolos. As aspas informam ao Python onde essa sequência começa e termina. Os caracteres dentro delas são dados, mesmo que pareçam código Python.

Escolha aspas correspondentes

Aspas simples e aspas duplas criam o mesmo tipo, str. Tanto 'Ada' quanto "Ada" contêm os mesmos três caracteres. Comece e termine uma string com o mesmo tipo de aspa.

Escolha as aspas externas para facilitar a escrita de uma aspa interna:

print("It's late")
print('She said "hi"')

A saída é:

It's late
She said "hi"

Em print('It's late'), o apóstrofo depois de It fecha a string antes da hora. O Python então não consegue ler o restante da instrução. Usar aspas duplas externas mantém o apóstrofo dentro do texto.

Use uma sequência de escape

Uma barra invertida inicia uma sequência de escape. Cada uma dessas sequências comuns representa um caractere:

Por exemplo, print("Line 1\nLine 2") exibe duas linhas. A barra invertida e o n no código representam juntos uma quebra de linha, não uma letra n visível. Da mesma forma, print('It\'s late') exibe It's late: a aspa com escape torna-se um caractere sem encerrar a string.

Para exibir uma barra invertida literal seguida de uma letra, escreva a barra invertida duas vezes. print("A\\B") exibe A\B. A primeira barra invertida indica que a próxima deve ser um caractere.

Mantenha quebras de linha ou nenhum caractere

Aspas triplas permitem que uma string ocupe várias linhas físicas. As quebras de linha passam a fazer parte de seu valor:

print("""Line one
Line two""")

Isso exibe Line one e Line two em linhas separadas. Aspas simples triplas também funcionam. Aspas triplas ainda criam uma string; elas não criam um comentário com #.

A string vazia, "", não tem caracteres. Ela é diferente de " ", que contém um espaço. Esse espaço pode ser difícil de ver na saída, mas continua fazendo parte dos dados.

Distinga texto de uma expressão ou nome

Compare estas instruções:

name = "Ada"
print("3 + 4")
print(3 + 4)
print("name")
print(name)

A saída é 3 + 4, depois 7, depois name e depois Ada. As aspas tornam o primeiro e o terceiro argumentos textos literais. Sem aspas, o Python avalia um cálculo ou procura uma variável.

Esquecer as aspas em uma mensagem como Hello faz o Python procurar um nome. Se Hello não tiver sido definido, print(Hello) lança NameError. Escreva print("Hello") quando quiser essa palavra.

Strings podem conter caracteres de muitos idiomas e símbolos como "café", "naïve" e "°F". Dígitos podem aparecer junto deles: "Room 101" é inteiramente texto. Um caractere de dígito entre aspas não se torna um inteiro.

Uma variável é um nome que se refere a um valor na memória. Uma instrução de atribuição associa um nome à esquerda de = ao valor de uma expressão à direita.

Leia primeiro o lado direito

Em age = 30, o Python avalia 30 e depois faz age referir-se a esse inteiro. O lado esquerdo deve ser um lugar válido para atribuir um valor. 30 = age é um erro de sintaxe: você não pode atribuir um novo valor ao literal 30.

O sinal = significa “atribuir”. Ele não pergunta se dois valores são iguais. O teste de igualdade usa ==. Ler a atribuição como uma direção de trabalho torna compreensíveis instruções como x = x + 1: use o valor antigo de x à direita, calcule o novo valor e depois atribua-o a x à esquerda.

Considere um retângulo:

width = 4
height = 2.5
area = width * height
print(area)

Após a primeira linha, width refere-se a 4. Após a segunda, height refere-se a 2.5. Na terceira linha, o Python consulta os dois valores atuais e avalia 4 * 2.5, produzindo 10.0. Ele atribui esse resultado a area. A última linha exibe 10.0.

A atribuição em si não exibe o valor. Use o nome em uma chamada posterior de print() quando quiser exibi-lo.

Atribua um valor antes de usar um nome

O Python segue a ordem das instruções. Este código falha na primeira linha:

print(total)
total = 10

Nesse ponto, total não tem valor. A atribuição posterior não pode fornecer um valor a uma instrução anterior. Mova total = 10 para antes de print(total).

Um interpretador interativo pode manter nomes de experimentos anteriores. Um programa salvo deve fornecer as atribuições necessárias em sua própria ordem de execução, para que seu resultado não dependa do que você digitou antes.

Reatribua um nome existente

A reatribuição faz um nome referir-se a um novo valor:

score = 10
score = 15

Agora score é 15; o 10 anterior não é mais acessível por esse nome. Para uma atualização baseada no valor antigo:

x = 3
x = x + 1

A segunda linha avalia 3 + 1 e depois atribui 4 a x. Não há uma equação a resolver nem uma contradição.

Um tipo pertence ao valor, não permanentemente ao nome da variável. O Python permite temp = 3 seguido de temp = "three"; depois disso, type(temp) informa str. Manter consistentes o significado e o tipo esperado de um nome geralmente torna um programa mais fácil de acompanhar.

Um valor copiado não é uma ligação futura

a = 5
b = a
a = 10
print(a, b)

Isso exibe 10 5. Em b = a, ambos os nomes se referem ao inteiro atual 5. Reatribuir a altera o valor ao qual a se refere; b continua referindo-se a 5. Da mesma forma, armazenar width * height salva seu resultado, não uma fórmula que se atualiza quando width muda.

Uma instrução pode atribuir valores a vários nomes. a = b = 0 dá a ambos os nomes o valor 0. Em x, y = 1, 2, os valores correspondem aos nomes pela posição, fazendo x ser igual a 1 e y ser igual a 2.

Um nome precisa atender à gramática do Python e ajudar uma pessoa a entender o programa. São verificações distintas: o Python pode aceitar um nome que ainda torna o código difícil de ler.

Siga as regras de nomenclatura

Um nome de variável pode conter letras, dígitos e sublinhados. Ele não pode começar com um dígito, conter um espaço ou usar sinais de pontuação como um hífen.

O Python também aceita letras de outros alfabetos. Letras inglesas são uma escolha comum para identificadores. Quaisquer que sejam as letras escolhidas, mantenha a escrita consistente: age, Age e AGE são três nomes diferentes. Atribuir age = 30 não define Age.

Distinga palavras reservadas de nomes embutidos

Uma palavra reservada é reservada para a gramática do Python. Você não pode usá-la como nome de variável. As palavras estritamente reservadas são:

False None True and as assert async await break class
continue def del elif else except finally for from
global if import in is lambda nonlocal not or pass
raise return try while with yield

Você não precisa memorizar a lista antes de escrever um programa. Por enquanto, reconheça que um nome como class não está disponível: class = 3 é um erro de sintaxe. Os editores costumam mostrar palavras reservadas em uma cor especial.

Nomes de funções embutidas, incluindo print, input, int, str, type, sum e max, não são palavras reservadas. O Python permite atribuir valores a eles, mas essa atribuição oculta a função original:

print = 5
print("hi")

A segunda linha tenta chamar o inteiro 5 e lança TypeError. Escolha um nome que descreva seus dados, como total, para que a função embutida continue disponível. Reiniciar o interpretador interativo desfaz substituições acidentais feitas durante experimentos.

Escreva nomes em um estilo consistente

A PEP 8 recomenda snake_case para nomes de variáveis: palavras em minúsculas unidas por sublinhados, como em hourly_rate e first_name. O sublinhado mantém unido um nome de várias palavras sem usar espaços.

Uma constante é um valor que você pretende manter inalterado. Por convenção, seu nome usa letras maiúsculas:

SALES_TAX_RATE = 0.08

O Python não bloqueia esse nome. Uma atribuição posterior pode alterá-lo; as letras maiúsculas comunicam uma intenção ao leitor.

Inclua significado e unidades

hours_worked = 38 informa mais que h = 38. Um nome como distance_miles ou temp_f também identifica a unidade, reduzindo a chance de usar milhas como se fossem quilômetros ou Fahrenheit como se fosse Celsius. Nomes curtos como x e y funcionam bem para coordenadas ou uma fórmula breve em que seus significados já estejam claros.

Evite nomes quase idênticos, como total e totl. Um erro de digitação pode produzir um NameError ou usar acidentalmente outra variável existente. A PEP 8 também desaconselha as letras isoladas l, O e I, que podem parecer dígitos. Algumas letras a mais podem tornar um cálculo muito mais fácil de examinar.

Uma atualização usa o valor atual de uma variável para calcular o próximo. Acompanhar cada atualização em ordem permite prever a saída e encontrar erros de lógica antes de executar o programa.

Atribua um valor inicial antes de atualizá-lo

count = count + 1 soma um à contagem anterior. Essa mudança é um incremento. Uma variável que guarda um total acumulado é um acumulador; dê a ela um valor inicial, como total = 0, antes de somar quantidades.

A atribuição aumentada combina uma operação com uma atribuição. Para números, x += 3 tem o mesmo efeito que x = x + 3. As formas disponíveis incluem +=, -=, *=, /=, //=, %= e **=.

score = 10
score -= 3
score **= 2
print(score)

A subtração altera score para 7. A potência então o altera para 49, que é exibido. Sem a atribuição inicial, uma atualização tentaria usar um nome indefinido e lançaria NameError.

O operador escolhido também afeta o tipo. Começando com n = 7, n /= 2 produz o float 3.5. Começando novamente com n = 7, n //= 2 produz o inteiro 3. O Python não tem operador de incremento ++: x++ é inválido. Escrever ++x aplica o mais unário duas vezes e não atualiza x; use x += 1.

Rastreie uma instrução por vez

Uma tabela de rastreamento registra os valores das variáveis após cada instrução. Escreva uma coluna por variável e uma linha por etapa:

price = 20
quantity = 3
total = price * quantity
price = 25
total += 5
print(total, price)

A saída é 65 25. Alterar price não repetiu a multiplicação anterior. A variável total guardava o valor calculado 60; ela não era uma fórmula de planilha vinculada a price. Somente sua própria atualização posterior alterou seu valor para 65.

Para rastrear à mão, avalie o lado direito usando a linha imediatamente acima e depois atualize o nome que recebe a atribuição. Deixe todas as outras colunas inalteradas. Compare a previsão com a saída real do programa.

Preserve os dois valores em uma troca

Suponha a = 1 e b = 2. A tentativa a = b seguida de b = a fornece 2 2. A primeira atribuição perde o acesso ao valor original de a por esse nome, portanto a segunda linha copia o novo valor de volta.

Uma variável temporária mantém o valor original disponível:

a = 1
b = 2
temp = a
a = b
b = temp
print(a, b)

Isso exibe 2 1. Você também pode escrever a, b = b, a. O Python avalia os dois valores à direita antes de atribuir qualquer um dos nomes à esquerda, portanto os dois valores originais ficam disponíveis para a troca. Rastreie a versão com variável temporária quando quiser ver exatamente onde cada valor original é preservado.

Uma expressão é avaliada para produzir um valor. Ela pode ser um único literal, uma variável ou uma combinação como 2 + 3. O + é um operador; os valores sobre os quais ele atua são seus operandos.

Escolha o operador

Os operadores aritméticos do Python funcionam da seguinte forma:

Escreva a multiplicação explicitamente com *. A notação matemática 2x não funciona como multiplicação em Python. Escreva 2 * x ou 2 * (x + 1). Com x = 1, 2(x + 1) tenta chamar o inteiro 2 como se fosse uma função e lança TypeError.

O operador de potenciação é **, não ^. Por exemplo, 7 ** 2 é 49, enquanto 7 ^ 2 é 5, pois o acento circunflexo executa outra operação. Portanto, um programa pode ser executado e calcular um resultado que você não pretendia.

Preveja o tipo e também o número

A divisão com / fornece um float para operandos inteiros mesmo quando a divisão é exata: 6 / 2 é 3.0. Para uma contagem inteira de grupos completos, use //: 6 // 2 é 3.

Com dois operandos inteiros, adição, subtração, multiplicação, divisão com arredondamento para baixo e resto fornecem resultados inteiros. Potências com expoentes inteiros não negativos também: 2 ** 10 fornece o inteiro exato 1024. Um expoente negativo muda isso: 2 ** -1 fornece o float 0.5.

Na aritmética comum com um inteiro e um float, o cálculo usa valores de ponto flutuante. 3 + 4.0 fornece 7.0; 7.0 // 2 fornece 3.0. A divisão com arredondamento para baixo descreve como o quociente é arredondado, não garante que seu tipo seja sempre int.

Uma potência fracionária pode calcular uma raiz de um número positivo. 4 ** 0.5 fornece 2.0, e 2 ** 0.5 fornece aproximadamente 1.4142135623730951.

Construa um cálculo com valores nomeados

Um carro percorre 287 milhas usando 10,25 galões:

miles = 287
gallons = 10.25
mpg = miles / gallons
print("Miles per gallon:", mpg)

A divisão calcula 28.0, portanto a saída é Miles per gallon: 28.0. Os nomes identificam as quantidades, e o rótulo exibido identifica a unidade do resultado. Multiplicar 28.0 * 10.25 recupera 287 milhas, permitindo verificar a divisão.

Um divisor zero causa falha em /, // e %. Por exemplo, 10 / 0 lança ZeroDivisionError. Examine a variável usada como divisor quando esse erro ocorrer.

Espaços ao redor dos operadores não mudam seu significado: 2+3 e 2 + 3 fornecem 5. Espaços ao redor de = e da maioria dos operadores facilitam a leitura das partes. Eles não podem substituir um operador; 2 x continua não significando multiplicação.

O Python não calcula uma expressão simplesmente da esquerda para a direita. A precedência determina quais operações acontecem primeiro. Os parênteses permitem escolher um agrupamento diferente ou tornar claro o agrupamento pretendido.

Aplique os níveis em ordem

Para os operadores apresentados aqui, use esta ordem:

1. Expressões entre parênteses.
2. Potências, **.
3. Sinais unários, como o menos em -x.
4. Operações de multiplicação e divisão: *, /, //, %.
5. Adição e subtração: +, -.

Para 3 + 4 * 2 ** 2, avalie 2 ** 2 para obter 4. A expressão torna-se 3 + 4 * 4. A multiplicação fornece 16, e a adição fornece 19. Com (3 + 4) * 2 ** 2, a soma entre parênteses é 7; a potência é 4; o produto é 28.

Os operadores no nível de multiplicação e divisão têm a mesma prioridade. Calcule da esquerda para a direita: 8 / 2 * 4 significa (8 / 2) * 4, fornecendo 16.0. A multiplicação não passa à frente da divisão. Da mesma forma, 100 / 10 / 5 fornece 2.0, e 10 - 4 - 3 fornece 3.

Trate potências e sinais com cuidado

Potências repetidas são agrupadas da direita para a esquerda. 2 ** 3 ** 2 significa 2 ** (3 ** 2). Primeiro 3 ** 2 fornece 9; depois 2 ** 9 fornece 512. Agrupar pela esquerda forneceria 64, um resultado diferente.

Um sinal de menos inicial é aplicado depois de uma potência que vem a seguir: -2 ** 2 significa -(2 ** 2) e fornece -4. Em (-2) ** 2, os parênteses fazem de menos dois a base, portanto o resultado é 4. Um sinal de menos depois de ** pode pertencer ao expoente: 2 ** -1 fornece 0.5.

Traduza todo o agrupamento de uma fórmula

Uma média exige somar os dois valores antes de dividir por dois:

average = (88 + 92) / 2

A soma é 180, e a divisão fornece 90.0. Sem parênteses, 88 + 92 / 2 divide apenas 92 e fornece 134.0.

Uma barra de fração também agrupa tudo acima e abaixo dela. Um numerador que contém a + b e um denominador que contém c + d tornam-se (a + b) / (c + d). Omitir qualquer um dos pares pode mudar quais termos são divididos.

A mesma questão aparece em uma conversão de temperatura:

celsius = (98.6 - 32) * 5 / 9

A subtração fornece 66.6, a multiplicação fornece 333.0, e a divisão fornece 37.0. Sem o agrupamento, 98.6 - 32 * 5 / 9 fornece 80.82222222222222.

Use os sinais de agrupamento adequados

Parênteses agrupam uma expressão. Colchetes e chaves têm outros significados em Python. Por exemplo, [2 + 3] * 4 produz [5, 5, 5, 5], não 20.

Parênteses ao redor de uma operação que já aconteceria primeiro mantêm o resultado inalterado: (2 * 3) + 1 e 2 * 3 + 1 fornecem 7. Parênteses que alteram o agrupamento podem alterar o valor: 2 * (3 + 1) fornece 8. Acrescente agrupamentos onde tornarem mais fácil entender o significado do cálculo.

A divisão com arredondamento para baixo e o resto respondem a duas perguntas relacionadas: quantos grupos completos cabem e o que resta depois de formá-los. Para quantidades inteiras não negativas, o par é útil para tempo, dinheiro, embalagem e dígitos.

Encontre o quociente e o resto juntos

17 // 5 fornece 3, o número de grupos completos de cinco. 17 % 5 fornece 2, a quantidade que sobra. Os dois resultados reconstituem a quantidade inicial:

print((17 // 5) * 5 + 17 % 5)

A expressão fornece 17: três grupos de cinco mais dois. De modo mais geral, para inteiros e um divisor diferente de zero, (a // b) * b + a % b é igual a a. Use essa relação para verificar as duas respostas.

Divida quantidades reais

Para 135 minutos:

hours = 135 // 60
minutes = 135 % 60

Há 2 horas completas e 15 minutos restantes. O divisor é 60 porque uma hora contém 60 minutos. A divisão com / fornece 2.25, que expressa horas fracionárias; ela não fornece separadamente os minutos restantes.

A mesma estrutura funciona com outro tamanho de grupo:

A contagem de caixas é o número de caixas completas. Se você também precisar de um recipiente para os ovos restantes, essa é uma pergunta diferente de quantos grupos completos cabem.

Use valor posicional e paridade

Para um inteiro positivo, dividir por dez separa seu último dígito. 1234 % 10 fornece 4, e 1234 // 10 fornece 123. Recombinar 123 * 10 + 4 recupera 1234.

Para qualquer inteiro n, n % 2 é 0 quando ele é par e 1 quando é ímpar. Isso também funciona para negativos: -7 % 2 é 1. Para inteiros e um divisor positivo b, o resto está no intervalo de 0 até b - 1.

Entenda a divisão com números negativos

A divisão com arredondamento para baixo arredonda em direção ao infinito negativo, não em direção a zero. Como menos sete dividido por dois é -3,5, -7 // 2 fornece -4. O resto então é 1, pois -4 * 2 + 1 é igual a -7.

Um resto diferente de zero tem o sinal do divisor. Com um divisor negativo, 7 % -2 fornece -1, e 7 // -2 fornece -4. Eles ainda reconstituem o original: -4 * -2 + -1 é 7.

Isso difere de converter um quociente com int(): int(-7 / 2) fornece -3 porque a conversão trunca em direção a zero.

Ambos os operadores também aceitam floats. 7.5 // 2 é 3.0, e 7.5 % 2 é 1.5. Eles compartilham o nível de precedência de * e /, portanto 5 * 3 + 17 % 5 fornece 17. O operador % aqui significa resto, não porcentagem: calcule 8 por cento de um preço com price * 0.08 ou price * 8 / 100.

O símbolo de um operador é apenas parte de seu significado. O Python também usa os tipos de seus operandos. Os operadores + e * funcionam com strings, mas nesse caso executam operações de texto.

Una strings com o sinal de mais

A concatenação une uma string ao final de outra:

print("ab" + "cd")
print("Hello" + "Ada")
print("Hello " + "Ada")

Essas linhas exibem abcd, HelloAda e Hello Ada. A concatenação não acrescenta espaço por conta própria. O espaço no terceiro resultado vem do último caractere de "Hello ".

Caracteres de dígitos seguem a mesma regra: "5" + "3" fornece a string "53". Sem aspas, 5 + 3 fornece o inteiro 8. Escolha valores numéricos quando quiser fazer aritmética e strings quando quiser trabalhar com texto.

Repita uma string com multiplicação

Uma string multiplicada por um inteiro repete seus caracteres. "3" * 2 fornece "33", enquanto 3 * 2 fornece 6. A contagem de repetições pode ficar em qualquer um dos lados: 3 * "ab" fornece "ababab". Repetir zero vezes fornece a string vazia, portanto "ab" * 0 é "".

Uma contagem de repetições deve ser um inteiro. "ab" * 2.5 lança TypeError, assim como "ab" * "cd". Não há número fracionário de cópias nessa operação.

Combine operações em ordem

A multiplicação tem precedência maior que a adição também nessas expressões:

print("-" * 4 + "Menu" + "-" * 4)

Primeiro, cada repetição cria "----". Depois, as adições unem as três strings, produzindo ----Menu----. A ordem das concatenações preserva a ordem de seus caracteres.

Para um cálculo que se torna parte de uma string:

print("7" + str(3 * 2))

A operação aritmética interna fornece o inteiro 6. str(6) cria a string "6". Por fim, a concatenação produz "76". Ela não produz 13, pois o + final tem duas strings como operandos.

Resolva incompatibilidades de tipos de forma intencional

"Age: " + 30 lança TypeError. Converta o inteiro antes de concatenar:

print("Age: " + str(30))

Isso produz Age: 30. Como alternativa, print("Age:", 30) exibe os dois valores com um espaço entre eles. Esse é o comportamento de print() com argumentos separados, não uma adição de textos.

Inteiros e floats podem ser misturados na aritmética comum: 2 * 3.0 fornece o float 6.0. O Python não transforma da mesma forma uma string numérica em número durante +. Se você precisar fazer cálculos com "30", converta-a primeiro para um tipo numérico.

A subtração não funciona com esses operandos de string. "10" - 3 lança TypeError, embora os caracteres 10 possam descrever um número. Para prever uma expressão com tipos diferentes, identifique o tipo de cada operando, avalie as operações de maior prioridade e verifique novamente os tipos na operação seguinte. Uma conversão pode mudar a regra seguida pelo próximo operador.

A conversão de tipo, também chamada de casting, cria um valor de outro tipo. As funções int(), float() e str() permitem escolher a forma necessária para a próxima operação.

Guarde o resultado convertido

x = "42"
int(x)
print(type(x))

Isso ainda exibe <class 'str'>. A conversão criou um inteiro, mas nenhuma atribuição o guardou. Escreva x = int(x) para fazer x referir-se a esse inteiro ou atribua-o a outro nome quando quiser manter as duas formas.

Escolha uma conversão numérica

int() aceita uma string que representa um inteiro, incluindo um sinal opcional e espaços ao redor. int("42"), int("-12") e int(" 42 ") produzem 42, -12 e 42.

Um ponto decimal em uma string impede a conversão direta em inteiro. int("3.5") e int("4.0") lançam ValueError; o mesmo ocorre com int("abc") e int(""). O fato de 4,0 ser matematicamente inteiro não faz de "4.0" uma string na forma de inteiro.

float() aceita texto decimal e notação com expoente. float("3.5") fornece 3.5, float("3") fornece 3.0, e float("1e3") fornece 1000.0. Ele também converte inteiros: float(7) fornece 7.0. Uma vírgula decimal causa falha: float("3,5") lança ValueError.

Trunque ou arredonde de propósito

Converter um float em int descarta sua parte fracionária em direção a zero. int(3.99) fornece 3, e int(-3.99) fornece -3. Isso não escolhe o inteiro mais próximo. Para converter texto decimal e depois truncar, use int(float("3.5")), que fornece 3.

round() escolhe um valor mais próximo. round(3.7) fornece o inteiro 4; round(3.14159, 2) fornece o float 3.14. O segundo argumento determina as casas decimais.

Em um ponto exatamente intermediário, o Python escolhe o vizinho par: round(2.5) fornece 2, enquanto round(3.5) fornece 4. Frações decimais armazenadas como floats podem não ser valores exatamente intermediários. round(2.675, 2) fornece 2.67 devido à sua representação binária.

Essas operações respondem a perguntas diferentes. Escolha a operação que corresponda ao resultado pretendido, especialmente quando valores negativos forem possíveis.

Converta em texto para concatenar

str(42) produz "42", e str(3.0) produz "3.0". Após a conversão, + une seus caracteres:

print("7" + "3")
print(int("7") + int("3"))
print(str(7) + str(3))
print(float("7") + 3)

As saídas são 73, 10, 73 e 10.0. As conversões determinam se o + final recebe texto ou números.

Um ValueError aponta conteúdo inadequado para uma conversão, como em int("abc"). Um TypeError aponta uma operação incompatível com seus operandos, como "5" + 5. Use essa diferença para decidir se deve examinar o texto de entrada ou mudar a operação.

print() exibe valores para uma pessoa ler. Seus argumentos são os valores ou expressões dentro de seus parênteses. Vírgulas separam os argumentos; o Python os avalia antes de exibir seus resultados.

Exiba valores com rótulos úteis

print("Total:", 5)
print(3 + 4)
print("3 + 4")

As linhas mostram Total: 5, 7 e 3 + 4. Um rótulo informa ao leitor o significado de um valor. Um cálculo sem aspas é avaliado; uma expressão entre aspas é exibida como texto.

Por padrão, print() coloca um espaço entre os argumentos e termina com uma nova linha. Ele converte cada valor para exibição, portanto print("Total:", 5) pode misturar texto e um inteiro sem um str() explícito.

Compare print("Total:" + str(5)), que exibe Total:5. Aqui o + constrói uma string antes que print() a receba. A concatenação não fornece espaço automático, e há apenas um argumento a exibir.

Defina o separador

O argumento nomeado sep define o texto colocado entre os argumentos:

print("a", "b", sep="-")
print(1, 2, 3, sep=", ")
print("A", 12, sep="")

A saída é:

a-b
1, 2, 3
A12

Use o nome sep. Escrever print("a", "b", "-") fornece um terceiro valor, portanto o resultado é a b -. Um separador vazio une diretamente os argumentos exibidos; ele não remove espaços que já estejam dentro de suas strings.

Defina o terminador

O argumento nomeado end altera o que vem depois do último valor. Por padrão, é uma nova linha. Um terminador vazio mantém a próxima saída na mesma linha:

print("a", end="")
print("b")

Isso mostra ab em uma linha. Você pode incluir pontuação e uma nova linha juntos:

print("Hello,", "Ada", end="!\n")

A saída é Hello, Ada! seguida de uma nova linha. sep se aplica entre argumentos de uma chamada; end se aplica depois do argumento final dessa chamada. Eles controlam posições diferentes.

Acrescente quebras de linha e escolha a precisão exibida

Chamar print() sem argumentos exibe uma linha vazia. Um \n dentro de uma string cria uma quebra de linha nessa string, como em print("Line 1\nLine 2"). Texto repetido pode formar um separador: print("=" * 20) exibe vinte sinais de igual.

O Python exibe um float em uma forma curta que representa seu valor armazenado. print(1 / 3) mostra 0.3333333333333333. Para exibir um valor arredondado, calcule-o primeiro dentro da chamada: print(round(1 / 3, 2)) mostra 0.33.

O arredondamento não garante um número fixo de casas decimais visíveis. round(2.50, 2) é exibido como 2.5, pois o float não armazena zeros finais como uma instrução de exibição. Use a saída exatamente como o Python a produz ao verificar um programa.

input() exibe uma mensagem de solicitação de entrada, espera alguém digitar e pressionar Enter e depois retorna o texto digitado como uma string sem o Enter. Um programa curto e completo lê os dados necessários, processa-os e exibe um resultado.

Leia texto e converta números

name = input("What is your name? ")
print("Hello", name)

O espaço no final da mensagem separa a resposta digitada da pergunta. A variável armazena o texto exatamente como texto, mesmo quando o usuário digita dígitos. Digitar 30 em input() produz "30", não o inteiro 30.

Escolha uma conversão antes de fazer cálculos aritméticos:

age = int(input("Age in whole years: "))
print("Next year:", age + 1)

O input() interno é executado primeiro. Se o usuário digitar 30, ele retorna "30"; int() converte esse valor em 30; a atribuição guarda o inteiro. A adição então produz 31.

Use float(input(...)) quando valores fracionários forem permitidos. Uma mensagem deve dizer que tipo de resposta é esperado. Inserir 2.5 ou thirty para uma conversão com int() lança ValueError. Inserir 98,6 para uma conversão com float() também falha; o separador decimal deve ser um ponto.

A falta de conversão nem sempre lança um erro. Se duas chamadas de entrada receberem 5 e 3, seus valores não convertidos são somados como strings e produzem 53. Ambos os operandos têm um tipo que aceita +, mas essa é a operação errada para somar quantidades.

Acompanhe um cálculo completo

O padrão entrada–processamento–saída facilita a análise das etapas principais:

# Convert a temperature from Fahrenheit to Celsius.
fahrenheit = float(input("Temperature in °F: "))
celsius = (fahrenheit - 32) * 5 / 9
print(fahrenheit, "°F is", round(celsius, 1), "°C")

Com a entrada 98.6, o programa lê o float 98.6. Ele subtrai 32 para obter 66.6, multiplica por 5 para obter 333.0 e divide por 9 para obter 37.0. A linha exibida é 98.6 °F is 37.0 °C. A entrada 50 torna-se 50.0, portanto a linha é 50.0 °F is 10.0 °C.

Aqui está um programa com dados inteiros:

total_minutes = int(input("Enter a whole number of minutes: "))
hours = total_minutes // 60
minutes = total_minutes % 60
print("Hours:", hours, "Minutes:", minutes)

A entrada 135 produz Hours: 2 Minutes: 15. Os rótulos funcionam para resultados zero, um e maiores sem alterar o texto. As duas linhas de processamento usam o mesmo total original; atribuir um valor a hours não remove nada de total_minutes.

Teste valores comuns e valores limite

Escolha entradas com respostas que você possa calcular à mão. Para o programa de temperatura, 32 deve produzir 0.0 °C e 212 deve produzir 100.0 °C. Para minutos, teste 0, 59 e 60: eles verificam o valor inicial e a passagem de nenhuma hora completa para uma hora completa.

Teste também um valor típico como 135. Compare os rótulos exatos, o espaçamento, os resultados numéricos e os tipos com sua previsão. Se o código for executado, mas o resultado estiver errado, rastreie os valores armazenados e a ordem das operações. Se uma conversão falhar, examine o texto digitado e o tipo solicitado pela mensagem.