Paradigmas PYTHON

Prévia do material em texto

CENTRO DE ENSINO SUPERIOR FUCAPI – CESF
ENGENHARIA DA COMPUTAÇÃO
"Tendo, pois, tal esperança, usamos de muita ousadia no falar."
 Jesus de Nazaré
www.facebook.com/vsegueme www.twitter.com/vemesegueme30
LINGUAGEM DE PROGRAMAÇÃO PYTHON
MANAUS-AM
MAIO / 2011
�
CENTRO DE ENSINO SUPERIOR FUCAPI – CESF
ENGENHARIA DA COMPUTAÇÃO
ANDREZA CARVALHO DE SOUZA - 200810067
ALBERT OTTO - 
DELSON DO VALE ASSUNÇÃO - 2008100
JOEL SARMENTO BARROS – 200810055
PARADIGMAS DE LINGUAGENS DE PROGRAMAÇÃO
MANAUS-AM
MAIO / 2011
INTRODUÇÃO
O Python é uma linguagem de programação de alto nível criada por Guido Van Rossum, cuja primeira versão foi publicada em 1991. O Python suporta vários paradigmas de programação, como a programação estruturada, a programação orientada a objetos e também alguns elementos da programação funcional, mas nenhuma destas escolhas é imposta ao utilizador, sendo possível utilizar o paradigma que se achar mais adequado. As principais vantagens de usar Python são:
A qualidade do código: A sintaxe do Python facilita e encoraja a legibilidade do ódigo, o que o torna mais fácil de manter e reutilizar.
A produtividade do programador: É mais rápido desenvolver um mesmo código em Python do que noutras linguagens como o C, C++ ou Java.
O código é mais compacto, requerendo menos linhas, e não necessita da declaração prévia do tipo das variáveis. Para além disso, não requer um ciclo de compilação, podendo o programa ser executado imediatamente.
 A portabilidade: Muitos programas Python correm sem qualquer alteração em várias plataformas como o Linux e o Windows.
 Uma vasta biblioteca padrão
A linguagem Python é referida usualmente como uma linguagem de “scripting” pois é usualmente aplicada nessas tarefas, mas não existe uma diferença de fundo entre um “script” e um programa, sendo o primeiro entendido como um programa simples. Um uso comum do Python é o de servir de linguagem de controlo de componentes escritos noutra linguagem (como o C++), no entanto o Python não está limitado a tarefas simples, podendo ser usado em programas de qualquer dimensão. 
Uma possível desvantagem do Python em relação a outras linguagens de programação compiladas é a velocidade de execução, o que dadas as capacidades dos computadores actuais não é um problema para a maior parte dos programas. Para os programas em que essa diferença é importante, é sempre possível desenvolver a maior parte do programa em Python suplementado por um módulo chamado a partir do Python e desenvolvido noutra linguagem.
TIPOS DE DADOS
São categorias de valores que são processados de forma semelhante. Por exemplo, números inteiros são processados de forma diferente dos números de ponto flutuante (decimais) e dos números complexos.
Tipos primitivos: são aqueles já embutidos no núcleo da linguagem
Simples: números (int, long, float, complex) e cadeias de caracteres (strings).
Compostos: listas, dicionários, tuplas e conjuntos 
Tipos definidos pelo usuário: são correspondentes a classes (orienta-ção objeto).
VALORES NUMERICOS
Como já foi dito acima, o Python suporta números inteiros, reais e complexos, que podemos manipular
com as operações aritméticas convencionais (ver Tab. 2.1). Por exemplo
Listagem 2.1:
	n = 3*5**2 # Variável inteira
x = 3.14 / 2.0 # Variável real
z = 1 j # Variável complexa
Neste exemplo n = 3 · 52 = 75 e à variável z é atribuído o valor da unidade imaginária, que em Python é representada por j, mas que tem sempre que se seguir a um número para se distinguir da variável j. As operações que envolvam números inteiros e reais retornam um resultado real e as que envolvam dois inteiros devolvem um inteiro. Uma consequência importante desta última propriedade é que o mesmo operador divisão efetua a divisão inteira para dois valores inteiros, mas a divisão real quando um dos valores é real.
Listagem 2.2:
	print 1/3 #Imprime 0
