Blocos são conjuntos contendo uma ou mais instruções.
Existem tipos de blocos principais:
Os blocos condicionais são executados atendendo a condições lógicas.
Os blocos de repetição são executados repetitivamente atendendo a condições lógicas.
Os blocos de função são executados com a chamada parametrizadas dos nomes das funções.
Os blocos de classe são contituidos pelos blocos de métodos da classe, que utilizam variáveis da classe.
Os blocos de iteradores são contituidos pelos blocos de métodos dos iteradores.
Os blocos de excessão são contituidos pelos blocos das cláusulas try, except, else e finally.
O Python suporta as comparações lógicas usuais da matemática.
Na tabela a seguir são realizadas comparações entre duas variáveis a e b.
== | Igual | a == b |
!= | Diferente | a != b |
< | Menor que | a < b |
<= | Menor ou igual que | a <= b |
> | Maior que | a > b |
>= | Maior ou igual que | a >= b |
Essas condições podem ser usadas de várias maneiras, mais comumente com os blocos em instruções if e de laços (loops).
Uma instrução if é escrita usando a palavra-chave if .
a = 33
b = 200
if b > a:
print("b é maior que a")
Neste exemplo, usamos duas variáveis, a e b , usadas como operadores condicionais da instrução if para testar se b é maior que a.
Como o valor da variável a é 33 e o da variável b é 200, temos na ondição do bloco if que 200 é maior que 33, e assim é executada a instrução única do bloco if imprimindo na tela que "b é maior que a".
Python conta com recuo (um espaço ou mais em branco no início das linhas do bloco) para definir o escopo das instruções do bloco no código.
Outras linguagens de programação costumam usar colchetes para essa finalidade.
Na declaração d um bloco if não for utilizado o recuo é gerado um erro.
a = 33
b = 200
if b > a:
print("b is greater than a") ## é gerado um erro
As instruções elif definem blocos executadas se as condições anteriores não forem verdadeiras, tente esta condição.
a = 33
b = 33
if b > a:
print("b é maior que a")
elif a == b:
print("a aeend 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 palavra-chave 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")
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:
a = 200
b = 33
if b > a:
print("b é maior que a")
else:
print("b é menor que a")
Se você tiver apenas uma instrução para executar, poderá colocá-la na mesma linha da instrução if.
if a > b: print("a is greater than b")
Se você tiver apenas uma instrução para executar, uma para if e outra para else, você pode colocar tudo na mesma linha.
a = 2
b = 330
print("A") if a > b else print("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") if a > b else print("=") if a == b else print("B")
A palavra-chave and é um operador lógico e é usada para combinar instruções condicionais.
a = 200
b = 33
c = 500
if a > b and c > a:
print("Ambas condições são verdadeiras")
A palavra-chave or é um operador lógico 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.")
Você pode ter instruções if dentro de um bloco if, isso é chamado de instruções aninhadas de instruções if.
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")
As declarações não podem ser vazias, mas se você por algum motivo tiver uma declaração if sem conteúdo, coloque a declaração pass para evitar a ococrrência de erro.
a = 33
b = 200
if b > a:
pass
Laços (ou loops) são blocos de repetição contendo uma ou mais instruções executadas enquanto forem atendidas as condições especificadas.
Um laço for é usado para iterar sobre uma sequência (que é uma lista, uma tupla, um dicionário, um conjunto ou uma string).
Isso é menos parecido com a palavra-chave 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.
Imprima cada fruta em uma lista de frutas:
frutas = ["maçã", "banana", "cereja"]
for x in frutas: print(x)
O laço for não requer que uma variável de indexação seja definida antecipadamente.
Fazendo um laço em uma string
Mesmo as strings são objetos iteráveis, elas contêm uma sequência de caracteres:
Exemplo: percorrer as letras da palavra "banana":
x = "banana"
for x in "banana": print(x)
Com a instrução break podemos parar o laço antes que ele tenha percorrido todos os itens.
No exemplo a seguir 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
No exemplo a seguir o laço é encerrado com a instrução break quando o valor de x for "banana", antes da execução da instrução
frutas = ["maçã", "banana", "cereja"]
for x in frutas:
if x == "banana": break
print(x)
Com o laço while podemos executar um conjunto de instruções desde que uma condição seja verdadeira.
No exemplo a seguir o laço é executado enquanto o valor de i for menor que 6.
i = 1
while i < 6:
print(i)
i += 1
Nota: lembre-se de incrementar i, senão o laço continuará para sempre.
O laço while requer que as variáveis relevantes estejam prontas, neste exemplo precisamos definir uma variável de indexação i com o valor 1.
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("Encerrado com i = {}".format(i))
break
i += 1
Uma função é um bloco de instruções identificado por um nome e executado quando é evocado (chamado).
Você pode passar dados, conhecidos como argumentos ou parâmetros, para uma função.
Uma função pode retornar dados com os resultado calculados na 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")
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()
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)
Os argumentos geralmente são abreviados como "args" nas documentações do Python.
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))
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))
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))
Python é uma linguagem de programação orientada a objetos.
Quase tudo em Python são objetos com propriedades e métodos.
Uma classe é como um construtor de objetos, ou um "projeto" para criar objetos.
Para criar uma classe use a palavra-chave class.
class MinhaClasse:
x = 5
Agora podemos usar a classe MinhaClasse para um objeto do tipo da classe.
objeto = MinhaClasse()
print(objeto.x)
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.
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()
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__().
Listas, tuplas, dicionários e conjuntos são todos objetos iteráveis. Eles são contêineres iteráveis dos quais você pode obter um iterador.
Todos esses objetos têm um método iter() que é usado para obter um iterador:
Exemplo: retornar um iterador de uma tupla e imprimir cada valor.
mytuple = ("maçã", "banana", "cereja")
myit = iter(mytuple)
#
print(next(myit))
print(next(myit))
print(next(myit))
Mesmo strings são objetos iteráveis e podem retornar um iterador:
fruta = "maçã"
iterador = iter(fruta)
#
print(next(iterador))
print(next(iterador))
print(next(iterador))
print(next(iterador))
Usamos o laço for para iterar um objeto iterável:
tupla = ("maçã", "banana", "cereja")
#
for x in tupla:
print(x)
Utlizamos o laço
texto = "banana"
for x in texto:
print(x)
O laço for na cria um objeto iterador e executa o método next() para iteração do laço.
Para criar uma classe para que seus objetos sejam iteradores são declarados métodos __iter__() e __next__() na classe.
No método __init__() são realizadas as inicializações necessárias na criação do objeto da classe.
O método __iter__() age de forma semelhante, você pode fazer operações (inicialização etc.), mas deve sempre retornar o próprio objeto iterador.
O método __next__() permite a execução de instruções retornando o item seguinte na sequência.
Exemplo: Criação de iterador retornando números, começando com 1, e cada sequência aumentará em um (retornando 1,2,3,4,5 etc.).
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))
O exemplo acima continuaria para sempre se você tivesse instruções next() suficientes ou se fosse usado em um forloop.
Para evitar que a iteração continue para sempre, podemos usar a StopIterationinstrução.
No __next__()método, podemos adicionar uma condição de término para gerar um erro se a iteração for feita um número especificado de vezes:
Exemplo:
Pare após 20 iterações:
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)
O bloco try-except permite testar um bloco de código quanto a erros.
O bloco except permite que você lide com o erro.
O bloco else permite executar código quando não há erro.
O bloco finally permite que você execute código, independentemente do resultado dos blocos try e except.
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 x não está definido.
try:
print(z)
except:
print("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(z)
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(z)
except NameError:
print("A variável 'z' não está definida")
except:
print("Algo mais deu errado")
Você pode usar a elsepalavra-chave 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:
O bloco finally, se especificado, será executado independentemente de o bloco try gerar um erro ou não.
Exemplo:
try:
print(z)
except:
print("Algo deu errado")
finally:
print("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")
O programa pode continuar, sem deixar o objeto de arquivo aberto.
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-chave 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-chave 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")