Arquivo de Python - Página 87 de 90

Informações que constam nos números de telefones

19/12/202504/01/2025 Por antonino

Hoje vamos falar sobre as informações que Constam nos números de telefones.

Número de Telefone

Os números de telefones contêm informações valiosas que podem ser extraídas e analisadas com a biblioteca phonenumbers no Python. Essa biblioteca oferece ferramentas poderosas para identificar detalhes sobre a estrutura, a localização e a validade de números telefônicos. Ela simplifica o processo de análise de dados relacionados a números de telefone e facilita tarefas comuns em sistemas de comunicação ou validação de dados.

Estrutura e Validação de Números

A biblioteca phonenumbers ajuda a validar se um número segue o formato correto para um país específico. Além disso, ela permite verificar se o número é possível de ser atribuído dentro do sistema telefônico global. Com isso, você pode garantir que os dados inseridos em formulários ou sistemas sejam consistentes e válidos.

Outro recurso importante é a identificação do tipo de número, como fixo, móvel ou comercial. Isso permite personalizar abordagens, como campanhas de marketing ou sistemas de atendimento, de forma mais precisa.

Localização e Detalhes Geográficos

Além da validação, a biblioteca também fornece informações geográficas associadas ao número. Por exemplo, ela identifica o país e, em muitos casos, a região onde o número foi registrado. Essas informações são especialmente úteis em aplicativos que dependem de localização ou no gerenciamento de chamadas internacionais.

Formatação e Compatibilidade
Outro destaque da phonenumbers é sua capacidade de formatar números de telefone de forma consistente. Ela permite exibir números em formatos internacionais ou nacionais, atendendo às normas específicas de cada país. Dessa maneira, a padronização melhora a apresentação de dados em relatórios ou interfaces de usuário.

Com a biblioteca phonenumbers, você pode explorar e gerenciar informações dos números de telefone de forma eficiente e confiável. Ela proporciona as ferramentas necessárias para melhorar a qualidade e a usabilidade dos dados relacionados a contatos telefônicos.

Chamadas indesejadas

Existem diversos bloqueadores de telefones para bloquear spans, mas temos que tomar o cuidado de não bloquear por engano o telefone de uma pessoa conhecida.

Você já se perguntou quais informações você tem sobre esses números de telefones e como poderia identificar se é um span para criar critérios de bloqueio ?

Essas chamadas frequentemente interrompem momentos importantes e geram frustração, especialmente quando se percebe que não são contatos relevantes ou conhecidos.

Infelizmente, não se trata de apenas um número específico.

Ao bloquear um, outro número diferente aparece, frequentemente com um bot (robô) realizando a ligação.

O que podemos fazer ?

No entanto, a tecnologia pode ser uma grande aliada para lidar com esse problema.

O Python, por exemplo, oferece diversas ferramentas úteis. Uma delas é a biblioteca phonenumbers, que permite analisar dados dos números de telefone, como a localização de origem.

Com esses dados, é possível criar critérios para identificar futuros números suspeitos.

import phonenumbers
from phonenumbers import carrier, geocoder, number_type, timezone

def extrair_informacoes(numero):
    try:
        phone = phonenumbers.parse(numero, None)
        operadora = str(carrier.name_for_number(phone,'pt-BR'))
        return {
            "valido": phonenumbers.is_valid_number(phone),  # Se o número é válido
            "possivel": phonenumbers.is_possible_number(phone),  # Se é um número plausível
            "regiao": geocoder.description_for_number(phone, "pt-BR"),  # Nome da região
            "operadora": operadora if operadora else "Não disponível",  # Nome da operadora
            "tipo": number_type(phone),  # Tipo móvel ou fixo
            "formato_internacional": phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.INTERNATIONAL),
            "formato_nacional": phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.NATIONAL),
            "time zone": timezone.time_zones_for_number(phone)
        }
    except Exception as e:
        return {"erro": str(e)}

telefones = ["+5568999999999", "+5521999999999", "+5511999999999"]

for telefone in telefones:
    informacoes = extrair_informacoes(telefone)
    print(informacoes)
