Exame Normal

1.
(a)Identidade: referência para a zona da memória onde se encontra armazenado o objecto. Valor: o estado do objecto num dado momento, em termos simples,o seu conteúdo. Tipo: determina o conjunto de valores e as operações que podem ser efectuadas com os objectos do tipo.


(b)As chaves de um dicionário têm que ser objectos imutáveis.

2.
Nas duas primeiras linhas associamos nomes diferentes ao mesmo objecto, logo a identidade tem que ser a mesma. Na terceira linha criamos uma cópia desse objecto e associamos-lhe o nome c. Assim neste último caso a identidade tem que ser diferente. A figura ilustra a situação.





3.

Para a soma de uma constante a um vector apresentamos duas soluções.

def soma_constante(c, vector):
    """ Soma a constante c a cada uma das componentes do vector v."""
    return [ c + elem for elem in vector]

def soma_constante_b(c, vector):
    """ Soma a constante c a cada uma das componentes do vector v."""
    res= []
    for elem in vector:
        res.append(c+elem)
    return res

4.
De um ficheiro a um dicionários de frequências. Apresenta-se primeiro uma solução simples, mas que é aceite como resposta correcta.

def fich_dic_a(ficheiro):
    """ Lê o conteúdo do ficheiro e constrói um dicionário 
    com chave um inteiro e valor uma lista com as palavras de
    comprimento igual ao valor da chave.
    """
    f_in = open(ficheiro, 'r')
    lista_pal = f_in.read().split()
    dic = {}
    for palavra in lista_pal:
        comp = len(palavra)
        dic[comp] = dic.get(comp,[]) + [palavra]
    return dic

Agora uma solução que prevê o uso de símbolos especiais.

def fich_dic_b(ficheiro):
    """ Lê o conteúdo do ficheiro e constrói um dicionário 
    com chave um inteiro e valor uma lista com as palavras de
    comprimento igual ao valor da chave.
    """
    f_in = open(ficheiro, 'r')
    lista_pal = f_in.read().split()
    dic = {}
    especiais = ['\n','.',',','!','?']
    for palavra in lista_pal:
        if palavra[-1] in especiais:
            palavra = palavra[:-1]
        comp = len(palavra)
        if comp:
            dic[comp] = dic.get(comp,[]) + [palavra]
    return dic

Notar o uso de uma lista onde guardamos caracteres especiais que não devem fazer parte da palavra. Notar ainda o teste ao comprimento: se um símbolo estiver isolado, ao ser retirado passa a ser uma cadeia sem caracteres e não deve ser incluída.

Finalmente, uma solução em que as palavras repetidas só são incluídas um vez.

def fich_dic_c(ficheiro):
    """ Lê o conteúdo do ficheiro e constrói um dicionário 
    com chave um inteiro e valor uma lista com as palavras de
    comprimento igual ao valor da chave.
    """
    especiais = ['\n','.',',','!','?']
    f_in = open(ficheiro, 'r')
    lista_pal = f_in.read().split()
    # filtra
    lista_final = []
    for palavra in lista_pal:
        # símbolos especiais fora
        if palavra in especiais:
            continue
        elif palavra[-1] in especiais:
            palavra = palavra[:-1]
        # repetições fora
        if palavra not in lista_final:
            lista_final.append(palavra)   
    # Constrói dicionário   
    dic = {}
    for palavra in lista_final:
        comp = len(palavra)
        dic[comp] = dic.get(comp,[]) + [palavra]
    return dic

5.
Nesta solução temos uma definição auxiliar (tri) para desenhar um triângulo incompleto. O programa main é responsável por usar este programa, tantas vezes quantos os triângulos incompletos que queremos desenhar, e ainda definir os valores do lado, do incremento e da rotação.

from cTurtle import *

def tri(tartaruga,lado, inc):
    """ Desenha um triângulo incompleto."""
    for i in range(3):
        tartaruga.fd(lado)
        tartaruga.rt(120)
        lado = lado + inc
        tartaruga.hideturtle()
        
def main(n):
    """ Desenha n triângulos incompletos que vão rodando."""
    tartaruga = Turtle()
    lado = 30
    inc_lado = 10
    head = 0
    for i in range(n):
        tartaruga.setheading(heading() + head)
        tri(tartaruga,lado, inc_lado)
        lado = lado + 3 * inc_lado
        head = head + 8

    tartaruga.exitOnClick()

if __name__ =='__main__':
    hideturtle()
    main(5)