print 1/3.0 #Imprime 0.333333333333
print 1.0 / 3.0 #Imprime 0.333333333333
Este comportamento vai mudar na versão 3.0 do Python, sendo então o operador / sempre a divisão real, e utilizando // para a divisão inteira. Podemos forçar esse novo comportamento já na versão actual do Python se a primeira linha do nosso programa for:
Listagem 2.3:
	from __future__ import d i v i s i o n
Tabela 2.1: Operadores aritméticos
	Operador
	Descrição
	+
-
*
/
//
**
%
	Soma
Subtração
Multiplicação
Divisão (real ou inteira)
Divisão inteira
Elevar a uma potência
Módulo (resto da divisão inteira)
"Tendo, pois, tal esperança, usamos de muita ousadia no falar."
 Jesus de Nazaré
www.facebook.com/vsegueme www.twitter.com/vemesegueme30�
CADEIA DE CARACTERES
As cadeias de caracteres são delimitadas em Python por ` ou ". Por exemplo:
Listagem 2.4:
	s = " abcde f "
mensagem = 'Olá , Mundo ! '
Estas cadeias de caracteres não podem ter mudanças de linha. Se for necessário incluir mudanças de linha pode-se ou colocar explicitamente o código de mudança de linha \n ou usar aspas triplas """.
Listagem 2.5:
	s2 = "Linha 1\ nLinha2 "
mensagem_longa = """Ao iniciarmos uma cadeia de caracteres com aspas triplas podemos usar mudanças de linha sem que isso constitua um erro de sintaxe """
Podemos aceder a caracteres individuais ou secções de uma cadeia de caracteres usando a notação de parêntesis retos e sequênciais:
Listagem 2.6:
	s = " abcde f "
print len ( s ) #A função l en ( s ) devolve o tamanho de s ,
 # neste caso 6
print s [ 0 ] #Imprime o primeiro caracter de s , ' a '
print s [−1] #Índices negativos contam a partir do fim ,
 #neste caso ' f '
print s [ 2 : 4 ] #Sequência de índices , o primeiro é 2 e
 #menor que 4 (2 e 3) , neste caso imprime ' cd '
A sintaxe geral de uma sequência é inicio:m:incremento, em que cada um destes valores é opcional.
Listagem 2.7:
	s = " abcde f "
print s [ : : 2 ] #Todos os elementos , incremento 2 ,
 #imprime ' ace '
print s [ : : −1 ] #Todos os e lementos em ordem inv e r sa ,
 #imprime ' f e d c b a '
print s [ 3 : ] #I n í c i o no í n d i c e 3 , imprime ' d e f '
LISTAS
Uma lista é um conjunto ordenado de objetos. Uma lista pode ser alterada,inserindo, apagando ou substituindo um ou mais elementos. Em Python as listas são delimitadas por parêntesis retos.
Listagem 2.8:
	l = [ 3 . 1 4 , " pi " , 7 ]
print l [ 0 ] #Imprime 3.14
l [ 2 ] += 3 # Agora l é [ 3 . 1 4 , " p i " ,10]
l . append (1 j ) #Ins e r e o número complexo 1 j
 #no f im da l i s t a
As listas, tal como as cadeias de caracteres e tuplos suportam inde
usando sequências.
Listagem 2.9:
	l = [ 1 , "a" , 3 . 1 4 , 2 . 7 1 8 ]
print l [ : 2 ] #Imprime [ 1 , ' a ' ]
Tabela 2.2: Métodos das listas
	Método
	Descrição
	insert(i,v)
append(v)
remove(v)
pop()
index(v)
count(v)
sort()
reverse()
	Insere o valor v na posição i
Acrescenta o valor v ao �m da lista
Remove da lista o primeiro item com valor v
Retorna o último valor da lista, removendo-o.
Retorna o índice da primeira ocorrência de v. Se não existir retorna um erro.
Número de vezes que v está na lista
Ordena a lista
Inverte a ordem dos elementos dalista
	print s [ 4 : 2 ] #I n í c i o no í n d i c e 4 , termina no 2 ,
 #como não corresponde a nenhum índice
 #p o s s í v e l , r e torna uma cadeia de
 #c a r a c t e r e s vaz ia , ' '
Em Python as cadeias de caracteres são imutáveis e embora possamos aceder a caracteres individuais não os podemos alterar:
	In [1]: s = “abc”
In [2]: s[0] = “z”
TypeError: 'str' object does not support item assignment
Podemos no entanto atribuir à mesma variável um novo valor construído com base no anterior:
	In [1]: s = “abc”
In [2]: s = “z” + s[1:]
In [3]: print s
zbc
TUPLOS
Os tuplos são sequências ordenadas de objectos, semelhantes às listas, mas imutáveis. Os tuplos são delimitados por parêntesis.
Listagem 2.10:
	t = ( 1 , " abc " , 5 . 0 , 7 . 4 )
print t [ 1 : 3 ] #Imprime ( ' abc ' , 5 . 0 )
t2 = ( 1 0 , ) #Um t u p l o com apenas um elemento
Para criar um tuplo com apenas um elemento é necessário por uma vírgula a seguir esse elemento, de outra forma seria apenas um valor entre parêntesis. Os próprios parêntesis são opcionais onde tal não é ambíguo:
Listagem 2.11:
	a = 10
b = 20
a , b = b , a #Operação ent r e tup l o s , apesar de não ter
 #p a r e n t e s i s . Agora a=20 e b=10
DICIONÁRIO
Um dicionário associa valores a chaves. As chaves têm de ser valores imutáveis (números, cadeias de caracteres ou tuplos destes), sendo associadas um valor que pode ser qualquer objecto Python.
Listagem 2.12:
	d = { } #Um d i c i o n á r i o v a z i o
d [ 1 ] = " abc " #As socia o v a l o r " abc " à chave 1
Podemos ver quais são as chaves de um dicionário com o método keys()
Listagem 2.13:
	d = { 1 : "um" , 2 : " do i s "}
print d . keys ( ) #Imprime [ 1 , 2 ]
i f 2 in d :
print "O d i c i o n á r i o tem a chave 2 , com o v a l o r " ,d [ 2 ]
Python também permite a definição dos tipos de dados próprios, através de classes. Instâncias são construídas invocando a classe (FooClass()), e as classes são instância da classe type, o que permite metaprogramação e reflexão. Métodos são definidos como funções anexadas à classe, e a sintaxe instância.método(argumento) é um atalho para Classe.método(instância, argumento). Os métodos devem referenciar explicitamente a referência para o objeto incluindo o parâmetro self como o primeiro argumento do método.[23]
Antes da versão 3.0, Python possuia dois tipos de classes: "old-style" e "new-style". Classes old-style foram eliminadas no Python 3.0, e todas são new-style. Em versões entre 2.2 e 3.0, ambos tipos de classes podiam ser usadas. A sintaxe de ambos estilos é a mesma, a diferença acaba sendo de onde objeto da classe é herdado, direta ou indiretamente (todas classes new-style herdam de object e são instancias de type). As classes new-styles nada mais são que tipos definidos pelo usuário.
TRATAMENTO DE EXCEÇÕES
Python suporta e faz uso constante de tratamento de exceções como uma forma de testar condições de erro e outros eventos inesperados no programa. É inclusive possível capturar uma exceção causada por um erro de sintaxe. O estilo da linguagem apóia o uso de exceções sempre que uma condição de erro pode aparecer. Por exemplo, ao invés de testar a disponibilidade de acesso a um recurso, a convenção é simplesmente tentar usar o recurso e capturar a exceção caso o acesso seja rejeitado (recurso inexistente, permissão de acesso insuficiente, recurso já em uso, ...).
Exceções são usadas frequentemente como uma estrutura de seleção, substituindo blocos if-else, especialmente em situações que envolvem threads. Uma convenção de codificação é o EAFP, do inglês, "é mais fácil pedir perdão que permissão". Isso significa que em termos de desempenho é preferível capturar exceções do que testar atributos antes de os usar. Segue abaixo exemplos de código que testam atributos ("pedem permissão") e que capturam exceções ("pedem perdão"):
	Teste de atributo 
if hasattr(spam, 'eggs'):
 ham = spam.eggs
else:
 handle_error()
	Captura de exceção 
try:
 ham = spam.eggs
except AttributeError:
 handle_error()
Ambos os códigos produzem o mesmo efeito, mas há diferenças de desempenho. Quando spam possui o atributo eggs, o código que captura exceções é mais rápido. Caso contrário, a captura da exceção representa uma perda considerável de desempenho, e o código que testa o atributo é mais rápido. Na maioria dos casos o paradigma da captura de exceções é mais rápido, e também pode evitar problemas de concorrência.[27] Por exemplo, num ambiente multitarefa, o espaço de tempo entre o teste do atributo e seu uso de fato pode invalidar o atributo, problema que não acontece no caso da captura de exceções.
Exceções 
Em geral, com laços convencionais, todas as necessidades `normais' de controle de um programa podem ser implementadas. No entanto, quando algo inesperado ocorre, ou uma condição de erro conhecido é atingida, Python oferece uma forma adicional de controlar o fluxo de execução: a exceção. 
A exceção é um recurso de linguagens de programação modernas que serve para informar que uma condição incomum ocorreu. Embora existam outras aplicações, em geral comunicam-se através de exceções erros ou problemas que ocorrem durante a execução de um programa. 
Exceções são internamente geradas pelo interpretador Python quando situações excepcionais ocorrem. No exemplo abaixo, 
 >>> a = [1, 2, 3]
 >>> print a[5]
