Para ser útil, um programa geralmente precisa se comunicar com o mundo externo obtendo dados de entrada do usuário e exibindo os dados do resultado de volta para o usuário. Este tutorial apresentará a entrada (input) e saída (output) do Python.
A entrada pode vir diretamente do usuário através do teclado ou de alguma fonte externa, como um arquivo ou banco de dados. A saída pode ser exibida diretamente no console ou IDE, na tela por meio de uma interface gráfica do usuário (GUI) ou novamente em uma fonte externa.
Leitura de entrada do teclado
Os programas geralmente precisam obter dados do usuário, geralmente por meio de entrada do teclado. A maneira mais simples de realizar isso em Python é com input().
input([<prompt>])
input() lê uma linha de entrada do teclado.
input() pausa a execução do programa para permitir que o usuário digite uma linha de entrada do teclado. Quando o usuário pressiona a tecla Enter, todos os caracteres digitados são lidos e retornados como uma string:
>> p = input()
Olá mundo!
>> p
‘Olá mundo!’
>>
Observe que a nova linha gerada quando o usuário pressiona a tecla Enter não é incluída como parte da string de retorno.
Se você incluir o argumento opcional <prompt>, o input() o exibirá como um prompt para o usuário antes de pausar para ler a entrada:
>> nome = input(“Qual é o seu nome? “)
Qual é o seu nome? Louis
>> nome
‘Louis’
input() sempre retorna uma string. Se você quer um tipo numérico, então você precisa converter a string para o tipo apropriado com as funções internas int(), float() ou complex():
>> n = input(“Digite um número: “)
Digite um número: 50
>> print(n + 100)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
TypeError: can only concatenate str (not “int”) to str
>> n = int(input(“Digite um número: “))
Digite um número: 50
>> print(n + 100)
150
No exemplo acima, a expressão (n + 100) na linha 3 é inválida porque “n” é uma string e 100 é um inteiro. A linha 8 converte “n” em um inteiro, portanto a instrução print() na linha 10 é bem-sucedida.
Escrevendo saída para o console
Além de obter dados do usuário, um programa geralmente também precisará apresentar dados de volta ao usuário. Você pode exibir dados do programa no console em Python com print().
Saída de console não formatada
Para exibir objetos no console, passe-os como uma lista de argumentos separados por vírgula para print().
print(<obj>, …, <obj>)
print() exibe uma representação de string para cada <obj> para o console.
Por padrão, print() separa cada objeto por um único espaço e acrescenta uma nova linha ao final da saída:
>> pnome = “Louis”
>> snome = “Wolkers”
>> print(“Nome:”, pnome, snome)
Nome: Louis Wolkers
Qualquer tipo de objeto pode ser especificado como um argumento para print(). Se um objeto não for uma string, o print() o converterá em uma representação de string apropriada, exibindo-o:
>> a = [1, 2, 3]
>> type(a)
<class ‘list’>
>> b = -12
>> type(b)
<class ‘int’>
>> c = {“foo”: 1, “bar”: 2}
>> type(c)
<class ‘dict’>
>> type(len)
<class ‘builtin_function_or_method’>
>> print(a, b, c, len)
[1, 2, 3] -12 {‘foo’: 1, ‘bar’: 2} <built-in function len>
Como você pode ver, até mesmo tipos complexos como listas, dicionários e funções podem ser exibidos no console com print().
Argumentos de palavras-chave para o print()
print() possui alguns argumentos adicionais que fornecem controle modesto sobre o formato da saída. Cada um deles é um tipo especial de argumento chamado argumento de palavra-chave (keyword argument).
O Argumento de palavras-chave sep=
Adicionar o argumento da palavra-chave sep=<str> faz com que os objetos sejam separados pela string <str> em vez do espaço único padrão:
>> print(‘foo’, 42, ‘bar’)
foo 42 bar
>> print(‘foo’, 42, ‘bar’, sep=’/’)
foo/42/bar
>> print(‘foo’, 42, ‘bar’, sep=’…’)
foo…42…bar
>> d = {‘foo’: 1, ‘bar’: 2, ‘baz’: 3}
>> for k, v in d.items():
… print(k, v, sep=’ -> ‘)
…
foo -> 1
bar -> 2
baz -> 3
Para colocar objetos juntos sem qualquer espaço entre eles, especifique sep=”:
>> print(‘foo’, 42, ‘bar’, sep=”)
foo42bar
Você pode especificar qualquer string arbitrária como separador com a palavra-chave sep=.
O end= Argumento de palavras-chave
O argumento de palavra-chave end= faz com que a saída seja terminada por <str> em vez da nova linha padrão:
>> if True:
… print(‘foo’, end=’/’)
… print(42, end=’/’)
… print(‘bar’)
…
foo/42/bar
Por exemplo, se você estiver exibindo valores em um loop, poderá usar end= para fazer com que os valores sejam exibidos em uma linha, em vez de em linhas individuais:
>> for n in range(10):
… print(n)
…
0
1
2
3
4
5
6
7
8
9>> for n in range(10):
… print(n, end=(‘ ‘ if n < 9 else ‘n’))
…
0 1 2 3 4 5 6 7 8 9
Qualquer string pode ser especificada como o terminador de saída com a palavra-chave end=.
Argumentos de palavras-chave do fluxo de saída
print() aceita dois argumentos de palavra-chave adicionais, os quais afetam o processamento do fluxo de saída:
file=<stream> : Por padrão, print() envia sua saída para um fluxo padrão chamado sys.stdout, que geralmente é equivalente ao console. O argumento file=<stream> faz com que a saída seja enviada para um fluxo alternativo designado por <stream>.
flush=True: Normalmente, o print() armazena em buffer sua saída e grava apenas no fluxo de saída de forma intermitente. flush=True especifica que o fluxo de saída é liberado à força com cada print().
Saída de String Formatada
O print() suporta formatação de saída de console que é rudimentar na melhor das hipóteses. Você pode escolher como separar os objetos impressos e especificar o que vai no final da linha impressa.
Em muitos casos, você precisará de um controle mais preciso sobre a aparência dos dados destinados à exibição. O Python fornece várias maneiras de formatar os dados da string de saída. Nesta seção, você aprenderá sobre um dos mais antigos: o operador de módulo de string.
Em versões recentes do Python, existem maneiras mais recentes de formatar dados de strings que são indiscutivelmente superiores ao operador de módulo de string: o método string.format() e f-strings.
Embora outras opções de formatação estejam disponíveis, o operador de módulo de string ainda é amplamente usado. Se você estiver lendo um código Python existente, é provável que você encontre o operador de módulo de string, portanto, será benéfico se familiarizar com ele.
O Operador Módulo de String
O operador de módulo (%) é geralmente usado com números, caso em que calcula o resto da divisão:
>> 11 % 3
2
Como operandos de string, o operador de módulo tem uma função totalmente diferente: formatação de string. (As duas operações não são muito semelhantes. Elas compartilham o mesmo nome porque são representadas pelo mesmo símbolo: %.)
Veja como é a sintaxe do operador de módulo de string:
<string_de_formatação> % <valores>
No lado esquerdo do operador %, <string_de_formatação> é uma string contendo um ou mais especificadores de conversão. Os <valores> do lado direito são inseridos em <string_de_formatação> no lugar dos especificadores de conversão. A string formatada resultante é o valor da expressão.
Vamos começar com um exemplo. Aqui está uma declaração print() que exibe uma string formatada usando o operador módulo de string:
>> print(‘%d %s custam $%.2f’ % (6, ‘bananas’, 1.74))
6 bananas custam $1.74
Além de representar a própria operação do módulo de string, o caractere ‘%’ também indica os especificadores de conversão na string de formatação – nesse caso, ‘%d’, ‘%s’ e ‘% .2f’.
Nesta saída, cada item da tupla de valores é convertida para um valor string e inserido na string de formatação no local correspondente ao especificador de conversão:
O primeiro item na tupla é “6”, um valor numérico que substitui “%d” na string de formatação.O próximo item é a string com o valor “bananas”, que substitui “%s”.O último item é um float com o valor 1.74, que substitui “%.2f”.
A string resultante é “6 bananas custam $1.74”, conforme demonstrado no diagrama a seguir:
Se houverem vários valores para inserir, eles devem ser incluídos em uma tupla, conforme ilustrado acima. Se houver apenas um valor, ele poderá aparecer por si só:
>> print(‘Olá, meu nome é %s.’ % ‘Louis’)
Olá, meu nome é Louis.
Observe também que a operação do módulo de string não é apenas para impressão. Você também pode formatar valores e atribuí-los a outra variável de string:
>> s = ‘Olá, meu nome é %s.’ % ‘Louis’
>> s
‘Olá, meu nome é Louis.’
Especificadores de conversão
Os especificadores de conversão aparecem na <string_de_formatação> e determinam como os valores são formatados quando são inseridos.
Um especificador de conversão começa com um caractere % e consiste nesses componentes:
%[<sinalizador>][<largura>][.<precisão>]<tipo>
% e <tipo> são requeridos. Os componentes restantes mostrados em colchetes são opcionais.
A tabela a seguir resume o que cada componente de um especificador de conversão faz:
ComponenteSignificado%Introduz o especificador de conversão<sinalizador>Indica um ou mais sinalizadores
que exercem controle mais
preciso sobre a formatação<largura>Especifica a largura mínima do
resultado formatado.<precisão>Determina o comprimento e a
precisão do ponto flutuante ou saída de string<tipo>Indica o tipo de conversão a ser executada
Conversão de Tipos
O tipo de conversão, <tipo>, é o último componente do especificador de conversão:
%[<sinalizadores>][<largura>][.<precisão>]<tipo>
Ele determina o tipo de conversão que o valor correspondente sofre antes da inserção na string de formatação.
Veja uma tabela que lista os possíveis tipos de conversão:
<tipo>Conversão de tiposd, i, uInteiro decimalx, XInteiro hexadecimaloInteiro octalf, FPonto flutuantee, EExponencialg, GPonto Flutuante ou ExponencialcÚnico caracteres, r, aString%Único ‘%’ caractere
Tipos de conversão de inteiro
Os tipos de conversão d, i, u, x, X e o correspondem a valores inteiros.
d, i e u: São funcionalmente equivalentes. Todos eles convertem o argumento correspondente em uma representação de string de um inteiro decimal:
>> ‘%d, %i, %u’ % (42, 42, 42)
’42, 42, 42′
>> ‘%d, %i, %u’ % (-42, -42, -42)
‘-42, -42, -42’
O valor pode ser positivo ou negativo. Se for negativo, o valor resultante começará com um caractere ‘-‘.
x e X: Convertem para uma representação de string de um valor inteiro hexadecimal
o: Converte para uma representação de string de um valor inteiro octal:
>> ‘%x, %X’ % (252, 252)
‘fc, FC’
>> ‘%o’ % 16
’20’
x produz saída minúscula e X produz maiúscula. (Maiúsculas ‘O’ não é um tipo de conversão válido.)
Você pode ganhar algum controle adicional sobre o formato resultante usando sinalizadores de conversão.
Tipos de Conversão de Ponto Flutuante
Tipos de conversão f e F convertem em uma representação de string de um número de ponto flutuante, enquanto e e E produzem uma string representando uma notação exponencial (científica):
>> ‘%f, %F’ % (3.14159, 3.14)
‘3.141590, 3.140000’
>> ‘%e, %E’ % (1000.0, 1000.0)
‘1.000000e+03, 1.000000E+03’
Mergulho Profundo: inf e NaN
Em algumas circunstâncias, uma operação de ponto flutuante pode resultar em um valor que é essencialmente infinito. A representação de string de tal número no Python é ‘inf’.
Também pode acontecer que uma operação de ponto flutuante produza um valor que não seja representável como um número. O Python representa isso com a string ‘NaN’.
Quando esses valores são convertidos com o operador de módulo de string, o caractere de tipo de conversão controla o caso da saída resultante. f e e produzem saída minúscula, enquanto F e E produzem maiúsculas:
>> x = float(‘NaN’)
>> ‘%f, %e, %F, %E’ % (x, x, x, x)
‘nan, nan, NAN, NAN’
>> y = float(‘Inf’)
>> ‘%f, %e, %F, %E’ % (y, y, y, y)
‘inf, inf, INF, INF’
Os tipos de conversão g e G escolhem entre ponto flutuante ou saída exponencial, dependendo da magnitude do expoente e do valor especificado para .<precisão>. A saída é a mesma que e/E se o expoente for menor que -4 ou não menor que .<precisão>. Caso contrário, é o mesmo que f/F:
>> ‘%g’ % 3.14
‘3.14’
>> ‘%g’ % 0.00000003
‘3e-08’
>> ‘%G’ % 0.00000003
‘3E-08’
Basicamente, você pode pensar nesses tipos de conversão como uma opção “razoável”. Eles produzirão saída de ponto flutuante se o valor em questão for razoavelmente adequado para ele e formato exponencial de outra forma.
Semelhante aos outros tipos de conversão de ponto flutuante, g produz saída minúscula e G produz maiúsculas.
Tipos de Conversão de Caracteres
c insere um único caractere. O valor correspondente pode ser um inteiro ou uma cadeia de caracteres simples:
>> ‘%c’ % 97
‘a’
>> ‘[%c]’ % ‘y’
‘[y]’
O tipo de conversão c também suporta conversão para caracteres Unicode:
>> ‘%c’ % 8721
‘∑’
s, r e uma saída de string de produção usando as funções internas str(), repr() e ascii(), respectivamente:
>> ‘%s’ % ‘foo’
‘foo’
>> ‘%r’ % ‘foo’
“‘foo'”
>> ‘%a’ % ‘foo’
“‘foo'”
A justificação e o preenchimento da saída de string podem ser controlados com os especificadores <largura> e <precisão>.
Inserindo um caractere ‘%’
Para inserir um caractere literal ‘%’ na saída, especifique dois caracteres % consecutivos na string de formatação. O primeiro introduz um especificador de conversão (como de costume) e o segundo especifica que o tipo de conversão é %, o que resulta em um único caractere ‘%’ na saída.
Neste exemplo, %d %% significa um tipo de conversão decimal inteiro seguido por um caractere literal ‘%’:
>> ‘Pegue %d%% de desconto em %s somente hoje!’ % (30, ‘bananas’)
‘Pegue 30% de desconto em bananas somente hoje!’
Observe que o tipo de conversão % não consome nenhum dos <valores> à direita do operador do módulo de string.
Especificadores de largura e precisão
<largura> e <precisão>, estão no meio do especificador de conversão:
%[<sinalizadores>][<largura>][.<precisão>]<tipo>
Eles determinam quanto espaço horizontal um valor formatado ocupa.
O especificador <largura>
<largura> especifica a largura mínima do campo de saída. Se a saída for menor que <largura>, por padrão, ela será justificada à direita em um campo com <largura> caracteres de largura e preenchida com caracteres de espaço ASCII à esquerda:
>> ‘%5s’ % ‘foo’
‘ foo’
>> ‘%3d’ % 4
‘ 4’
Se o comprimento de saída for maior que <largura> , <largura> não terá efeito:
>> ‘%2d’ % 1234, ‘%d’ % 1234
(‘1234’, ‘1234’)
>> ‘%2s’ % ‘foobar’, ‘%s’ % ‘foobar’
(‘foobar’, ‘foobar’)
Um desses exemplos especifica uma largura de campo de 2. Mas, como os valores a serem formatados têm mais de dois caracteres, o resultado é o mesmo de quando nenhum especificador <largura> é especificado.
O especificador .<precisão>
.<precisão> afeta os tipos de conversão de ponto flutuante, exponencial e string. Para os tipos f, F, e e E. <precisão> determina o número de dígitos após o ponto decimal:
>> ‘%.2f’ % 123.456789
‘123.46’
>> ‘%.2e’ % 123.456789
‘1.23e+02’
Para os tipos g e G, determina o número total de dígitos significativos antes e depois do ponto decimal:
>> ‘%.2g’ % 123.456789
‘1.2e+02’
Strings formatados com os tipos s, r e a são truncados para o comprimento especificado por .<precisão>:
>> ‘%.4s’ % ‘foobar’
‘foob’
É muito comum ver <largura> e <precisão> usados juntos:
>> ‘%8.2f’ % 123.45678
‘ 123.46’
>> ‘%8.3s’ % ‘foobar’
‘ foo’
Qualquer um dos especificadores <largura> ou .<precisão> pode ser especificado como um caractere asterisco (*), caso em que o valor a ser usado é obtido do próximo item na tupla <valores>:
>> ‘%*d’ % (5, 123)
‘ 123’
Não há muita necessidade disso quando o valor <largura> é dado como constante. Não há qualquer diferença funcional entre o exemplo dado acima e este:
>> ‘%5d’ % 123
‘ 123’
Mas você também pode especificar <largura> e .<precisão> por variável:
>> for i in range(3):
… w = int(input(‘Enter width: ‘))
… print(‘[%*s]’ % (w, ‘foo’))
…
Enter width: 5
[ foo]
Enter width: 6
[ foo]
Enter width: 7
[ foo]
Isso permite que a largura ou precisão seja determinada em tempo de execução e, potencialmente, mude de uma execução para outra.
Sinalizadores de conversão
A conversão opcional <sinalizadores> é especificada logo após o caractere % inicial:
% [<sinalizadores>][<largura>][.<precisão>]<tipo>
Isso permite um controle mais refinado sobre a exibição de certos tipos de conversão <sinalizadores> pode incluir qualquer um dos caracteres mostrados na tabela a seguir:
CaractereControle#Exibição de base ou ponto decimal
para valores inteiros e de ponto flutuante0preenchimento de valores menores que a
largura do campo especificado–Justificativa de valores menores que a
largura de campo especificada+
‘ ‘ (espaço)Exibição do sinal principal para valores numéricos
As seções a seguir explicam como os flags de conversão operam com mais detalhes.
O sinalizador #
Para os tipos de conversão octal e hexadecimal, o sinalizador # faz com que informações básicas sejam incluídas na saída formatada. Para o tipo de conversão o, este sinalizador adiciona um ‘0o’ inicial. Para os tipos de conversão x e X, adiciona um ‘0x’ ou ‘0X’ principal:
>> ‘%#o’ % 16
‘0o20’
>> ‘%#x’ % 16, ‘%#X’ % 16
(‘0x10’, ‘0X10’)
O sinalizador # é ignorado para os tipos de conversão decimais d, ie u.
Para valores de ponto flutuante, o sinalizador # força a saída a sempre conter um ponto decimal. Normalmente, os valores de ponto flutuante não conterão um ponto decimal se não houver nenhum dígito depois dele. Este sinalizador força um ponto decimal a ser incluído:
>> ‘%.0f’ % 123
‘123’
>> ‘%#.0f’ % 123
‘123.’
>> ‘%.0e’ % 123
‘1e+02’
>> ‘%#.0e’ % 123
‘1.e+02’
O sinalizador 0
Quando um valor numérico formatado é menor que a largura de campo especificada, o comportamento padrão é preencher o campo com caracteres de espaço ASCII. O sinalizador 0 causa preenchimento com caracteres ‘0’:
>> ‘%05d’ % 123
‘00123’
>> ‘%08.2f’ % 1.2
‘00001.20’
O sinalizador 0pode ser usado com todos tipos de conevrsão numéricos: d, i, u, x, X, o, f, F, e, E, g, G.
O sinalizado –
Quando um valor formatado é menor que a largura de campo especificada, normalmente é justificado à direita no campo. O sinalizador – faz com que o valor seja justificado à esquerda no campo especificado, em vez disso:
>> ‘%-5d’ % 123
‘123 ‘
>> ‘%-8.2f’ % 123.3
‘123.30 ‘
>> ‘%-*s’ % (10, ‘foo’)
‘foo
Você pode usar o sinalizador – com os tipos de conversão de string s, a e r, bem como todos os tipos de conversão numéricos. Para tipos numéricos, se ambos 0 e – estiverem presentes, então 0 será ignorado.
As sinalizações + e ‘ ‘
Por padrão, valores numéricos positivos não possuem um caractere de sinal inicial. O sinalizador + adiciona um caractere ‘+’ à esquerda da saída numérica:
>> ‘%+d’ % 3
‘+3’
>> ‘%+5d’ % 3
‘ +3’
O sinalizador ” “(caractere de espaço) faz com que valores numéricos positivos sejam precedidos por um caractere de espaço:
>> ‘% d’ % 3
‘ 3’
Esses sinalizadores não têm efeito em valores numéricos negativos, que sempre têm um caractere ‘-‘ inicial.
Especificando Valores por Mapeamento de Dicionário
Os <valores> inseridos na string de formatação podem ser especificados como um dicionário em vez de uma tupla. Nesse caso, cada especificador de conversão deve conter uma das chaves do dicionário entre parênteses imediatamente após o caractere ‘%’.
Aqui um exemplo:
>> ‘%d %s custam $%.2f’ % (6, ‘bananas’, 1.74)
‘6 bananas custam $1.74’
>> d = {‘quantidade’: 6, ‘item’: ‘bananas’, ‘preço’: 1.74}
>> ‘%(quantidade)d %(item)s custam $%(preço).2f’ % d
‘6 bananas custam $1.74’
Usando essa técnica, você pode especificar os valores inseridos em qualquer ordem
>> d = {‘quantidade’: 6, ‘item’: ‘bananas’, ‘preço’: 1.74}
>> ‘%(quantidade)d %(item)s custam $%(preço).2f’ % d
‘6 bananas custam $1.74’
>> ‘Vou lhe cobrar $%(preço).2f pelas %(item)s, se você comprar %(quantidade)d’ % d
‘Vou lhe cobrar $1.74 pelas bananas, se você comprar 6’
Todos os itens do especificador de conversão mostrados acima – <sinalizadores>, <largura> , .<precisão> e <tipo> – têm o mesmo significado:
>> ‘Quantidade: %(quantidade)03d’ % d
‘Quantidade: 006’
>> ‘Item: %(item).5s’ % d
‘Item: banan’
Entrada e Saída em Python: Conclusão
Neste tutorial, você aprendeu sobre a entrada e saída do Python e como o seu programa em Python pode se comunicar com o usuário. Agora você deve conseguir obter dados do usuário com input() e exibir os resultados no console com print().
Você também aprendeu a tornar os dados exibidos ao usuário mais apresentáveis formatando-os com o operador de módulo de string.
Por mais versátil que seja o operador de módulo de string, o Python fornece duas maneiras mais recentes de formatar dados de string que são ainda melhores: o método string.format() e o literal de string formatado.
Eu, particularmente, gosto de utilizar o f-string, que será uma assunto para outro post.
Fonte: https://realpython.com/python-input-output/
Este artigo foi importado automaticamente por fazer parte do Planetário Dev. Quer fazer parte deste HUB de conteúdos? Faça parte do Planetário e veja as vantagens.
Não tem site ou blog? Seja um autor do site e ainda pode ser remunerado.
Mais sobre Newsletters?
32 melhores newsletters sobre negócios, startups e tecnologia para assinar em 2022
Leia também: