Estudando a Linguagem de Programação Python¶

Neste notebook, vamos analisar as estruturas básicas da linguagem de programação Python. É pertinente saber que tal linguagem possui bastante uso atualmente e ela é uma das mais simples de usar, mas graças a colaboratividade dos usuário, temos inúmeras bibliotecas prontas para uso que nos possibilitam executar tarefas complexas na programação.¶

Vamos começar o nosso estudo em Python por uma definição que resume os ideais dessa linguagem de programação:

"Python é uma linguagem de programação de alto nível, interpretada, de script, imperativa, orientada a objetos, funcional, de tipagem dinâmica e forte. Foi lançada por Guido van Rossum em 1991. Atualmente possui um modelo de desenvolvimento comunitário, aberto e gerenciado pela organização sem fins lucrativos Python Software Foundation." (Wikipédia)

Dissecando a Definição¶

Acima foi copiado um pequeno trecho da Wikipédia que fala sobre a linguagem de programação Python. Nele, podemos aprender diversas características da linguagem em sí, tais como:

Características da Linguagem de Programação Python
Linguagem de Progamação de Alto Nível: Python é uma linguagem que sua escrita é bem próxima da linguagem humana usando como idioma principal o inglês, dado que é a sua linguagem nativa. Dessa forma, podemos nos comunicar com a máquina através de um forte e intuitivo interpretador.
Linguagem Interpretada: o código fonte nessa linguagem é executado por um programa de computador chamado interpretador, que em seguida é executado pelo sistema operacional ou processador. Método esse que difere das linguagens que são compiladas para a linguagem de máquina, tais como a linguagem de progamação C e suas derivadas.
Linguagem de Script: é básicamente o ato de desenvolver um algoritmo para automatizar a execução de tarefas que poderiam alternativamente ser executadas uma por vez por um operador humano.
Linguagem Imperativa: Trata do ato de usar ações para dar ordens, ou seja, através de comandos podemos dar ordens para serem executadas determinadas ações pelo programa. Desse modo, surgem os laços de repetição, estruturas condicionais, atribuição de valor à variáveis e controle de estado para implementar melhor essa ideia de imperatividade.
Linguagem Orientada a Objetos: Trata da ideia de se ter uma linguagem de programação voltada ao conceito de "objetos", usando para isso atributos (dados na forma de campo) e métodos (procedimentos de execução).
Linguagem Funcional: Trata da ideia de possuir uma linguagem com avaliação de funções para executar determinadas ações. Especificamente o Python, possui inúmeras bibliotecas repletas de funções para serem importadas e usadas, dando ênfase a inúmeros campos de estudo na qual a programação se aplica.
Linguagem de Tipagem Dinâmica: sendo uma caracteristica positiva para o Python, esse tipo de tipagem permite o uso de variáveis que não exigem declarações de tipos de dados, pois são capazes de escolher que tipo utilizar dinamicamente para cada variável, podendo alterá-lo durante a compilação ou a execução do programa.
Linguagem forte: Python é uma linguagem de programação multiplataforma e atualmente está presente em diversos sistemas operacionais, seja eles embarcados ou não. Temos a Microsoft usando nos consoles Xbox, de mesmo modo a Sony nos consoles Playstation, a empresa Apple a utiliza nos seus sistema operacionais IOS ou macOS, está presente em inúmeras SmartTvs, presente em operações para realizar automações em residências, automação industrial e várias outras aplicações.
Além disso: o recurso de ponto e vírgula para paradas de comandos foi substituido pelo recuo utilizado na construção do código, juntamente com os dois pontos (:) usando para delimitar subcomandos de operações maiores.

Agora, vamos ver como funciona a linguagem de progamação Python. Vale a pena lembrar que esse progama está sendo escrito levando em consideração que o leitor já foi introduzido a programação e, dado a amplitude de recursos que o Python possui, vamos nos ater somente a comandos básicos que permitem um bom início com ela, visando trazer todo o conhecimento necessário para lidar com os outros programas utilizados nesse repositório.

Imprimindo Dados de Saída (Outputs)¶

Podemos utilizar diretamente o prompt de comando do Python para imprimir dados de saída simples como

In [1]:

# imprimindo dados diretamente no prompt de comando (soma númerica)
3 + 4

Out[1]:

ou até

In [2]:

# imprimindo dados diretamente no prompt de comando (concatenação de string)
"Álgebra" + " Linear"

Out[2]:

'Álgebra Linear'

Entretanto, esse tipo de impressão dos dados de saída na tela é demasiadamente utilizado em operações simples, sendo de maior uso para testar recursos triviais que podem ser implementados em funções maiores.

Quando lidamos com progamas mais bem estruturados, com scripts bem definidos, devemos utilizar o comando "print".

In [3]:

# imprimindo dados usando o comando print (soma numérica)
print(3 + 4)

In [4]:

# imprimindo dados usando o comando print (concatenação de strings)
print("Álgebra" + " Linear")

Álgebra Linear

Mais adiante vamos ver outras formar de imprimir os dados de saída na tela usando o comando "print".

Tipagem Dinâmica: Tipos de Dados em Variáveis¶

Como foi explanado anteriormente, na linguagem de programação Python, não há mais a necessidade de se inicializar variáveis, pois usamos um recurso chamado Tipagem Dinâmica, esse que permite o uso de variáveis que não exigem declarações de Tipos de Dados, pois a linguagem é capaz de escolher que tipo utilizar dinamicamente para cada variável, podendo ser alterado em qualquer momento do programa.

Vamos agora aprender a trabalhar com variáveis no Python.

Tipos de Dados Básicos	Comandos
Números	int, long, float e complex
Strings	str
Lista e Tuplas	list, tuple
Dicionários	dict
Arquívos	file
Booleanos	bool(True, False)
Conjuntos	set, frozenset

In [5]:

# definindo variáveis com diversos tipos de dados sem precisar inicializá-las

# variável com dados do tipo números inteiros (int) 
inteiro = 12
# variável com dados do tipo números flutuantes (float) 
flutuante = 3.1434489
# variável com dados do tipo string (str)
string = "Eu prefiro morrer do que perder a vida!"
# variável que armazena uma lista com diferentes tipos de dados
lista = [1, 2, 3, "cachorro", 3.14, "tchubirabirum", 5, 6]
# variável que armazena uma tupla com um único tipo de dado (int)
tupla1 = (1, 2, 3, 4, 5, 6)
# variável que armazena uma tupla com um único tipo de dado (str)
tupla2 = ("cachorro", "gato", "galinha", "estudante")
# variável que armazena uma tupla com um único tipo de dado (float)
tupla3 = (3.13, 3.14, 3.6756)

Veja acima os principais tipos de dado que podem ser utilizados em Python. Vamos verificar a forma como eles estão armazenados usando a função "type".

In [6]:

# usando a função type para identificar o tipo de dado armazenado em uma variável
type(inteiro)

Out[6]:

int

In [7]:

# usando a função type para identificar o tipo de dado armazenado em uma variável
type(flutuante)

Out[7]:

float

In [8]:

# usando a função type para identificar o tipo de dado armazenado em uma variável
type(string)

Out[8]:

str

In [9]:

# usando a função type para identificar o tipo de dado armazenado em uma variável
type(lista)

Out[9]:

list

In [10]:

# usando a função type para identificar o tipo de dado armazenado em uma variável
type(tupla1)

Out[10]:

tuple

Além disso, a definição de tipagem dinâmica garante que é possível alterar o tipo de dado de uma variável a qualquer momento do progama, então podemos ter o seguinte processo:

In [11]:

# imprimindo o dado armazenado na variável inteiro
print(inteiro)

In [12]:

# mundando o tipo de dado da variável inteiro
inteiro = "Álgebra Linear"

In [13]:

# imprimindo o dado armazenado na variável inteiro
print(inteiro)

Álgebra Linear

In [14]:

# usando a função type para identificar o tipo de dado armazenado em uma variável
type(inteiro)

Out[14]:

str

Logo, a tipagem dinâmica nos permite mais versatilidade na criação dos nossos progamas. De modo que não há necessida de se manter preso ao cuidado de não alterar o tipo de dado de uma variável. Todavia, o mesmo recurso que pode ser de grande ajuda também pode permitir erros lógicos, sendo necessário ter todo cuidado necessário para se evitar erros lógicos durante a execução do código.

Listas e Tuplas, qual a principal diferença entre elas?¶

Uma confusão muito comum quando se usa uma Lista ou uma Tupla em Python é saber diferenciar cada uma delas. Do ponto de vista conceitual devemos utilizar tuplas para montar estruturas de dados heterogêneos enquanto a lista deveria ser usada para dados homogêneos, ou seja, todos seus elementos deveriam ser do mesmo tipo. Veja que a lista contém diferentes tipos de dados armazenados em uma única variável.

In [15]:

# vendo os tipos de dados dos elementos usados na lista
print(type(lista[0]), type(lista[3]), type(lista[4]))

<class 'int'> <class 'str'> <class 'float'>

Veja acima que foi definido uma lista com diferentes tipos de dados. Além disso, podemos acessar cada elemento individual das listas, tuplas ou arrays sabendo que os elementos são númerados de 0 até (quantidade de elementos - 1), dado que o último elemento é o número de parada. A sintaxe é: lista[número do elemento], tupla[número do elemento] ou array[número da linha][número da coluna]. Sobre arrays vamos discutir mais detalhadamente em outro progama, dado que é o principal alvo do estudo no nosso repositório e na Álgebra Linear.

In [16]:

# vendo o tipo de dado dos elementos usados na lista
print(type(tupla1[0]), type(tupla2[0]), type(tupla3[0]))

<class 'int'> <class 'str'> <class 'float'>

Veja que nas tuplas, devemos iniciar uma variável diferente para cada tipo de dado, diferentemente das listas. Além disso, as tuplas não permitem adicionar ou remover elementos, fato esse que também pode ser feito em uma lista.

In [17]:

# adicionando elemetos a lista usando a função append
lista.append(7)

In [18]:

# imprimindo a variável lista
print(lista)

[1, 2, 3, 'cachorro', 3.14, 'tchubirabirum', 5, 6, 7]

Veja que o número 7 foi adicionado a lista.

In [19]:

# removendo um elemento da lista usando a função remove
lista.remove(lista[8])

In [20]:

# imprimindo a variável lista
print(lista)

[1, 2, 3, 'cachorro', 3.14, 'tchubirabirum', 5, 6]

Agora veja que o número 7 foi devidamente removido da lista, mostrando que ela é totalmente mutável.

In [21]:

# tentando adicionar um elemento a tupla de dados do tipo inteiro usando a função append
tupla1.append(6)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-21-610288ec2f10> in <module>
      1 # tentando adicionar um elemento a tupla de dados do tipo inteiro usando a função append
----> 2 tupla1.append(6)

AttributeError: 'tuple' object has no attribute 'append'

In [22]:

# tentando remover um elemento a tupla de dados do tipo inteiro usando a função remove
tupla1.remove(tupla1[0])

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-22-3676f7efa11c> in <module>
      1 # tentando remover um elemento a tupla de dados do tipo inteiro usando a função remove
----> 2 tupla1.remove(tupla1[0])

AttributeError: 'tuple' object has no attribute 'remove'

Veja que não é possível adicionar ou remover nenhum elemento da tupla. Portanto, essas são as principais diferenças entre listas e tuplas no Python. Ou seja, em relação a mutabilidade a lista é plástica e a tupla é rígida.

Operadores Aritméticos¶

Operadores Aritméticos	Comando
Soma	+
Subtração	-
Multiplicação	*
Divisão	/
Exponenciação	**

Como já dizia Bill Gates, progamar não é nada mais e nada menos do que somar, subtrair, multiplicar e dividir. De fato, a partir desses princípios matemáticos básicos podemos desenvolver qualquer operação complexa sob tutela da manipulações aritméticas. Então, vamos mostrar exemplos de uso para cada operador individualmente. Antes de fazermos isso, é importante saber a ordem pela qual as operações são realizadas, visando contornar erros lógicos em seus progamas.

Ordem de Precedência dos Operadores Aritméticos
1 - Parentêses
2 - Exponenciação
3 - Multiplicação e Divisão
4 - Soma e Subtração

Os operadores com a mesma precedência são avaliados da esquerda para a direita. Quando essa ordem não for tão clara assim, opte por usar parênteses para forçar as ordens das operações, seja por motivos de esquecimentos ou motivos propositais.

In [23]:

# usando operadores aritméticos: soma
print(7 + 3)

In [24]:

# usando operadores aritméticos: subtração
print(7 - 3)

In [25]:

# usando operadores aritméticos: multiplicação
print(7 * 3)

In [26]:

# usando operadores aritméticos: divisão
print(7 / 3)

2.3333333333333335

In [27]:

# usando operadores aritméticos: exponenciação
print(7 ** 3)

Funções da biblioteca Python¶

A própia linguagem de progamação Python oferece inúmeras funções para implentar em nossos progamas. Não nos cabe listar todas elas aqui, pois ao longo dos progamas desenvolvidos no nosso repositório elas vão sendo usados e bem comentadas, permitindo o seu aprendizado mais aprofundado nos recursos da linguagem. Vale salientar que podemos utilizar a função "dir" para saber quais funções estão disponíveis para um tipo de variável. Veja abaixo como utilizar esse recurso.

In [28]:

# vendo quais funções estão disponíveis para uma variável qualquer
# nesse exemplo, vamos ver as funções disponíveis para uma variável que armazena um número inteiro (int)
dir(inteiro)

Out[28]:

['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__getnewargs__',
 '__gt__',
 '__hash__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mod__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__rmod__',
 '__rmul__',
 '__setattr__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'capitalize',
 'casefold',
 'center',
 'count',
 'encode',
 'endswith',
 'expandtabs',
 'find',
 'format',
 'format_map',
 'index',
 'isalnum',
 'isalpha',
 'isascii',
 'isdecimal',
 'isdigit',
 'isidentifier',
 'islower',
 'isnumeric',
 'isprintable',
 'isspace',
 'istitle',
 'isupper',
 'join',
 'ljust',
 'lower',
 'lstrip',
 'maketrans',
 'partition',
 'replace',
 'rfind',
 'rindex',
 'rjust',
 'rpartition',
 'rsplit',
 'rstrip',
 'split',
 'splitlines',
 'startswith',
 'strip',
 'swapcase',
 'title',
 'translate',
 'upper',
 'zfill']

In [29]:

# vendo quais funções estão disponíveis para uma variável qualquer
# nesse exemplo, vamos ver as funções disponíveis para uma variável que armazena uma lista (list)
dir(lista)

Out[29]:

['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

Assim, de acordo com a necessidade de implementação de recursos em um progama, podemos usar a função "dir" para conseguir olhar todos os atributos/propiedades e funções/métodos disponíveis para uma determinada variável.

Imprimindo Usando o comando "print"¶

Agora que você já sabe sobre as variáveis e o método de tipagem dinâmica com Python, vamos apresentar outras melhores formas de se usar o comando "print".

In [30]:

# adicionando um número inteiro do tipo de dado (int) a variável inteiro
inteiro = 12

# imprimindo uma variável unicamente
print(inteiro)

In [31]:

# imprimindo uma variável com uma string explicando-a
print("6 + 6 = ", inteiro)

6 + 6 =  12

In [32]:

# imprimindo uma variável alocando-a adequadamente no local definido para saída de dados
print("6 + 6 = {}".format(inteiro))

6 + 6 = 12

In [33]:

# imprimindo um número flutuante
print("{}".format(flutuante))

3.1434489

In [34]:

# imprimindo um número flutuante com números de casas decimais bem definidas
# nesse exemplo, 3 casa decimais após a vírgula
print("{:.3f}".format(flutuante))

3.143

In [35]:

# imprimindo uma saída de dados com mais variáveis alocadas nos espaços desejados
print(" string: {}, número inteiro: {} e número real: {:.3f}".format(string, inteiro, flutuante))

 string: Eu prefiro morrer do que perder a vida!, número inteiro: 12 e número real: 3.143

Recebendo Dados de Entrada¶

Vamos usar a função "input" para receber um dado de entrada e adicinar esses dados em variáveis.

In [36]:

# recebendo um dado de entrada usando a função "input" e armazenando em uma variável
entrada = input("Insira Algo: ")

In [37]:

# imprimindo o conteúdo informado na variável usando a função "print"
print(entrada)

Álgebra Linear é uma disciplina importante

In [38]:

# verificando o tipo da variável usando a função "type"
type(entrada)

Out[38]:

str

Observe que foi digitado um número inteiro, mas foi armazenado como uma string. Isso ocorre pois a função "input" não funciona com tipagem dinâmica, diferentemente se a variável for inicializada diretamente no progama. Caso seja necessário receber algum tipo de dado do usuário, devemos ter em mente qual tipo de dado será solicitado e inicializá-lo. Veja um exemplo:

In [39]:

# recebendo um dado de entrada do tipo de dado float e atribuindo a uma variável
entrada = float(input("Insira um número real: "))

In [40]:

# imprimindo o dado usando na variável entrada usando a função "print"
print(entrada)

3.14159

In [41]:

# verificando o tipo de dado armazenado na variável entrada
type(entrada)

Out[41]:

float

Desse modo, caso não seja especificado o tipo de dado a ser inicializado na variável, automaticamente ele será armazenado como uma string. Por esse motivo, especificar o tipo de dado a ser requerido do usuário usando na função "input" é uma boa prática de programação.

Fatiamento¶

O fatiamento pode ser utilizado principalmente em strings (que são cadeias de caracteres), listas, tuplas e arrays (esse que será estudado com maior profundidade em outro progama). Basicamente, trata-se do ato de pegar uma parte do todo de qualquer um desses elementos citados acima. Para fazer isso, vamos utilizar os exemplos já criados.

In [42]:

# fatiando uma string
print(string[0:10])

Eu prefiro

Na cadeia de caracteres que a string continha, pegamos o primeiro elemento, começando a contagem em 0, até o elemento 9. Desse modo, a frase "Eu prefiro morrer do que perder a vida!" foi fragmentada. Vale a pena lembrar, que a estrutura "string[0:10]" não está indo até o 10º elemento quando se conta a partir do 0, mas sim até o 9º elemento. Isso ocorre porque nessa situação o último caractere assume o valor de caractere de parada.

In [43]:

# fatiando uma lista
# lembrando que começamos a contar a partir do 0 e vamos do 2º elemento até o 3º elemento, 
# nesse exemplo
lista[2:4]

Out[43]:

[3, 'cachorro']

In [44]:

# fatiando uma tupla
# lembrando que começamos a contar a partir do 0 e vamos do 1º elemento até o 2º elemento, 
# nesse exemplo
lista[1:3]

Out[44]:

[2, 3]

Operadores Lógicos¶

Operadores Lógicos	Comandos
Igual	==
Diferente	!=
Menor	<
Maior	>
Menor igual	<=
Maior Igual	>=
Booleanos	True, False
Conectivos	and, or

Os operadores lógicos são usados para representar situações lógicas responsáveis por ajudar na tomada de decisões pela máquina e escolhas de opções definidas. Também são chamados conectivos lógicos por unirem duas expressões simples numa composta. Dessa forma, podemos ter ótimas ferramentas computacionais para realizar os nossos algoritmos.

In [45]:

# analisando o operador lógico de igualdade
7 == 8

Out[45]:

False

In [46]:

# analisando o operador lógico de igualdade
7 == 7

Out[46]:

True

In [47]:

# analisando o operador lógico de diferença
7 != 8

Out[47]:

True

In [48]:

# analisando o operador lógico de diferença
7 != 7

Out[48]:

False

In [49]:

# analisando o operador lógico de menor
8 < 4

Out[49]:

False

In [50]:

# analisando o operador lógico de menor ou igual
5 <= 5

Out[50]:

True

In [51]:

# analisando o operador lógico de maior
8 > 4

Out[51]:

True

In [52]:

# analisando o operador lógico de maior ou igual
5 >= 5

Out[52]:

True

In [53]:

# analisando o concectivo and (e)
(7 == 8 and 5 != 7)

Out[53]:

False

In [54]:

# analisando o conectivo or (ou)
(7 == 8 or 5 != 7)

Out[54]:

True

Estrutura de Decisão¶

Vamos agora ver estruturas responsáveis por tomadas de decisões, como "if", "elif" e "else". Basicamente podemos entender esses comandos, respectivamente, da seguinte forma: se, se não se e caso contrário.

Veja isso em um exemplo abaixo:

In [55]:

# recebendo o valor do primeiro número inteiro (int)
numero1 = int(input("Insira um primeiro número inteiro: "))
# recebendo o valor do segundo número inteiro (int)
numero2 = int(input("Insira um segundo número inteiro: "))

# imprimindo os dois números informados pelo usuário
print("\nnúmero 01 = {} e número 02 = {}\n".format(numero1, numero2))

# se o primeiro número informado for maior que o primeiro...
if(numero1 > numero2):
    # imprime que o primeiro número é maior que o segundo número
    print("{} é maior a {}".format(numero1, numero2))
# se não for maior, testar se não é igual..
elif(numero1 == numero2):
    # imprime que o primeiro número é igual ao segundo número
    print("{} é igual a {}".format(numero1, numero2))
# caso nenhuma sentença acima seja verdadeira...
else:
    # imprime que o primeiro número é menor que o segundo número
    print("{} é menor a {}".format(numero1, numero2))

número 01 = 3 e número 02 = 4

3 é menor a 4

Nesse exemplo, observe que os comandos "if", "elif" e "else" devem estar acompanhados por dois pontos para indicar o momento pelo qual o conteúdo para cada decisão deve ser implementado. Além disso, observe o recuo entre as linhas de código, esse que muito além de estilístico, é usado para indicar subcomandos de comandos superiores, sendo obrigatório o seu uso. Além disso, o comando "\n" indica ao progama uma quebra de linha.

Estrutura de Repetição: for¶

A estrutura de repetição "for" é utilizada quando se deseja repetir determinados passos programados em um número determinando de vezes previamente conhecidos. E para esse fim, geralmente deve-se utilizar o comando auxiliar "range", esse que recebe dois comandos de entrada: o número inicial da contagem e o número pela qual deve-se parar. Veja abaixo um exemplo simples de como deve-se usar a estrutura de repetição "for".

In [56]:

# estrutura de repetição for que vai de 0 - 10
for indice in range(0,11):
    # imprime o número atual da repetição
    print(indice)

In [57]:

# definindo uma lista
frase = ["Você", "construiu", "uma", "máquina", "do", "tempo", "com", "um", "Delorean", "?"]
# estrutura de repetição for que vai de 0 - a quantidade de elementos da lista (função len)
for indice in range(0, len(frase)):
    # imprime cada elemento da lista no respectivo valor que estiver o indice
    # o  comando end = " " indica que o progama ao invés de ir para a próxima linha quando terminar o
    # subcomando no instante de uma das repetições, ele irá adicionar um caractere em branco
    print(frase[indice], end = " ")
    

Você construiu uma máquina do tempo com um Delorean ?

Estrutura de repetição: While¶

A estrutura de repetição "while" ela está nas mesmas condições que a estrutura de repetição "for". A diferença notável entre as duas é que a ordem de parada do "for" é previsível e a do "while" não. Por esse motivo, devemos criar uma estrutura de condição para a ordem de parada em uma estrutura de repetição "while". Veja um exemplo abaixo:

In [58]:

# inicializando as variáveis "a" e "b" com o número inteiro (int) 1
a, b = 1, 1
# enquanto a repetição for verdadeira...
while True:
    # imprime os valores armazenados nas variáveis "a" e "b"
    print("{}, {}".format(a, b))
    # "a" é incrementado com "a * 2" 
    a *= 2
    # "b" é incrementado com "b * 2" 
    b *= 3
    # se "a" ou "b" tiverem um valor armazenado em sua variável menor que 500...
    if(a >= 500 or b >= 500):
        # para a estrutura de repetição while
        break
    
    

Veja que foi definido a estrutura de repetição "while" como verdadeira a todo momento. Caso não fosse especificado uma ordem de parada, responsável por quebrar essa repetição, ela entraria em um laço loop, tendo como consequência a execução desenfreada dos subcomandos do "while". Para contornar esse problema, usamos o comando "break", que vamos falar mais um pouco sobre ele agora.

Comandos: break e continue¶

O uso de comandos "break" e "continue" são grandes aliados para se usar em estruturas de repetições. Com o "break" o comando irá parar de vez, vamos pensar nele como um freio de mão de um carro, que o faz parar e não é mais possível acelerá-lo. Já o comando "continue" ele permite dar uma pausa para depois continuar na execução do comando, vamos pensar nele como se fosse um freio de um carro, que o faz desacelerar, mas após isso podemos continuar o processo de aceleração do automóvel. Vamos usar a estrutura de repetição "for" para tornar essa ideia mais clara.

In [59]:

# estrutura de repetição que vai de 1 - 10
for indice in range(1, 11):
    # imprime o valor atribuido a variável indice em cada repetição
    print(indice)
    # se indice for igual a 5...
    if(indice == 5):
        # comando de parada
        break

In [60]:

# estrutura de repetição que vai de 1 - 10
for indice in range(1, 11):
    # imprime o valor atribuido a variável indice em cada repetição
    print(indice)
    # se indice for igual a 5...
    if(indice == 5):
        # comando de continuar 
        continue

Observe que para ambos os exemplos definimos uma estrutura de decisão quando a variável "indice" estivesse armazenando o número inteiro 5. No primeiro exemplo, usamos o subcomando "break" para a estrutura de decisão. Desse modo, a estrutura de repetição "for" parou de executar quando a variável indice armazenava o valor inteiro 5. No segundo exemplo, usamos o mesmo algoritmo, mas o invés de usar o comando de parada "break", foi usando o comando de prosseguir "continue". Assim, quando a variável indice tinha armazenada o inteiro 5, a estrutura de decisão executou o subcomando "continue", indicando que a estrutura de repetição "for" deveria continuar a executar suas repetições. Logo, os comandos "break" e "continue" são ferramentas eficazes em estruturas de repetição.

Criando Suas Própias Funções¶

Como já foi visto, a linguagem de progamação Python é muito rica por possuir inúmeras funções prontas para uso. Entretanto, sempre é necessário criar funções própias para finalidades específicas, possibilitando a criação de inúmeros progamas para diversos fins. Vamos analisar como se dá a estrutura de uma função. Para isso, vamos trabalhar com o algoritmo da sequência de fibonacci pelo método recursivo (função que chama ela mesma, com uma ordem específica de parada).

In [61]:

# definindo uma função de nome fibonacci, cujo parâmetro de entrada é o termo que se deseja obter da 
# sequência
def fibonacci (termo):
    # caso o termo seja o primeiro, a sequência de fibonacci para esse termo é 1
    if(termo == 1):
        # a função retorna o valor 1 quando é chamada e se a estrutura de decisão desse subcomando é 
        #verdadeira
        return 1
    # caso o termo seja o segundo, a sequência de fibonacci para esse termo é 1
    elif(termo == 2):
        # a função retorna o valor 1 quando é chamada e se a estrutura de decisão desse subcomando é 
        #verdadeira
        return 1
    # caso o termo não seja o primeiro nem o segundo, realiza uma função recursiva para a sequência de 
    #fibonacci
    else:
        # explicando a recursão: a função abaixo ela vai recebendo os termos (termo - 1) + (termo - 2) +
        # (termo - 2) + (termo - 3) + (termo - 3) + (termo - 4) + (termo - n) + (termo - m), de forma que
        # quando (termo - n) == 2 e (termo - m) == 1, teremos uma ordem de parada e a função original que
        # fez a recursão terá o número preciso da sequência de fibonacci no termo solicitado
        return fibonacci(termo - 1) + fibonacci(termo - 2)

Como toda operação com funções, precisamos de uma função principal para organizar o nosso progama. No nosso repositório, essa ideia não será tão relevante, pois estamos mais interessados em mostrar processos da programação aplicados em Álgebra Linear do que em desenvolver um produto final. Entretanto, é importante mostrar como se faz a chamada da função principal, dado que para montar um bom progama, esse quesito faz parte da necessidade do mesmo e é uma boa prática de programação.

In [62]:

# definindo a função principal do nosso exemplo
def main():
    # dando um título ao nosso progama exemplo
    print("Programa Sequência de Gibonacci.\n\n")
    
    n = int(input("Digite o termo da sequência desejada, em números inteiros: "))
    
    # estrutura de repetição for para mostrar a sequência de fibonacci até o termo de parada
    for indice in range(1, n + 1):
        # imprime os termos de fibonacci que serão definidos na função chamada
        # o  comando end = " " indica que o progama ao invés de ir para a próxima linha quando terminar o
        # subcomando no instante de uma das repetições, ele irá adicionar um caractere em branco
        print(fibonacci(indice), ",", end  = "")
    
    # indicando que a função principal terminou com sucesso
    return 0

Por fim, após definir que a função principal está chamado a função fibonacci definida, vamos agora fazer a chamada da função principal para executar o progama exemplo.

In [63]:

if __name__ == '__main__':
    main() # chamada da função main

Programa Sequência de Gibonacci.

1 ,1 ,2 ,3 ,5 ,8 ,13 ,21 ,34 ,55 ,

Há um problema no GitHub que não é possível visualizar os dados de entrada que o usuário digita, mas para exemplicar foi digitado o número inteiro 10, equivalente a quantidade de números da sequência desejada.

Alguma Dúvida? Entre em Contato Comigo:¶

Me envie um e-mail;