Introdução a Linguagem de Programação Python¶

Neste módulo, serão analisadas as estruturas básicas da linguagem de programação Python. É pertinente saber que tal linguagem possui bastante uso atualmente, sendo uma das mais simples de se utilizar. Graças a colaboratividade dos usuário, atualmente há inúmeros pacotes prontos para uso que nos possibilitam executar diversas tarefas complexas.

Versão do Python: 3.x

"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. 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.

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 multi-plataforma, e atualmente está presente em diversos sistemas operacionais, seja eles embarcados ou não.

Agora que alguns conceitos foram definidos, está na hora de colocar a mão na massa. É interessante ressaltar que este conteúdo 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]:

3 + 4

Out[1]:

ou até

In [2]:

"Á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]:

print(3 + 4)
print("Álgebra" + " Linear")

7
Álgebra Linear

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

Como foi explanado anteriormente, no 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 ter seu valor e tipo alterados na memória a qualquer momento.

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

Dados númericos¶

In [4]:

int_ = 1
float_ = 1.5
complex_ = 5 + 4j # parte real e parte complexa

print('inteiro:', int_, 'type:', type(int_))
print('número real: {:.2f} type: {}'.format(float_, type(float_)))
print('número complexo: ' + str(complex_) + ' type: ' + str(type(complex_))) 
# existem muitas formas de se imprimir uma mesma informação!

inteiro: 1 type: <class 'int'>
número real: 1.50 type: <class 'float'>
número complexo: (5+4j) type: <class 'complex'>

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 [5]:

int_ = 1.234567765432 + 4.4567876543j

print('é inteiro?', int_ == int)
print('\tnúmero complexo:', int_, 'type:', type(int_))

int_ = 'a' + " vida" + """ é""" + ''' bela''' # observe a liberdade com as aspas!

print('\nainda é complexo?', int_ == int)
print('\tstring:', int_, 'type:', type(int_)) # você observou alguns caracteres especiais?

é inteiro? False
	número complexo: (1.234567765432+4.4567876543j) type: <class 'complex'>

ainda é complexo? False
	string: a vida é bela type: <class '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 (mas como você é um estudante esperto, sei que não fará isso). Todavia, o mesmo recurso que pode ser de grande ajuda também pode permitir erros lógicos, sendo necessário ter cuidado para evitar erros lógicos.

Cadeias de caracteres (strings)¶

Usar strings no python não tem muito mistério, a concatenção entre duas strings podem ser feitas através do operador de adição +, e qualquer outro tipo de dado número pode ser facilmente convertido em strings usando str(). Veja abaixo algumas implementações.

In [6]:

mandamentos_python = """The Zen of Python, by Tim Peters

                        Beautiful is better than ugly.
                        Explicit is better than implicit.
                        Simple is better than complex.
                        Complex is better than complicated.
                        Flat is better than nested.
                        Sparse is better than dense.
                        Readability counts.
                        Special cases aren't special enough to break the rules.
                        Although practicality beats purity.
                        Errors should never pass silently.
                        Unless explicitly silenced.
                        In the face of ambiguity, refuse the temptation to guess.
                        There should be one-- and preferably only one --obvious way to do it.
                        Although that way may not be obvious at first unless you're Dutch.
                        Now is better than never.
                        Although never is often better than *right* now.
                        If the implementation is hard to explain, it's a bad idea.
                        If the implementation is easy to explain, it may be a good idea.
                        Namespaces are one honking great idea -- let's do more of those!"""

print(mandamentos_python) # digite 'import this' no interpretador do python e veja o que acontece!

The Zen of Python, by Tim Peters

                        Beautiful is better than ugly.
                        Explicit is better than implicit.
                        Simple is better than complex.
                        Complex is better than complicated.
                        Flat is better than nested.
                        Sparse is better than dense.
                        Readability counts.
                        Special cases aren't special enough to break the rules.
                        Although practicality beats purity.
                        Errors should never pass silently.
                        Unless explicitly silenced.
                        In the face of ambiguity, refuse the temptation to guess.
                        There should be one-- and preferably only one --obvious way to do it.
                        Although that way may not be obvious at first unless you're Dutch.
                        Now is better than never.
                        Although never is often better than *right* now.
                        If the implementation is hard to explain, it's a bad idea.
                        If the implementation is easy to explain, it may be a good idea.
                        Namespaces are one honking great idea -- let's do more of those!