o código interno do interpretador sabe que não podemos acessar uma lista através um índice não-existente, e gera uma exceção: 
 Traceback (most recent call last):
 File "<stdin>", line 1, in ?
 IndexError: list index out of range
Vamos analisar a mensagem exibida. A primeira linha anuncia um traceback, que é a forma como é exibida a pilha de execução que gerou a exceção. A segunda indica a linha de código na qual ocorreu o problema, e o arquivo. Como estamos usando o modo interativo neste exemplo, o arquivo aparece como <stdin>, que é a entrada padrão. A terceira linha indica o tipo de exceção levantada -- neste caso, IndexError -- e informa uma mensagem que descreve mais especificamente o problema. 
Tratando exceções 
A exceção normalmente imprime um traceback e interrompe a execução do programa. Uma ação comum é testar e controlar a exceção; para este fim, usamos uma cláusula try/except: 
 >>> a = [1, 2, 3]
 >>> try:
 ... print a[5]
 ... except IndexError:
 ... print "O vetor nao possui tantas posições!"
 O vetor nao possui tantas posições!
A instrução try captura exceções que ocorrerem no seu bloco de código; a linha except determina quais tipos de exceção serão capturados. A sintaxe da cláusula except segue os formatos: 
 except tipo_da_excecao [, variavel_da_excecao]:
 # bloco de código
