6 - Programação Estruturada

O bloco de condição if... elif... else tem o cabeçalho iniciado com o uso da palavra-reservada if, e pode ter apenas o bloco if, ou mais blocos de seleção com o uso das palavras-reservada elif e else.

if <condição-1>:
    bloco-1
elif <condição-2>:
    bloco-2
elif <condição-3>:
    bloco-3
else:
    bloco-4

Diagrama:

O cabeçalho if é obrigatório para iniciar um bloco condicional e os cabeçalhos elif e else são opcionais.

Exemplo:

a = 33
b = 200
if b > a:
    print("b é maior que a")

b é maior que a

Na terceira linha a condição "if b > a:" define o cabeçalho do bloco de condição no exemplo. A condição é avaliada e, sendo verdadeira, é executada a instrução print presente, única no corpo do bloco.

O Python suporta as comparações lógicas usuais da matemática, usando símbolos especiais para representar essas comparações.

Na matemática, o operador = é utilizando tanto na atribuição de um valor a uma variável quanto para comparação entre uma variável com outra variável ou com um literal.

No Python, o operador "=" é utilizado na atribuição de um valor a uma variável enquanto o operador "==" é utilizado na comparação de igualdade entre variáveis e literais.

A tabela abaixo mostra os operadores de comparação do Python, usandos as comparações entre as variáveis a e b como exemplo.

Essas condições podem ser usadas de várias maneiras, sendo muito comuns com os blocos condicionais if... elif ...else e em laços (loops) for e while.

Os blocos condicionais são controles de fluxo em que o código respeita uma estrutura de decisão considerando o atendimento a condições lógicas if... elif ...else.

A instrução if

Um bloco condicional é iniciado com uso da palavra-reservada if.

a = "texto"
b = "texto"
if b == a:
    print("a é igual a b")

a é igual a b

Neste exemplo, usamos duas variáveis, a e b, usadas como operadores condicionais da instrução if, para testar se b é igual a a.

Como o valor da variável a é "texto" e o da variável b também é "texto", e temos na condição do bloco a interpretação de "se b igual a a", o que é verdade, então as instruções no bloco são executadas.

Recuo

Python usa recuos (um espaço ou mais em branco no início das linhas do bloco) para definir o escopo das instruções dentro do bloco no código.

Outras linguagens de programação costumam usar 'abre-fecha' com colchetes [], parenteses (), parágrafos {} ou outros delimitadores similares usados para essa finalidade.

No Python, as intruções pertencem ao corpo de um bloco até quando não for utilizado mais o recuo, e deve haver ao menos uma instrução com recuo, senão é gerado um erro sintático e a execução é interrompida.

Exemplo: Erro no bloco if por falta de recuo na instrução seguinte ao cabeçalho do bloco.

a = 33
b = 200
if b > a:
print("b é maior que a") ## é gerado um erro

IndentationError: expected an indented block after 'if' statement on line 3 (<string>, line 4) <traceback object at 0x0000018D4355E380>

A instrução elif

As instruções elif definem blocos executadas se as condições anteriores não forem verdadeiras.

a = 33
b = 33
if b > a:
    print("b é maior que a")
elif a == b:
    print("a e b são iguais")

a e b são iguais

Neste exemplo a é igual a b, então a primeira condição não é verdadeira, mas a condição elif é verdadeira, então imprimimos na tela que "a e b são iguais".

A instrução else

A palavra-reservada else captura qualquer coisa que não seja capturada pelas condições anteriores.

a = 200
b = 33
if b > a:
    print("b é maior que a")
elif a == b:
    print("a aend b são iguais")
else:
    print("a é maior que b")

a é maior que b

Neste exemplo a é maior que b, então a primeira condição não é verdadeira, também a condição elif não é verdadeira, então vamos para a condição else e imprimimos na tela que "a é maior que b".

Você também pode ter um else sem o elif, apenas com o if:

a = 200
b = 33
if b > a:
    print("b é maior que a")
else:
    print("b é menor que a")

b é menor que a

Mão curta "if"

Se você tiver apenas uma instrução para executar, poderá colocá-la na mesma linha da instrução if.

a = 200
b = 33
if a > b: print("a é maior que b")

a é maior que b

Mão curta "if... else"

Se você tiver apenas uma instrução para executar, uma para if e outra para else, você pode colocar a instrução condicional toda na mesma linha.

