Python

1
Índice

Comandos Python 1
Codificação 2
Números 3
Lógica Booleana 4
Strings 5
Variáveis 7
Variáveis Globais e Locais 7
Funções 8
Instruções Condicionais – if … elif … else 10
Instruções cíclicas 12
While 12
For 12
Controlo de estruturas de fluxo 13
Coleção de dados 14
Listas 14
Tuplos 18
Dicionários 18
Matrizes 19
Ficheiros 20
Classes 22

2
C
Codificação
# -*- coding: encoding -*- V
Controlo de fluxo
break XVI
continue XVI

D
Dicionário
dic = {'a': a, 'b': b,..., 'z': z} XXI

F
for x in range (): XVI
Funções
def (): XI
None XII
return XI

L
Lógica Booleana
False VII
True VII

N
Números
complex () VI
float () VI
int () VI

R
range (m, n, p) XV

S
Strings
len () IX
str () IX
string [inicio: fim: intervalo] IX

3
Comandos Python

 pwd: imprime a pasta onde nos encontramos

 hostname: nome do computador
 cd: muda de diretoria (cd ~: vai para c:\Users\Isa)
 ls: lista o conteúdo da pasta onde nos encontramos
 md/mkdir nome: cria a pasta nome
 rmdir nome: apaga a pasta nome (se não tiver ficheiros dentro)
 notepad: cria um ficheiro notepad
 rm: apaga um ficheiro
 cp: copia um ficheiro ou pasta, cp nome local
 mv: move um ficheiro ou pasta, mv nome local
 less: imprime o conteúdo de um ficheiro
 exit: sai da Shell

1
Codificação

Por norma, os ficheiros Python são identificados como uma

codificação UTF-8. Este código permite usar caracteres da maior parte das
línguas do mundo. Para se visualizarem todos os caracteres correctamente,
o editor tem de reconhecer que o ficheiro é UTF-8 e tem de usar uma fonte
que suporte todos os caracteres do ficheiro.
É possível alterar a codificação dos ficheiros. Para fazer isso é
necessário fazer um cometário especial: # -*- coding: encoding -*-. Com
esta declaração, tudo no ficheiro vai ser tratado como tendo uma
codificação encoding. A lista de possíveis encodings pode ser encontrada
na Biblioteca de Referências Python, na secção codecs.
No Python 35, para se poder utilizar a acentuação do português é
necessário alterar a codificação do ficheiro colocando # -*- coding:
cp860 -*- na primeira linha do ficheiro.
Tem de ser ter em atenção que a alteração da codificação é diferente
para versões diferentes do python.

2
Números

Podem ser inteiros (integer), decimais (float) ou complexos.

print (type (3), type (3.0)) # Run: <class 'int'> <class'float'>

Pode-se converter entre os diferentes tipos de data usando int (), float
() e complex (). Tem que se ter em consideração que não é possível
converter complexos em números inteiros ou decimais.
 int (x) converte x num número inteiro
print (int (3.14159), int (-2.8)) # Run: 3 -2

 float (x) converte x num número decimal

print (float (3), float (-1)) # Run: 3.0 -1.0

 complex (x) converte x num número complexo

print (complex (2), complex (4.0)) # Run: (2 + 0j) (4 + 0j)