"""
Resultado:

{'valido': True, 'possivel': True, 'regiao': 'Acre', 'operadora': 'Vivo', 'tipo': 1, 'formato_internacional': '+55 68 99999-9999', 'formato_nacional': '(68) 99999-9999', 'time zone': ('America/Rio_Branco',)}
{'valido': True, 'possivel': True, 'regiao': 'Rio de Janeiro', 'operadora': 'Vivo', 'tipo': 1, 'formato_internacional': '+55 21 99999-9999', 'formato_nacional': '(21) 99999-9999', 'time zone': ('America/Sao_Paulo',)}
{'valido': True, 'possivel': True, 'regiao': 'São Paulo', 'operadora': 'Vivo', 'tipo': 1, 'formato_internacional': '+55 11 99999-9999', 'formato_nacional': '(11) 99999-9999', 'time zone': ('America/Sao_Paulo',)}
"""

import phonenumbers

from phonenumbers import carrier, geocoder, number_type, timezone

def extrair_informacoes(numero):

try:

phone = phonenumbers.parse(numero, None)

operadora = str(carrier.name_for_number(phone,'pt-BR'))

return {

"valido": phonenumbers.is_valid_number(phone), # Se o número é válido

"possivel": phonenumbers.is_possible_number(phone), # Se é um número plausível

"regiao": geocoder.description_for_number(phone, "pt-BR"), # Nome da região

"operadora": operadora if operadora else "Não disponível", # Nome da operadora

"tipo": number_type(phone), # Tipo móvel ou fixo

"formato_internacional": phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.INTERNATIONAL),

"formato_nacional": phonenumbers.format_number(phone, phonenumbers.PhoneNumberFormat.NATIONAL),

"time zone": timezone.time_zones_for_number(phone)

}

except Exception as e:

return {"erro": str(e)}

telefones = ["+5568999999999", "+5521999999999", "+5511999999999"]

for telefone in telefones:

informacoes = extrair_informacoes(telefone)

print(informacoes)

"""

Resultado:

{'valido': True, 'possivel': True, 'regiao': 'Acre', 'operadora': 'Vivo', 'tipo': 1, 'formato_internacional': '+55 68 99999-9999', 'formato_nacional': '(68) 99999-9999', 'time zone': ('America/Rio_Branco',)}

{'valido': True, 'possivel': True, 'regiao': 'Rio de Janeiro', 'operadora': 'Vivo', 'tipo': 1, 'formato_internacional': '+55 21 99999-9999', 'formato_nacional': '(21) 99999-9999', 'time zone': ('America/Sao_Paulo',)}

{'valido': True, 'possivel': True, 'regiao': 'São Paulo', 'operadora': 'Vivo', 'tipo': 1, 'formato_internacional': '+55 11 99999-9999', 'formato_nacional': '(11) 99999-9999', 'time zone': ('America/Sao_Paulo',)}

"""

Por exemplo, você pode implementar filtros baseados em padrões numéricos ou regiões geográficas conhecidas por originar spam.

Aprendizado de máquina

Se você se interessa por Inteligência Artificial, pode ir além: desenvolver um modelo de machine learning capaz de determinar se um número é spam. Esse processo começa com o treinamento de um modelo usando uma base de dados contendo números rotulados como spam ou não.

Esses dados podem estar organizados em planilhas (nos formatos CSV ou XLSX) e incluir informações como frequência de chamadas, horários e prefixos.

Após o treinamento, o modelo será capaz de analisar novos números e prever, com certa precisão, se eles são ou não indesejados.

A Inteligência Artificial é excelente para identificar padrões ocultos e ajudar em situações como essa.

No entanto, lembre-se de usar essa tecnologia com responsabilidade e ética, respeitando sempre a privacidade e a legislação de proteção de dados.

Observação: Os números de telefone abaixo são fictícios e foram incluídos apenas como exemplo.

A partir destes dados você poderá analisar melhor os telefones ou criar uma planilha para um treinamento de máquina.

Hoje falamos, sobre as informações que constam nos números de telefones e de suas possíveis aplicações para esses dados.

Referências:

Documentação phonenumbers

Publicidade – Livros da Amazon:

Livros sobre Python da Amazon
Livros sobre Machine Learning da Amazon

Interno:

Área de Convivência

Lista , Tupla , Conjunto e Dicionário

19/12/202526/12/2024 Por antonino

Veremos a seguir estruturas de dados nativas do Python: lista, tupla, conjunto e dicionário.

Compreenda as Diferenças Essenciais

Em Python, compreender as principais coleções de dados é essencial para desenvolver soluções eficientes.

1 – Lista

Para começar, as listas são estruturas dinâmicas que permitem armazenar elementos em uma ordem específica. Dessa forma, elas são ideais para situações onde a sequência dos dados precisa ser mantida. Além disso, as listas aceitam elementos duplicados, o que garante maior flexibilidade no gerenciamento das informações.

Tipo	Características
List	Cada elemento possi um indice iniciado em 0. Após sua declaração podemos adicionar, remover ou modifica-lo.

Criando listas com Range

0 a 10

for num in range(11):
  print(num, end = ' ')

"""
Resultado:

0 1 2 3 4 5 6 7 8 9 10
"""

for num in range(11):

print(num, end = ' ')

"""

Resultado:

0 1 2 3 4 5 6 7 8 9 10

"""

10 a 1

for num in range(10,0,-1):
  print(num, end = ' ')

"""
Resultado:

10 9 8 7 6 5 4 3 2 1 
"""

for num in range(10,0,-1):

print(num, end = ' ')

"""

Resultado:

10 9 8 7 6 5 4 3 2 1

"""

3 a 10

for num in range(3,11):
  print(num, end = ' ')

"""
Resultado:

3 4 5 6 7 8 9 10
"""

for num in range(3,11):

print(num, end = ' ')

"""

Resultado:

3 4 5 6 7 8 9 10

"""

5 a 100 com saltos de 5 em 5

for num in range(5,100,5):
  print(num, end = ' ')
"""
Resultado:

5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95
"""

for num in range(5,100,5):

print(num, end = ' ')

"""

Resultado:

5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85 90 95

"""

Acessando dados de uma Lista

print("====")
print("Lista")
print("====")
# criando uma lista e imprimindo seus itens
minha_lista = list(range(5))
for item in minha_lista:
    print(item)

"""
Resultado:

====
Lista
====
0
1
2
3
4
"""

print("====")

print("Lista")

print("====")

# criando uma lista e imprimindo seus itens

minha_lista = list(range(5))

for item in minha_lista:

print(item)

"""

Resultado:

====

Lista

====

"""

Adicionando item a uma Lista

print("====")
print("Lista")
print("====")
# criando uma lista e imprimindo seus itens
minha_lista = list(range(5))
print("Valor Inicial:",minha_lista)
minha_lista.append(10)
print("Valor Final:",minha_lista)

"""
Resultado:

====
Lista
====
Valor Inicial: [0, 1, 2, 3, 4]
Valor Final: [0, 1, 2, 3, 4, 10]
"""

print("====")

print("Lista")

print("====")

# criando uma lista e imprimindo seus itens

minha_lista = list(range(5))

print("Valor Inicial:",minha_lista)

minha_lista.append(10)

print("Valor Final:",minha_lista)

"""

Resultado:

====

Lista

====

Valor Inicial: [0, 1, 2, 3, 4]

Valor Final: [0, 1, 2, 3, 4, 10]

"""

Sorteio de um número inteiro entre 1 e 60 com randint()

import random
# Sorteia número entre 1 e 60
numero_sorteado = random.randint(1,60)
print(numero_sorteado)
"""
Possível Resultado:

22
"""

import random

# Sorteia número entre 1 e 60

numero_sorteado = random.randint(1,60)

print(numero_sorteado)

"""

Possível Resultado:

"""

Sorteio de uma opção de uma lista

import random
lista = ["segunda","terça","quarta","quinta","sexta","sábado","domingo"]
selecionado = random.choice(lista)
print(selecionado)
"""
Possível Resultado:

domingo
"""

import random

lista = ["segunda","terça","quarta","quinta","sexta","sábado","domingo"]

selecionado = random.choice(lista)

print(selecionado)

"""

Possível Resultado:

domingo

"""

Embaralhar uma lista

import random
deck = 'ace two three four'.split()
print(deck)
random.shuffle(deck)  
print(deck)
"""
Possível Resultado:

['ace', 'two', 'three', 'four']
['ace', 'four', 'two', 'three']
"""

import random

deck = 'ace two three four'.split()

print(deck)

random.shuffle(deck)

print(deck)

"""

Possível Resultado:

['ace', 'two', 'three', 'four']

['ace', 'four', 'two', 'three']

"""

Selecionando quatro amostras aleatórias sem reposição

import random
universo = [10, 20, 30, 40, 50]
resultado = random.sample(universo, k=4)
print(resultado)
"""
Possível Resultado:

[40, 10, 30, 20]
"""

import random

universo = [10, 20, 30, 40, 50]

resultado = random.sample(universo, k=4)

print(resultado)

"""

Possível Resultado:

[40, 10, 30, 20]

"""

Removendo dados de uma Lista

Estrutura	Método	Descrição
Lista	`remove()`	Remove pelo valor (primeira ocorrência).
Lista	`pop()`	Remove pelo índice e retorna o valor.
Lista	`del`	Remove pelo índice ou toda a lista.

print("====")
print("Lista")
print("====")
# criando uma lista e imprimindo seus itens
minha_lista = list(range(5))
print("Valor Inicial:",minha_lista)
minha_lista.pop(0)
print("Valor Final:",minha_lista)
"""
Resultado:

====
Lista
====
Valor Inicial: [0, 1, 2, 3, 4]
Valor Final: [1, 2, 3, 4]
"""

print("====")

print("Lista")

print("====")

# criando uma lista e imprimindo seus itens

minha_lista = list(range(5))

print("Valor Inicial:",minha_lista)

minha_lista.pop(0)

print("Valor Final:",minha_lista)

"""

Resultado:

====

Lista

====

Valor Inicial: [0, 1, 2, 3, 4]

Valor Final: [1, 2, 3, 4]

"""

Comprimento (o número de itens) de um objeto com len( ).

print(len("Área de Trampo")) # número de caracteres
print(len(["amora","banana","melancia"])) # número de itens de uma lista
print(len({"amora","banana","melancia"})) # número de itens de um conjunto
print(len(["amora","banana","melancia"][1:2])) #intervalo entre 1 e 2
"""
Resultado:

14
3
3
1
"""

print(len("Área de Trampo")) # número de caracteres

print(len(["amora","banana","melancia"])) # número de itens de uma lista

print(len({"amora","banana","melancia"})) # número de itens de um conjunto

print(len(["amora","banana","melancia"][1:2])) #intervalo entre 1 e 2

"""

Resultado:

"""

2 – Tupla

As tuplas são semelhantes às listas, mas possuem uma diferença crucial: elas são imutáveis. Como resultado, os dados contidos em uma tupla não podem ser alterados após a sua criação. Assim, as tuplas são frequentemente utilizadas quando se deseja proteger a integridade das informações. Além disso, a imutabilidade também contribui para a eficiência do código, especialmente em operações que envolvem grandes volumes de dados.

Tipo	Características
Tupla	Cada elemento possi um indice iniciado em 0. Após sua declaração não podemos modifica-lo.

dias_semana = ('segunda','terça','quarta',
'quinta','sexta','sábado','domingo')
print(dias_semana)
"""
Resultado:

('segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado', 'domingo')
"""

dias_semana = ('segunda','terça','quarta',

'quinta','sexta','sábado','domingo')

print(dias_semana)

"""

Resultado:

('segunda', 'terça', 'quarta', 'quinta', 'sexta', 'sábado', 'domingo')

"""

Atenção: Tupla tem a finalidade de ser uma constante, portanto, depois da declaração ela não pode ser alterada !

3 – Conjunto

Quando a necessidade envolve dados únicos, os conjuntos se destacam. Primeiramente, essa coleção não mantém uma ordem específica, mas elimina automaticamente os elementos duplicados. Portanto, os conjuntos são perfeitos para operações como união, interseção e diferença entre coleções. Apesar disso, eles não possuem índices, mas são altamente otimizados para buscas rápidas.

Tipo	Características
Conjunto	A ordem não é garantida. Podemos adicionar ou remover elementos. Cada elemento aprarece uma única vez. Entre conjuntos podemos verificar a interseção, diferença e a união

Acessando dados de um Conjunto

print("====")
print("Conjunto")
print("====")
# criando um conjunto e imprimindo seus itens
meu_conjunto = set(range(5))
for item in meu_conjunto:
    print(item)