a = 2
b = 330
print("A") if a > b else print("B")

B

Essa técnica é conhecida como operação ternária ou expressão condicional.

Você também pode ter várias instruções else na mesma linha.

a = 330
b = 330
print("A > B") if a > b else print("A = B") if a == b else print("A < B")

A = B

A palavra-reservada and corresponde ao conector "e", sendo usada para combinar instruções condicionais entre dois operandos.

a = 200
b = 33
c = 500
if (a > b) and (c > a):
    print("Ambas condições são verdadeiras")

Ambas condições são verdadeiras

No exemplo são testados primeiro se a é maior que b e se c é maior que a, depois são comparados se os resultados obtidos são verdadeiros usando-se o conector and. O resultado é positivo e portanto a instrução no bloco condicional if é executada.

A palavra-reservada or é um operador lógico igualmente usado para combinar instruções condicionais.

a = 200
b = 33
c = 500
if (a > b) or (a > c):
    print("Pelo menos uma das condições é verdadeira.")

Pelo menos uma das condições é verdadeira.

No exemplo então a condição é atendida, porque a condição a > c é falsa mas a condição a > b é verdadeira, e portanto a instrução no bloco condicional if é executada, com a utilização do conector or.

Aninhamento

Você pode ter um bloco if dentro de outro bloco if, sendo chamado de bloco if aninhado de instruções.

x = 41
print ("x =",x)
if x > 10:
    print("x é maior que dez")
    if x > 20:
        print("x é maior que 20!")
    else:
        print("x é menor que 20")

x = 41
x é maior que dez
x é maior que 20!

A declaração pass de passagem

As declarações não podem ser vazias, mas se você por algum motivo tiver uma declaração de bloco if sem conteúdo, coloque a declaração pass para evitar a ocorrência de erro.

a = 33
b = 200

if b > a:
    pass

As instruções match e case definem blocos executados de acordo com a condição lógica.

x = 5
match x:
    case 1:
        print("x é 1")
    case 2:
        print("x é 2")
    case 3:
        print("x é 3")
    case _:
        print("x não é 1, 2 ou 3")

x não é 1, 2 ou 3

O bloco de repetição for é um laço (loop) contendo uma ou mais instruções executadas enquanto a condição especificada no cabeçalho do laço for atendida.

Um laço for é usado para iterar sobre uma sequência (que é uma lista, uma tupla, um dicionário, um conjunto ou um texto).

Isso é menos parecido com a palavra-reservada for em outras linguagens de programação, e funciona mais como um método iterador, conforme encontrado em outras linguagens de programação orientadas a objetos.

Com o laço for podemos executar um conjunto de instruções, uma vez para cada item de uma lista, tupla, conjunto etc, na ordem da iteração.

Exemplo: Imprima cada fruta em uma lista de frutas.

frutas = ["maçã", "banana", "cereja"]
for x in frutas:
    print(x)

maçã
banana
cereja

O laço for não requer que uma variável de indexação seja definida antecipadamente.

Mesmo textos são objetos iteráveis, contendo uma sequência de caracteres.

Exemplo: Percorrer as letras da palavra "banana".

x = "banana"
for x in "banana": print(x)

b
a
n
a
n
a

A declaração de quebra

O laço pode ser encerrado antes de ter percorrido todos os itens com a instrução break.

Exemplo: O laço for é finalizado quando o valor de x for "banana".

frutas = ["maçã", "banana", "cereja"]
for x in frutas:
    print(x)
    if x == "banana": break

maçã
banana

Exemplo: O laço é encerrado com a instrução break quando o valor de x for "banana", mas antes da execução da instrução .

frutas = ["maçã", "banana", "cereja"]
for x in frutas:
    if x == "banana": break
    print(x)

maçã

A declaração de continuação

O laço atual pode ser finalizado e passar para o próximo com a instrução continue.

Exemplo: O laço for é continuado quando o valor de x for "banana".

frutas = ["maçã", "banana", "cereja", "banana", "abacaxi","cereja"]
for x in frutas:
    if x == "banana": continue
    print(x)

maçã
cereja
abacaxi
cereja

Com compreensão de listas ficaria da seguinte forma:

frutas = ["maçã", "banana", "cereja", "banana", "abacaxi","cereja"]
sem_banana = [x for x in frutas if x != "banana"]
for x in sem_banana: print(x)

maçã
cereja
abacaxi
cereja

O bloco de repetição while é utilizado para executar um conjunto de instruções enquanto a condição do cabeçalho for verdadeira.

i = 1
while i < 6: # cabeçalho do bloco while
    print(i) # primeira instrução do corpo
    i += 1   # segunda instrução do corpo

1
2
3
4
5

No exemplo o laço é executado enquanto o valor de i for menor que 6, como definido no cabeçalho "while i < 6:" do bloco, na linha 2.

As linhas 3 e 4 estão recuadas e portanto pertencem ao corpo do bloco. Na linha 3 a variável i é impressa e na linha 4 é incrementada em 1.

O laço while requer que as variáveis ​​relevantes estejam prontas, no exemplo definimos a variável de indexação i igual a 1 logo antes do bloco.

Se a variável i não fosse incrementada dentro do corpo, o laço se tornaria infinito e a repetição jamais pararia. Portanto, este é um cuidado sempre necessário, o de se atender à condição de saida em algum momento do laço.

A declaração de quebra com break

Com a instrução break podemos parar o laço mesmo se a condição na instrução while for verdadeira.

No exemplo a seguir o laço é encerrado com i igual a 3.

i = 1
while i < 6:
    print(i)
    if i == 3:
        print(f"Encerrado com i = {i}")
        break
    i += 1

1
2
3
Encerrado com i = 3

A declaração de continuação com continue

Com a instrução continue podemos saltar para a próxima instrução do corpo do laço.

i = 0
while i < 6:
    i += 1
    if i == 3:
        print(f"Ignoradodo i = {i}")
        continue
    print(i)

1
2
Ignoradodo i = 3
4
5
6

O bloco de função é o conjunto do cabeçalho, contendo um nome e argumentos, e o corpo, contendo as instruções da função.

Chamamos simplesmente função um bloco de função, e uma vez declarada, pode ser chamada pelo nome, junto com os argumentos necessários.

Uma função pode retornar um resultado com diferentes tipos de dados.

Declaração de uma função

Uma função é declarada com a palavra-chave def seguida pelo nome da função e os argumentos dentro de parenteses.

def minha_funcao():
    print("Olá de uma função")

Chamada da função

A chamada de uma função é feita com a declaração do nome da função seguido dos argumentos entre parenteses e separados por vírgula.

def minha_funcao():
  print("Olá de uma função")
#
minha_funcao()

Olá de uma função

Argumentos

Os argumentos são valores de diferentes tipos especificados após o nome da função, dentro dos parênteses, sepados por vírgula, para serem utilizados dentro das funções.

def minha_funcao(nome, idade):
  print("meu nome é {} e minha idade é {}".format(nome,idade))
#
minha_funcao("Roberto",58)
minha_funcao("Pedro",27)
minha_funcao("Rosana",59)

meu nome é Roberto e minha idade é 58
meu nome é Pedro e minha idade é 27
meu nome é Rosana e minha idade é 59

Os argumentos geralmente são abreviados como "args" nas documentações do Python.

Lambda

Uma função lambda é uma pequena função anônima, que pode receber qualquer número de argumentos, mas pode ter apenas uma expressão.

A expressão é executada e o resultado é retornado.

Exemplo: adicionar 10 ao argumento e retornar o resultado.

x = lambda a : a + 10
print(x(5))

15

As funções lambda podem receber qualquer número de argumentos.

Exemplo: multiplicar os argumentos a e b e retornar o resultado.

x = lambda a, b : a * b
print(x(5, 6))

30

Exemplo: somar os argumentos a, b e c e retornar o resultado.

x = lambda a, b, c : a + b + c
print(x(5, 6, 2))

13

O bloco de classe é um conjunto de instruções, com cabeçalho sendo iniciado com a palavra-reservada class, seguida pelo nome da classe e a classe ancestral entre parênteses, se houver.

Não havendo será a classe object e os parenteses poderão ser omitidos.

O método __init__() é o construtor da classe.

Classes em Python são estruturas fundamentais que permitem a criação de objetos organizados e reutilizáveis.

Elas agrupam atributos (dados) e métodos (funções) em um único bloco de código, promovendo a modularidade e a clareza.

