O Tipo bool

Em python o tipo bool especifica os valores booleanos falso (False) e verdadeiro (True).

• Podemos criar variáveis associadas a booleanos mas o uso mais comum é na verificação de resultados de expressões relacionais e lógicas.

  >>> a = True
  >>> type(a)
  <class 'bool'>

Expressões relacionais

Expressões relacionais

Expressões relacionais são aquelas que realizam uma comparação entre duas expressões e retornam

1. False, se o resultado é falso

2. True, se o resultado é verdadeiro.

Operadores Relacionais

Os operadores relacionais da linguagem Python são:

• == : igualdade.

• != : diferente.

• > : maior que.

• < : menor que.

• >= : maior ou igual que.

• <= : menor ou igual que.

Expressões relacionais

• expressão == expressão : Retorna verdadeiro quando as expressões forem iguais.

  >>> 9 == 9
  True
  >>> 9 == 9.0   #<-- note este exemplo - compara OK int e float
  True
  >>> 9 == 10
  False
  >>> 9 == 9.0000001
  False
  >>> 

• expressão != expressão : Retorna verdadeiro quando as expressões forem diferentes.

• expressão > expressão : Retorna verdadeiro quando a expressão da esquerda tiver valor maior que a expressão da direita.

• expressão < expressão : Retorna verdadeiro quando a expressão da esquerda tiver valor menor que a expressão da direita.

• expressão >= expressão : Retorna verdadeiro quando a expressão da esquerda tiver valor maior ou igual que a expressão da direita.

• expressão <= expressão : Retorna verdadeiro quando a expressão da esquerda tiver valor menor ou igual que a expressão da direita.

Expressões lógicas

Expressões lógicas

Expressões lógicas são aquelas que realizam uma operação lógica (ou, e, não, etc...) e retornam verdadeiro ou falso (como as expressões relacionais).

Operadores Lógicos

Na linguagem Python temos os seguintes operadores lógicos:

• and: operador E.

• or: operador OU.

• not: operador NÃO.

Expressões lógicas

• expressão and expressão : Retorna verdadeiro quando ambas as expressões são verdadeiras. Sua tabela verdade é:

  Op_1	Op_2	Ret
  V	V	V
  V	F	F
  F	V	F
  F	F	F

Qual o resultado da expressão lógica abaixo?

    a = 0
    b = 0
    a == 0 and b == 0

Expressões lógicas

• expressão or expressão : Retorna verdadeiro quando pelo menos uma das expressões é verdadeira. Sua tabela verdade é:

  Op_1	Op_2	Ret
  V	V	V
  V	F	V
  F	V	V
  F	F	F

Qual o resultado da expressão lógica abaixo?

    a = 0
    b = 1
    a == 0 or b == 0

Expressões lógicas

• not expressão : Retorna verdadeiro quando a expressão é falsa e vice-versa. Sua tabela verdade é:

  Op_1	Ret
  V	F
  F	V

Qual o resultado da expressão lógica abaixo?

    a = 0
    b = 1
    not (a != b)

Precedência

Precedência é a ordem na qual os operadores serão avaliados quando o programa for executado. Em Python, os operadores são avaliados na seguinte ordem:

• **

• *, /, //, na ordem em que aparecerem na expressão.

• %

• + e -, na ordem em que aparecerem na expressão.

• ou seja faz as contas matemáticas antes das comparações.

• comparações na ordem que aparecem

• not

• and

• or

Normalmente essa precedencia para os operadores lógicos é a mais intuitiva, mas na dúvida coloque parenteses.

Cuidado com testar se uma variável esta entre 2 valores

em Matemática 1 < x \leq 10

Em Python NÃO podemos escrever

1 < x <= 10

mas temos que escrever assim:

1 < x and x <= 10

Comandos condicionais

Comandos condicionais

Um comando condicional é aquele que permite decidir se um determinado bloco de comandos deve ou não ser executado, a partir do resultado de uma expressão relacional ou lógica.

Bloco de comandos

• É um conjunto de instruções agrupadas.

• Os comandos agrupados do bloco devem estar indentados dentro de um comando anterior seguido de dois pontos.