"""
Resultado:

====
Conjunto
====
0
1
2
3
4
"""

print("====")

print("Conjunto")

print("====")

# criando um conjunto e imprimindo seus itens

meu_conjunto = set(range(5))

for item in meu_conjunto:

print(item)

"""

Resultado:

====

Conjunto

====

"""

Adicionando item a um Conjunto

print("====")
print("Conjunto")
print("====")
# criando um conjunto e imprimindo seus itens
meu_conjunto = set(range(5))
print("Valor Inicial:",meu_conjunto)
meu_conjunto.add(10)
print("Valor Final:",meu_conjunto)
"""
Resultado:

====
Conjunto
====
Valor Inicial: {0, 1, 2, 3, 4}
Valor Final: {0, 1, 10, 2, 3, 4}
"""

print("====")

print("Conjunto")

print("====")

# criando um conjunto e imprimindo seus itens

meu_conjunto = set(range(5))

print("Valor Inicial:",meu_conjunto)

meu_conjunto.add(10)

print("Valor Final:",meu_conjunto)

"""

Resultado:

====

Conjunto

====

Valor Inicial: {0, 1, 2, 3, 4}

Valor Final: {0, 1, 10, 2, 3, 4}

"""

Removendo itens de Conjunto

Estrutura	Método	Descrição
Conjunto	`remove()`	Remove o elemento; erro se não existir.
Conjunto	`discard()`	Remove o elemento; sem erro se não existir.
Conjunto	`pop()`	Remove um elemento arbitrário.

print("====")
print("Conjunto")
print("====")
# criando um conjunto e imprimindo seus itens
meu_conjunto = set(range(5))
print("Valor Inicial:",meu_conjunto)
meu_conjunto.remove(0)
print("Valor Final:",meu_conjunto)

"""
Resultado:

====
Conjunto
====
Valor Inicial: {0, 1, 2, 3, 4}
Valor Final: {1, 2, 3, 4}
"""

print("====")

print("Conjunto")

print("====")

# criando um conjunto e imprimindo seus itens

meu_conjunto = set(range(5))

print("Valor Inicial:",meu_conjunto)

meu_conjunto.remove(0)

print("Valor Final:",meu_conjunto)

"""

Resultado:

====

Conjunto

====

Valor Inicial: {0, 1, 2, 3, 4}

Valor Final: {1, 2, 3, 4}

"""

Subtração, união e interseção com Conjuntos

hortifruti = {"banana","abacate", "laranja", "pera", "limão", "goiaba", "melão"}
# Perceba que vamos tentar adicionar 'acerola' 3 vezes ma o tipo conjunto não permite itens duplicados
hortifruti.add("acerola")
hortifruti.add("acerola")
hortifruti.add("acerola")
print(f'Hortifruti tem: {hortifruti}n')
lista_de_compras_minha_mae = {"mamão","banana","pera"}
minha_lista_de_compras = {"laranja","goiaba","mamão"}
# DIFERENÇA entre minha_lista_de_compras e lista_de_compras_minha_mae
print(f'minha lista - lista da minha mãe = \n{minha_lista_de_compras - lista_de_compras_minha_mae}n ')
# UNION - unir a minha lista e a da minha mãe para fazer todas as compras da casa
lista_de_casa = minha_lista_de_compras | lista_de_compras_minha_mae
print(f'LISTA_DE_CASA = minha lista + lista da minha mãe : \n{lista_de_casa}n ')
# INTERSEÇÃO - verificar dentre os itens desejados o que tem no hortifruti
o_que_achei_da_lista_no_hortifruti = hortifruti & lista_de_casa
print(f'Da LISTA DE CASA encontramos apenas {o_que_achei_da_lista_no_hortifruti} no hortifruti') 
"""
Resultado:

Hortifruti tem: {'acerola', 'abacate', 'goiaba', 'banana', 'laranja', 'limão', 'melão', 'pera'}n
minha lista - lista da minha mãe = 
{'goiaba', 'laranja'}n 
LISTA_DE_CASA = minha lista + lista da minha mãe : 
{'goiaba', 'banana', 'laranja', 'mamão', 'pera'}n 
Da LISTA DE CASA encontramos apenas {'goiaba', 'banana', 'laranja', 'pera'} no hortifruti
"""

