Capítulo 3: Operadores e Expressões

Capítulo 3: Operadores e Expressões#

ch3

Compreender os operadores e expressões é importante para a manipulação eficiente de dados e a execução de operações fundamentais em qualquer linguagem. Estes elementos, abrangendo operadores aritméticos, relacionais, lógicos e de atribuição, assumem papéis específicos, desde cálculos matemáticos até avaliações condicionais. Entender tais conceitos não apenas facilita a escrita de códigos mais eficazes, mas também permite a resolução de problemas complexos e a compreensão de códigos existentes.

Operadores Aritméticos#

Os operadores aritméticos são fundamentais em qualquer linguagem de programação. Eles permitem realizar operações matemáticas essenciais em variáveis e valores numéricos. Vamos explorar os principais operadores aritméticos em Python, seus símbolos e como eles funcionam na prática:

Operador	Símbolo	Descrição	Exemplo	Resultado
Adição	`+`	Soma dois valores.	`3 + 5`	`8`
Subtração	`-`	Subtrai o valor à direita do valor à esquerda.	`10 - 3`	`7`
Multiplicação	`*`	Multiplica dois valores.	`4 * 2`	`8`
Divisão	`/`	Divide o valor à esquerda pelo valor à direita.	`10 / 2`	`5.0`
Módulo	`%`	Retorna o resto da divisão.	`10 % 3`	`1`
Divisão Inteira	`//`	Retorna a parte inteira da divisão.	`10 // 3`	`3`
Exponenciação	`**`	Eleva o valor à esquerda à potência do valor à direita.	`2 ** 3`	`8`

Exemplos de Uso:

# Adição (+)
soma = 5 + 3

# Subtração (-)
subtracao = 7 - 4

# Multiplicação (*)
multiplicacao = 6 * 2

# Divisão (/)
divisao = 10 / 3

# Módulo (%)
modulo = 15 % 4

# Divisão Inteira (//)
divisao_inteira = 20 // 3

# Exponenciação (**)
potencia = 2 ** 4

print("Adição:", soma)
print("Subtração:", subtracao)
print("Multiplicação:", multiplicacao)
print("Divisão:", divisao)
print("Módulo:", modulo)
print("Divisão Inteira:", divisao_inteira)
print("Potência:", potencia)

Saída do Código:

Adição: 8
Subtração: 3
Multiplicação: 12
Divisão: 3.3333333333333335
Módulo: 3
Divisão Inteira: 6
Potência: 16

Precedência dos Operadores Aritméticos#

A ordem de precedência dos operadores determina quais operações serão realizadas primeiro em uma expressão. A tabela abaixo resume essa hierarquia:

Operadores Matemáticos	Prioridade
Exponenciação	Alta (primeira)
Multiplicação, Divisão e Módulo	Média
Adição e Subtração	Baixa (última)

Para alterar a ordem de execução, você pode usar parênteses ().

Exemplo de Precedência:

resultado1 = (2 + 3) * 4  # Aqui, somamos antes e depois multiplicamos
print(resultado1)  # 20

resultado2 = 2 + 3 * 4  # Aqui, multiplicamos primeiro e depois somamos
print(resultado2)  # 14

Exemplo de Combinação de Operadores:

resultado = 2 ** 3 + 4 * 5 - 10 / 2

Vamos entender passo a passo:

Exponenciação (**): 2 ** 3 resulta em 8.
Multiplicação e Divisão (*, /): 4 * 5 resulta em 20 e 10 / 2 resulta em 5.0.
Adição e Subtração (+, -): Agora, somamos e subtraímos na ordem: 8 + 20 = 28, depois 28 - 5 = 23.0.

Resultado final:

resultado = 23.0

Operadores Unários#

Os operadores unários atuam em um único operando. Um exemplo comum é o operador de negação (-). Vamos ver como ele funciona com outros operadores:

res_unario = -5 + 2 * 3

Aqui:

Primeiro aplicamos o operador unário - a 5, resultando em -5.
Depois, multiplicamos 2 por 3, resultando em 6.
Finalmente, somamos -5 com 6, resultando em 1.

Resultado:

res_unario = 1

Operadores Relacionais#

Os operadores relacionais permitem a comparação entre valores, retornando um resultado booleano (True ou False). Essa capacidade é fundamental para controlar o fluxo de um programa e tomar decisões baseadas em condições. Vamos explorar como esses operadores funcionam e onde eles são mais usados:

Instruções condicionais (if): Executam diferentes ações de acordo com o resultado da comparação.
Comparação de strings: Verifica se duas strings são iguais ou diferentes, como em validações de dados.
Validação de dados: Garante que valores fornecidos pelo usuário estejam dentro de limites específicos.
Ordenação de listas: Compara elementos de uma lista para ordená-los.
Cálculos condicionais: Usa comparações para decidir como realizar operações matemáticas.

Principais Operadores Relacionais#

Operador	Símbolo	Descrição	Exemplo	Resultado
Igualdade	`==`	Retorna `True` se os operandos forem iguais.	`5 == 5`	`True`
Diferença	`!=`	Retorna `True` se os operandos não forem iguais.	`5 != 3`	`True`
Menor que	`<`	Retorna `True` se o operando esquerdo for menor que o direito	`3 < 5`	`True`
Maior que	`>`	Retorna `True` se o operando esquerdo for maior que o direito	`3 > 5`	`False`
Menor ou igual	`<=`	Retorna `True` se o operando esquerdo for menor ou igual ao direito	`3 <= 5`	`True`
Maior ou igual	`>=`	Retorna `True` se o operando esquerdo for maior ou igual ao direito	`3 >= 5`	`False`

Exemplos:

Aqui estão alguns exemplos simples de uso de operadores relacionais:

# Comparando números
numero1 = 10
numero2 = 5

igual_a = (numero1 == numero2)
diferente_de = (numero1 != numero2)
menor_que = (numero1 < numero2)
maior_que = (numero1 > numero2)
menor_ou_igual_a = (numero1 <= numero2)
maior_ou_igual_a = (numero1 >= numero2)

print("Igual a:", igual_a)
print("Diferente de:", diferente_de)
print("Menor que:", menor_que)
print("Maior que:", maior_que)
print("Menor ou igual a:", menor_ou_igual_a)
print("Maior ou igual a:", maior_ou_igual_a)

Saída do Código:

Igual a: False
Diferente de: True
Menor que: False
Maior que: True
Menor ou igual a: False
Maior ou igual a: True

Comparação de Strings#

As strings também podem ser comparadas. A comparação de strings segue a ordem lexicográfica (ordem alfabética):

nome1 = "João"
nome2 = "Maria"

igual_a = (nome1 == nome2)
diferente_de = (nome1 != nome2)

print("Igual a:", igual_a)
print("Diferente de:", diferente_de)

Saída do Código:

Igual a: False
Diferente de: True

Operadores Lógicos#

Os operadores lógicos em Python são usados para combinar condições e construir expressões booleanas mais complexas. Eles são fundamentais em várias situações de programação, como:

Combinação de condições em instruções if: Executa diferentes ações com base em combinações de resultados de comparações.
Validação de dados complexos: Verifica se várias condições são atendidas simultaneamente.
Controle de fluxo do programa: Direciona o programa de acordo com diferentes condições.
Criação de algoritmos complexos: Permite a combinação de múltiplas condições para realizar tarefas mais sofisticadas.

Principais Operadores Lógicos

Operador	Símbolo	Descrição	Exemplo	Resultado	Precedência
Negação	`not`	Inverte o valor do operando.	`not True`	`False`	Alta
E lógico	`and`	Retorna `True` se ambos os operandos forem `True`.	`True and False`	`False`	Média
Ou lógico	`or`	Retorna `True` se pelo menos um dos operandos for `True`.	`True or False`	`True`	Baixa

Precedência dos Operadores Lógicos#

Os operadores lógicos têm uma ordem de precedência que define como as expressões são avaliadas quando combinados. O operador not tem a maior precedência, seguido por and e, finalmente, or, com a menor precedência.

Aqui estão exemplos que demonstram como a precedência funciona:

# Exemplo 1: Sem parênteses
result1 = True or True and False
print(result1)

# Exemplo 2: Com parênteses, alterando a precedência
result2 = (True or True) and False
print(result2)

Saída do Código:

True
False

Explicação dos Resultados:

No primeiro exemplo, sem parênteses, o operador and é avaliado antes do or, pois and tem uma precedência maior. Assim, a expressão True and False é avaliada primeiro, resultando em False. Em seguida, a expressão se torna True or False, o que resulta em True, já que o operador or retorna True se pelo menos um dos operandos for verdadeiro.
No segundo exemplo, o uso de parênteses altera a ordem de avaliação. A expressão dentro dos parênteses True or True é avaliada primeiro, resultando em True. Em seguida, temos a expressão True and False, que resulta em False, pois o operador and exige que ambos os operandos sejam True para retornar True.

Tabela Verdade do Operador and:

A	B	A and B
True	True	True
True	False	False
False	True	False
False	False	False

Tabela Verdade do Operador or:

A	B	A or B
True	True	True
True	False	True
False	True	True
False	False	False

Tabela Verdade do Operador not:

A	not A
True	False
False	True

Exemplo: Verificando se um número é par e maior que 10

numero = int(input("Digite um número: "))

# E lógico: verifica se ambas as condições são verdadeiras
par_e_maior_que_10 = (numero % 2 == 0) and (numero > 10)

if par_e_maior_que_10:
    print("O número é par e maior que 10.")
else:
    print("O número não é par ou não é maior que 10.")

Saída do Código:

Digite um número: 12
O número é par e maior que 10.

Exemplo: Verificando se o usuário digitou “sim” ou “não”

resposta = input("Digite sim ou não: ").lower()

# Ou lógico: verifica se pelo menos uma das condições é verdadeira
resposta_valida = (resposta == "sim") or (resposta == "não")

if resposta_valida:
    print("Resposta válida.")
else:
    print("Resposta inválida. Digite apenas 'sim' ou 'não'.")

Saída do Código:

Digite sim ou não: não
Resposta válida.

Exemplo: Uso do operador not para inverter uma condição

idade = int(input("Digite sua idade: "))

# Verificando se a idade não é maior ou igual a 18 (ou seja, é menor de 18)
if not (idade >= 18):
    print("Você não é maior de idade.")
else:
    print("Você é maior de idade.")

Saída do Código:

Digite sua idade: 17
Você não é maior de idade.

Observações Relevantes

Precedência dos Operadores: O operador not tem a maior precedência, seguido de and, e depois or. Para controlar a ordem de execução, use parênteses.
Uso de Tipos Booleanos: Os operadores lógicos operam apenas em valores booleanos (True ou False). Certifique-se de que as condições estejam retornando valores corretos para evitar erros de tipo.
Negação: O operador not pode ser usado para negar o resultado de qualquer expressão booleana.

Operadores de Associação#

Os operadores de associação em Python são utilizados para verificar se um valor está presente em uma sequência. Eles são muito úteis em diversas situações de programação, como:

Verificação de elementos em coleções: Busca valores em listas, tuplas ou strings.
Validação de dados: Verifica se uma entrada está dentro de um conjunto de valores válidos.
Filtragem de dados: Seleciona elementos com base em critérios de pertencimento.
Controle de fluxo do programa: Direciona o programa com base na presença ou ausência de elementos.

Principais Operadores de Associação

Operador	Símbolo	Descrição	Exemplo	Resultado
Pertence	`in`	Verifica se um valor está presente na sequência.	`'a' in 'python'`	`False`
Não pertence	`not in`	Verifica se um valor não está presente na sequência.	`'a' not in 'python'`	`True`

Exemplos de Uso#

Os operadores de associação podem ser utilizados com diferentes tipos de sequências em Python. Aqui estão alguns exemplos práticos:

Exemplo: Verificando valores válidos em um menu

opcoes_validas = ['1', '2', '3', '4']
opcao = input("Digite uma opção (1-4): ")

if opcao in opcoes_validas:
    print("Opção válida!")
else:
    print("Opção inválida! Digite um número de 1 a 4.")

Saída do Código:

Digite uma opção (1-4): 5
Opção inválida! Digite um número de 1 a 4.

Exemplo: Verificando vogais em uma string

letra = input("Digite uma letra: ").lower()
vogais = 'aeiou'

if letra in vogais:
    print(f"A letra '{letra}' é uma vogal.")
else:
    print(f"A letra '{letra}' é uma consoante.")

Saída do Código:

Digite uma letra: E
A letra 'e' é uma vogal.

Exemplo: Verificando elementos em uma lista de permissões

usuarios_permitidos = ['admin', 'gerente', 'supervisor']
usuario = input("Digite seu nível de acesso: ").lower()

if usuario not in usuarios_permitidos:
    print("Acesso negado!")
else:
    print("Acesso permitido!")

Saída do Código:

Digite seu nível de acesso: visitante
Acesso negado!

Observações Relevantes

