Introdução
Neste laboratório, você aprenderá como verificar se um conjunto contém apenas números em Python. O laboratório foca na definição de conjuntos numéricos, incluindo conjuntos vazios, conjuntos de inteiros, conjuntos de floats e conjuntos mistos contendo tanto inteiros quanto floats. Você também explorará como os conjuntos lidam com valores duplicados, garantindo a unicidade.
O laboratório guia você através da criação de um arquivo Python chamado numeric_sets.py, adicionando código para definir e imprimir vários conjuntos, e executando o script para observar a saída. Você aprenderá como usar o construtor set() e como os conjuntos removem automaticamente valores duplicados, demonstrando as propriedades fundamentais dos conjuntos em Python.
Definir Conjuntos Numéricos
Nesta etapa, você aprenderá como definir conjuntos contendo números em Python. Conjuntos são coleções desordenadas de elementos únicos. Isso significa que um conjunto não pode conter valores duplicados. Vamos focar na criação de conjuntos de inteiros e floats.
Primeiro, vamos criar um arquivo Python chamado numeric_sets.py no seu diretório ~/project usando o editor VS Code.
## Create an empty set
empty_set = set()
print("Empty Set:", empty_set)
## Create a set of integers
integer_set = {1, 2, 3, 4, 5}
print("Integer Set:", integer_set)
## Create a set of floats
float_set = {1.0, 2.5, 3.7, 4.2, 5.9}
print("Float Set:", float_set)
## Create a mixed set (integers and floats)
mixed_set = {1, 2.0, 3, 4.5, 5}
print("Mixed Set:", mixed_set)
Salve o arquivo como numeric_sets.py no seu diretório ~/project. Agora, execute o script usando o seguinte comando no terminal:
python numeric_sets.py
Você deve ver a seguinte saída:
Empty Set: set()
Integer Set: {1, 2, 3, 4, 5}
Float Set: {1.0, 2.5, 3.7, 4.2, 5.9}
Mixed Set: {1, 2.0, 3, 4.5, 5}
Observe que a ordem dos elementos no conjunto pode não ser a mesma ordem em que foram definidos. Isso ocorre porque os conjuntos são coleções desordenadas. Além disso, os conjuntos removem automaticamente valores duplicados.
Agora, vamos adicionar mais alguns exemplos ao seu arquivo numeric_sets.py para demonstrar a unicidade dos conjuntos:
## Create a set with duplicate values
duplicate_set = {1, 2, 2, 3, 4, 4, 5}
print("Duplicate Set:", duplicate_set)
## Create a set from a list with duplicate values
duplicate_list = [1, 2, 2, 3, 4, 4, 5]
unique_set = set(duplicate_list)
print("Unique Set from List:", unique_set)
Salve as alterações e execute o script novamente:
python numeric_sets.py
Você deve ver a seguinte saída:
Empty Set: set()
Integer Set: {1, 2, 3, 4, 5}
Float Set: {1.0, 2.5, 3.7, 4.2, 5.9}
Mixed Set: {1, 2.0, 3, 4.5, 5}
Duplicate Set: {1, 2, 3, 4, 5}
Unique Set from List: {1, 2, 3, 4, 5}
Como você pode ver, o duplicate_set e o unique_set contêm apenas valores únicos, mesmo que tenhamos tentado criá-los com valores duplicados.
Usar all() com isinstance()
Nesta etapa, você aprenderá como usar a função all() em combinação com a função isinstance() para verificar se todos os elementos em um conjunto são de um tipo numérico específico. Isso é útil para validar o conteúdo de um conjunto antes de realizar operações nele.
A função all() retorna True se todos os elementos em um iterável (como um conjunto) forem verdadeiros. A função isinstance() verifica se um objeto é uma instância de uma classe ou tipo especificado.
Vamos modificar o arquivo numeric_sets.py que você criou na etapa anterior para incluir essas verificações. Abra numeric_sets.py no editor VS Code e adicione o seguinte código:
def check_if_all_are_integers(input_set):
"""Checks if all elements in the set are integers."""
return all(isinstance(x, int) for x in input_set)
def check_if_all_are_floats(input_set):
"""Checks if all elements in the set are floats."""
return all(isinstance(x, float) for x in input_set)
## Example usage:
integer_set = {1, 2, 3, 4, 5}
float_set = {1.0, 2.5, 3.7, 4.2, 5.9}
mixed_set = {1, 2.0, 3, 4.5, 5}
print("Are all elements in integer_set integers?", check_if_all_are_integers(integer_set))
print("Are all elements in float_set floats?", check_if_all_are_floats(float_set))
print("Are all elements in mixed_set integers?", check_if_all_are_integers(mixed_set))
print("Are all elements in mixed_set floats?", check_if_all_are_floats(mixed_set))
Salve o arquivo e execute-o usando o seguinte comando:
python numeric_sets.py
Você deve ver a seguinte saída:
Are all elements in integer_set integers? True
Are all elements in float_set floats? True
Are all elements in mixed_set integers? False
Are all elements in mixed_set floats? False
A saída mostra que integer_set contém apenas inteiros, float_set contém apenas floats, e mixed_set contém uma mistura de inteiros e floats, então as verificações retornam False para ambas as verificações de inteiro e float.
Agora, vamos adicionar uma função para verificar se todos os elementos são inteiros ou floats (ou seja, numéricos):
def check_if_all_are_numeric(input_set):
"""Checks if all elements in the set are either integers or floats."""
return all(isinstance(x, (int, float)) for x in input_set)
print("Are all elements in mixed_set numeric?", check_if_all_are_numeric(mixed_set))
string_set = {"a", "b", "c"}
print("Are all elements in string_set numeric?", check_if_all_are_numeric(string_set))
Salve o arquivo e execute-o novamente:
python numeric_sets.py
Você deve ver a seguinte saída:
Are all elements in integer_set integers? True
Are all elements in float_set floats? True
Are all elements in mixed_set integers? False
Are all elements in mixed_set floats? False
Are all elements in mixed_set numeric? True
Are all elements in string_set numeric? False
Isso demonstra como usar all() e isinstance() para validar os tipos de elementos dentro de um conjunto.
Lidar com Conjuntos Vazios
Nesta etapa, você aprenderá como lidar com conjuntos vazios ao usar as funções all() e isinstance(). Conjuntos vazios são um caso especial porque não contêm elementos. Entender como essas funções se comportam com conjuntos vazios é crucial para escrever código robusto.
Vamos considerar o que acontece quando você usa all() com um conjunto vazio. A função all() retorna True se todos os elementos no iterável forem verdadeiros. Como um conjunto vazio não tem elementos, pode-se argumentar que "todos" os seus elementos são verdadeiros, simplesmente porque não há elementos para serem falsos.
Vamos modificar o arquivo numeric_sets.py para demonstrar isso. Abra numeric_sets.py no editor VS Code e adicione o seguinte código:
def check_if_all_are_integers(input_set):
"""Checks if all elements in the set are integers."""
return all(isinstance(x, int) for x in input_set)
## Example with an empty set:
empty_set = set()
print("Is empty_set all integers?", check_if_all_are_integers(empty_set))
Salve o arquivo e execute-o usando o seguinte comando:
python numeric_sets.py
Você deve ver a seguinte saída:
Is empty_set all integers? True
Este resultado pode parecer contraintuitivo a princípio. No entanto, é consistente com a definição de all().
Agora, vamos considerar um cenário em que você deseja lidar explicitamente com conjuntos vazios de maneira diferente. Você pode adicionar uma verificação para um conjunto vazio antes de usar all():
def check_if_all_are_integers_safe(input_set):
"""Checks if all elements in the set are integers, handling empty sets explicitly."""
if not input_set:
return False ## Or True, depending on your desired behavior for empty sets
return all(isinstance(x, int) for x in input_set)
empty_set = set()
print("Is empty_set all integers (safe)?", check_if_all_are_integers_safe(empty_set))
integer_set = {1, 2, 3}
print("Is integer_set all integers (safe)?", check_if_all_are_integers_safe(integer_set))
Salve o arquivo e execute-o novamente:
python numeric_sets.py
Você deve ver a seguinte saída:
Is empty_set all integers (safe)? False
Is integer_set all integers (safe)? True
Neste exemplo, a função check_if_all_are_integers_safe retorna False para um conjunto vazio. Você pode modificar o valor de retorno no bloco if not input_set: para atender às suas necessidades específicas. Lidar com conjuntos vazios explicitamente pode evitar comportamentos inesperados em seu código.
Resumo
Neste laboratório, você aprendeu como definir conjuntos contendo números em Python, incluindo conjuntos vazios, conjuntos de inteiros, conjuntos de floats e conjuntos mistos contendo tanto inteiros quanto floats. Você também observou que conjuntos são coleções não ordenadas e removem automaticamente valores duplicados.
O laboratório demonstrou como criar conjuntos diretamente e a partir de listas com valores duplicados, destacando a propriedade do conjunto de manter apenas elementos únicos. Os exemplos forneceram uma compreensão prática de como os conjuntos lidam com diferentes tipos numéricos e eliminam a redundância.