hortifruti = {"banana","abacate", "laranja", "pera", "limão", "goiaba", "melão"}

# Perceba que vamos tentar adicionar 'acerola' 3 vezes ma o tipo conjunto não permite itens duplicados

hortifruti.add("acerola")

print(f'Hortifruti tem: {hortifruti}n')

lista_de_compras_minha_mae = {"mamão","banana","pera"}

minha_lista_de_compras = {"laranja","goiaba","mamão"}

# DIFERENÇA entre minha_lista_de_compras e lista_de_compras_minha_mae

print(f'minha lista - lista da minha mãe = \n{minha_lista_de_compras - lista_de_compras_minha_mae}n ')

# UNION - unir a minha lista e a da minha mãe para fazer todas as compras da casa

lista_de_casa = minha_lista_de_compras | lista_de_compras_minha_mae

print(f'LISTA_DE_CASA = minha lista + lista da minha mãe : \n{lista_de_casa}n ')

# INTERSEÇÃO - verificar dentre os itens desejados o que tem no hortifruti

o_que_achei_da_lista_no_hortifruti = hortifruti & lista_de_casa

print(f'Da LISTA DE CASA encontramos apenas {o_que_achei_da_lista_no_hortifruti} no hortifruti')

"""

Resultado:

Hortifruti tem: {'acerola', 'abacate', 'goiaba', 'banana', 'laranja', 'limão', 'melão', 'pera'}n

minha lista - lista da minha mãe =

{'goiaba', 'laranja'}n

LISTA_DE_CASA = minha lista + lista da minha mãe :

{'goiaba', 'banana', 'laranja', 'mamão', 'pera'}n

Da LISTA DE CASA encontramos apenas {'goiaba', 'banana', 'laranja', 'pera'} no hortifruti

"""

4 – Dicionário

Por fim, os dicionários oferecem uma forma de armazenar pares de chave e valor, permitindo acesso direto aos valores por meio das suas respectivas chaves. Por essa razão, os dicionários são indispensáveis quando se trabalha com dados estruturados. Além do mais, a flexibilidade para utilizar diferentes tipos de dados como chaves ou valores amplia ainda mais sua aplicabilidade em diversos contextos.

No Dicionário cada elemento é um par chave: valor, onde a chave é única.
Você pode adicionar, remover ou modificar elementos.

Use um dicionário para acessar diretamente o valor por sua chave, evitando fazer For e While desnescessários.

Acessando dados de um Dicionário