ou 
 except (tipo_excecao_1, tipo_excecao_2, ...) 
 [, variavel_da_excecao]:
 # bloco de código
O primeiro elemento da cláusula except é um tipo da exceção, ou uma tupla de tipos caso múltiplas exceções devam ser tratadas da mesma forma. O segundo elemento é opcional; permite que seja capturada uma instância que armazena informações da exceção. Um uso trivial desta instância é imprimir a mensagem de erro: 
 >>> a = "foo"
 >>> print a + 1
 Traceback (most recent call last):
 File "<stdin>", line 1, in ?
 TypeError: cannot add type "int" to string
Podemos capturar e tratar de forma especial o erro acima, imprimindo a mensagem fornecida e continuando a execução normalmente. 
 >>> try:
 ... print a + 1
 ... except TypeError, e:
 ... print "Um erro ocorreu: %s" % e
 ... 
 Um erroocorreu: cannot add type "int" to string
 >>>
Diversos tipos de exceções vêm pré-definidas pelo interpretador Python; o guia de referência contém uma lista completa e os casos onde são levantadas. Note também que esta introdução a exceções não cobre a sua sintaxe completa; consulte a seção Errors and Exceptions do tutorial Python para maiores detalhes. 
ESTRUTURAS DE CONTROLE
 Estrutura if
