No artigo de hoje, o dataholic Rodrigo Santana abordará temas e conceitos fundamentais para um programador, além de várias dicas para lhe auxiliar e ajudar a desenvolver os seus programas sempre com as melhores práticas da linguagem Python. Bom aprendizado!
Introdução
Nesta terceira parte sobre Python Fundamentos, vamos trazer os seguintes temas:
· Tuplas;
· Listas;
· Dicionários;
· Funções;
· Módulos e Pacotes;
· Tratamento de Erros e Exceções.
Espero que tenha uma leitura agradável, e que esse conteúdo possa lhe auxiliar de alguma forma.
Tuplas
No Python existem 03 tipos de variáveis compostas, sendo elas: Tuplas, Listas e Dicionários. Vamos começar com as Tuplas e entender como funciona o conceito por traz dessa funcionalidade.
Tuplas é um conceito que vem para lhe auxiliar na criação de variáveis do tipo compostas. Diferente das variáveis simples que você armazena na memória apenas uma informação no espaço reservado, ao utilizar variáveis compostas, no caso das Tuplas, você consegue atribuir a uma única variável diversas informações.
Por exemplo:
Variável Simples:
bebida = ‘café’
Se nesta variável fosse preciso adicionar uma nova bebida, um suco por exemplo, quando tentar atribuir no decorrer do seu código uma nova variável também de nome bebida, e na memória salvar o ‘suco’, ficando da seguinte forma:
Variável Simples:
bebida = ‘suco’
A informação do ‘café’ será eliminada e você não conseguirá mais atribuir essa informação ao seu código, já que foi substituída por ‘suco’.
Desta forma temos a possibilidade de usar as variáveis do tipo compostas, sendo elas:
· Tuplas();
· Listas[];
· Dicionários{}.
Logo, atribuindo diversas informações na mesma variável, ficando da seguinte forma:
Variável Composta:
bebida = (‘café’, ‘suco’, ‘refrigerante’, ‘água’)
E para acessar cada informação dentro da variável composta do tipo Tupla, basta referenciar através de índices, começando sempre do 0 até o último valor armazenado.
Para nosso exemplo, ficando índices: 0, 1, 2, 3.
Vamos reproduzir alguns exemplos:
print(bebida) - O retorno desse print seria de todos os itens atribuídos a variável: ‘café’, ‘suco’, ‘refrigerante’, ‘água’
print(bebida[2]) - Já nesta opção, aplicando a técnica de fatiamento, estaríamos referenciando o índice número 2 e teríamos como print o ‘refrigerante’.
print(bebida[0:2]) - Se aplicarmos referência de fatiamento com início e fim, devemos nos atentar que a referência inicial é o start de onde será extraída a informação, e o índice final é o delimitador, porém não será retornado, recebemos então como retorno as seguintes informações: ‘café’, ‘suco’.
print(bebida[1:]) - Aplicando o fatiamento valor do índice seguido de dois pontos “:”, o retorno para variável será do índice apontado como início, e indo até o fim da Tupla: ‘suco’, ‘refrigerante’, ‘água’.
print(bebida[-1]) - Agora se nosso índice for apontado com um valor negativo, basta considerar a contagem dos índices de traz para frente, neste caso o retorno seria: ‘água’.
Também podemos utilizar dentro de coleções e Tuplas o uso de funções e estruturas de repetição, como for e while, vejamos algumas opções abaixo:
len(bebida) - Ao retornar o print da variável, teremos o retorno: 4.
for c in bebida:
print(c)
O retorno para este loop do for será o seguinte print: ‘café’, ‘suco’, ‘refrigerante’, ‘água’. E ao fim do retorno de todos os itens armazenados na variável ele encerra o for e finaliza o programa.
OBSERVAÇÃO: AS TUPLAS SÃO IMUTÁVEIS.
É importante que você não esqueça esse detalhe.
O que eu quis dizer com essa frase? Isso significa que uma variável após recebimento e atribuição de valores, não poderá sofrer qualquer tipo de alteração durante sua execução, logo são imutáveis.
Diferente de muitas linguagens de programação, o Python permite adicionar dentro de uma Tupla vários tipos de dados, ou seja: int, str, float.
Variável Composta:
pessoa = (‘Rodrigo’, 32, ‘M’, 95.50)
print(pessoa)
O retorno do print será: (‘Rodrigo’, 32, ‘M’, 95.50)
Existe apenas uma única ação que pode mudar toda Tupla, que é apagá-la.
Variável Composta:
pessoa = (‘Rodrigo’, 32, ‘M’, 95.50)
del(pessoa)
print(pessoa)
Dentro do Python, ao usar a palavra ‘del’ ele apaga a respectiva referência e isso faz com que suma qualquer tipo de correspondência atribuída ao item.
Listas
As Listas possuem estruturas similares às Tuplas, porém com algumas características que as tornam únicas.
Tuplas como vimos anteriormente são imutáveis.
Já as Listas são mutáveis.
Em outras palavras, é possível realizar alterações após sua primeira definição/construção.
Tuplas são representadas por parênteses ()
As Listas usamos colchetes []
Veja alguns exemplos abaixo:
Variável Composta Tipo Lista:
bebida = [‘café’, ‘suco’, ‘refrigerante’, ‘água’]
Essa Lista criada ficaria com índice de 0 a 3. Se fosse uma Tupla, essa sequência como já mencionamos, seria imutável.
Na lista podemos realizar as seguintes alterações:
bebida[3] = ‘vinho’
Isso representaria a seguinte informação: Onde está água, altere para vinho.
E a Variável bebida ficaria da seguinte forma:
bebida = [‘café’, ‘suco’, ‘refrigerante’, ‘vinho’]
Caso você queira realizar a inclusão de um novo item a sua lista, basta usar o seguinte método: append()
Exemplo:
bebida.append(‘cerveja’)
Desta forma será adicionado ao final da lista o novo item apontado junto ao método append(), assim reformulando sua variável para:
bebida = [‘café’, ‘suco’, ‘refrigerante’, ‘vinho’, ‘cerveja’]
E podemos ver que o índice agora passou de: 0 a 3 para 0 a 4.
A flexibilização que temos para trabalhar, também nos permite incluir itens em outras posições, ou seja, não é necessário sempre usar o método append() para incluir o item ao final da lista. Basta realizar uma referência da posição que desejar inserir o item, porém fazendo uso do método: insert().
Exemplo:
bebida.insert(0, ‘tequila’)
Assim a variável que antes estava representada da seguinte forma:
bebida = [‘café’, ‘suco’, ‘refrigerante’, ‘vinho’, ‘cerveja’]
Com índice: 0 a 4.
Será alterado e ficará da seguinte forma:
bebida = [‘tequila’, ‘café’, ‘suco’, ‘refrigerante’, ‘vinho’, ‘cerveja’]
E o índice passa a ser: 0 a 5.
Veja que toda estrutura foi deslocada para direita, e o item ‘tequila’ foi inserido no início da lista.
Assim como podemos acrescentar itens a nossa lista, é possível eliminá-los. Vejamos abaixo algumas possibilidades de como realizar esse procedimento:
Exemplo:
del bebida[3]
Após execução desta linha de código a variável:
bebida = [‘tequila’, ‘café’, ‘suco’, ‘refrigerante’, ‘vinho’, ‘cerveja’]
O item referente ao índice 3 que é a refrigerante será eliminado, e teremos o seguinte retorno:
bebida = [‘tequila’, ‘café’, ‘suco’, ‘vinho’, ‘cerveja’]
Outra possibilidade seria utilizar o método: pop().
Vejamos abaixo sua aplicabilidade.
bebida.pop()
Geralmente o método pop() é utilizado para eliminar o último elemento/índice, mas você pode referenciar o item que desejar excluir, apontando o índice da lista.
Exemplo:
bebida.pop(3)
bebida = [‘tequila’, ‘café’, ‘suco’, ‘refrigerante’, ‘vinho’, ‘cerveja’]
Assim teremos o item refrigerante removido da lista.
E por fim, temos o método: remove().
No método em questão, diferente do pop() que aponta o índice do elemento, é necessário apontar o ‘valor’ do que você deseja eliminar.
Exemplo:
bebida.remove(‘refrigerante’)
Retornando assim a variável tipo Lista sem o item que foi excluído anteriormente:
bebida = [‘tequila’, ‘café’, ‘suco’, ‘vinho’, ‘cerveja’]
Independente do caso utilizado: del, pop ou remove.
A lista será refeita e o item apontado será eliminado, e posteriormente a ordenação dos índices será refeita com base na quantidade de elementos restantes na variável.
E se eu porventura tentar excluir um item que não tem mais na lista?
Uma forma que o Python possibilita contornar sem apresentar uma mensagem de erro, é fazer uso do operador ‘in’ dentro da condicional ‘if’.
Exemplo:
if ‘Pizza’ in bebida:
bebida.remove(‘refrigerante’)
Também podemos realizar criação de listas através de ranges.
Exemplo:
Obs: Abaixo o uso da função list, para realização da declaração de uma lista.
valores = list(range(4, 11))
Logo será criada uma: Lista;
Atrelada a variável: Valores;
Com um range iniciado em 4 terminando em 10, já o último número apontado não é incluído na relação.
valores = [4, 5, 6, 7, 8, 9, 10]
E os índices desses elementos ficariam de 0 até 6.
Se for necessário também é possível incluir dentro desse range, a interpolação de valores, por exemplo:
valores = list(range(4, 11, 2))
Resultado:
valores = [4, 6, 8, 10]
E os índices: 0 até 3
Realizando a criação de listas com range, é criada a lista de forma ordenada.
Agora se a opção for ter essa relação fora de ordem, será preciso apontar item a item dentro da lista.
valores = [8, 2, 5, 4, 9, 3, 0]
O Python também oferece o método sort(), ele lhe possibilita a ordenação da sua lista.
Exemplo:
valores = [8, 2, 5, 4, 9, 3, 0]
valores.sort()
print(valores)
Dessa forma o valor obtido da lista será:
valores = [0, 2, 3, 4, 5, 8, 9]
Seguindo a mesma premissa mas para ordem inversa, ou seja, apresentar valores de forma decrescente usamos o método sort() com o parâmetro reverse = True.
Exemplo:
valores = [8, 2, 5, 4, 9, 3, 0]
valores.sort(reverse = True)
Desta forma obtemos os valores ordenados de forma decrescente.
valores = [9, 8, 5, 4, 3, 2, 0]
E para contagem de elementos dentro da lista, podemos utilizar o comando: len.
valores = [8, 2, 5, 4, 9, 3, 0]
len(valores)
E o retorno obtido nessa contagem é de: 7 elementos (0 ao 6).
A praticidade de manipular listas também nos oferece a chance de inserir listas dentro de listas.
Exemplo:
Lista Simples (Única)
dados = list()
dados.append(‘Pedro’)
dados.append(25)
print(dados[0])
print(dados[1])
resultado do print: Pedro
resultado do print: 25
Nesta lista os índices dos elementos da lista são: 0 e 1 respectivamente.
Para gerar uma lista dentro de uma lista, ao invés de realizarmos um append() em um valor, realizamos append() em uma estrutura completa.
Exemplo:
Lista Composta (Lista dentro de Lista)
pessoas = list()
pessoas.append(dados[:])
Dessa forma tudo que estava em dados será abraçado pela lista/variável pessoas, já que foi utilizada a técnica de fatiamento e copiando todas as informações de dados.
E nossa estrutura final ficará:
pessoas = [[‘Pedro’, 25]]
Ao realizar a junção da lista dentro da lista pessoas, o índice de pessoas é igual a 0, já para acessar as informações contidas no índice 0, precisamos referenciar 0 e 1 para retornar informação: Pedro ou 25.
Também é possível acrescentar outras listas dentro da lista pessoas:
Exemplo:
pessoas = [[‘Pedro’, 25], [‘Maria’, 19], [‘João’, 32]]
E aqui a leitura dos índices é feita da seguinte maneira:
Lista = Pessoas;
Índices = 0, 1, 2;
Dentro de cada Índice = índices 0 e 1 que é equivalente a: Nome e Idade.
Podemos acessar as informações da seguinte maneira:
print(pessoas[0][0]) - Pedro
print(pessoas[1][1]) - 19
print(pessoas[2][0]) - João
print(pessoas[1]) - retorna toda informação, no caso = [‘Maria’, 19]
Dicionários
Chegamos a terceira estrutura de variáveis compostas do Python, passamos por Tuplas, Listas e agora iniciaremos com Dicionários.
Durante o manuseio das Listas, a referência dos índices era feita através de valores numéricos, e este tipo de ação poderia nos gerar certa dificuldade ou dúvidas de acordo com o que fosse necessário apontar.
Para facilitar e agilizar essas indicações, podemos realizar através de índices literais, ou seja, chaves literais fazendo uso de letras ou palavras (mas também é possível utilizar números). Essa estrutura composta é chamada de: Dicionário.
Vamos revisar a representação simbólica das Tuplas, Listas e agora Dicionários:
· Tuplas: Representada por parênteses - ()
· Listas: Representada por colchetes - []
· Dicionários: Representado por chaves - {}
Para declarar um dicionário podemos utilizar duas opções:
Exemplos:
dados = dict() (Variável recebe dicionário vazio () )
Ou então criar a variável e já inserir os dados dentro
dados = {‘nome’:’José’, ‘idade’:50}
Dessa forma, os valores/índices não são mais representados por 0 e 1 (através de números), e sim pelo nome declarado antecedendo a informação, no caso: ‘nome’, ‘idade’. Esses serão os índices das informações contidas na variável dados.
E seguindo essa mesma premissa, para realizar a impressão/print da informação, não faremos uso de números para referenciar o índice e sim os nomes:
Exemplo:
dados = {‘nome’:’José’, ‘idade’:50}
print(dados[‘nome'])
print(dados[‘idade’])
E os respectivos prints serão:
José
50
Uma curiosidade, é que para realizar adição de informação no Dicionário, não fazemos uso do método append como foi feito em Listas. Assim, precisaremos criar um elemento referenciando os dados a serem inseridos:
Exemplo:
dados[‘sexo’] = ‘M’
E a estrutura ficara da seguinte forma:
dados = {‘nome’:’José’, ‘idade’:50, ‘sexo’:’M’}
Se for preciso remover um elemento, podemos fazer uso do comando del.
Exemplo:
del dados[‘idade’]
E o retorno seria:
dados = {‘nome’:’José’, ‘sexo’:’M’}
Ao iniciar um dicionário, não existe uma regra que aponte a obrigação de inserir ambas as chaves {} na mesma linha, o importante é abrir e fechar as chaves respectivamente.
Dessa forma podemos também representar a escrita da variável fazendo uso do dicionário da seguinte forma:
pessoa = {‘nome’:’Carlos’,
‘idade’:25,
‘sexo’:’M'
}
Assim a estrutura de dados criada ficou:
variável - pessoa;
índices - nome, idade, sexo;
elementos - ‘Carlos’, 25, ‘M’.
Esses elementos também são chamados de Chaves(Keys).
No Python se utilizarmos o método interno: .values(), temos o seguinte retorno:
pessoa = {‘nome’:’Carlos’,
‘idade’:25,
‘sexo’:’M'
}
print(pessoa.values())
Todos os valores serão retornados - ‘Carlos’, 25, ‘M’
Agora se a intenção é retornar os índices, usamos o método: .keys(), considerando a mesma estrutura, teremos:
pessoa = {‘nome’:’Carlos’,
‘idade’:25,
‘sexo’:’M'
}
print(pessoa.keys())
O resultado será - nome, idade, sexo.
Se a opção de retorno for todos valores e todas as chaves, basta fazer uso do método: .items()
pessoa = {‘nome’:’Carlos’,
‘idade’:25,
‘sexo’:’M'
}
print(pessoa.items())
E o retorno será tanto dos elementos quanto dos índices: ‘Carlos’, 25, ‘M’, nome, idade, sexo.
Fazendo referência das chaves(Keys) e valor(Values) dentro do items(), podemos inseri-los em uma estrutura de repetição como o ‘for’ e retornar informações como:
Exemplo:
for k, v in pessoa.items():
print(f’(k) é (v)’)
Retorno do laço for:
Nome é Carlos
Idade é 25
Sexo é M
Funções
Funções, ou Rotinas como também são conhecidas, é a forma pela qual o Python proporciona ao usuário o poder de criar processos com menor número de repetições. O Python por padrão, já vem com diversas funcionalidades internas e que fazemos uso constantemente durante a programação, por exemplo, usar as seguintes funções:
· Print;
· Len;
· Int;
· Input;
· Float;
· E muitas outras.
Assim como um carro que sai de fábrica com funcionalidades já pré-definidas essas funções nativas do Python são de uso padrão dentro da linguagem. Mas, vamos pensar que em determinado momento eu precise realizar tal funcionalidade diversas vezes, e executar essa tarefa maçante, tornasse o meu código sujo e repetitivo, ou até mesmo alguma rotina que não tenha em suas funções de ‘fábrica’, como poderia suprir essa necessidade?
Para sanar essa questão, podemos fazer uso da palavra reservada ‘def’ (Definição de Função), que nada mais é do que a possibilidade de criar uma função para executar alguma tarefa que você escreva, vejamos abaixo alguns exemplos:
----------------------------------------
Sistema de Alunos
----------------------------------------
----------------------------------------
Cadastro de Funcionários
----------------------------------------
----------------------------------------
Erro do Sistema
----------------------------------------
Nos 3 exemplos acima, podemos entender as linhas como rotinas ou funções que precisaríamos aplicar diversas vezes sempre que fosse preciso representá-las no output. Para cada linha precisaríamos aplicar um print(), totalizando assim 6 aplicações.
Fazendo uso do def, otimizamos o processo da seguinte forma:
Exemplo:
print(‘----------------------------------------‘)
print(‘ Sistema de Alunos ‘)
print(‘----------------------------------------‘)
print(‘----------------------------------------‘)
print(‘ Cadastro de Funcionários ‘)
print(‘----------------------------------------‘)
print(‘----------------------------------------‘)
print(‘ Erro do Sistema ‘)
print(‘----------------------------------------‘)
O que antes era representado por inúmeros prints(), foi substituído pela criação da função: def aplicaLinha().
def aplicaLinha():
print(‘----------------------------------------‘)
aplicaLinha()
print(‘ Sistema de Alunos ‘)
aplicaLinha()
aplicaLinha()
print(‘ Cadastro de Funcionários ‘)
aplicaLinha()
aplicaLinha()
print(‘ Erro do Sistema ‘)
aplicaLinha()
Dessa forma, independente do momento que essa def for inserida, teremos a sua aplicação no código. Basta fazer a devida referência, criando a ‘def’ antes do código e aplicá-la quando necessário.
Também é possível trabalhar o ‘def’ com parâmetros, vamos ver alguns exemplos:
def mensagem(msg):
print(‘----------------------------------------‘)
print(msg)
print(‘----------------------------------------‘)
mensagem(‘Sistema de Alunos’)
No código acima, vimos que foi criado uma def, referenciando um código: mensagem, e dentro dos parênteses um parâmetro. Em resumo, a mensagem informada no fim do código, será enviada para o def na parte superior e posteriormente replicado no ponto onde o paramento (msg) está sendo apontado.
Recebendo assim o output:
----------------------------------------
Sistema de Alunos
----------------------------------------
Quando um parâmetro é declarado ele deve ser respeitado e na hora de repassar a informação no código, deverá seguir a mesma quantidade de informações declarada dentro do def.
Exemplo:
def soma(a, b):
s = a + b
print(s)
soma(4, 5)
soma(8, 9)
soma(2, 1)
Mas como citado acima, se repassar:
soma(4)
Será gerado erro ao rodar o código por falta de parâmetro declarado. Assim como a quantidade de parâmetros apontados for maior que a def (definição).
Outra possibilidade é explicitar a informação no repasse do parâmetro, exemplo:
soma(a=4, b=5)
Também podendo alterar a ordem: onde é ‘’a’’ ficar ‘’b’’ e vice-versa. Resumindo, explicitando é possível alocar o valor para o parâmetro desejado independentemente da ordem, caso contrário, ele é alocado na ordem.
Mas o Python oferece uma ótima funcionalidade para auxiliar quando precisamos repassar parâmetros a mais ou a menos na def, e o nome dado a este conceito é:
Empacotar Parâmetros.
Exemplo:
def contador(* núm):
print(núm)
contador(2, 1, 7)
contador(8, 0)
contador(4, 4, 7, 6, 2)
Ao executar esse código, o Python vai gerar 3 Tuplas como saída, pois todos os valores foram lançados para dentro do “núm”, e depois impressos no output. A partir da criação dessas Tuplas, é possível trabalhar com as possibilidades que este modelo de variável composta oferece.
Exemplo:
def contador(* núm):
for valor in núm:
print(f’{valor} ‘, end=’’)
print(‘FIM!’)
contador(2, 1, 7)
contador(8, 0)
contador(4, 4, 7, 6, 2)
Também é possível fazer a leitura do tamanho (len) do parâmetro (núm) de cada informação repassada.
Exemplo:
def contador(*núm):
tam = len(núm)
print(f'Recebi os valores {núm} e são ao todo {tam} números')
contador(2, 1, 7)
contador(8, 0)
contador(4, 4, 7, 6, 2)
Como vimos, existe a possibilidade de aplicar def para retornar Tuplas no retorno dos valores, mas também podemos utilizar este conceito com Listas, já que são multáveis, tornando-se mais maleável trabalhar com as informações.
Exemplo:
def dobra(lst):
pos = 0
while pos < len(lst):
lst[pos] *= 2
pos += 1
valores = [7, 2, 5, 0, 4]
dobra(valores)
print(valores)
O retorno desse código seria: [14, 4, 10, 0, 8]
Ainda em Funções, temos alguns conceitos que devemos abordar, sendo eles:
· Interactive Help;
· Docstrings;
· Argumentos opcionais;
· Escopo de variáveis;
· Retorno de Resultados.
· Interactive Help
Interactive Help ou Ajuda Interativa, é a forma do Python oferecer suporte para funções que são nativas em sua linguagem, por exemplo:
Usando o comando - help(print)
O retorno será uma tela com as funcionalidades que o print lhe proporciona ao ser utilizado. Esse mesmo método pode ser aplicado para todas as funções internas do Python, a fim de auxiliar e entender como utilizar seus comandos, serve exatamente como um guia da linguagem.
Uma outra maneira de buscar esta mesma informação, é fazendo uso da impressão do doc interno do comando.
Exemplo:
print(input.__doc__)
E teremos o mesmo retorno que foi aplicado durante o chamado do help(print).
· Docstring
Docstrings é aplicado exatamente após um comando def, onde realizamos a criação de funções. Por funções do tipo def não serem nativas da linguagem Python, não podemos realizar o chamado Interactive Help, para auxiliar e assim explicar o que determinada função está desempenhando. Por isso, fazemos uso da Docstrings, onde será criado um dicionário para auxiliar tanto o criador, quanto pessoas que forem consultar o código futuramente para entender do que se trata cada aplicação.
Para criar uma docstrings basta abrir aspas duplas (“) três vezes abaixo do comando def.
Exemplo:
def contador(i, f, p):
“””
Faz uma contagem e mostra na tela.
:param i: início da contagem
:param f: fim da contagem
:param p: passo da contagem
:return: sem retorno
“””
c = i
while c <= f:
print(f’{c}’, end=’’)
c += p
print(‘FIM!’)
help(contador)
O Python gera uma legenda e você tem autonomia de preenchê-la com informações que considere pertinente para entendimento futuro, seja seu ou de outros colaboradores do código. Desde que seja aplicada para busca, o help(<def_criada>).
· Argumentos Opcionais
Parâmetros Opcionais é a forma de declarar um parâmetro com um valor (zero), dentre os parâmetros. Podendo ser para um ou quantos achar necessário, desta forma o Python não precisaria aplicar técnica de empacotamento.
Exemplo:
def somar(a=0, b=0, c=0):
s = a + b + c
print(f’A soma vale {s}’)
somar(3, 2, 5) - # a = 3, b = 2, c = 5
somar(8, 4) - # a = 8, b = 4, c = 0
somar() - # a = 0, b = 0, c = 0
Quando referenciados os 3 parâmetros definidos, o código não gera erro.
somar(3, 2, 5)
Caso o código seja aplicado com um número menor do que o definido, o erro persistirá. Mas se for feito apontamento de Parâmetros Opcionais, não teremos problemas.
somar(3, 2)
somar()
Se for informado mais parâmetros do que o definido, deve ser utilizada a técnica de múltiplos parâmetros. Também é possível aplicar lançamento de parâmetros fora de ordem, desde que seja respeitada a quantidade de valores apontados.
somar(c=3, a=2)
· Escopo de Variáveis
Escopo de Variáveis ou Escopo de Declarações pode ser entendido como onde a variável vai existir e não vai mais existir.
Para exemplificar podemos entender da seguinte forma:
Tudo que estiver sendo declarado abaixo do def, mas antes do programa principal é reconhecido como Escopo Local.
Agora as declarações feitas a partir do início do seu programa principal, é um Escopo Global.
Exemplo:
# Escopo Local
def funcao():
n1 = 4
print(f'N1 dentro vale {n1}')
# Programa Principal / Início Escopo Global
n1 = 2
funcao()
print(f'N2 fora vale {n1}')
Assim o resultado para código assim será:
N1 dentro vale 4
N2 fora vale 2
Mas existe a possibilidade de solicitar dentro do Escopo Local, que o valor informado não seja inserido localmente, enviando assim para o Escopo Global.
Basta iniciar a referência do Escopo Local com a palavra reservada ‘global’.
· Retorno de Resultados
O retorno de Valores, lhe auxiliara na personalização e retorno de valores que podem ser incorporados em variáveis e ao reproduzir o print dos valores, além de não lhe causar limitação e repetição do tipo da resposta. Podendo assim, formatar e apresentar de uma forma clara e elegante.
Exemplo:
def somar(a=0, b=0, c=0):
s = a + b + c
return s
r1 = somar(3, 2, 5)
r2 = somar(2, 2)
r3 = somar(6)
print(f’Os resultados foram {r1}, {r2} e {r3}’)
Assim, o print retornará todos os valores em uma única frase representados pelas variáveis que receberão os parâmetros. Outro diferencial do return, é que ele pode ser utilizado também em valores lógicos (verdadeiro ou falso), inteiros, literais, listas, tuplas e dicionários.
Módulos e Pacotes
O conceito de modularização surgiu no início da década de 60, como os sistemas estavam ficando cada vez mais robustos a ideia era criar uma forma de dividir um programa grande em pequenos pedaços para oferecer uma melhor performance e até mesmo manutenções futuras. Já que com essa premissa aplicada, a legibilidade do código ficava mais clara e limpa.
Desta forma, foi adotada a opção de separar por módulos as funções desenvolvidas dentro do programa.
Exemplo:
def fatorial(n):
f = 1
for c in range(1, n + 1):
f *= c
return f
def dobro(n):
return n * 2
def triplo(n):
return n * 3
num = int(input(‘Digite um número: ‘))
fat = fatorial(num)
print(f’O fatorial de {num} é {fat}’)
Percebemos que foram criadas funções para ter retorno referente ao fatorial, dobro e triplo do valor informado. Mas o programa que vai apresentar a resposta para essas funções é:
num = int(input(‘Digite um número: ‘))
fat = fatorial(num)
print(f’O fatorial de {num} é {fat}’)
print(f’O dobro de {num} é {dobro(num)}’)
print(f’O triplo de {num} é {triplo(num)}’)
Portanto, para separarmos as funções do programa principal, que apresentará todos nossos outputs, criamos um arquivo exclusivo para as funções. E levamos as funções para este novo arquivo criado, conforme apresentado abaixo:
def fatorial(n):
f = 1
for c in range(1, n + 1):
f *= c
return f
def dobro(n):
return n * 2
def triplo(n):
return n * 3
Como o código e funções foram separados em arquivos distintos, precisamos referenciá-los para que um reconheça o outro, e possa fazer uso de suas informações.
Desta forma, no arquivo onde está o código principal, realizamos a importação das funções e posteriormente referenciamos o módulo, veja o exemplo abaixo:
Obs: Uteis é o nome do arquivo criado para armazenar as funções do exemplo.
import uteis
num = int(input(‘Digite um número: ‘))
fat = uteis.fatorial(num)
print(f’O fatorial de {num} é {fat}’)
print(f’O dobro de {num} é {uteis.dobro(num)}’)
print(f’O triplo de {num} é {uteis.triplo(num)}’)
Importante:
É possível realizar a importação de forma simplificada, ou seja, fazendo referência apenas dos módulos que serão utilizados no código.
from uteis import fatorial, dobro, triplo
Mesmo assim, deve-se ter muito cuidado com essa prática, pois os módulos criados não são nativos do próprio Python. E se durante a criação dos módulos houver duplicidade de nome entre as funções, o Python irá entrar em conflito e consequentemente considerar apenas a última função lida. Então, para esses casos o mais recomendado é a importação completa do módulo.
Com isso podemos concluir que ao aplicar a criação de módulos, temos vantagens como a organização do código para melhor manipulação e desempenho do programa, beneficiando a manutenção e otimização quando necessário. Isso porque, ao aplicar melhorias dentro dos módulos todas as partes que são referenciadas com o módulo em questão, terão essas melhorias refletidas e também a possibilidade de reutilização do módulo em outros projetos. Já que, sendo copiados, basta serem mencionados dentro de seus respectivos projetos para receber as funcionalidades que eles possuem.
Mas o que vimos até aqui, resume o deslocamento de parte do código para os módulos e a possível criação de inúmeros módulos. Com isso, apenas desviamos o problema de um ponto para o outro, pois se criarmos modelos grandes, também será difícil de controlar e prestar manutenções quando necessárias.
Portanto, as linguagens de programação adotaram uma outra prática, a criação de bibliotecas. Entretanto, no Python, o nome para essa prática é Pacotes.
· Qual a finalidade de um pacote?
Os pacotes têm como objetivo organizar os módulos criados por categoria, ou seja criar grupos categóricos onde cada módulo criado executa determinados tipos de funções, como por exemplo:
· números;
· strings;
· datas;
· cores;
Se criássemos um pacote com nome: Pacote Uteis e dentro deste pacote tivesse os grupos/pastas citados acima, para obter acesso as categorias basta realizar a menção:
import uteis
Mas se for necessário apenas o uso de números ou strings dentre as categorias, usamos:
from uteis import números
from uteis import strings
Um outro ponto importante é que para cada pasta criada dentro do pacote, é necessária a criação de um arquivo com a seguinte sintaxe:
__init__.py
Após a criação do pacote, e separação por pasta, basta ir no código principal e realizar a importação para uso:
from uteis import numeros
num = int(input(‘Digite um número: ‘))
fat = numeros.fatorial(num)
print(f’O fatorial de {num} é {fat}’)
print(f’O dobro de {num} é {numeros.dobro(num)}’)
print(f’O triplo de {num} é {numeros.triplo(num)}’)
E para finalizarmos esse tópico sobre módulos e pacotes, uma última dica: Uma das boas práticas é usar pacotes somente quando seu projeto estiver realmente grande, caso contrário os módulos são mais do que suficientes para lhe atender adequadamente.
Tratamento de Erros e Exceções
Erros e Exceções são as duas formas das linguagens de programação mais modernas apresentarem que algo está errado com seu código.
Certo, mas você pode estar se perguntando:
O que são erros? E o que são Exceções?
Os erros ou também conhecidos como erros de sintaxe, são os que provavelmente usuários iniciantes se deparam quando estão codificando, já que eles refletem algum erro de escrita durante o código.
Retornando na tela da seguinte forma:
SyntaxError: Invalid Syntax
Junto a mensagem de erro, é apresentada a linha/posição onde o erro está sendo gerado, para auxiliar o usuário na identificação e posterior correção do código.
Já as exceções, temos que analisar de uma forma diferente. Pois, mesmo que seu código esteja com sintaxe correta e não retorne um erro durante a escrita do código, pode retornar um erro quando o código for executado, e existem vários tipos de erro de exceção.
Por Exemplo:
· ValueError;
· ZeroDivisionError;
· IndexError;
· NameError;
· TypeError.
Esses são apenas alguns exemplos, mas existem muitos outros. Mesmo assim, diferente de muitas outras linguagens de programação, o Python oferece a possibilidade de tratamento desses tipos de erro.
Podemos utilizar a instrução: try em conjunto com as cláusulas: except. Também é possível incluir as cláusulas: else e finally, mas essas em questão são opcionais, nem sempre haverá necessidade de inclui-las.
Exemplo:
try:
a = int(input(‘Numerador: ‘))
b = int(input(‘Denominador: ‘))
r = a / b
except:
print(‘Infelizmente tivemos um problema’))
else:
print(f’O resultado é {r:.1f}’)
finally:
print(‘Volte sempre! Muito obrigado!’)
Um ponto que vale destacar, é que uma instrução ‘try’ pode ter vários ‘except’ com diversos tipos de exceções, cada um ficará dentro de seu bloco, recebendo o seu tratamento.
Conclusão
Bem, com isso chegamos ao fim deste conteúdo, conseguimos exemplificar e passar por alguns pontos do conceito e fundamentos da linguagem Python.
· Vimos a importância das variáveis compostas e as diversas formas de se trabalhar com as: Tuplas, Listas e Dicionários;
· A variedade de opções que as Funções (def) nos proporcionam para extrair o melhor que a linguagem tem a nos oferecer;
· Também conferimos a importância da organização e cuidado em manter tudo organizado dentro de módulos e pacotes;
E claro, saber tratar e executar a melhor codificação do seu código até para evitar passar uma experiencia ruim para o seu usuário final, afinal ninguém gosta de usar um programa bugado, não é mesmo?
Por mais que possa parecer muita coisa o que vimos até aqui, eu vejo tudo isso apenas como o básico da linguagem em si, então vá atras de mais matérias, estude mais e não deixe de treinar. Pois, um bom programador só será bom mesmo quando colocar em prática todo conhecimento que adquiriu, caso contrário acabará esquecendo.
Espero que o conteúdo repassado até aqui tenha sido valido para você, e boa sorte nos estudos. Não esqueça de conferir os conteúdos anteriores introdutórios à programação, sobre como iniciar na programação e sobre os fundamentos do Python. (link para os dois últimos artigos)
Sabe o que também ajuda? Estudar com os amigos! Por isso, não deixe de compartilhar com seus amigos programadores este conteúdo.
Até a próxima! 🚀📖