In [7]:

str_ = 'você vai usar'
str_ += ' álgebra linear'
str_ = str_.__add__(' durante toda sua carreira!') # acabei de usar um dos 'métodos mágicos', busque mais a respeito sobre eles!
str__ = ' Estude!'
str_ = str_ + str__

print(str_)

você vai usar álgebra linear durante toda sua carreira! Estude!

In [8]:

print(str_.find('álgebra linear'))
print(str_[14 : 14 + len('álgebra linear')]) 
# muita coisa aconteceu por aqui, separe o problema em pedaços e tente entender o escopo geral!

14
álgebra linear

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 [9]:

list_ = ['café', 'cuscuz', 'água', 'lágrimas']

print('alimentação básica do estudante: ', list_)

alimentação básica do estudante:  ['café', 'cuscuz', 'água', 'lágrimas']

In [10]:

variedades = ['computadores', 12, 12.0, 4 + 5j, ['tablets', 'celulares'], list_]

print(variedades)

['computadores', 12, 12.0, (4+5j), ['tablets', 'celulares'], ['café', 'cuscuz', 'água', 'lágrimas']]

In [11]:

for itens in list_:
    print(itens)
    
list_.append('arroz') # qual o limite de armazenamento em uma lista?

print('\n', list_)

del list_[3]

print('\n', sorted(list_)) # porque 'água' não ficou no primeiro indice da lista?

café
cuscuz
água
lágrimas

 ['café', 'cuscuz', 'água', 'lágrimas', 'arroz']

 ['arroz', 'café', 'cuscuz', 'água']

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 no intervalo de (0, n-1) n = len(list), dado que o último elemento é o número de parada.

In [12]:

tuple_ = (1, 12.0, 3 + 4j, list_)

print(tuple_, '\n', type(tuple_))

(1, 12.0, (3+4j), ['café', 'cuscuz', 'água', 'arroz']) 
 <class 'tuple'>

In [15]:

del tuple_[0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-15-ab89e1737781> in <module>()
----> 1 del tuple_[0]

TypeError: 'tuple' object doesn't support item deletion

In [14]:

tuple_.append(7)

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-14-40d1f414c4fb> in <module>()
----> 1 tuple_.append(7)

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

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.

Dicionários¶

Dicionários são um tipo de dado muito interessante. Sabendo utilizá-los bem, é possível montar toda uma aplicação em que o salvamento de arquivos pode ser totalmente baseados em estruturas de dicionário! a sua estrutura obedece a seguinte sintaxe: {'chave': elementos}. Outra importância dos dicionários é a compactação de informações em um so elemento, veja o exemplo abaixo.

In [16]:

# === Montando uma mala ===
pessoal = ['sabonete', 'shampoo', 'condicionador', 'escova de dentes']
livros = ['flores para algernon', 'fahrenheit 451', 'State of art in Deep Learning']
roupas = ['camisas', 'calças', 'cuecas', 'meias', 'sapato']
local = 'Natal - Rio Grande do Norte'
pessoas = 5
mala = {'itens pessoais': pessoal, 
        'livros': livros,
        'tipos de roupas': roupas,
        'local da viagem': local,
        'total de pessoas': pessoas}

mala['não esquecer'] = ['passaporte', 'casaco', 'colocar comida do cachorro']

print(mala)

{'itens pessoais': ['sabonete', 'shampoo', 'condicionador', 'escova de dentes'], 'livros': ['flores para algernon', 'fahrenheit 451', 'State of art in Deep Learning'], 'tipos de roupas': ['camisas', 'calças', 'cuecas', 'meias', 'sapato'], 'local da viagem': 'Natal - Rio Grande do Norte', 'total de pessoas': 5, 'não esquecer': ['passaporte', 'casaco', 'colocar comida do cachorro']}

In [17]:

for chaves in mala.keys():
    print(chaves, mala[chaves])

itens pessoais ['sabonete', 'shampoo', 'condicionador', 'escova de dentes']
livros ['flores para algernon', 'fahrenheit 451', 'State of art in Deep Learning']
tipos de roupas ['camisas', 'calças', 'cuecas', 'meias', 'sapato']
local da viagem Natal - Rio Grande do Norte
total de pessoas 5
não esquecer ['passaporte', 'casaco', 'colocar comida do cachorro']

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 [18]:

2 ** (((3 + 7) - (-10 + 15) * 2) / 5 ) 

Out[18]:

1.0

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 que o seu aprendizado seja 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 [19]:

dir(list_)

Out[19]:

['__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.

Recebendo Dados de Entrada¶

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

In [20]:

entrada = input("Insira Algo: ") 

print(entrada)

Insira Algo: Álgebran Linear
Álgebran Linear

In [21]:

numero = input('Insira um número: ')

print(numero + 4) # porque isso não funcionou?

Insira um número: 34

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-21-23a492fbe326> in <module>()
      1 numero = input('Insira um número: ')
      2 
----> 3 print(numero + 4) # porque isso não funcionou?

TypeError: must be str, not int

Observe que foi digitado um número inteiro, mas foi armazenado como uma string. Isso ocorre porque a função input não funciona com tipagem dinâmica. 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.

In [22]:

numero1 = int(input('Insira um número: '))
numero2 = input('Insira um outro número: ')

print(numero1 + int(numero2)) 

Insira um número: 34
Insira um outro número: 35
69

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 [23]:

print(str_)
print(str_[14: 14 + len('álgebra linear')])

você vai usar álgebra linear durante toda sua carreira! Estude!
álgebra linear

In [24]:

flag = 0
history = []

for i in range(0, 10000):
    history.append(flag)
    flag += 1
    
print(history[:10])
print(history[-10: -1])
print(len(history))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[9990, 9991, 9992, 9993, 9994, 9995, 9996, 9997, 9998]
10000

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 [25]:

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

Out[25]:

False

In [26]:

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

Out[26]:

True

In [27]:

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

Out[27]:

True

In [28]:

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

Out[28]:

False

In [29]:

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

Out[29]:

False

In [30]:

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

Out[30]:

True

In [31]:

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

Out[31]:

True

In [32]:

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

Out[32]:

True

In [33]:

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

Out[33]:

False

In [34]:

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

Out[34]:

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 [35]:

numero1 = int(input("Insira um primeiro número inteiro: "))
numero2 = int(input("Insira um segundo número inteiro: "))

print("\nnúmero 01 = {} e número 02 = {}\n".format(numero1, numero2))

if(numero1 > numero2):
    print("{} é maior a {}".format(numero1, numero2))
elif(numero1 == numero2):
    print("{} é igual a {}".format(numero1, numero2))
else:
    print("{} é menor a {}".format(numero1, numero2))

# você observeu a ausência do ponto e vírgula?
# se esses recuos fossem removidos das estruturas de repetição ou decisão, a lógica continuaria correta?

Insira um primeiro número inteiro: 12
Insira um segundo número inteiro: 14

número 01 = 12 e número 02 = 14

12 é menor a 14

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" é um caractere especial que 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, mas não necessariamente, 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 [36]:

for indice in range(0,11):
    print(indice)

In [37]:

frase = ["Você", "construiu", "uma", "máquina", "do", "tempo", "com", "um", "Delorean", "?"]

for itens in frase:
    print(itens, 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 [38]:

a, b = 1, 1 # essa inicialização parece comum?

while True:
    print("{}, {}".format(a, b))
    a *= 2
    b *= 3
    if(a >= 500 or b >= 500):
        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 [40]:

for indice in range(1, 11):
    print(indice)
    if(indice == 5):
        break

In [41]:

for indice in range(1, 11):
    print(indice)
    if(indice == 5):
        continue

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 [42]:

def fibonacci (termo):
    if(termo == 1):
        return 1
    elif(termo == 2):
        return 1
    else:
        return fibonacci(termo - 1) + fibonacci(termo - 2)

# como se chama mesmo eh... 
    # como se chama mesmo eh... uma função que chama ela mesma?
        # como se chama mesmo eh... uma função que chama ela mesma? recurso...
            # como se chama mesmo eh... uma função que chama ela mesma? recurso, excursão...
                # como se chama mesmo eh... uma função que chama ela mesma? recurso, excursão... RECURSÃO!

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 programa, esse quesito conta.

In [43]:

def main():
    print("Programa Sequência de Gibonacci.\n\n")
    n = int(input("Digite o termo da sequência desejada, em números inteiros: "))
    for indice in range(1, n + 1):
        print(fibonacci(indice), ",", end  = "")
    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 [44]:

if __name__ == '__main__':
    main()

Programa Sequência de Gibonacci.


Digite o termo da sequência desejada, em números inteiros: 10
1 ,1 ,2 ,3 ,5 ,8 ,13 ,21 ,34 ,55 ,

Tratamento de excessões e erros¶

Tratamento de excessões e erros é uma forma prática de garantir que o programa não termine sua execução no meio da operação. Através de seu uso, é possível garantir que determinados erros não travem um programa por completo. Abaixo, será ilustrado alguns problemas comuns.

In [45]:

try:
    12 / 0
except ZeroDivisionError:
    print('Não é possível dividir por zero!')

Não é possível dividir por zero!

In [46]:

try:
    lista = [1, 2, 3]
    print(list[4])
except:
    print('Um erro ocorreu!')

Um erro ocorreu!

In [47]:

try:
    x, y, z = 1, 0 , 1
    coordenadas = (x, y)
    coordenadas.append(z)
except AttributeError:
    pass

Utilizando pacotes¶

É uma prática comum na programação utilizar ferramentas já prontas e implementadas, de modo que seja possível abstrair diversas operações e focar em problemas mais complexos. O Python, em particular, possui uma grande comunidade de contribuidores na plataforma PyPi, essa que tem o propósito de disponibilizar milhões de pacotes práticos e úteis para qualquer usuário utilizar. Além disso, o processo de obtenção e uso é simples, de modo que através de linhas de comando (considerando que a pasta de scripts do python está configurada nas váriaveis do sistema), o usuário consiga obté-las.

OBS: execute os códigos abaixo como linha de comando no sistema, não são interpretáveis pelo Python.

Instalar um pacote: pip install nome_do_pacote1 nome_do_pacote2 ... nome_do_pacote_n

pip install numpy pip install numpy seaborn matplotlib

Desinstalar um pacote: pip uninstall nome_do_pacote1 nome_do_pacote2 ... nome_do_pacote_n

pip uninstall numpy pip uninstall numpy seaborn matplotlib

Atualizar pacote existente: pip instal nome_do_pacote --upgrade

pip install tensorflow --upgrade

Instalar uma versão específica: pip install nome_do_pacote==version

pip install tensorflow==2.0.0

Visualizar pacotes instalados: pip list

pip list

In [48]:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.collections import LineCollection

from sklearn.linear_model import LinearRegression
from sklearn.isotonic import IsotonicRegression
from sklearn.utils import check_random_state

n = 100
x = np.arange(n)
rs = check_random_state(0)
y = rs.randint(-50, 50, size=(n,)) + 50. * np.log(1 + np.arange(n))

###############################################################################
# Fit IsotonicRegression and LinearRegression models

ir = IsotonicRegression()

y_ = ir.fit_transform(x, y)

lr = LinearRegression()
lr.fit(x[:, np.newaxis], y)  # x needs to be 2d for LinearRegression

###############################################################################
# plot result

segments = [[[i, y[i]], [i, y_[i]]] for i in range(n)]
lc = LineCollection(segments, zorder=0)
lc.set_array(np.ones(len(y)))
lc.set_linewidths(0.5 * np.ones(n))

fig = plt.figure(figsize = (15,10))
plt.plot(x, y, 'r.', markersize=12)
plt.plot(x, y_, 'g.-', markersize=12)
plt.plot(x, lr.predict(x[:, np.newaxis]), 'b-')
plt.gca().add_collection(lc)
plt.legend(('Data', 'Isotonic Fit', 'Linear Fit'), loc='lower right')
plt.title('Isotonic regression')
plt.show()

# == código extraido da documentação do scikit-learn ==
# https://scikit-learn.org/0.16/auto_examples/plot_isotonic_regression.html

(Opcional) Orientação a objetos¶

Programação Orientada a Objetos (POO) é um modelo de análise, projeto e programação de software baseado na composição e interação entre diversas unidades chamadas de 'objetos'. A linguagem de programação Python também suporta POO, de modo que em poucas linhas classes úteis podem ser implementadas. Abaixo será exemplificado a construção de uma classe para resolução de problemas em regressão linear. Tudo bem se você não entender muito o que está acontecendo nos códigos abaixo, esse conteúdo será abordado posteriormente. Preste atenção em como uma classe é construida e em como os objetos são instanciados.

In [49]:

# importação de pacotes auxiliares
import numpy as np
import matplotlib.pyplot as plt

class SimpleLinearRegression():
    '''Classe que resolve problemas de regressão linear simples'''
    
    def __init__(self, len_scatter):
        '''construtor da classe'''
        
        self.len_scatter = len_scatter
        self.X = []
        self.y = []
        self.parameters = []
        
        return None
    
    def generate_linear_data(self, seed = 42):
        '''método para geração de dados lineares arbitrários'''
        
        np.random.seed(seed)
        self.X = np.random.randint(1, seed, (self.len_scatter, 1))
        self.y = self.X * seed
        
        return (self.X, self.y)
    
    def get_parameters(self, X, y):
        '''retorna os parâmetros do modelo (equação linear) a partir do ajuste nos dados'''
        
        m = self.y.size
        X_bias = np.concatenate([np.ones((m, 1)), self.X], axis=1)
        self.parameters = np.dot(np.dot(np.linalg.inv(np.dot(X_bias.T, X_bias)), X_bias.T), self.y)
        
        return self.parameters
    
    def plot_model(self, X, y, parameters):
        '''visualização gráfica do modelo treinado'''
        
        plt.figure(figsize = (10,5))
        plt.scatter(X, y, label = 'data')
        plt.plot(np.arange(min(X) - 5, max(X) + 5), parameters[0] + parameters[1] * np.arange(min(X) - 5, max(X) + 5), label = 'model')
        plt.xlabel('X')
        plt.ylabel('y')
        plt.title('Linear Regression with Normal Equation - Vectorized')
        plt.legend()
        plt.grid(False)
        plt.box(False)
        plt.show()
        
        return None 

In [50]:

# instanciação de um objeto da classe
regressor = SimpleLinearRegression(len_scatter = 10)

# obtendo os dados lineares a partir de uma semente de geração randômica
X, y = regressor.generate_linear_data(seed = 42)

# obtendo os parâmetros do modelo 
parameters = regressor.get_parameters(X, y)

# visualizando o modelo treinado com os dados
regressor.plot_model(X, y, parameters)

Alguma Dúvida? Entre em Contato Comigo: Me envie um e-mail ¶

Extra¶

O repositório abaixo contém mais de 100 exemplos de códigos em python para treinar. Além disso, os conteúdos abordados são bem divididos em:

Introdução ao Python
Variáveis
Listas
Usando Listas
Usando Tuplas
Condições
Dicionários
Dados de entrada
Estruturas de repetição
Funções
Importação de módulos e pacotes
Classes (POO)
Manipulação de Arquivos
Tratamento de Excessão e erro