E estrutura do if do Python não é muito diferente ao if de outras linguagens de programação, exceto pela ausência de delimitador de bloco de comandos, que no Python é feita pela indentação do texto. Sua sintaxe é apresentada abaixo:
if <condição 1>:
 <comandos>
elif <condição 2>:
 <comandos>
elif <condição 3>:
 ...
else:
 <comandos>
Os elif (contração else + if) e o else são opcionais na estrutura do if. As condicionais foram apresentadas na seção 2.7.1. Booleanos e condicionais.
Segue abaixo um pequeno programa para fazer uma simples checagem da paridade de um número:
	1
2
3
4
5
6
7
8
9
10
11
12
	#!/bin/env python
# -*- coding: iso-8859-1 -*-
# Verifica se um número é par ou impar
#
n = input("Entre com um inteiro: ")
if type(n) == int:
 if (n % 2) == 0:
 print '%d é um par' % n
 else:
 print '%d é impar' % n
else:
 print 'Este número (%s) não é um inteiro!' % n
O comando input, introduzido no código acima, permite a entrada apenas de valores numéricos. Para a entrada de strings, deve-se usar o raw_input, que possui uma sintaxe semelhante ao input.
Estrutura for
A estrutura de laço for segue a mesma ideia do for do bash, com a adição da sentença else. No laço for, a variável do laço alterna seu conteúdo com os valores da lista passada e caso nenhum break seja encontrado, até que o último elemento da lista seja processado, os comandos da sentença else serão executados. Sua sintaxe segue a forma abaixo:
for <variável> in <lista ou tupla de valores>:
 <comandos>
 ...
 break
 ...
 continue
else:
 <comandos>
O break, continue e o else são opcionais. O break e o continue podem aparecer em qualquer nível de indentação, dentro do laço for. Ao alcançar um break, o laço irá terminar imediatamente, enquanto que um continue irá iniciar, imediatamente, a próxima interação do laço for.
Abaixo segue alguns exemplos de laços for, executados no interpretador Python:
>>> semana = ['dom', 'seg', 'ter', 'qua', 'qui', 'sex', 'sab']
>>> for s in semana:
... print s,
...
dom seg ter qua qui sex sab
>>> for d in range(30):
... if (d+1) % 7 == 0:
... print '%4s' % (d+1)
... else:
... print '%4s' % (d+1),
...
 1 2 3 4 5 6 7
 8 9 10 11 12 13 14
 15 16 17 18 19 20 21
 22 23 24 25 26 27 28
 29 30
A função range(i[, j]) é muito útil para gerar listas com uma progressão numéricas no intervalo de i a j-1. Se j for omitido a lista gerada será de zero a i-1. Alguns exemplos abaixo podem ajudar a elucidar o funcionamento desta função.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5, 12)
[5, 6, 7, 8, 9, 10, 11]
Para terminar a apresentação do for, um clássico algorítimo para imprime os primos no intervalo de 1 a n, com o emprego do break e else:
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
	#!/bin/env python
# -*- coding: iso-8859-1 -*-
# primo1.py: imprime os primos
print 'Imprime os números primos de 1 até n.\n'
 
# Entra com o limite:
n = input('Entre com o limite superior para o primo: ')
 
print '\nSão primos:'
print 1,
for i in range(2, n):
 for j in range(2, i):
 if i % j == 0:
 break
 else:
 print i,
O break é empregado para interromper o for interno, a cada vez que o resto da divisão do número testado é nulo, que indica ter encontrado um divisor.
List Comprehension
List Comprehension é uma forma curta de se criar uma lista a partir de um laço for embutido. Sua sintaxe é apresentada a seguir:
 [ expressão_com_var for var in lista_de_valores if <condicional> ]
O if é opcional. Os dois exemplos a segui geram uma lista de múltiplos de 4:
>>> [ 4*x for x in range(1,11)]
[4, 8, 12, 16, 20, 24, 28, 32, 36, 40]
>>> [ x for x in range(1,41) if x % 4 == 0 ]
[4, 8, 12, 16, 20, 24, 28, 32, 36, 40]
Vários List Comprehension podem ser associados em uma única lista:
>>> [ '%d%d' % (x, y) for x in range(2) for y in range(2)]
['00', '01', '10', '11']
Generator Expression
Generator Expression são similares a List Comprehension, com um diferença fundamental, ele retorna um iterador a uma tupla e não uma lista.
	( expressão_com_var for var in lista_de_valores if <condicional> )