Operadores Aritméticos
Precedência dos operadores = (), **, *, /, +, -
+ mais adição
- menos subtração
* vezes multiplicação
/ dividir por divisão retorna sempre um decimal
// quociente divisão inteira descarta a parte decimal
% resto
** elevado exponenciação
print (1 + 2, , 5 * 6, 2 ** 5, 49 // 10, 49 % 10) # Run: 3 30 -32 4 9

Além dos operadores, também existem algumas funções builtin:

Função Descrição

abs (x) Valor absoluto

complex (re, im) Número complexo com parte real re e parte imaginária im

c.conjugate () Conjugado do número complexo c

pow (x, y) x elevado a y

round (x, y) Arredonda o número x a y casas decimais

3
Lógica Booleana
Todos os valores podem ser ou verdadeiros ou falsos. O verdadeiro é
chamado True e é igual a 1, enquanto o falso é chamado False e é igual a
zero. São considerados falsos: False, None, 0 e qualquer sequência vazia.
São considerados verdadeiros, todos os outros objetos.

Operadores de comparação
> maior que
< menor que
>= maior ou igual que
<= menor ou igual que
== igual a
!= diferente
print ( 3 > 3) # Run: False
print ('Hello' == "Hello") # Run: True

Operadores Booleanos
Operador A B Result Descrição Exemplo

A * B = True. Ambas as a = True

and 1 1 True expressões têm de ser b = False
verdadeiras

A + B = False. Ambas print (not a) # Run: False

or 0 0 False as expressões têm de print (a and b) # Run: False
ser falsas print (a or b) # Run: True
not 0 True Nega a expressão

True se receber duas a = 9

is x is x referências ao mesmo print (a is a)

objeto

True se um item de s é
in x in s igual a x, caso
contrário é False

Além dos operadores booleanos, existem as funções all(), que

retorna verdadeiro quando todos os itens forem verdadeiros na sequência
usada como parâmetro, e any (), que retorna verdadeiro se algum dos item
for verdadeiro.

4
Strings

Têm que estar entre aspas simples ou duplas. Podem ser constituídas
por linhas consecutivas, desde que estejam entre três aspas simples ou
duplas.

Combinar strings
Strings podem ser juntas (sem espaço) com o operador + e podem ser
repetidas com *.
# Converte as horas num formato de 24-horas "03:00"
hour = 3
ones = hour % 10
tens = hour // 10
print (tens, ones, ":00") # Run: 0 3 :00
print (str (tens), str (ones), ":00") # Run: 0 3 :00
print (str (tens) + str (ones) + ":00") # Run: 03:00

Letras e porções
Nas strings pode-se seleccionar apenas uma letra ou determinada
porção da string. Para isso, indicia-se a string: começando na primeira
letra da string, considera-se que esta se encontra na posição zero;
começando na última letra da string considera-se que esta se encontra na
posição -1.

Quando se quer seleccionar apenas uma letra usa-se string [posição].

Para selecionar uma porção da string usa-se string [inicio: fim:
intervalo], tendo em atenção que o caractere que se encontra na posição
fim não é incluído na porção de string definida. Se não for definido o
início, será considerado zero. Se não for definido o fim, será
considerado o tamanho da string. O intervalo, se não for definido, será
1.
Para se conhecer o comprimento da string utiliza-se a função len
(string).
s = 'Warren wears nice ties!'

5
print (s [13:]) # Run: nice ties!
Converter em strings
Para converter números em strings utiliza-se str (number).

Formatação
Conversão Descrição

%d Número Inteiro

%o Valor octal

%x Hexadecimal

%e Decimal com formato exponencial

%f Número Decimal

%r String (converte qualquer objeto Python usando repr ())

%s String (converte qualquer objeto Python usando str ())

%% Nenhum argumento é convertido, resulta o caracter '%'

Caracteres especiais

Representação Descrição

\n Paragrafo

\r Paragrafo

\r\n 2 * Paragrafo

\t Tabulação

Funções
x in s True se um elemento da lista s é igual a x

Retorna a posição da primeira ocorrência de x.

s.find (x)
Retorna -1 se não for encontrada

s.count (x) Número total de ocorrências de x na lista

s.replace (x, y) Substitui todas as ocorrências de x por y

6
Variáveis

Uma variável é um nome que se refere a um valor. São usadas para

evitar reescrever os valores e dar-lhes nomes que ajudam os leitores a
perceber o código.
Dá-se um nome a uma variável usando o sinal =.
Os nomes das variáveis só podem ser constituídos por letras, números
e underscore (_). Tendo em atenção que não podem começar por números, são
case sensitive e que se tiverem mais que uma palavra, estas são ligadas
por um underscore.
Nomes Permitidos - ninja, Ninja, n_i_n_j_a, elite_ninja, ninja_1337
Nomes Não Permitidos - 1337, 1337ninja, 1337_ninja

Variáveis Globais e Locais

Quando se define uma variável fora de funções Python, esta é uma
variável global. Variáveis criadas dentro de uma função são designadas
variáveis locais.
Deve-se usar sempre variáveis locais. Quando se usam variáveis
globais dentro de uma função é necessário dizer à função que a variável é
global.

n = 0
def increment():
global n
n = n + 1
increment ()
increment ()
print (n) # Run: 2

7
Funções

São compostas por duas partes o cabeçalho e o corpo.

Cabeçalho - def xxx (): introduz a função defenition, que deve ser
seguida pelo nome da função e por uma lista entre parenteses dos
parâmetros de entrada. A função pode ter zero parâmetros ou tantos
quantos se quer. Acaba com dois pontos (:).
Corpo: tudo o que está indentado depois dos dois pontos. Acaba com
return, que faz o output do valor da variável local dentro da função.

def triangle_area (base, height): # cabeçalho

area = (1.0 / 2) * base * height # corpo
return area # corpo
'''
Ao correr o programa acima não acontece nada porque uma função só é executada
quando é chamada.
'''
a1 = triangle_area (3, 8)
print (a1) # Run: 12

def hello ():

print ("Hello, world!")

hello () # call to hello prints "Hello, world!"

h = hello () # call to hello prints "Hello, world!" a second time
print (h) # prints None since there was no return value

No Python, quando se esquece e/ou não é necessário o return, este

automaticamente adiciona um. É como se tivesse escrito return None.

8
# -*- coding: cp860 -*-
import math

def graus_para_radianos (graus):

'''Converte graus em radianos'''
radianos = (graus * math.pi) / 180
return (radianos)

def teste1 ():

graus = float (input ('Valor do angulo em graus: '))
radianos = graus_para_radianos (graus)
print ('%f º = %f radianos' % (graus, radianos))

def area_volume_esfera (r):

''' Calcula a área e o volume de esferas'''
area = 4 * math.pi * r **2
volume = (4 * math.pi * r **3) / 3
return (area, volume)

def teste2 ():

r = float (input('O raio da esfera e: '))
(area, volume) = area_volume_esfera (r)
print ('A área da esfera e %d e o seu volume e %d' % (area, volume))

9
Instruções Condicionais – if…elif…else

if condição 1:
bloco de instruções a executar quando a condição 1 é verdadeira
elif condição 2:
bloco de instruções a executar quando a condição 2 é verdadeira
else:
bloco a executar quando as condições anteriores são falsas

def greet(friend, money):

if friend and (money > 20):
print ("Hi!")
money = money - 20
elif friend:
print ("Hello")
else:
print ("Ha ha")
money = money + 10
return money

'''If the person I meet is my friend and I have more than 20$ I say Hi! and give
him 20$. If I meet a friend but don’t have 20$ I say Hello! And don’t give him
any money. If the person I meet is not my friend I say Ha ha and get 10$'''

money = 15
money = greet (True, money) # Run: Hello
print ("Money:", money) # Run: Money: 15

money = greet (False, money) # Run: Ha ha

print ("Money:", money) # Run: Money: 25

money = greet (True, money) # Run: Hi!

print ("Money:", money) # Run: Money: 5

10
def conversoes_monetarias (escolha, escudos):
''' Converte escudos noutra unidade monetária à escolha'''
if escolha == 'a':
francos = 23.5 * escudos
return ('%d escudos = %d francos' % (escudos, francos))
elif escolha =='b':
libras = 300 * escudos
return ('%d escudos = %d libras' % (escudos, libras))
elif escolha =='c':
euros = escudos / 200.482
return ('%d escudos = %d euros' % (escudos, euros))
else:
return('Unidade monetária desconhecida')

def teste3 ():

escudos = float (input ('Insira o valor em escudos: '))
escolha = input ('Deseja converter para:\na) Francos\nb) Libras\nc) Euros\
n')
moeda = conversoes_monetarias (escolha, escudos)
print (moeda)

11
Instruções cíclicas

While
O bloco de código dentro do while é repetido enquanto a condição for
verdadeira.
Adequado quando não há como determinar quantas iterações vão ocorrer
e não há uma sequência a seguir
while (condição):
bloco de instruções a executar enquanto a condição for verdadeira

# Soma de 0 a 99
s = 0
x = 1
while x < 100:
s = s + x
x = x + 1
print (s)

For
Iteração sobre os items de uma qualquer sequência (ex.: lista ou
string), na ordem em que eles se encontram na sequência.
for variável a iterar in sequência:
bloco de instruções a executar em cada iteração

range (m, n, p) retorna uma lista de inteiros, começando em m e

menores que n, em passos de comprimento p
for i in range(10): (0 a 9)
for i in range(5,10): (5 a 9)
for i in range(5,20,2): (5 a 19 com um intervalo de 2 unidades)
for i in range(10,0,-1): (sentido inverso --> 10 a 1)

# Soma de 0 a 99
s = 0
for x in range (1, 100):
s = s + x
print (s)

12
Controlo de estruturas de fluxo

Por vezes quando é atingido determinado critério na execução de um

ciclo pretende-se interromper esse mesmo ciclo ou então passar para a
próxima iteração ou declaração. Para isso, o Python tem as instruções
break (permite interromper um ciclo for ou while) e continue (força o
interpretador a passar para a próxima iteração interrompendo a actual).~

name = 'bioinformatica'
for i in name:
if i == 'm':
break
print (i) # Run: bioinfor

name = 'bioinformatica'
for i in range (len (name)):
if i >= 5 and i <= 8:
continue
print (name [i]) # Run: bioinatica

13
Coleção de dados

Em Python existem três tipos de coleções: listas, tuplos e

dicionários.

Colecção Mutável Indexação

Lista Sim Ordenada

Tuplo Não Ordenada

Dicionário Sim Desordenada

Listas
Variáveis capazes de guardar um conjunto de objectos de vários tipos
(strings, valores numéricos, listas, etc...). Uma lista é uma sequência
de objectos ordenados, em que se pode acrescentar, remover e modificar
objectos. Esta define-se através do uso de parêntesis rectos como
delimitadores, em que os seus elementos são separados por vírgulas.
l = []
l1= [1, 2, 3]
l2 = ['Ana', 'Isa', 'Hugo', 'Joaquina']

Consultar listas
s [i] Elemento da lista que se encontra na posição i

s [i:j] Porção de s de i até j

s [i:j:k] Porção de s de i até j de passos k

x in s True se um elemento da lista s é igual a x

x not in s False se um elemento da lista s é igual a x

s.count (x) Número total de ocorrências de x na lista

s.index (x) Localização do elemento x na lista

print (l1 [0]) # Run: 1

print (l2 [1:3]) # Run: ['Isa', 'Hugo']
print (3 in l1) # Run: True
print (l1.index (2)) # Run: 1

14
Funções sobre listas
len (s) Comprimento da lista s

min (s) Elemento mais pequeno da lista s

max (s) Elemento maior da lista s

x.sort () Ordena a lista (crescente)

x.reverse () Inverte a lista

print (len (l), len (l1), len (l2)) # Run: 0 3 4

print (max (l1)) # Run: 3
print (min (l1)) # Run: 1

Modificar listas
s [i] = x O elemento da posição i é substituído por x

Os elementos de s [i:j] são substituídos pelos

s [i:j] = t
elementos de t

del s[i:j] s[i:j] = []

s.extend (t)
Junção das listas s e t
or s += t

s.append (x) Adiciona x ao fim da sequência

s.insert (i, x) Insere x na posição i

s.pop () Remove o último elemento da lista

s.pop ([i]) Remove o elemento que está na posição i

s.remove (x) Remove o primeiro elemento da lista que é igual a x

s.clear () Remove todos os elementos da lista

l2 [0] = 'Francisco'
print (l2) # Run: ['Francisco', 'Isa', 'Hugo', 'Joaquina']

l2.append ('Rosa')
print (l2) # Run: ['Francisco', 'Isa', 'Hugo', 'Joaquina', 'Rosa']

l2.pop ()
print (l2) # Run: ['Francisco', 'Isa', 'Hugo', 'Joaquina']

def sequencia ():

15
 ''' Cria uma lista com n números'''
seq = [] #lista
n = int (input ('Insira quantos elementos tem a sequência: '))
for i in range (n):
x = float (input ('Insira %.f número: ' % (i + 1)))
seq.append (x)
return (seq)

def maximo_sequencia ():

''' Encontra o máximo de uma lista'''
seq = sequencia ()
return (max (seq))
def teste4a ():
max = maximo_sequencia ()
print ('Máximo: %d' % max)

def maximo_sequencia2 (seq):

maximo = seq [0]
for i in range (1, len (seq)):
if seq [i] > maximo:
maximo = seq [i]
return (maximo)
def teste4b ():
seq = sequencia ()
maximo = maximo_sequencia2 (seq)
print ('Máximo: %d' % max)

def tres_max_min (seq):

16
 ''' Encontra os três maiores e menores números de uma sequência'''
maximos = []
minimos = []
if len(seq) >= 6:
while len (maximos) < 3:
maximos.append (max (seq))
seq.remove (max (seq))
while len (minimos) < 3:
minimos.append (min (seq))
seq.remove (min (seq))
return ('Três maiores: %r\nTrês menores: %r' % (maximos, minimos))
else:
return ('A sequência tem que ter 6 ou mais elementos')

def teste5 ():

seq = sequencia ()
x = tres_max_min (seq)
print (x)

def media (seq):

''' Faz a média dos valores da sequência'''
soma = 0
for i in seq:
soma += i
media = soma / len (seq)
return media

def teste6 ():

seq = sequencia ()
med = media (seq)
print ('Média dos elementos da sequência: %d' % med)

17
Tuplos
Semelhantes as listas, porém são imutáveis: não se pode acrescentar,

apagar ou fazer atribuições aos itens. Ex: tuplo = () ou tuplo = ('maria',

3, 0.89).
Os tuplos são mais eficientes do que as listas convencionais, pois
consomem menos recursos computacionais (memória), por serem estruturas
mais simples.
Funções len, max, min funcionam coma nas listas, no entanto, funções
que tentam mudar os tuplos dão erro.
Listas podem ser convertidas em tuplos: tuple (lista)
E tuplos podem ser convertidas em listas: list (tupla)

Dicionários
Um dicionário é uma lista de associações compostas por uma chave
única e estruturas correspondentes. Dicionários são mutáveis, tais como
as listas.
A chave precisa ser de um tipo imutável, geralmente são usadas
strings, mas também podem ser tuplas ou tipos numéricos. Já os itens dos
dicionários podem ser tanto mutáveis quanto imutáveis. O dicionário do
Python não fornece garantia de que as chaves estarão ordenadas.
Criação de um dicionário: dic = {'a': a, 'b': b,..., 'z': z}

dic.keys () Devolve a lista com as chaves

dic.values () Devolve lista com os itens

dic.get (x) Devolve o valor associado à chave x

del dic [x] Remove x do dicionário

x in dic Verifica a existência de x no dicionário

18
Matrizes

São implementadas como listas de uma lista, sendo que cada lista
representa uma linha da matriz.

19
Ficheiros

O python tem funções que permitem abrir, ler, manipular e escrever

sobre ficheiros. No entanto existe uma função principal open () que
guarda uma referência a um objecto do tipo arquivo, sobre o qual as
restantes funções podem ser utilizadas: open ('ficheiro', 'modo').

Modo Descrição

r Abre um ficheiro em modo de leitura

Abre um ficheiro em modo de leitura e escrita. O apontador

r+
inicia no início do ficheiro

w Abre um ficheiro em modo de escrita

Abre um ficheiro em modo de leitura e escrita. Sobre-grava um

w+
ficheiro existente, ou cria um novo caso não exista.

Abre um ficheiro para anexação. O apontador inicia no final do

a
ficheiro.

Abre um ficheiro para leitura e anexação. Caso já exista o

a+ ficheiro o apontador inicia no final, caso não exista cria um
novo em modo de leitura e escrita.

Existem cinco métodos distintos que poderão ser usados na

leitura/escrita do ficheiro e são estes:
 readline (): retorna uma linha completa incluindo os
caracteres (\n) que indicam uma nova linha
 readlines (): retorna uma lista com todas as linhas presentes
no ficheiro. Cada linha corresponde a um elemento da lista
 read (): retorna todo o conteúdo do ficheiro como uma única
string
 write (str): escreve uma string num ficheiro (grava apenas
texto como uma única string). Este método não pode gravar
objectos iteráveis (por exemplo: listas)
 writelines (seq): escreve uma sequência de strings para um
ficheiro, porém a diferença, é que este método pode escrever
objectos iteráveis (listas).

20
 Após ler ou escrever ficheiros existe uma função close () para
fechar esses mesmos ficheiros. É importante aplicar esta função após uma
tarefa de leitura ou escrita porque enquanto o ficheiro estiver aberto,
está-se desnecessariamente a ocupar recursos do sistema, principalmente
memória. A função é utilizada do seguinte modo: ficheiro.close ().

21
Classes

22
---------------------??????????????????????------------------------------
def factorial (n):
''' Calcula o fatorial de um número'''
if n < 0:
return ('{}. Fatorial não é definido por números negativos')
elif n == 0 or n == 1:
return (1)
else:
fatorial = n * factorial (n - 1)
return (fatorial)

def teste7 ():

n = float (input ('n = '))
f = factorial (n)
print ('%d! = %s' % (n, f))

23