Uma Introdução Informal a Python

Prévio Próximo

Python LogoNos exemplos a seguir, a entrada e saída são distinguidos pela presença ou ausência de avisos (>>> e …): para repetir o exemplo, você deve digitar tudo após o prompt, quando o prompt aparecer; linhas que não começam com um prompt são emitidos pela interpretador. Note-se que um prompt secundário em uma linha por si só em um exemplo significa que você deve digitar uma linha em branco; isto é usado para terminar um comando multi-line.

Muitos dos exemplos neste manual, mesmo aqueles que entraram no prompt interativo, incluem comentários. Comentários em Python começam com o caractere de hash, #, e se estendem até o final da linha física. Um comentário pode aparecer no início de uma linha ou na sequência de espaços em branco ou código, mas não dentro de uma string literal. Um caractere de hash dentro de uma string literal é apenas um caractere hash. Já que os comentários são para esclarecer código e não são interpretados por Python, eles podem ser omitidos quando se digita em exemplos.

Alguns exemplos:

# este é o primneiro comentário
spam = 1  # e este é o segundo comentário
          # ... e agora o terceiro!
text = "# Este não é um comentário porque está entre quotas."

3.1. Usando Python como uma Calculadora

Vamos tentar alguns comandos simples em Python. Inicie o interpretador e aguarde o prompt primário, >>>. (Não deve demorar muito tempo.)

3.1.1. Números

O interpretador atua como uma calculadora simples: você pode digitar uma expressão para ele e ele vai escrever o valor. A sintaxe da expressão é simples: os operadores +, -, * e / funcionam da mesma forma que em outras linguagens (por exemplo, Pascal ou C); parênteses (()) pode ser utilizado para agrupar. Por exemplo:
>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5.0*6) / 4
5.0
>>> 8 / 5.0
1.6
Os números inteiros (por exemplo, 2, 4, 20) têm o tipo int, os únicos com uma parte fracionária (por exemplo, 5.0, 1.6) tem tipo float. Veremos mais sobre tipos numéricos mais tarde no tutorial.O tipo de retorno de uma operação de divisão (/) depende de seus operandos. Se os dois operadores são do tipo int, divisão piso é realizada e um int é retornado. Se o operando é um float, clássica divisão é realizada e um flutuador é retornado. O operador // também é fornecido para fazer a divisão floor não importa o que os operadores são. O restante pode ser calculada com o operador %:
>>> 17 / 3  # int / int -> int
5
>>> 17 / 3.0  # int / float -> float
5.666666666666667
>>> 17 // 3.0  # explícita floor divisão descarta a parte fracional
5.0
>>> 17 % 3  # o operador % retorna o resto da divisão
2
>>> 5 * 3 + 2  # result * divisor + remainder
17
Com Python, é possível utilizar o operador ** para calcular as potências [1]:
>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128
O sinal de igual (=) é usado para atribuir um valor a uma variável. Depois disso, nenhum resultado é exibido antes do próximo prompt interativo:
>>> width = 20
>>> height = 5 * 9
>>> width * height
900
Se uma variável não estiver “definida” (um valor), tentando usá-la lhe dará um erro:
>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined
Há total suporte para ponto flutuante; operadores com operandos de diferentes tipos convertem o operando inteiro para ponto flutuante:
>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5
No modo interativo, a última expressão impressa é atribuída à variável _. Isto significa que quando você está usando Python como uma calculadora de mesa, é um pouco mais fácil prosseguir com os cálculos, por exemplo:
>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
Esta variável deve ser tratada como somente leitura pelo usuário. Não atribua explicitamente um valor a ela – você criaria uma variável independente local com o mesmo nome mascarando a variável interna com seu comportamento mágico.Além de int e float, Python suporta outros tipos de números, tais como Decimal e Fraction. Python também tem suporte embutido para números complexos, e usa o j J ou sufixo para indicar a parte imaginária (por exemplo, 3 + 5-J).

3.1.2. Strings