Tipos de Sequências: Os operadores de associação funcionam com strings, listas, tuplas, sets e dicionários (neste último caso, a verificação é feita nas chaves).
Case Sensitive: Em strings, a verificação é case sensitive. Para ignorar maiúsculas/minúsculas, converta a string para minúsculo ou maiúsculo antes da comparação.
Performance: Em listas grandes, usar o operador in pode ser menos eficiente que outras estruturas de dados como sets ou dicionários.

Operadores de Atribuição#

Os operadores de atribuição são usados para armazenar valores em variáveis e atualizar esses valores posteriormente. Eles são essenciais na manipulação de dados e ajudam a criar programas mais eficientes. A tabela abaixo apresenta os principais operadores de atribuição em Python, seus símbolos, descrições, exemplos e resultados:

Operador	Descrição	Exemplo	Resultado
`=`	Atribuição simples	`x = 5`	`x` recebe o valor `5`
`+=`	Soma e atribui	`a += 2`	`a` é incrementado em `2` (equivalente a `a = a + 2`)
`-=`	Subtrai e atribui	`b -= 3`	`b` é decrementado em `3` (equivalente a `b = b - 3`)
`*=`	Multiplica e atribui	`c *= 5`	`c` é multiplicado por `5` (equivalente a `c = c * 5`)
`/=`	Divide e atribui	`d /= 2`	`d` é dividido por `2` (equivalente a `d = d / 2`)
`%=`	Calcula o módulo e atribui	`e %= 4`	`e` recebe o resto da divisão por `4` (equivalente a `e = e % 4`)

Todos os operadores de atribuição em Python têm baixa precedência. Isso significa que, em uma expressão com múltiplos operadores de atribuição, eles serão avaliados da direita para a esquerda.

Embora Python não tenha operadores de incremento (++) e decremento (--) como algumas outras linguagens, o mesmo efeito pode ser alcançado usando x += 1 (para x++) e x -= 1 (para x--).

Exemplos:

# Atribuição simples
numero = 10
nome = "João"

# Atribuição com operações aritméticas
valor = 5
valor += 3  # Equivalente a: valor = valor + 3

resultado = 15
resultado /= 3  # Equivalente a: resultado = resultado / 3

# Incremento e decremento simulados
x = 10
x += 1  # Equivalente a x++
x -= 1  # Equivalente a x--

# Exibindo os valores
print("Número:", numero)
print("Nome:", nome)
print("Valor:", valor)
print("Resultado:", resultado)
print("Valor final de x:", x)

Saída do Código:

Número: 10
Nome: João
Valor: 8
Resultado: 5.0
Valor final de x: 10

Os operadores de atribuição combinados com operações aritméticas são uma maneira prática de realizar cálculos e atribuir o resultado em uma única etapa. Lembre-se sempre da ordem de precedência dos operadores para garantir o comportamento esperado das expressões. Além disso, certifique-se de que o tipo da variável seja compatível com o valor atribuído.

Operações com Bits#

As operações a nível de bits são fundamentais em computação, especialmente em áreas como criptografia, manipulação de dados, compressão e comunicação com hardware. Elas permitem que os programadores manipulem dados de forma eficiente, controlando diretamente os bits individuais que compõem um número. Isso é útil em situações onde o desempenho e o uso de memória são críticos, como em sistemas embarcados, algoritmos de processamento de sinais e computação gráfica.

Inversão Bit a Bit (`~`)#

O operador unário de inversão de bits, representado pelo caractere ~, inverte cada bit em uma representação binária de um número, transformando 0 em 1 e 1 em 0. Essa operação é particularmente útil em manipulações de bits de baixo nível.

Exemplo de Inversão de Bits:

# Número original em decimal
numero_original = 5

# Representação binária do número original
binario_original = bin(numero_original)

# Inverte os bits usando o operador ~
numero_invertido = ~numero_original

# Representação binária do número invertido
binario_invertido = bin(numero_invertido)

# Exibindo os resultados
print("Número original:", numero_original)
print("Representação binária do número original:", binario_original)
print("Número invertido:", numero_invertido)
print("Representação binária do número invertido:", binario_invertido)

Saída do Código:

Número original: 5
Representação binária do número original: 0b101
Número invertido: -6
Representação binária do número invertido: -0b110

Ao inverter os bits de um número, o operador ~ atua diretamente sobre a sua representação binária. Por exemplo, o número decimal 5 é representado como 0b101 em binário. Ao inverter os bits, 0 se torna 1 e 1 se torna 0, resultando em -0b110. O resultado final é -6 porque Python utiliza a representação em complemento de dois para números negativos, o que faz com que a inversão de bits gere um número negativo.