>>> b = ( '%d%d' % (x, y) for x in range(2) for y in range(2))
>>> for i in b: print i
...
00
01
10
11
>>> b
<generator object <genexpr> at 0x7fece5bb8690>
Uma grande vantagem de Generator Expression com relação a List Comprehension é o uso de recursos, já que estas primeiras utilizam estruturas mais simples, próprias para o uso em laços e acessos sequências, um iterador.
Estrutura while
O laço while é empregado quanto se deseja realizar um teste a cada interação do laço. O while também suporta as sentenças break, continue e else, como no laço for. Sua sintaxe é apresentada a seguir:
while <contição>:
 <comandos>
 ...
 break
 ...
 continue
else:
 <comandos>
O código a seguir retorna os primos no intervalo de 1 a n, usando uma técnica diferente da apresentada no exemplo anterior.
	1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
	#!/bin/env python 
# -*- coding: iso-8859-1 -*- 
# primo2.py: imprime os primos 
from math import sqrt 
 
print 'Imprime os números primos de 1 até n.\n'
 
# Entra com o limite:
n = input('Entre com o limite superior para o primo: ')
 
print '\nSão primos:'
a = range(n+1)
r = int(sqrt(n))
for i in range(2, r):
 if a[i] == 0:
 continue
 j = i+i
 while j <= n:
 a[j] = 0
 j += i
 
for i in range(n+1):
 if a[i] != 0:
 print i,
A ideia consiste em remover os múltiplos dos primos, de uma lista com todos os números até o último valor passado para se determinar o número primo. A linha 4 apenas carrega a função sqrt, raiz quadrada, do módulo math.
Embora seja bem mais dispendioso no consumo de memória que o código anterior, este último código consegue gerar os primos até 10.000, oitenta vezes mais rápido que o anterior.
As instruções break e continue
As instruções break e continue podem ser usadas dentro de ciclos for e while.
A instrução break causa uma saída imediata do ciclo, o continue interrompe o processamento do resto do bloco de código do ciclo, passando de imediato à próxima iteração.
�
SUB-PROGRAMAS
Programas são divididos em sub-programas, cada sub-programas é invocado por meio de um identificador e uma lista de entradas, os resultados computados por um sub-programa pode ser combinado com os de outro sub-programa.
Em Python, sub­programas têm o nome de funções.
FUNÇÕES
Uma função é um bloco de código ao qual são opcionalmente passados parâmetros e pode retornar um único valor. Por exemplo podemos escrever o exemplo de uma tabuada como sendo
Listagem 4.1:
	def tabuada (n ) :
 print "A tabuada do" ,n , " é : "
 for i in range ( 1 , 1 1 ) :
 print n , "*" , i , "=" ,n* i
tabuada ( 9 ) #Chama a função tabuada que
 #acabamos de de f i n i r para n=9
Uma função é definida pela instrução def, que é seguida pelo nome da função e por parêntesis, que contêm a lista de parâmetros. Opcionalmente uma função pode usar a instrução return, que termina a função e retorna ao chamador. A instrução return pode ser seguida de um valor, sendo esse o valor da chamada da função.
Listagem 4.2:
	def soma ( a , b ) :
 return a+b
c = soma ( 2 , 3 )
print soma ( " abc " , " de f " ) # Imprime a b c d e f
�
Neste exemplo de�nimos uma função que retorna a soma de dois números, sendo o resultado atribuído à variável c. Mesmo que uma função retorne um valor, não é obrigatório atribuir esse valor a uma variável, podendo este ser ignorado se assim o desejarmos. A função soma não tem de ser usada apenas com números, mas pode receber qualquer tipo de dados que possam ser somados com o operador “+” , como cadeias de caracteres.
À primeira linha de definição de uma função pode opcionalmente seguir-se uma cadeia de caracteres. Nesse caso essa cadeia de caracteres é a cadeia de documentação da função (“docstring”). Essa cadeia de caracteres é então associada à própria função, e pode ser consultada usando os mecanismos de introspecção do Python ou por programas (como IDEs) que as reconheçam.
Listagem 4.3:
	def soma ( a , b ) :
 """A função soma devolve a soma dos s eus pâramet ros """
 return a+b