Além de números, Python também pode manipular strings, que podem ser expressas de várias maneiras. Elas podem ser colocadas entre aspas simples (‘…’) ou aspas duplas (“…”), com o mesmo resultado [2]. \ Pode ser usado para escapar citações:
>>> 'spam eggs'  # single quotes
'spam eggs'
>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
No interpretador interativo, a string de saída está entre aspas e caracteres especiais são escapados com barras invertidas. Embora isso possa, por vezes, parecer um pouco diferente da de entrada (as aspas finais poderiam mudar), as duas strings são equivalentes. A string é colocada entre aspas duplas se a string contiver uma aspa simples e sem aspas duplas, caso contrário ela é colocada entre aspas simples. A declaração print produz uma saída mais legível, omitindo as aspas  e imprimindo caracteres escapados e especiais:
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print '"Isn\'t," she said.'
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print, \n is included in the output
'First line.\nSecond line.'
>>> print s  # with print, \n produces a new line
First line.
Second line.
Se você não quiser que os caracteres precedidos por \ sejam interpretados como caracteres especiais, você pode usar raw strings adicionando um r antes da primeira aspa:
>>> print 'C:\some\name'  # here \n means newline!
C:\someame
>>> print r'C:\some\name'  # note the r before the quote
C:\some\name
Strings literais pode abranger várias linhas. Uma maneira é usar aspas triplas: “” “…” “” ou ” ‘…’ ”. Fim de linhas são automaticamente incluídos na cadeia, mas é possível evitar isso adicionando um \ no final da linha. O exemplo que se segue:
print """\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
"""
produz o seguinte resultado (note que a nova linha inicial não está incluído):
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
Strings podem ser concatenadas (coladas em conjunto) com o operador +, e repetido com *:
>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'
Duas ou mais strings literais (ou seja, aquelas incluídas entre aspas) ao lado da outra são automaticamente concatenadas.
>>> 'Py' 'thon'
'Python'
Isso só funciona com dois literais, porém, não com variáveis ou expressões:
>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax
Se você quiser concatenar variáveis ou uma variável e uma literal, use +:
>>> prefix + 'thon'
'Python'
Este recurso é particularmente útil quando você quer quebrar strings longas:
>>> text = ('Put several strings within parentheses '
            'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'
Strings podem ser indexadas (subscritas), com o primeiro caractere com índice 0. Não há nenhum tipo de caractere em separado; um caractere é simplesmente uma string de tamanho um:
>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'
Índices também podem ser números negativos, para iniciar a contagem a partir da direita:
>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'
Note-se que uma vez que -0 é o mesmo que 0, os índices negativos começar a partir de -1.Além de indexação, o corte (slice) também é suportado. Enquanto indexação é usado para obter caracteres individuais, corte permite obter um texto:
>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'
Note como o início é sempre incluído, e o final sempre excluído. Isso garante que é [: i] + s [i:] é sempre igual a s:
>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'
índices fatiados têm padrões úteis; a omissão do primeiro índice a zero, a omissão do segundo índice para o tamanho da string que está sendo cortada.
>>> word[:2]  # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]  # characters from position 4 (included) to the end
'on'
>>> word[-2:] # characters from the second-last (included) to the end
'on'
Uma maneira de se lembrar de como trabalhar com slices é pensar que os índices são ponteiros entre os caracteres, com a margem esquerda do primeiro caracter numerado 0. Então a margem direita do último caracter de uma string de n caracteres, tem o index n, por exemplo:
+---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1
A primeira linha de números dá a posição dos índices 0 … 6 na cadeia; a segunda linha fornece os índices negativos correspondentes. A fatia de i até j consiste de todos os caracteres entre as bordas marcadas i e j, respectivamente.Por índices de não-negativos, o comprimento de uma fatia é a diferença dos índices de, se ambos estiverem dentro dos limites. Por exemplo, o comprimento de palavra [1: 3] é 2.A tentativa de usar um índice que é muito grande irá resultar em um erro:
>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range
No entanto, fora do alcance índices fatia são tratadas normalmente quando usado para cortar:
>>> word[4:42]
'on'
>>> word[42:]
''
Strings em Python não podem ser mudadas – elas são imutáveis. Portanto, atribuir a uma posição indexada nas string resulta em um erro:
>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment
Se você precisar de uma seqüência diferente, você deve criar uma nova:
>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'
A função interna len() retorna o comprimento de uma string:
>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34
Strings, e as cadeias de caracteres Unicode descritas na próxima seção, são exemplos de tipos de seqüência, e apoiam as operações comuns suportadas por esses tipos.
Ambas as cordas e cadeias de caracteres Unicode suporta um grande número de métodos para transformações básicas e de pesquisa.
Informações sobre a formatação de string com str.format() é descrito aqui.
As antigas operações de formatação invocadas quando strings e Unicode strings são o operando esquerdo do operador % são descritos em mais detalhes aqui.

3.1.3. Strings Unicode

Começando com o Python 2.0 um novo tipo de dados para o armazenamento de dados de texto está disponível ao programador: o objeto Unicode. Ele pode ser usado para armazenar e manipular dados Unicode (veja http://www.unicode.org/) e se integra bem com os objetos string existentes, proporcionando auto-conversões quando necessário.Unicode tem a vantagem de proporcionar um ordinal para cada caracter de cada script usado em textos modernos e antigos. Anteriormente, havia apenas 256 possíveis ordinais para personagens de script. Textos eram normalmente ligado a uma página de código que mapeou os ordinais para caracteres de script. Isso levou a uma enorme confusão, especialmente no que diz respeito à internacionalização (geralmente escrito como i18n – ‘i’ + 18 caracteres + N) de software. Unicode resolve esses problemas através da definição de uma página de código para todos os scripts.Criar strings Unicode em Python é tão simples quanto criar strings normais:
>>> u'Hello World !'
u'Hello World !'
O pequeno ‘u’ em frente à cotação indica que uma seqüência de caracteres Unicode é suposto ser criado. Se você quiser incluir caracteres especiais na string, você pode fazê-lo usando o Python codificação Unicode-Escape. O exemplo a seguir mostra como:
>>> u'Hello\u0020World !'
u'Hello World !'
A seqüência de escape \ u0020 indica para inserir o caractere Unicode com o 0x0020 valor ordinal (o caractere de espaço) na posição determinada.Outros personagens são interpretados por usando seus respectivos valores ordinais diretamente como ordinais Unicode. Se você tem strings literais na codificação padrão Latin-1 que é usado em muitos países ocidentais, você vai achar que é conveniente que os menores de 256 caracteres Unicode são os mesmos que os 256 caracteres de Latin-1.Para especialistas, há também um modo raw igual ao das strings normais. Você tem que prefixar a aspa de abertura com ‘ur’ para que Python use a codificação Raw-Unicode-Escape. Só será aplicado a conversão \uXXXX acima,  se houver um número ímpar de barras invertidas em frente do ‘u’.
>>> ur'Hello\u0020World !
'u'Hello World !'
>>> ur'Hello\\u0020World !
'u'Hello\\\\u0020World !'
O modo raw é mais útil quando você tem que digitar um monte de barras invertidas, como é necessário em expressões regulares.Além dessas codificações padrão, Python fornece todo um conjunto de outras formas de criação de strings de caracteres Unicode com base em uma codificação conhecida.A função interna unicode() fornece acesso a todos os codecs Unicode registrados (codificadores e descodificadores). Algumas das codificações mais bem conhecidas que estes codecs pode converter são Latin-1, ASCII, UTF-8 e UTF-16. Os dois últimos são codificações de comprimento variável que armazenam cada caractere Unicode em um ou mais bytes. A codificação padrão é normalmente definido como ASCII, que passa por caracteres no intervalo de 0 a 127 e rejeita qualquer outro com um erro. Quando uma seqüência de caracteres Unicode é impressa, escrita em um arquivo, ou convertido com str(), a conversão ocorre usando essa codificação padrão
>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)
Para converter uma seqüência de caracteres Unicode em uma string de 8 bits usando uma codificação específica, objetos  Unicode fornecem um método encode() que tem um argumento, o nome da codificação. São preferidos nomes em minúsculas para codificações.
>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'
Se você tiver dados em uma codificação específica e deseja produzir uma seqüência de caracteres Unicode correspondente a partir dele, você pode usar a função unicode () com o nome de codificação como o segundo argumento.
>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

3.1.4. Lists

Python sabe uma série de tipos de dados compostos, utilizados para agrupar outros valores. O mais versátil é a lista, que pode ser escrita como uma lista de valores separados por vírgula (itens) entre colchetes. As listas podem conter itens de diferentes tipos, mas geralmente todos os itens têm o mesmo tipo.
>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]
Como strings(e todos os outros tipos de sequência interna), as listas podem ser indexadas e cortadas:
>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]
Todas as operações de fatia retornam uma nova lista contendo os elementos solicitados. Isto significa que a fatia seguinte retorna uma nova cópia (rasa) da lista:
>>> squares[:]
[1, 4, 9, 16, 25]
As listas também suportam operações como concatenação:
>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
Ao contrário de strings, que são imutáveis, as listas são um tipo mutável, ou seja, é possível alterar o seu conteúdo:
>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]
Você também pode adicionar novos itens no final da lista, usando o método append() (veremos mais sobre os métodos mais tarde):
>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]
Atribuição de fatias também é possível, e isso pode até mesmo alterar o tamanho da lista ou limpá-la inteiramente:
>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]
A função interna len() também se aplica às listas:
>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4
É possível aninhar listas (criar listas que contêm outras listas), por exemplo:
>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2. Primeiros Passos para Programação