Conversão de Binário para Decimal#

Além de inverter bits, é essencial saber como converter um número binário para sua forma decimal. Isso pode ser feito facilmente com a função int() e o parâmetro de base 2.

Exemplo: Conversão de Binário para Decimal a partir de uma String

# Número binário representado como string
binario = "1101"

# Convertendo para decimal
numero_decimal = int(binario, 2)

print("O número decimal é:", numero_decimal)

Saída do Código:

O número decimal é: 13

Neste exemplo, a string "1101" é interpretada como um número binário e convertida para o valor decimal 13.

Exemplo: Conversão de Representação Binária com Prefixo 0b

Se você tiver uma representação binária gerada pela função bin(), que inclui o prefixo "0b", a conversão pode ser feita diretamente, conforme mostrado a seguir:

# Número original em decimal
numero_original = 28

# Representação binária com prefixo '0b'
binario_original = bin(numero_original)  # '0b11100'

# Convertendo a representação binária de volta para decimal
numero_convertido = int(binario_original, 2)

print("Número original:", numero_original)
print("Representação binária:", binario_original)
print("Número convertido de volta para decimal:", numero_convertido)

Saída do Código:

Número original: 28
Representação binária: 0b11100
Número convertido de volta para decimal: 28

Mesmo com o prefixo "0b", a função int() é capaz de converter corretamente o valor binário de volta para o decimal.

Deslocamento de Bits#

Além da inversão e conversão de bits, o deslocamento de bits é uma operação comum que pode otimizar cálculos em determinadas situações. Esses deslocamentos são úteis em operações de multiplicação e divisão rápida, em sistemas que precisam de eficiência de desempenho.

Números com e sem Sinal

Antes de entender o deslocamento de bits, é importante compreender a diferença entre números com e sem sinal:

Números sem sinal (unsigned): Representam apenas valores não negativos. Cada bit é usado para o valor numérico, o que permite representar uma maior faixa de números positivos.
Números com sinal (signed): Permitem a representação de valores negativos e positivos. Normalmente, o bit mais à esquerda (bit de maior peso) é usado como o “bit de sinal”, indicando se o número é positivo ou negativo.

Em Python, a distinção entre números com e sem sinal não é explícita para tipos inteiros, pois os inteiros são de precisão arbitrária. No entanto, ao trabalhar com deslocamentos de bits, é importante ter em mente como os números são tratados internamente, especialmente ao usar linguagens de programação com tipos numéricos fixos.

Operadores de Deslocamento

Deslocamento à Esquerda (<<): Este operador move os bits para a esquerda, adicionando zeros à direita. Cada deslocamento à esquerda multiplica o número por 2.
```
numero = 5
resultado_esquerda = numero << 1  # Desloca 1 posição à esquerda
print("Resultado:", resultado_esquerda)
```
Saída do Código:
```
Resultado: 10
```
Neste caso, 5 << 1 resulta em 10, que é equivalente a multiplicar 5 por 2.
Deslocamento à Direita (>>): Este operador move os bits para a direita. Para números com sinal, o bit mais à esquerda (bit de sinal) é mantido, preservando o sinal do número, enquanto para números sem sinal, os bits deslocados para a direita são substituídos por zeros. Cada deslocamento à direita divide o número por 2.
```
numero = 5
resultado_direita = numero >> 1  # Desloca 1 posição à direita
print("Resultado:", resultado_direita)
```
Saída do Código:
```
Resultado: 2
```
Aqui, 5 >> 1 resulta em 2, que é equivalente a dividir 5 por 2.

Operações a nível de bits, como inversão e deslocamento, são essenciais para a manipulação eficiente de dados e são amplamente utilizadas em áreas que exigem um controle preciso sobre o processamento de informações. Entender a distinção entre números com e sem sinal, assim como as operações de deslocamento, é crucial para otimizar cálculos em sistemas de baixo nível.

Precedência dos Operadores (Tabela)#

Por fim, a tabela a seguir apresenta a ordem de precedência dos principais tipos de operadores em Python, da maior para a menor precedência:

Tipo de Operador	Precedência	Exemplo	Descrição
Parênteses	Mais alta	`(2 + 3) * 4`	Agrupa expressões
Exponenciação	Alta	`2 ** 3`	Potenciação
Unário	Alta	`-x`, `~x`, `not x`	Negação e complemento
Deslocamento de Bits	Alta	`x << 1`, `y >> 2`	Operações com bits
Multiplicação e Divisão	Média-alta	`2 * 3`, `4 / 2`, `5 // 2`, `6 % 2`	Operações aritméticas
Adição e Subtração	Média	`2 + 3`, `4 - 1`	Operações aritméticas
Operadores de Associação	Média-baixa	`x in lista`, `y not in tupla`	Verificação de pertencimento
Comparação	Baixa	`2 < 3`, `4 >= 1`, `5 == 5`, `6 != 3`	Comparações relacionais
Operador and	Baixa	`x and y`	Operação lógica AND
Operador or	Mais baixa	`x or y`	Operação lógica OR
Atribuição	Mais baixa	`x = 2`, `y += 3`	Atribuição de valores

Notas importantes:

Operadores na mesma linha têm a mesma precedência
Quando operadores têm a mesma precedência, a avaliação é feita da esquerda para a direita
Use parênteses para garantir a ordem de avaliação desejada
A precedência pode ser sobrescrita usando parênteses

Exercícios#

“Antes de começar os exercícios, é importante notar que para testes com múltiplas entradas em uma mesma linha, é útil utilizar o método .split(). Este método divide a string recebida pelo input() em substrings, utilizando espaços em branco como delimitadores. Ele retorna uma lista contendo as substrings resultantes.

Por exemplo, para uma entrada: 1 1 6 6 4 4

entrada = input().split()
print(entrada)

Ao executar o código acima com a entrada 1 1 6 6 4 4, a saída será:

['1', '1', '6', '6', '4', '4']

Dada a expressão matemática: \(a = 4 * (2 + 3) - 7\). Crie uma variável chamada a e atribua a ela o resultado dessa expressão. Em seguida, crie uma variável chamada b e atribua a ela o valor de a multiplicado por 2. Por fim, imprima os valores de a e b.

# Teste 1
Entrada: Sem entrada
Saída:
O valor de 'a' é: 13
O valor de 'b' é: 26

Escreva um programa que solicita ao usuário um número inteiro positivo entre 100 e 1000. Em seguida, o programa deve calcular o resto da divisão desse número por 5, armazenar o resultado em uma variável chamada resto e imprimir este valor.

Certifique-se de que o programa lide adequadamente com entradas inválidas. Caso o usuário insira um número negativo ou fora do intervalo especificado, exiba a seguinte mensagem de erro: “Por favor, insira um número inteiro positivo entre 100 e 1000.”

# Teste 1
Entrada: 172
Saída: O resto da divisão de 172 por 5 é 2.

# Teste 2
Entrada: -10
Saída: Por favor, insira um número inteiro positivo entre 100 e 1000.

# Teste 3
Entrada: 2000
Saída: Por favor, insira um número inteiro positivo entre 100 e 1000.

# Teste 4
Entrada: 500
Saída: O resto da divisão de 500 por 5 é 0.

Escreva um programa que converta uma temperatura de Celsius para Fahrenheit. Utilize a fórmula: \(F = \frac{9}{5} * C + 32\).

Solicite ao usuário que digite a temperatura em Celsius.
Em seguida, converta a temperatura digitada para Fahrenheit utilizando a fórmula fornecida.
Por fim, exiba na tela o resultado da conversão para o usuário, formatado com 2 casas decimais.

# Teste 1
Entrada: 20.5
Saída: A temperatura em Fahrenheit é: 68.90

# Teste 2
Entrada: 0.75
Saída: A temperatura em Fahrenheit é: 33.35

Escreva um programa que recebe na entrada um número inteiro entre 10 e 20. O programa deverá converter esse número para sua representação binária, removendo o prefixo '0b' da conversão. Em seguida, cada bit dessa representação binária será salvo em uma lista, onde cada posição da lista conterá um dos bits. Por fim, o programa deverá imprimir o resultado.

# Teste 1
Entrada: 10
Saída: ['1', '0', '1', '0']

# Teste 2
Entrada: 16
Saída: ['1', '0', '0', '0', '0']

# Teste 3
Entrada: 34
Saída: O número inserido não está dentro do intervalo permitido.

Utilizando tuplas, você deve receber as coordenadas de um retângulo no plano cartesiano, onde (x_min, y_min) representa o canto inferior esquerdo e (x_max, y_max) representa o canto superior direito. Além disso, você tem um ponto representado por um par de coordenadas (x, y).