Funções base do Python
O Python têm algumas funções pré-definidas, que fazem parte da linguagem.
Estas incluem:
ˆ abs(x) - Retorna o valor absoluto de x
ˆ all(iteravel) - Retorna verdade se todos os elementos da expressão iterável são verdadeiros.
ˆ any(iteravel) - Retorna verdade se algum dos elementos da expressão iterável for verdadeiro.
ˆ bool(x) - Converte x para booleano, isto é, retorna True ou False de acordo com as regras expostas na Sec. 3.1.
ˆ chr(x) - Retorna o caracter com código ASCII x.
ˆ cmp(x,y) - Retorna um valor inteiro que é negativo se x<y, zero se x=y e positivo se x>y.
ˆ complex(s) - Converte a cadeia de caracteres s para um número complexo.
ˆ complex(re,im) - Retorna o número complexo re + 1j*im onde re e im são números reais.
ˆ dir(objecto) - O parâmetro objecto é opcional. Se for passado retorna uma lista dos atributos válidos do objecto (como funções e variáveis), caso contrário retorna o conteúdo da tabela de símbolos local.
ˆ divmod(a,b) - Sendo a e b números retorna um par de números que são o resultado da divisão inteira e o resto da divisão inteira de a por b.
ˆ enumerate(iteravel) - Retorna um objecto iterável que vai devolver tuplos com dois elementos, sendo o primeiro um valor que começa em zero e vai sendo incrementado, o segundo é o valor do iteravel que lhe foi passado como argumento.
 eval(expressao) - Avalia a expressão contida na cadeira de caracteres expressao. Por exemplo eval(“2+3”) retorna 5.
 lter(f,iteravel) - Retorna uma lista constituída por todos os elementos de iteravel para os quais a função f retornou True.
 oat(x) - Converte para número real o número ou cadeia de caracteres x.
 globals() - Retorna um dicionário contendo a tabela de símbolos global.