Claro, podemos usar Python para tarefas mais complicadas do que somar dois e dois juntos. Por exemplo, podemos escrever uma sub-seqüência inicial da série de Fibonacci da seguinte forma:
>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b
...
1
1
2
3
5
8
Este exemplo apresenta vários novos recursos.
  • A primeira linha contém uma atribuição múltipla: as variáveis ​​a e b simultaneamente recebem os novos valores 0 e 1. Na última linha este é usado novamente, o que demonstra que as expressões sobre o lado direito são sempre avaliadas primeiro, antes de qualquer das atribuições ter lugar. As expressões do lado direito são avaliadas a partir da esquerda para a direita.
  • O loop enquanto executa enquanto a condição (aqui: b <10) continua a ser verdade. Em Python, como em C, qualquer organização não-zero valor inteiro é verdade; zero é falso. A condição também pode ser uma lista ou string, na verdade qualquer sequência; qualquer coisa com um comprimento diferente de zero é verdade, sequências vazias são falsas. O teste utilizado no exemplo é uma comparação simples. Os operadores de comparação padrão são escritos da mesma maneira que em C: <(inferior),> (superior), == (igual), <= (menor ou igual),> = (maior do que ou igual a) e! = (não igual a).
  • O corpo do laço é recuado: recuo é o caminho de Python de agrupar declarações. No prompt interativo, você tem que digitar uma guia ou espaço (s) para cada linha recuada. Na prática, você vai preparar o seu contributo mais complicado para Python com um editor de texto; todos os editores de texto decentes ter uma opção de auto-indent. Quando um comando composto é introduzido de forma interativa, que deve ser seguido por uma linha em branco para indicar a conclusão (uma vez que o analisador não pode adivinhar quando você digitou a última linha). Note-se que cada linha dentro de um bloco de base deve ser recuado pela mesma quantidade.
  • O comando print escreve o valor da expressão (s) é dado. Ele difere de apenas escrever a expressão que você quer escrever (como fizemos anteriormente nos exemplos calculadora) na forma como ele lida com múltiplas expressões e strings. Strings são impressas sem aspas, e é inserido um espaço entre os itens, para que possa formatar as coisas bem, como este:
>>> i = 256*256
>>> print 'The value of i is', i
The value of i is 65536
A vírgula no final evita a nova linha após a saída:
>>> a, b = 0, 1
>>> while b < 1000:
...     print b,
...     a, b = b, a+b
...1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987
Note-se que o interpretador insere uma nova linha antes de imprimir o próximo prompt se a última linha não foi concluída.
Notas de Rodapé
[1] Já que ** tem precedência maior do que -, -3 ** 2 será interpretado como – (3 ** 2) e, portanto, resultar em -9. Para evitar isso e obter 9, você pode usar (-3) ** 2.
[2] Ao contrário de outras linguagens, caracteres especiais como \ n têm o mesmo significado com tanto simples (‘…’) e duplas (“…”) aspas. A única diferença entre os dois é que, dentro de aspas simples você não precisa escapar “(mas você tem que escapar \ ‘) e vice-versa.
Prévio Próximo