Sua tarefa é escrever um programa que determine se o ponto está dentro, tocando na borda ou fora do retângulo. O programa deve imprimir uma mensagem na saída padrão indicando o resultado da verificação.

Veja o exemplo didático do desenho ASCII para o Teste 1:

O + representa os cantos do retângulo.
O . representa o ponto.
As coordenadas do retângulo são (x_min, y_min) = (1,1) e (x_max, y_max) = (6,6).
As coordenadas do ponto são (x, y) = (4,4).

|          
|   +--------------+ (6,6)
|   |              |
|   |       .(4,4) |
|   |              |
|   |              |
|   +--------------+
| (1,1)        
  -+--+--+--+--+--+--+--+
1  2  3  4  5  6  7

# Teste 1
Entrada: 1 1 6 6 4 4
Saída: O ponto está dentro do retângulo.

# Teste 2
Entrada: 1 1 6 6 6 6
Saída: O ponto está tocando a borda do retângulo.

# Teste 3
Entrada: 1 1 6 6 0 1
Saída: O ponto está fora do retângulo.

# Teste 4
Entrada: 1 1 6 6 1 7
Saída: O ponto está fora do retângulo.

# Teste 5
Entrada: 1 1 6 6 6 1
Saída: O ponto está tocando a borda do retângulo.

# Teste 6
Entrada: 1 1 6 6 4 6
Saída: O ponto está tocando a borda do retângulo.

Desenvolva um sistema de autenticação que utilize um dicionário chamado usuarios_senhas para armazenar os nomes e as senhas de dois usuários. O programa deve solicitar que o usuário insira seu nome de usuário e senha. Em seguida, o sistema deve verificar se as credenciais inseridas correspondem às armazenadas no dicionário. Se as credenciais estiverem corretas, o programa deve exibir uma mensagem de “Login bem-sucedido! Bem-vindo, usuário.”. Caso contrário, deve informar ao usuário “Acesso negado. Credenciais inválidas.”.

Obs: Serão armazenados apenas três usuários.

# Teste 1
Entrada: usuario1 senha123 usuario2 abc456 usuario3 123456 usuario1 senha123
Saída: >> Login bem-sucedido! Bem-vindo, usuario1.

# Teste 2
Entrada: usuario1 senha143 usuario2 abc452 usuario3 654321 usuario2 123abc
Saída: >> Acesso negado. Credenciais inválidas.

Você é um biólogo trabalhando em um parque natural e está encarregado de monitorar três espécies de aves migratórias. Cada espécie tem um conjunto de ilhas preferidas para nidificação durante a temporada de migração. As preferências das espécies são as seguintes:

Espécie 1: Prefere as ilhas com IDs de 1 a 10.
Espécie 2: Prefere as ilhas com IDs de 6 a 17.

Algumas ilhas são compartilhadas entre as espécies, o que pode levar à competição por recursos. Seu trabalho é identificar quais ilhas são compartilhadas para implementar medidas de conservação. Dessa forma, dada uma entrada do usuário correspondente ao ID de uma das ilhas, verifique se essa ilha específica é uma área de competição ou se é exclusiva de uma das espécies.

# Teste 1
Entrada: 2
Saída: Ilha 2 é exclusiva da Espécie 1. 
Portanto, não é compartilhada com outras espécies.

# Teste 2
Entrada: 6
Saída: Ilha 6 é compartilhada entre espécie(s):1 2.

# Teste 3
Entrada: 10
Saída: Ilha 10 é compartilhada entre espécie(s):1 2.

# Teste 4
Entrada: 17
Saída: 
Ilha 17 é exclusiva da Espécie 2. 
Portanto, não é compartilhada com outras espécies.

Auxiliando o Hacker Neo a Desvendar a Verdade Sobre a Realidade.

História da Matrix: Neo, um hacker talentoso, vive uma vida dupla. No mundo que ele conhece, ele é um programador comum. Mas, e se existisse uma realidade escondida, uma verdade que ele nunca imaginou?

Após ser contatado por Morpheus, Neo se depara com uma escolha crítica: tomar a pílula vermelha e desvendar a verdade, ou tomar a pílula azul e continuar vivendo sua vida como sempre.

Fases do Programa:

Fase 1: A Escolha ● ●

Neo deve escolher entre a pílula vermelha e a pílula azul. A escolha é feita através de um input do usuário:
- Se o usuário digitar “vermelha”, Neo avança para a fase 2.
- Se o usuário digitar “azul”, Neo continua vivendo sua vida normal e o programa termina.