• A indentação é feita em geral com 2 ou 4 espaços em branco antes de cada comando que deve estar dentro do bloco.

Comandos condicionais - if - versão sem else

• O principal comando condicional é o if, cuja sintaxe é:

  if expressão relacional ou lógica :
     comando1
     comando2 
     ...
     comandon executados se a expressão é verdadeira
  
  proximoComando

• Os comandos são executados somente se a expressão relacional/lógica for verdadeira.

• o proximoComando sera sempre executado, já que ele é o comando de se segue ao if

• os comandos precisam estar alinhados - mesmo número de brancos antes de cada um

O programa abaixo determina se um valor é par.

a = int(input())
if a%2 == 0:
  print("O número digitado é par")

Comandos condicionais - if-else

• Uma variação do comando if é o if/else, cuja sintaxe é:

  if expressão relacional ou lógica :
     ...
     ...
     comandos executados se a expressão é verdadeira
  else:
     ...
     ...
     comandos executados se a expressão é falsa
  
  proximoComando

Exemplo: Determinando o menor de dois números:

a = int(input("Digite um número:"))
b = int(input("Digite um número:"))
if a < b:
   print("O menor número é: ", a )
else:
   print("O menor número é: ", b )

IF dentro/abaixo de IFs

• Note que o if é um comando, e como tal pode aparecer dentro do bloco de comandos de outro if.

Exemplo: Usando apenas operadores relacionais e aritméticos, vamos escrever um programa que lê um número e verifica em qual dos seguintes casos o número se enquadra:

• Par e menor que 100.

• Par e maior ou igual a 100.

• Ímpar e menor que 100.

• Ímpar e maior ou igual a 100.

a = int(input("Digite um número:"))
if a % 2 == 0:    #<-- Se número for par, executa bloco abaixo
   if a<100:
      print("O número é par e menor do que 100")
   else:
      print("O número é par e maior ou igual que 100")
else:           #<-- Se número for ímpar, executa bloco abaixo
   if a<100:
      print("O número é ímpar e menor do que 100")
   else:
      print("O número é ímpar e maior ou igual que 100")

Usando operadores lógicos, refazer este programa

IF abaixo do outro

print("Digite um número:")
a = int(input())
if (a % 2 == 0) and (a < 100):
   print("O número é par e menor do que 100")
if (a % 2 == 0) and (a >= 100):
   print("O número é par e maior ou igual que 100")
if (a % 2 != 0) and (a < 100):
   print("O número é ímpar e menor do que 100")
if (a % 2 != 0) and (a >= 100):
   print("O número é ímpar e maior ou igual que 100")

Comandos condicionais - indentação

Lembre-se que o que define a qual bloco de comandos um comando pertence é a sua indentação!

if cond1:
  if cond2:
    comando1
else:
  comando2

Quando o comando2 é executado?

Lembre-se que o que define a qual bloco de comandos um comando pertence é a sua indentação!

Quando o comando2 é executado?
Resposta: quando cond1 for falsa.

Exemplo: Comandos condicionais

if cond1:
  if cond2:
    comando1
  else:
    comando2

Quando o comando2 é executado?
Resposta: quando a cond1 for verdadeira e cond2 for falsa.

Exemplo: Comandos condicionais

if cond1:
  if cond2:
    comando1
  else:
    comando2
else:
  if cond3:
     comando3
  else:
     comando4 

Quando o comando4 é executado?
Resposta: quando a cond1 for falsa e cond3 for falsa.

Exemplo

a = 5
if a > 3:
  if a < 7:
    print("a")
else:
  if a > -10:
    print("b")
  else:
    print("c")

O que será impresso?

e agora?

a = -12
if a > 3:
  if a < 7:
    print("a")
else:
  if a > -10:
    print("b")
  else:
    print("c")

O que será impresso?

a = 9
if a > 3:
  if a < 7:
    print("a")
else:
  if a > -10:
    print("b")
  else:
    print("c")

O que será impresso?

Comandos Condicionais if-else