ˆ help() - Activa o sistema interactivo de ajuda. Se for passado um parâmetro, mostra ajuda acerca desse objecto.
ˆ hex(n) - Retorna uma cadeia de caracteres com a representação hexadecimal do número inteiro n.
ˆ int(x) - Converte para inteiro o número ou cadeia de caracteres x.
ˆ len(s) - Retorna o tamanho da cadeia de caracteres, tuplo, lista ou dicionário s.
ˆ list(iteravel) - Retorna uma lista com todos os elementos de iteravel.
ˆ locals() - Retorna um dicionário contendo a tabela de símbolos local.
ˆ map(f,iteravel1,...) - Recebe uma função f e um ou mais iteráveis. A função f tem de receber tantos parâmetros quantos iteráveis forem passados.Retorna uma lista constituída pelo resultado de f aplicada aos elementos dos iteráveis.
ˆ max(iteravel) - Retorna o valor máximo de entre os elementos de iteravel.
ˆ max(valor1,valor2,...) - Quando a função max() é chamada com mais do que um parâmetro, devolve o máximo desses parâmetros.
ˆ min() - Semelhante à função max(), mas retorna o valor mínimo.
ˆ open(�cheiro,[modo]) - Abre um �cheiro. Para mais detalhes ler todo o livro.
ˆord(c) - Retorna o código ASCII ou código Unicode do caracter c.
ˆpow(x,y) - Retorna x elevado a y. Equivalente a x**y.
ˆrange() - Cria uma lista contendo uma sequência. 
ˆraw_input(prompt) - Imprime prompt e devolve uma cadeia de caracteres que leu da entrada padrão, que é normalmente o teclado. Esta função é útil para pedir valores ao utilizador.
ˆreduce(f,iteravel) - Aplica a função de dois parâmetros f cumulativamente aos valores de iterável, de forma a reduzir iteravel a um único valor. Por exemplo, usando a função soma da Listagem 4.3, reduce(soma,[1,2,3,4]) retorna 10, pois primeiro chama a função soma com 1 e 2, depois com 3 e 3, e �finalmente com 6 e 4.
ˆ reload(modulo) - Volta a carregar o módulo especificado. Ver a Sec. 4.2 para mais detalhes.
ˆ repr(x) - Retorna uma cadeia de caracteres com uma representação do objecto x, que é o mesmo que seria impresso com “print x”.
ˆ reversed(seq) - Retorna um iterável constituído pelos elementos de seq pela ordem inversa.
ˆ round(x) - Arrendonda o valor real x. Opcionalmente pode receber um segundo parâmetro inteiro que indica o número de casas decimais a manter.
ˆ sorted(iteravel) - Retorna uma lista ordenada constituída pelos valores de iteravel.
ˆ str(x) - Converte o objecto x para cadeia de caracteres.
ˆ sum(iteravel) - Retorna a soma dos valores de iterável.
ˆ tuple(iteravel) - Retorna um tuplo constituído pelos elementos de iteravel, mantendo a ordem destes.
ˆ unichr(n) - Retorna o caracter Unicode correspondente ao código n.
ˆ xrange() - Semelhante a range, mas retorna um iterável e não uma lista, e está optimizado para a velocidade e menor consumo de memória do que o range(). A diferença entre o xrange() e o range() só é importante para sequências com muitos elementos.
ˆ zip(iteravel1, iteravel2, ...) - Retorna uma lista de tuplos, em que o n-ésimo elemento da lista consiste num tuplo dos n-ésimos valores dos iteráveis.
EXPRESSÕES
Meio fundamental de especificar computações em uma linguagem de programação.
Para entender a avaliação de expressões é necessário estar familiarizado com a ordem de avaliação de operadores e de operandos avaliação de operadores e de operandos.
A essência das linguagens de programação imperativas é dada pelo papel predominante das instruções de atribuição, cujo objetivo é mudar o valor de uma variável.
Expressões Aritméticas
A avaliação automática de expressões aritméticas foi uma das principais metas das primeiras linguagens de programação.
Expressões aritméticas consistem de operadores, operandos, parênteses e chamadas a função.
Questões de projeto
–Regras de precedência de operadores;
–Regras de associatividade dos operadores;
–Ordem de avaliação dos operandos;
–Efeitos colaterais da avaliação dos operandos;
–Sobrecarga de operadores;
–Mesclagem de modos nas expressões.
Operadores
–Unário;
–Binário;
–Ternário.
Precedência e Associatividade
Como deve ser avaliada a seguinte expressão: a+b*c**d**e/f ?
•Deveria ser
– ((((a+b)*c)**d)**e)/f – ((((a+b)*c)**d)**e)/f
–a+(((b*c)**d)**(e/f))
–a+((b*(c**(d**e)))/f)
•A última opção é usada por Fortran
Ordem de avaliação dos operadores
As regras de precedência para avaliação de expressões definem a ordem na qual operadores adjacentes de diferentes níveis de precedência são avaliados.
• Níveis de precedência comuns:
– parênteses
– operadores unários
– ** (se a linguagem o suporta)
– *, /
– +, -
Regras de associatividade
Regras de associatividade para avaliação de expressões definem em qual ordem operadoresadjacentes de mesma precedência são avaliados.
Regras de associatividade comuns
Da esquerda para a direita, exceto **, o qual é da direita para a esquerda a esquerda.
Em APL todos os operadores têm precedência iguais e são associativos da direita para a esquerda.
Regras de precedência e de associatividade podem ser substituídas pelo uso de parênteses.
Expressões Condicionais
•Operador ternário?
•C, C++ e Java
–Um exemplo:
 average = (count == 0)? 0 : sum/count
 –if-then-else equivalente
 if (count == 0) 
 average = 0
 else average = sum /count
"Tendo, pois, tal esperança, usamos de muita ousadia no falar."
 Jesus de Nazaré
www.facebook.com/vsegueme www.twitter.com/vemesegueme30
Trabalho realizado pela disciplina de Paradigmas de Linguagens de Programação, ministrado pela professora Kellen Pinagé, referente à segunda nota parcial do 6º período do curso de Engenharia da Computação.