Fase 2: Desvendando a Realidade

Neo precisa questionar a realidade em que vive. Ele deve responder a três perguntas:
- A realidade que você conhece é real? (Sim ou Não)
- Existe uma realidade escondida? (Sim ou Não)
- Você quer desvendar a verdade? (Sim ou Não)

Fase 3: Explorando a Verdade

Se Neo responder “Sim” a todas as perguntas da fase 2, ele terá acesso a informações sobre a verdade, e o programa termina com uma mensagem de sucesso.
Se Neo responder “Não” a qualquer uma das perguntas da fase 2, ele continua vivendo sua vida normal, e o programa termina com uma mensagem de que a escolha é dele.

Exemplos de Teste:

# Teste 1
Entrada: Vermelha Sim Não Sim
Saída: A escolha é sua, Neo continua vivendo sua vida normal.

# Teste 2
Entrada: Azul
Saída: Neo continua vivendo sua vida normal.

# Teste 3
Entrada: Vermelha Não Sim Sim 
Saída: A escolha é sua, Neo continua vivendo sua vida normal.

# Teste 4
Entrada: Vermelha Sim Sim Sim
Saída: Neo terá acesso a informações sobre a verdade.

Você é um fotógrafo profissional. Durante um trabalho, você se depara com um lago cristalino cercado por imensas montanhas. Seu objetivo é capturar uma foto aérea épica do lago, utilizando um drone. Para garantir a melhor perspectiva, você precisa determinar a altura ideal de voo do drone. Para isso, será necessário saber a distância horizontal entre você e a margem do lago, bem como a altura vertical que deseja alcançar com o drone.

A hipotenusa, que representa a distância diagonal percorrida pelo drone, pode ser calculada utilizando o Teorema de Pitágoras:

\( Hipotenusa = \sqrt(CatetoAdjacente^2 + CatetoOposto^2) \)

Seu programa receberá como entrada, em metros, o comprimento do cateto adjacente e do cateto oposto, e calculará a hipotenusa correspondente.

Exemplos de Teste:

# Teste 1
Entrada: 50 30
Saída: 58.00 metros

# Teste 2
Entrada: 40 20
Saída: 44.72 metros

# Teste 3
Entrada: 70 50
Saída: 86.02 metros

Um artesão está trabalhando em duas peças: um cone de metal e um paralepípedo de madeira. Para ajudá-lo em seu projeto, você precisa desenvolver um programa que receba as informações de dimensões em cm desses objetos e calcule seus volumes e massas.

Receber na entrada as seguintes informações para o cone: Altura e Raio.
Em seguida, receber as informações para o paralepípedo: Altura, Largura e Comprimento.

Considerando as fórmulas matemáticas adequadas para calcular o volume de cada objeto:

Volume do Cone: \(V_{\text{cone}} = \frac{1}{3} \pi r^2 h\)

Volume do Paralepípedo: \( V_{\text{paralel}} = l \times w \times h \)

Calcule a massa de cada objeto, considerando que a densidade do metal é de 8 g/cm³ e a densidade da madeira é de 0,5 g/cm³. Qual dos dois objetos, cone ou paralepípedo, é mais pesado? Considere que eles possuem o mesmo peso se a diferença entre as massas for menor do que 5g.

Exemplos de Teste:

# Teste 1
Entrada: 10 5 19 8 6
Saída: O cone é mais pesado com 2094.4g.

# Teste 2
Entrada: 4 2 10 8 8
Saída: O paralelepípedo é mais pesado com 320.0g.

# Teste 3
Entrada: 10 2.44 10 10 10
Saída: O paralepípedo e o cone possuem o mesmo peso.

# Teste 4
Entrada: 20 4.886 20 20 20
Saída: O paralepípedo e o cone possuem o mesmo peso.

Capítulo 3: Operadores e Expressões

Contents

Capítulo 3: Operadores e Expressões#

Operadores Aritméticos#

Precedência dos Operadores Aritméticos#

Operadores Unários#

Operadores Relacionais#

Principais Operadores Relacionais#

Comparação de Strings#

Operadores Lógicos#

Precedência dos Operadores Lógicos#

Operadores de Associação#

Exemplos de Uso#

Operadores de Atribuição#

Operações com Bits#

Inversão Bit a Bit (~)#

Conversão de Binário para Decimal#

Deslocamento de Bits#

Precedência dos Operadores (Tabela)#

Exercícios#

Inversão Bit a Bit (`~`)#