Esta seção apresenta uma introdução sucinta à linguagem Python. Pesquisadores com experiência prévia em programação procedural como Fortran, C ou MATLAB não deverão ter maiores dificuldades com o conteúdo a seguir, uma vez que ele define em Python conceitos familiares como atribuição de variáveis, controle de fluxo e iterações. Pesquisadores que não possuem conhecimentos prévios sobre programação de computadores podem buscar orientação no projeto Software Carpentry, destinado a ensinar diversas técnicas de computação a pesquisadores com formações acadêmicas variadas.
Há quatro tipos numéricos em Python: inteiros simples (plain integers - ou apenas inteiro), inteiros longo (long integers), números em ponto flutuante (floating points) e complexos.
A diferença entre o inteiro e o inteiro longo é que o último possui precisão infinita, permitindo a representação de qualquer número em $\mathbb{Z}$ (na prática, há limites impostos pela memória do computador). Na maior parte do tempo, o programador utiliza inteiros simples, capazes de representar números inteiros no intervalo $[-n - 1, n]$. O valor de $n$ varia de acordo com o sistema (32 ou 64 bits), podendo ser consultado na variável sys.maxint:
In [2]:
import sys
sys.maxint
Out[2]:
Inteiros são representados e manipulados trivialvente:
In [3]:
1 + 1
Out[3]:
Como usual na maioria das linguagens procedurais, uma atribuição de variável é realizada utilizando-se o operador =. Podemos conferir o tipo da variável utilizando a função type:
In [4]:
a = 4
type(a)
Out[4]:
O resto da divisão inteira pode ser obtido utilizando o operador %:
In [5]:
11 % 4
Out[5]:
Inteiros longos (precisão infinita) são representados acionando-se a letra l (minúscula ou maiúscual), ao final do inteiro:
In [6]:
a = 32L
a
Out[6]:
In [7]:
b = a * sys.maxint
b
Out[7]:
In [8]:
c = b * sys.maxint
c
Out[8]:
In [9]:
type(c)
Out[9]:
Diferenciam-se os números reais dos inteiros com o uso do caractere ".", opcionalmente anexando-se casas decimais se houver:
In [10]:
a = 2
type(a)
Out[10]:
In [11]:
a = 2.
type(a)
Out[11]:
In [12]:
a = 2.1
type(a)
Out[12]:
Informações sobre a representação dos números em ponto flutuante no sistema, como valores máximos e mínimos, podem sem obtidos com a variável sys.float_info:
In [13]:
sys.float_info
Out[13]:
Números complexos tem sua parte imaginária definida pelo caractere "j". Os atributos real e imag permitem acesso direto às partes real e imaginária do número.
In [14]:
a = 1.2 + 0.7j
a
Out[14]:
In [15]:
type(a)
Out[15]:
In [16]:
a.real
Out[16]:
In [17]:
a.imag
Out[17]:
Além das operações aritméticas de adição, subtração, multiplicação e divisão, Python fornece uma maneira simples de definir potenciação, utilizando a notação "**":
In [18]:
2**3
Out[18]:
Quanto à divisão, vale lembra a diferença entre dividir números inteiros e reais:
In [19]:
3/2
Out[19]:
In [20]:
3./2
Out[20]:
Todas as variáveis em Python, até mesmo as variáveis numéricas básicas, são objetos. Uma categoria especial de objetos em Python são os containers, capazes de armazenar outros objetos, como listas, tuplas e dicionários.
Listas são a sequência mais comum e mais utilizada em Python. Listas podem ser criadas diretamente utilizando-se colchetes "[]", como no exemplo abaixo contendo oito objetos string:
In [21]:
L = ['vermelho', 'azul', 'verde', 'amarelo', 'ciano', 'magenta', 'branco', 'preto']
type(L)
Out[21]:
In [22]:
L
Out[22]:
Elementos da lista podem ser acessados por seu índice, lembrando que, de modo similar a Fortran e C mas diferentemente de MATLAB, o primeiro elemento é indexado por 0:
In [23]:
L[0]
Out[23]:
In [24]:
L[2]
Out[24]:
Um recurso útil na indexação em Python é que índices negativos podem ser utilizados para acessar a lista em ordem reversa. Por exemplo, -1 pode ser utilizado para acessar o último elemento da lista:
In [25]:
L[-1]
Out[25]:
In [26]:
L[-2]
Out[26]:
Outro recurso útil é chamado de slicing. Utilizando a notação início:fim:passo, podemos obter listas que são subsequências da lista inicial:
In [27]:
L[2:6]
Out[27]:
In [28]:
L[2:]
Out[28]:
In [30]:
L[1:6:2]
Out[30]:
Listas podem conter tipos diferentes de objetos:
In [31]:
L = [3, -200.7, 3+5j, 'hello']
L
Out[31]:
O método pop pode ser utilizado para obter e simultaneamente retirar um objeto da lista. Seu comportamente padrão (sem argumentos) é remover o último elemento da lista:
In [32]:
x = L.pop()
x
Out[32]:
In [33]:
L
Out[33]:
A posição do elemento-alvo pode ser informada:
In [34]:
x = L.pop(0)
x
Out[34]:
In [35]:
L
Out[35]:
Os métodos append e extend podem ser utilizados para adicionar elementos à lista. O primero adiciona um único objeto como elemento da lista. Já extend adiciona a lista cada um dos elementos de uma segunda lista passada como argumento:
In [36]:
L
Out[36]:
In [37]:
L.append(42)
L
Out[37]:
In [38]:
L.extend([3, 5, 'ueba!'])
L
Out[38]:
Se uma lista for utilizada como argumento da função append, ela será inserida como um único elemento:
In [39]:
L.append([1,2,3])
L
Out[39]:
In [39]:
ponto = (23, 542)
In [40]:
ponto
Out[40]:
In [41]:
ponto[0]
Out[41]:
In [42]:
x, y = ponto
print x
print y
In [43]:
tel = {'emmanuelle': 5752, 'sebastian': 5578}
In [44]:
tel
Out[44]:
In [45]:
tel.keys()
Out[45]:
In [46]:
tel.values()
Out[46]:
In [47]:
tel['sebastian']
Out[47]:
Um nova entrada pode ser adicionada ao dicionário simplesmente atribuindo-se um valor a uma nova chave:
In [48]:
tel['thiago'] = 5823
tel
Out[48]:
In [49]:
for k in tel.keys():
print 'Fale com %s no ramal %d' % (k, tel[k])
In [50]:
if 2+2 == 4:
print 'OK, o Universo está bem'
In [51]:
a = 10
if a == 1:
print 'É pouco'
elif a == 2:
print 'É bom'
else:
print 'É demais!'
In [52]:
for i in range(5):
print i
In [53]:
for word in ('legal', 'poderoso', 'legível'):
print 'Python é %s' % word
In [54]:
for i, word in enumerate(('legal', 'poderoso', 'legível')):
print '%dº: Python é %s' % (i, word)
In [55]:
z = 1 + 1j
while abs(z) < 100:
if z.imag == 0:
break
z = z**2 + 1
z
Out[55]:
In [40]:
sqr = [i**2 for i in range(10)]
sqr
Out[40]:
A semântica do código acima é simples: sqr é uma lista contendo $i^2$ para cada $i$ na sequência range(10), que no caso é o intervalo $[0,9]$. Considere outro exemplo:
In [41]:
doc = ['Hello', 'Embrapa', 'Informática']
wlen = [len(word) for word in doc]
wlen
Out[41]:
Aqui, wlen é a lista contendo o comprimento de cada palavra na sequência doc. Usada corretamente, a compreensão de listas pode produzir códigos elegantes de fácil compreensão por parte de outros pesquisadores. Note como o primeiro exemplo corresponde diretamente a expressão matemática:
$i^2 \,,\forall i \in [0,9]$.