print("====")
print("Acessando um Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
print(meu_dicionario["Maria"])
"""
Resultado:

====
Acessando um Dicionário
====
Minha mãe
"""

print("====")

print("Acessando um Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

print(meu_dicionario["Maria"])

"""

Resultado:

====

Acessando um Dicionário

====

Minha mãe

"""

Veja que no exemplo acima o VALOR do item do Dicionário é acessado com sua CHAVE “Maria”.
A chave deve ser única no Dicionário de dados.
Perceba que um dicionário não é adequado para a iteração com For e While, a ideia é o acesso direto pela chave.

Alterando item do Dicionário

print("====")
print("====")
print("Alterando item do Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
meu_dicionario["Maria"] = "Minha sogra"
print(meu_dicionario["Maria"])
"""
Resultado:

====
Alterando item do Dicionário
====
Minha sogra
"""

print("====")

print("Alterando item do Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

meu_dicionario["Maria"] = "Minha sogra"

print(meu_dicionario["Maria"])

"""

Resultado:

====

Alterando item do Dicionário

====

Minha sogra

"""

Adicionando item a um Dicionário

print("====")
print("Adicionando um item a um Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
print("Valor Inicial:",meu_dicionario)
meu_dicionario["Silvio"] = "Colega de faculdade"
print("Valor Final:",meu_dicionario)
"""
Resultado:

====
Adicionando um item a um Dicionário
====
Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}
Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio', 'Silvio': 'Colega de faculdade'}
"""

print("====")

print("Adicionando um item a um Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

print("Valor Inicial:",meu_dicionario)

meu_dicionario["Silvio"] = "Colega de faculdade"

print("Valor Final:",meu_dicionario)

"""

Resultado:

====

Adicionando um item a um Dicionário

====

Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}

Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio', 'Silvio': 'Colega de faculdade'}

"""

Removendo item de um Dicionário

Estrutura	Método	Descrição
Dicionário	`pop()`	Remove pela chave e retorna o valor.
Dicionário	`del`	Remove pela chave ou todo o dicionário.
Dicionário	`clear()`	Remove todos os itens do dicionário.

print("====")
print("Removendo item Dicionário")
print("====")
meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}
print("Valor Inicial:",meu_dicionario)
meu_dicionario.pop("José")
print("Valor Final:",meu_dicionario)
"""
Resultado:

====
Removendo item Dicionário
====
Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}
Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe'}
"""

Observação:

Lista usa <strong>[ ] </strong><strong>'colchetes'</strong> , tupla <strong>( ) 'parênteses'</strong>, Conjunto e Dicionário <strong>{ } 'chaves'</strong> mas diferente do Conjunto apenas o Dicionário tem <strong>chave : valor</strong>.

print("====")

print("Removendo item Dicionário")

print("====")

meu_dicionario = {"Francisco":"Meu vizinho","Maria":"Minha mãe","José":"Meu tio"}

print("Valor Inicial:",meu_dicionario)

meu_dicionario.pop("José")

print("Valor Final:",meu_dicionario)

"""

Resultado:

====

Removendo item Dicionário

====

Valor Inicial: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe', 'José': 'Meu tio'}

Valor Final: {'Francisco': 'Meu vizinho', 'Maria': 'Minha mãe'}

"""

Observação:

Lista usa [ ] 'colchetes' , tupla ( ) 'parênteses', Conjunto e Dicionário { } 'chaves' mas diferente do Conjunto apenas o Dicionário tem chave : valor.

Convertendo

Convertendo Lista em Conjunto

lista = ['banana', 'maça','maça','maça','maça','maça','maça']
conjunto = set(lista)
print(conjunto)
"""
Resultado:

{'banana', 'maça'}
"""

lista = ['banana', 'maça','maça','maça','maça','maça','maça']

conjunto = set(lista)

print(conjunto)

"""

Resultado:

{'banana', 'maça'}

"""

Perceba que, ao transformar em conjunto, os itens repetidos foram automaticamente descartados.

Isso acontece porque, por definição, conjuntos não permitem repetições em seus itens. Portanto, essa característica os torna ideais para eliminar duplicatas de forma eficiente.

Convertendo Conjunto em Lista

adicionar = ["abacate","morango","Abacate","abacaxi","ABACATE"]
hortifruti = {"amora"}
for fruta in adicionar:
    hortifruti.add(fruta.lower())
    
resultado = list(hortifruti)
print(resultado)
"""
Resultado:

['abacaxi', 'abacate', 'morango', 'amora']
"""

adicionar = ["abacate","morango","Abacate","abacaxi","ABACATE"]

hortifruti = {"amora"}

for fruta in adicionar:

hortifruti.add(fruta.lower())

resultado = list(hortifruti)

print(resultado)

"""

Resultado:

['abacaxi', 'abacate', 'morango', 'amora']

"""

Observação:

Perceba que, no código anterior, ao usar um conjunto quando adicionávamos novos dados, conseguimos evitar a adição de elementos repetidos. No entanto, se não utilizarmos a função .lower() para transformar tudo em letras minúsculas, o conjunto interpretará que “abacate”, “Abacate” e “ABACATE” são diferentes, uma vez que Python é case-sensitive.

Em resumo, ao escolher entre listas, tuplas, conjuntos e dicionários, é essencial considerar as necessidades específicas do projeto. Dessa forma, a escolha adequada impactará diretamente a eficiência, a clareza e a manutenção do código. Assim, compreender as vantagens de cada coleção contribui para o desenvolvimento de soluções mais robustas e organizadas. Portanto, optar pela estrutura correta é fundamental para resolver problemas de forma eficiente em qualquer situação de programação.

Portanto, escolher a estrutura correta é essencial para resolver problemas de maneira eficiente e organizada em qualquer contexto de programação.

Dessa forma, hoje vimos o que são, suas principais características e além disso, aprendemos como tirar o melhor proveito de Lista, Tupla, Conjunto e Dicionário.

Ao final, trasformamos o conjunto em uma lista utilizando list( ).

Referências:

Documentação Python