O método especial __init__ desempenha um papel crucial na inicialização de novos objetos, garantindo que cada instância comece com um estado bem definido.

A definição de uma classe em si não ocupa memória para os dados dos atributos, mas a criação de instâncias aloca memória para cada instância individual, permitindo-lhes ter seus próprios dados enquanto compartilham os métodos da classe.

A herança, o encapsulamento e a capacidade de definir métodos de classe e estáticos tornam as classes em Python uma ferramenta poderosa para o desenvolvimento de software.

class MinhaClasse:

    def __init__(self, atributo_inteiro, atributo_float, atributo_texto, atributo_booleano):
        self.atributo_inteiro  = atributo_inteiro
        self.atributo_float    = atributo_float
        self.atributo_texto    = atributo_texto
        self.atributo_booleano = atributo_booleano

    def metodo_classe(self):
        print(f"Atributo inteiro: {self.atributo_inteiro}")
        print(f"Atributo float: {self.atributo_float}")
        print(f"Atributo texto: {self.atributo_texto}")
        print(f"Atributo booleano: {self.atributo_booleano}")

Python é uma linguagem de programação orientada a objetos, e nela todos dados são instâncias de objetos das classes, com seus atributos e métodos.

minha_classe_1 = MinhaClasse(5, 5.5, "Roberto", True)
minha_classe_2 = MinhaClasse(7, 7.5, "Lúcia", False)

Nas classes, os atributos são os correspondentes das variáveis e os métodos os correspondentes das funções.

Uma classe é um construtor de objetos, e cada objeto tem uma instância de uma classe, com atributos com valores próprios, mas compartilhando os mesmos métodos, usando o endereço do objeto na memória com os métodos da classe.

Criação da classe

Para declarar uma classe use a palavra-chave class seguida do nome da classe e dos parênteses com os nomes das classes ancestrais.

class ClasseAncestral:
    
    def __init__(self,argumento_1,argumento_2):
        self.argumento_1 = argumento_1
        self.argumento_2 = argumento_2

Criação do objeto de uma classe

Agora podemos usar a classe MinhaClasse para instanciar um objeto do tipo da classe.

objeto = ClasseAncestral(1,"Roberto")
print(objeto.argumento_1)

1

Herança de classes

A herança nos permite definir uma classe que herda todos os métodos e propriedades de outra classe.

A classe pai é a classe que está sendo herdada, também chamada de classe-base.

A classe filha é a classe que herda de outra classe, também chamada de classe-derivada.

Criar uma classe pai

Qualquer classe pode ser uma classe pai, então a sintaxe é a mesma da criação de qualquer outra classe

No exemplo a seguir é criada a classe Pessoa, com as propriedades primeiroNome e ultimoNome e o método imprimirNome,. Depois é criado um objeto da classe e depois executado o método printname.

class Pessoa:
  def __init__(self, fname, lname):
    self.primeiroNome = fname
    self.ultimoNome = lname

  def imprimirNome(self):
    print(self.primeiroNome, self.ultimoNome)

x = Pessoa("Roberto", "Teixeira")
x.printname()

Classe descendente

Para criar uma classe que herde a funcionalidade de outra classe colocamos a classe ancestral como parâmetro após o nome da classes descendente.

No exemplo a seguir é criada uma classe chamada Estudante, descendente da classe Pessoal e que herdará suas propriedades e métodos.

class Estudante(Pessoa):
    pass

Observação: use a palavra-chave pass quando não desejar adicionar outras propriedades ou métodos à classe.

Agora a classe Estudante tem as mesmas propriedades e métodos da classe Pessoa.

Exemplo: use a classe Estudante para criar um objeto e execute o método imprimirNome():

x = Estudante("Rosana", "Cecília")
x.imprimirNome()

Um iterador é um objeto que contém um número contável de valores e que pode ser iterado, significando que a sequência de valores pode ser percorrida.

Iteradores são objetos que implementam o protocolo do iterador, que consiste nos métodos __iter__() e __next__().

6.7.1 - Iterador vs Iterável

mytuple = ("maçã", "banana", "cereja")
myit = iter(mytuple)
#
print(next(myit))
print(next(myit))
print(next(myit))

maçã
banana
cereja

fruta = "maçã"
iterador = iter(fruta)
#
print(next(iterador))
print(next(iterador))
print(next(iterador))
print(next(iterador))

m
a
ç
ã

6.7.2 - Laço do iterador

tupla = ("maçã", "banana", "cereja")
#
for x in tupla:
  print(x)

maçã
banana
cereja

texto = "banana"

for x in texto:
  print(x)

b
a
n
a
n
a

6.7.3 - Criação do iterador

class MeusNumeros:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    x = self.a
    self.a += 1
    return x

myclass = MeusNumeros()
myiter = iter(myclass)

print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))
print(next(myiter))

1
2
3
4
5

6.7.4 - Finalização da iteração

class MeusNumeros:
  def __iter__(self):
    self.a = 1
    return self

  def __next__(self):
    if self.a <= 20:
      x = self.a
      self.a += 1
      return x
    else:
      raise StopIteration

numeros = MeusNumeros()
iterador = iter(numeros)

for x in iterador:
    print(x)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

Os blocos de excessões com as instruções de cabeçalho try... except... else... finally controlam o fluxo das instruções no bloco quanto a ocorrência de erros na execução.

• Bloco try: inicia a definição dos blocos de exceção.
• Bloco except: permite que você lide com o erro.
• Bloco else: permite executar código quando não há erro.
• Bloco finally: permite que você execute código, independentemente do resultado de erros dos blocos try... except... else.

Manipulação de exceção

Quando ocorre um erro, ou exceção, como chamamos, o Python normalmente para e gera uma mensagem de erro.

Essas exceções podem ser tratadas usando a instrução try.

Exemplo: o bloco try irá gerar uma exceção, pois xyz não está definido.

try:
  print(xyz)
except:
  print("Ocorreu uma excessão")

Ocorreu uma excessão

Como o bloco try gera um erro, o bloco except será executado.

Sem o bloco try, o programa irá travar e gerar um erro.

Exemplo: esta declaração irá gerar um erro, porque x não está definido:

print(xyz)

NameError: name 'xyz' is not defined <traceback object at 0x0000018D4356CF80>

Diferentes excessões

Você pode definir quantos blocos de exceção desejar, por exemplo, se você deseja executar um bloco de código especial para um tipo especial de erro:

Exemplo: imprima uma mensagem se o bloco try gerar a NameErrore outra para outros erros.

try:
  print(xyz)
except NameError:
  print("A variável 'xyz' não está definida")
except:
  print("Algo mais deu errado")

A variável 'xyz' não está definida

Instrução else

Você pode usar a palavra-reservada else para definir um bloco de código a ser executado se nenhum erro for gerado:

Exemplo: neste exemplo, o trybloco não gera nenhum erro

try:
    print("Alô")
except:
    print("Algo deu errado")
else:
    print("Nada deu errado")
Finally:
    print("O bloco finally, se especificado, será executado independentemente de o bloco try gerar um erro ou não.")

SyntaxError: invalid syntax (<string>, line 7) <traceback object at 0x0000018D43557B80>

Exemplo:

try:
  print(z)
except:
  print("Algo deu errado")
finally:
  print("O 'try except' terminou")

3
O 'try except' terminou

Isso pode ser útil para fechar objetos e limpar recursos.

Exemplo: tente abrir e gravar em um arquivo que não seja gravável.

try:
  f = open("demofile.txt","rt") # readonly text
  try:
    f.write("Lorum Ipsum")
  except:
    print("Alguma coisa deu errado durante a escrita ao arquivo")
  finally:
    f.close()
except:
  print("Alguma coisa deu errado durante a abertura do arquivo")

Alguma coisa deu errado durante a abertura do arquivo

O programa pode continuar, sem deixar o objeto de arquivo aberto.

Forçar uma exceção

Como desenvolvedor Python, você pode optar por lançar uma exceção se ocorrer uma condição.

Para lançar (ou levantar) uma exceção, use a palavra-reservada raise.

Exemplo: gere um erro e pare o programa se x for menor que 0.

x = -1

if x < 0:
    Exception("Desculpe, nenhum número abaixo de zero")

A palavra-reservada raise é usada para gerar uma exceção.

Você pode definir que tipo de erro gerar e o texto a ser impresso para o usuário.

Exemplo: gere um TypeError se x não for um inteiro.

x = "hello"

if not type(x) is int:
    raise TypeError("Somente números inteiros são permitidos")