Aula 15

Exception

try:
   ----
   ---- AAA
   ----
except:
   ----
   ----

Um erro/exception em AAA interrompe o bloco e executa o except

exceptions

NameError nome nao definido, variavel sem valor
TypeError
KeyError chave não existe no dicionario
IndexError index numa lista
MemoryError nao consegue alocar memoria

lista de exceptions predefinidas

user defined exceptions

outras versoes de try/except

Diferentes tratamentos para diferentes exceptions

try:
  ---
except TypeError:
  ---   
except (KeyError,IndexError):
  ---
except:
  ---

Nao usar except sem argumento

try: 
  ----
except Exception:
  ----

captura todas as exceptions menos control-C

Else e finally

try:
   ----
except Exception:
   ----
else:
   ---  so executa se nao houve exception

try:
   ----
except A:
   ----
finally:
   ---  sempre executa mesmo que tenha exceptions que nao foram pegas

finally sera discutido abaixo

outros

Como levantar uma exception: raise

Como definir sua propria exception

https://docs.python.org/3/tutorial/errors.html

Commando `pass`

try:
    ----
    ----
except  Exception as e:
    pass

truque p/ dicionários

try:
   dic[x]+=1
except:
   dic[x]=1

em vez de

if x in dic: 
   dic[x]+=1
else:
   dic[x]=1

pilha de execução

Exceções vão interrompendo a execução dos contextos (funções - pilha de execução) até que um except capture a exceção

def a():
   -- raise X

def b():
   ...
   a()
   ...
   
def c():
    ...
    b()
    ...
    
def d():
    try:
      c()
    except X:
      -- trata

a exceção gerada la dentro. Todos os contextos sao percorridos e removidos até chegar no d

O ambiente iterativo ou o ambiente em batch capturam todas as exceções que chegam neles - no ambiente em batch o programa é terminado. No iterativo só a pilha de execução é interrompida e a execução volta para o REPL

O finally (ate onde eu entendo)

def a()
    try:
        --- raise X
    finally:
        print(y)

o finally do a é executado antes de jogar a exceção para cima no contexto do a

Funções

def func(a,b,linha):
    ''' descricao 
       descricao'''
    ----
    ----
    ----
    return c

return

return expressao
return a,b - tupla
return None a funçao é sintaticamente/praticamente um procedimento/comando

def f(x):
    ----
    return None

f(4)

default arguments

def askok(prompt, retries=4, reminder='Please try again!'):
  ----

prompt é obrigatório

askok('Do you really want to quit?')
askok('Do you really want to quit?',2)
askok('Do you really want to quit?',2,'Sim ou nao')

Chamando a função

Parametros casados por posição:

askok('Do you really want to quit?',2,'Sim ou nao')

ou por nome:

askok(‘Do you really want to quit?’,remainder = ‘Sim ou nao’)
askok(‘Do you really want to quit?’,retries = 2)
askok(retries = 2,prompt = ‘Do you really want to quit?’)

http://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html

valores default

Cuidado: o default só é avaliado uma vez (quando a função é carregada??)

def f(a, L=[]):
    L.append(a)
    return L

print(f(1))
print(f(10))
print(f(30))

numero qq de argumentos

def somatoria(*lista):
    soma=0.0
    for x in lista:
       soma+=x
    return soma

todos os valores passados são coletados na lista

ha também a possibilidade de passar numero qq de argumentos por nome (a=3,b="string", velocidade=9.7) que sao coletados num dicionário (notação **var)

def somatoria(**dic):
    if "b" in dic and len(dic["b"]) > 10 :
    ---
    ---

Variaveis locais e globais

Não há declaracao de variáveis entao vc não sabe só vendo se uma variavel é local ou global

Uma variavel é em principio local se a função atribui um valor a ela

x=0
y=10

def f():
  x=100
  print(x+1)
  print(y+1)

f()
print(x)

x é local na funçao, y é global

Onde voce atribui o valor à variavel não é importante

x=0
y=10

def f():
  print(x+1)
  print(y+1)
  if False: 
     x=100   # nunca é executado!

f()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 4, in f
UnboundLocalError: local variable 'x' referenced before assignment

no caso acima, x é local por causa da atribuição que nunca é executada.

ATENCAO: Modificar uma variavel mutavel não é atribuir um valor a ela e não torna ela local

l={'a':1,'b':2,'c':3}
def ff():
  l['x']=44  # l é global


ff()
print(l)

global

a declaraçao global indica que a variavel sera global

x=0
def f():
  global x
  x=100
  print(x+1)
  print(y+1)


f()
x

Funcoes internas a outras funções

def fora(x):
   ---- 
   def dentro(y):
      ---
      z = x+y
      return z
   ---

x é local a fora mas é global para dentro O mais correto é dizer que x é não-local para dentro

nonlocal

def fora(x):
   z=10
   def dentro(y):
      z = x+y

z é local a dentro

z=100
def fora(x):
    z=10
    def dentro(y):
      nonlocal z
      z = x+y
    
    dentro(10)
    print("z fora = ",z)
    
fora(0)

z é o z de fora (mas z não é global).

z=100
def fora(x):
   z=10
   def dentro(y):
      global z
      z = x+y
   
   dentro(10) 
   print("z fora = ",z)

fora(0)

funções que retornam funções

def gg():

    def aux(l):
      l.reverse()
      return l

    return aux

a = gg()
a([1,2,3])

closures

def gera():
   x=0

   def aux():
     nonlocal x
     x +=1
     print(x)

   return aux

a = gera()

a()
a()
x

x é uma variavel local de gera e não local de aux mas que se mantem viva por todo o programa

escopo é a região do programa que pode acessar uma variável pelo seu nome
extensão é o duração temporal de uma variável
para variáveis locais a extensão é a duração do escopo, a não ser que a variável seja um clousure.

OO in Python

class

class Pessoa:
   def setidade(self,x):
       if x >0 :
         self.idade=x

   def getidade(self):
        return self.idade

Só dá para definir os métodos. (Normalmente) não há a definição de atributos/campos/variavies

Há sempre o parâmetro self para os metodos, que indicam o objeto sobre o qual o método esta sendo executado. Ate onde eu sei vc pode usar qq nome para o primeiro argumento, mas eu so vi self sendo usado.

objetos

Atribuos/campos/variaveis dos objetos são sempre visiveis e modificaveis!! Nao ha atributos privados

x=Pessoa()

x.setidade(12)
x.getidade()

x.idade

x.idade=99

x.nome="jose"

Usualmente indica-se um atributo privado usando dois underscores no inicio e no fim (regra para programadores, não para o ambiente de execução) __nome__

Construtor

Pessoa() cria um objeto, se existe isso chama o construtor __init__

class Pessoa:
   def __init__(self,idade,nome):
      if idade>0:
         self.idade=idade
      self.nome=nome

x = Pessoa(-45,"jose")

Herança

class Aluno(Pessoa):
   pass

a=Aluno()
isinstance(a,Aluno)
isinstance(a,Pessoa)

atributos de classe

class Pessoa:
   npernas=2

x=Pessoa()
y=Pessoa()

x.npernas
x.npernas=9
x.npernas
y.npernas
Pessoa.npernas
Pessoa.npernas=10
y.npernas
x.npernas

OO in python?

Usualmente não se cria um monte de objetos.

Usualmente objetos são uma interface para as bibliotecas