• Vamos fazer um programa que calcula a área de três tipos de objetos geométricos: quadrado, retângulo e círculo.

• Primeiramente deve ser lido um caractere que indica o tipo de objeto a ter a área calculada: ‘q’ para quadrado, ‘r’ para retângulo e ‘c’ para círculo.

• Em seguida deverá ser lido as dimensões do objeto:

  • Para um quadrado deve ser lido o tamanho de um lado.

  • Para um retângulo devem ser lidos os tamanhos de cada lado.

  • Para um círculo, deve ser lido o raio.

• Em seguida o programa faz o cálculo da área e a imprime.

• Se o usuário digitar um caractere diferente de ‘q’, ‘r’, e ‘c’ o programa deverá imprimir uma mensagem de erro.

Alternativa: um if debaixo do outro

print("Digite uma opção (q, r, ou c):")
a = input()
if a == "q":
  ...
if a == "r":
  ...
if a == "c":
  ...
if a != "q" and a != "r" and a != "c":
  print("Opção inválida!")

• O programa lê um caractere e testa se este corresponde a cada uma das opções válidas.

• O if final testa se o caractere lido não corresponde a nenhuma opção.

• Basta agora, dentro de cada opção, implementar a leitura dos dados e o cálculo da área.

Alternativa: um if debaixo do outro

print("Digite uma opção (q, r, ou c):")
a = input()
if a == "q":
  x = input("Digite o tamanho do lado do quadrado: ")
  lado = float(x)
  print("A área é", lado*lado)
if a == "r":
  ...
if a == "c":
  ...
if a != "q" and a != "r" and a != "c":
  print("Opção inválida!")

Vamos chamar essa solução de um if debaixo do outro

Alternativa: um if debaixo do outro

print("Digite uma opção (q, r, ou c):")
a = input()
if a == "q":
   ... 
if a == "r":
   ...
if a == "c":
   ...
if a != "q" and a != "r" and a != "c":
   print("Opção inválida!")

• para que um if debaixo do outro funcione, cada condição do if só pode ser verdade uma vez

• a ultima condição diz: se a for diferente de “q” e de “r” e de “c” então:

• um outro jeito de escrever essa condicão é

  if not (a == "q" or a == "r" or a == "c"):
     print("Opção inválida!")

Alternativa: if-else encaixados

Refazendo o programa utilizando if-else:

print("Digite uma opção (q, r, ou c):")
a = input()
if a == "q":
   ...
else:
   if a == "r":
      ... 
   else:
      if a == "c":
         ...
      else:
         ...

Na versão de if-else encaixados, a parte then sabe o que fazer, as outras perguntas ficam apenas na parte else

O ultimo caso, ficou no ultimo else - não precisamos escreve-lo explicitamente.

Comparação

• A versão if debaixo do outro é visualmente mais simples, mas todos os testes precisam ser excludentes, quando um da certo os outros não podem dar certo, o que tornou o ultimo teste meio complexo

• a versão do if-else encaixados só faz os testes necessários até achar a alternativa correta, mas o programa fica “escorregando” para a direita.

• Há uma alternativa que combina a eficiência do if-else encaixado com a simplicidade visual do if debaixo do outro. O if-elif.

• o if-elif combina os comandos de else e o if seguinte do if-else encaixados, num único comando elif

• a ultima alternativa da sequencia é o else (o mesmo que no if-else encaixado.

Alternativa: if-elif

print("Digite uma opção (q, r, ou c):")
a = input()
if a == "q":
    ...
elif a == "r":
    ... 
elif a == "c":
    ...
else:
    ...

Comando if-elif

A versão completa do programa:

print("Digite uma opção (q, r, ou c):")
a = input()
if a == "q":
  x = input("Digite o tamanho do lado do quadrado: ")
  l = float(x)
  print("A área é :", l*l)
elif a == "r":
  x1 = input("Digite o tamanho de um lado do retângulo: ")
  l1 = float(x1)
  x2 = input("Digite o tamanho do outro lado do retângulo: ")
  l2 = float(x2)
  print("A área é :", l1*l2)
elif a == "c":
  x = input("Digite o tamanho do raio: ")
  r = float(x)
  print("A área é :", 3.1415*r*r)
else:
  print("Opção inválida!")

Funções - primeira visita

Funções

• Um ponto chave na resolução de um problema complexo é conseguir “quebrá-lo" em subproblemas menores.

• Ao criarmos um programa para resolver um problema, é crítico quebrar um código grande em partes menores, fáceis de serem entendidas e administradas e geradas pelo ChatGPT

• Isto é conhecido como modularizacão, e é empregado em qualquer projeto de engenharia envolvendo a construção de um sistema complexo.

• Funções são estruturas que agrupam um conjunto de comandos, que são executados quando a função é chamada/invocada.

• As funções normalmente retornam um valor ao final de sua execução.

Exemplo de função:

a = input()

Definindo uma função

Definindo uma função

Uma função é definida da seguinte forma:

def nome(parâmetro1, ..., parâmetroN):
    comando
    ...
    return valor

• Os parâmetros são variáveis, que são inicializadas com valores indicados durante a invocação da função.

• O comando return devolve para o invocador da função o resultado da execução desta.

• os comandos dentro da função estão indentados

Definindo uma função: Exemplo 1

A função abaixo recebe como parâmetro dois valores inteiros. A função faz a soma destes valores, e devolve o resultado.

def soma(a, b):
    c = a + b
    return c

• Quando o comando return é executado, a função para de executar e retorna o valor indicado para quem fez a invocação (ou chamada) da função.

• Qualquer função ou o programa principal pode invocar esta função, passando como parâmetro dois valores, que serão atribuídos para as variáveis/parametros a e b respectivamente.

  r = soma(12, 90)
  
  velocidade = 90
  z = 27
  x = soma(velocidade, z+4)

Definindo uma função: Exemplo 2

• A lista de parâmetros de uma função pode ser vazia.

  def leNumeroInt():
     c = input("Digite um número inteiro: ")
     return int(c)

• O retorno será usado pelo invocador da função:

  r = leNumeroInt()
  print("Número digitado: ", r)

Atenção: a definição da função tem que vir antes do seu uso!

r = leNumeroInt()
print("Número digitado: ", r)

def leNumeroInt():
   c = input("Digite um número inteiro: ")
   return int(c)

% python a.py 
Traceback (most recent call last):
  File "a.py", line 2, in <module>
    r = leNumeroInt()
NameError: name 'leNumeroInt' is not defined

Exemplo de função 3

def soma(a, b):
   c = a + b
   return c

x1 = 4 
x2 = -10
res = soma(5, 6)
print("Primeira soma: ",res)
res = soma(x1, x2)
print("Segunda soma: ",res)

• Qualquer programa começa executando os comandos fora de qualquer função na ordem de sua ocorrência.

• Quando se encontra a chamada para uma função, o fluxo de execução passa para ela e se executa os comandos até que um return seja encontrado ou o fim da função seja alcançado.

• Depois disso o fluxo de execução volta para o ponto onde a chamada da função ocorreu.

Exemplo de função 4

def somaEsquisita(x, y) :
  x = x + 1
  y = y + 1
  return x + y


a=10
b=5
print ("Soma de a e b:", a + b)
print ("Soma de x e y:", somaEsquisita(a, b))
print ("a:", a)
print ("b:", b)

Os valores de a e b não são alterados por operações feitas em x e y

Retornando mais de um valor

uma funçao pode retornar mais de um valor (veremos que isso significa que a funçao retorna uma tupla).

• no return, coloque os valores separados por virgula

• na chamada, a função retornará os valores entre parenteses (isso é uma tupla que veremos em outra aula)

def soma_diff(a,b):
    return a+b, a-b

>>> soma_dif(4,5)
(9,-1)

Programando em modo batch e testando no modo interativo

Uma forma interessante de trabalhar com o python e escrever um arquivo com as suas funções (inclusive a main()) e testar as funções em modo interativo.

Quando voce acha um erro, voce edita o arquivo com as funções, volta a carrega-lo e testa de novo.

• python -i prog.py carrega o prog.py e vai para o modo iterativo