Aula Prática 7 - tipos estruturados de informação

Os objetivos desta aula são os seguintes: ter um primeiro contacto com os tipos estruturados de informação. Após a realização da prática, deverá ter sido adquirida uma noção dos seguintes conceitos:

  • tuplos
  • listas
  • dicionários

1. Escreva uma função que recebe uma lista ou um tuplo e devolve a média dos seus valores

    media( (1, 4, 8 ,12) )  --> 6.25
    media( [1, 2, 3, 4] ) --> 2.5
In [39]:
def media(v):
    if len(v) == 0:
        return 
    soma = 0
    for i in v:
        soma += i
    return soma/len(v)
In [40]:
x=(1, 4, 8 ,12)
media(x)
Out[40]:
6.25
In [41]:
media([1, 2, 3, 4])
Out[41]:
2.5

2. Escreva uma função que recebe uma lista ou um tuplo e devolve o maior dos seus valores

    maior((1, 4, 18 ,12)) --> 18
In [42]:
def maior(v):
    if len(v) == 0:
        return
    maior = v[0]
    for i in range(1,len(v)):
        if maior < v[i]:
            maior = v[i]
    return maior
In [43]:
maior((1, 4, 18 ,12))
Out[43]:
18

3. Escreva uma função que recebe uma cadeia de carateres e devolve um dicionário com a frequência de cada uma das vogais "a", "e", "i", "o", "u" nessa nessa cadeia de carateres.

In [1]:
def freq_vogais(texto):
    vogais = ["a", "e", "i", "o", "u"]
    freq = {}
    for c in texto:
        if c in vogais:
            if c in freq:
                freq[c] += 1
            else:
                freq[c] = 1
    return freq
In [2]:
frase="o tempo pergunta ao tempo quanto tempo o tempo tem"
freq_vogais(frase)
Out[2]:
{'o': 8, 'e': 6, 'u': 2, 'a': 3}

4. Desenvolva um programa que permite simular uma agenda telefónica.

Uma agenda é composta por contactos telefónicos, em que cada contacto telefónico tem os atributos nome, telefone, email principal (opcional). Deverá definir a classe de objetos Agenda deve permitir todas as operações seguintes.

  1. Adicionar um contacto à agenda
  2. Listar os contactos existentes;
  3. Devolver os detalhes de uma pessoa, dado o seu nome.
  4. Remover um contacto da agenda dado o nome da pessoa;
  5. Substituir o número de telefone de uma pessoa, dados o nome da pessoa e um novo número de telefone;
  6. Listar os contactos existentes, cujo nome contém uma determinada sequência de caráteres.

Escreva um programa que apresenta o menu anterior ao utilizador e, consoante a sua escolha faz a operação correspondente. O programa termina quando o utilizador introduzir a opção 0.

In [12]:
class Contact:

    def __init__(self, name, number, email = ""):
        self.__name = name
        self.number = number
        self.email = email


    @property
    def name(self):
        return self.__name

    def __str__(self):
        return "{},{},{}".format(self.name, self.number, self.email)
    
    def __eq__(self, other):
        if not isinstance(other, self.__class__):
            return False
        return self.name == other.name and self.number == other.number


class Agenda:

    def __init__(self):
        self.__contacts = []

    def add(self, c):
        self.__contacts.append(c)

    def listar(self):
        for c in self.__contacts:
            print(c)
            
    def details(self, name):
        for i in self.__contacts:
            if i.name == name:
                return i.number
        return None

    def remove(self, name):
        i = 0
        while i != len(self.__contacts) and self.__contacts[i].name != name:
            i += 1
        if i != len(self.__contacts):
            del self.__contacts[i]

    def modify(self, name, number):
        i = 0
        while i != len(self.__contacts) and self.__contacts[i].name != name:
            i += 1
        if i != len(self.__contacts):
            self.__contacts[i].number = number
In [13]:
c1 = Contact("Maria Joana", 9999999, "joana@me.com")
c2 = Contact("Jararé Titó", 5555555, "jacare@lago.br")
In [14]:
# teste da classe agenda            
a = Agenda()
a.add(c1)
a.add(c2)
print("=== Contactos na agenda ===")
a.listar()

=== Contactos na agenda ===
Maria Joana,9999999,joana@me.com
Jararé Titó,5555555,jacare@lago.br

5. Pretende-se desenvolver um programa que permita gerir uma fila de espera de uma repartição pública.

O funcionamento que se pretende para a repartição é o seguinte:

  • Quando um utente entra na repartição, é-lhe pedido o seu número do bilhete de identidade. Este número é depois dado pelo funcionário que opera o sistema ao programa a desenvolver para inserção na fila de espera. Para isso o funcionário selecciona a opção apropriada do programa;
  • Quando a (única) cabina de atendimento fica livre, o operador do sistema selecciona no programa a opção de retirar o número do bilhete de identidade do utente há mais tempo à espera, sendo esse número mostrado ao operador (que depois o anuncia) e retirado da fila de espera gerida pelo programa;
  • O operador pode também simplesmente ver qual o número do bilhete de identidade do próximo utente a ser atendido, sem para isso precisar de o retirar da fila de espera. Para tal deve seleccionar no programa uma opção apropriada;
  • Podem estar à espera na sala um máximo de 12 (por exemplo) utentes. Se entrar o 13º utente, o programa deve-se recusar a inseri-lo na fila de espera.

Desenvolva a classe fila de espera de modo a que o funcionamento acima seja possível. Na construção de um objeto deste tipo deve ser fornecido ao construtor o número máximo de pessoas admitido.

6. Desenvolva uma classe IntSet para representar conjuntos de inteiros.

Esta classe deve ter operações que permitam:

  1. Saber a sua cardinalidade (número de elementos);
  2. Verificar se é um conjunto vazio;
  3. Verificar se determinado número existe no conjunto:
  4. Obter uma lista com os elementos do conjunto;
  5. Adicionar um número ao conjunto (atenção: num conjunto não existem números repetidos);
  6. Remover um elemento do conjunto, caso exista;
  7. Obter um novo conjunto que resulta da união com um conjunto dado; 
     def union(self, other):
     ...
  8. Obter um novo conjunto que resulta da intersecção com um conjunto dado.

7. Escreva uma função que recebe uma lista ou um tuplo e que devolve um dicionário com a frequência de cada tipo de dados presente nessa lista ou tuplo. Recorde que a função isinstance(a, class) permite testar se um dado elemento pertence a uma dada classe.

In [51]:
def count_types(v):
    contagem = {"inteiros":0, "floats": 0, "tuplos": 0, "listas": 0, "outros":0}
    for x in v:
        if isinstance(x, int):
            contagem["inteiros"] += 1
        elif isinstance(x, float):
            contagem["floats"] += 1
        elif isinstance(x, tuple):
            contagem["tuplos"] += 1
        elif isinstance(x, list):
            contagem["listas"] += 1
        else:
            contagem["outros"] += 1
    return contagem
In [52]:
v = [2, 1.0, 4.2, "Iscte", ["a", "b"], (1,2)]
count_types(v)
Out[52]:
{'inteiros': 1, 'floats': 2, 'tuplos': 1, 'listas': 1, 'outros': 1}
In [ ]: