1 - Introdução ao Python

Python atingiu a versão 1.0 em janeiro de 1994. Foram incluídas as ferramentas de programação funcional lambda, map, filter e reduce.

A última versão lançada enquanto Van Rossum estava no CWI foi Python 1.2. Em 1995, Van Rossum continuou seu trabalho em Python na Corporation for National Research Initiatives (CNRI) em Reston, Virgínia, de onde lançou várias versões.

Na versão 1.4, o Python havia adquirido vários novos recursos. Entre eles, destacam-se os argumentos nomeados em funções e métodos e o suporte interno para números complexos.

Python 2.0, lançado em outubro de 2000, introduziu a compreensão de listas e introduziu um coletor de lixo capaz de coletar ciclos de referência.

Com o Python 2.1 sua licença foi renomeada para Python Software Foundation License e todo o código, documentação e especificações, adicionadas desde o lançamento alfa do Python 2.1 em diante, tornaram-se de propriedade da Python Software Foundation (PSF), uma organização sem fins lucrativos formada em 2001.

O lançamento incluiu uma mudança na especificação da linguagem para suportar escopos aninhados e escopos estáticos.

O Python 2.2 foi lançado em dezembro de 2001 unificando os tipos e classes do Python em uma hierarquia, tornando o modelo de classes do Python - pura e consistentemente - orientado a objetos. Também foram adicionados geradores inspirados no Icon.

O Python 2.5 foi lançado em setembro de 2006 e introduziu a instrução with, que inclui um bloco de código dentro de um gerenciador de contexto para, por exemplo, adquirir um bloqueio antes que o bloco de código seja executado e liberar o bloqueio posteriormente, ou abrir um arquivo e depois fechando-o, e também estabelecendo uma sintaxe try/finally comum.

O Python 2.6 foi lançado para coincidir com o Python 3.0 e incluiu alguns recursos dessa versão, bem como um modo de "avisos" que destacava o uso de recursos que foram removidos no Python 3.0.

O Python 2.7 coincidiu e incluiu recursos do Python 3.1, que foi lançado em 26 de junho de 2009. Os lançamentos paralelos 2.x e 3.x cessaram e o Python 2.7 foi o último lançamento na série 2.x. Em novembro de 2014, foi anunciado que o Python 2.7 seria suportado até 2020, e os usuários foram incentivados a migrar para o Python 3 o mais rápido possível.

Uma versão final, 2.7.18, ocorreu em 20 de abril de 2020 e incluiu correções para bugs críticos e bloqueadores de lançamento, e isso marcou o fim da vida útil do Python 2.

O Python 3.0 foi lançado em 3 de dezembro de 2008.

Ele foi projetado para corrigir falhas de design fundamentais na linguagem. As alterações necessárias não puderam ser implementadas mantendo total compatibilidade com versões anteriores com a série 2.x, exigindo um novo número de versão principal.

O princípio orientador do Python 3 era "reduzir a duplicação de recursos removendo formas antigas de fazer as coisas".

O Python 3.0 foi desenvolvido com a mesma filosofia das versões anteriores.

No entanto, como o Python acumulou maneiras novas e redundantes de programar a mesma tarefa, o Python 3.0 enfatizou a remoção de construções e módulos duplicados, de acordo com o Zen do Python: "Deve haver uma - e de preferência apenas uma - maneira óbvia de fazer isso".

No entanto, o Python 3.0 permaneceu uma linguagem multiparadigma.

Os programadores ainda poderiam seguir os paradigmas de programação orientada a objetos, estruturada e funcional, dentre outros paradigmas, mas com escolhas tão amplas, os detalhes deveriam ser mais óbvios no Python 3 do que no Python 2.

O prompt de comandos do Python - prompt-Python - permite a digitação de instruções pelo programador com o teclado e a execução pressionando a tecla [ENTRA].

Assim, o programador pode desenvolver interativamente seu aplicativo, incorporando posteriormente os comandos digitados em um arquivo-Python (arquivo-texto com terminação .py).

Se a instrução do comando exigir mais de uma linha, por exemplo a instrução for, o interpretador solicitará passo a passo as linhas seguintes até a instrução se completada.

Digite no prompt-Python:

>>> for i in [1,2,3]: [ENTRA]

O interpretador apresentará 3 pontos indicando que está esperando a próxima instrução do comando:

...

Digite " print(i)". O recuo é necessário para o bloco da instrução for.

>>>     print(i) [ENTRA]

A máquina-virtual apresentará novamente 3 pontos indicando que está esperando a próxima instrução do comando:

...

Não havendo mais instruções para o bloco for, pressione [ENTRA]:

... [ENTRA]

O bloco (com apenas uma instrução) será executado e será impresso no console:

1
2
3

Ao ser instalado o diretório do Python é adicionado ao PATH que permite a localização dos aplicativos pelo SO.

Os programas-Python rodam no escopo do SO com o Interpretador da máquina-virtual, carregado quando o arquivo-executável do Python é executado.

São arquivos-texto com extensão .py que são executados pelo Interpretador no escopo do SO.

O Python básico, desprovido da complementação de pacotes instalados, importados e integradas na máquina-virtual, tem poucos recursos para entrada de dados via tela e teclado e saida na tela, apenas basicamente disponibilizando os comandos input e print, respectivamente.

Com a importação de pacotes, entretanto, novos recursos para entrada e saida (E/S) de dados usando o teclado e tela podem ser incorporados, tornando o Python bastante rico em recursos de E/S.

O Python permite o desenvolvimento de aplicativos servidores para rodar na retaguarda de sistemas-web, usando com os pacotes DJango e Flask.

Existem cinco tipos primitivos de dados no Python:

• Numérico: inteiro, real e complexo
• Caracter
• Lógico
• Data
• Coleção: lista, tupla, conjunto e dicionário

As variáveis são declaradas apontando objetos com os operadores de atribuição.

Os operadores de atribuição são os simbolos "=", "*=", "+=", "-=", "/=", entre outros.

Exemplos:

x = y = k = m = n = 10
y += 5
k -= 5
m *= 5
n /= 5
#
print(x, y, k, m, n)

10 15 5 50 2.0

1.13.1.1 - As cláusulas condicionais if, elif e else

A execução de blocos de instruções pode ser controlada com as cláusulas condicionais if, elif e else.

x = 1
y = 2
if (x > y):
    print("x é maior que y")
elif (x < y):
    print("x é menor que y")
else:
    print("x é igual a y")

x é menor que y

As instruções em blocos podem ser executadas repetidamente com a utilização da cláusulas while ou for.

1.13.2.1 - O laço while

O laço while executa um bloco enquanto uma determinada condição for verdadeira.

i = 0
while i < 3:
    print(i)
    i += 1

0
1
2

1.13.2.2 - O laço for

O laço for itera sobre os itens de sequências, como listas ou textos, na ordem que aparecem na sequência.

letras = ["A","B","C"]
for letra in letras:
    print(letra)

A
B
C

1.13.2.3 - Controle de laços

Apesar de termos condições lógicas nos nossos laços, em algum momento, podemos decidir parar o laço por determinado motivo sem que o resto do laço seja executado.

i = 0
while i < 10:
    print(i)
    if i == 3:
        break
    i += 1

0
1
2
3

A instrução continue retorna o fluxo ao início do bloco de repetição.

letras = ["A","B","C","D"]
for letra in letras:
    if letra == "B":
        continue
    print(letra)

A
C
D

Existem pelo menos dois tipos distintos de erros: erros de sintaxe e exceções.

Erros de sintaxe, também conhecidos como como erros de parse, são os mais frequentes, causando a interrupção da execução da instrução (e do script):

>>>
>>> while True print('Hello world')
  File "<stdin>", line 1
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

Mesmo que um comando ou expressão estejam sintaticamente corretos, pode ocorrer um erro na hora de sua execução.

Erros detectados durante a execução são chamados exceções e não são necessariamente fatais: logo veremos como tratá-las em programas Python. A maioria das exceções não são tratadas pelos programas e acabam resultando em mensagens de erro:

>>> 10 * (1/0) # Erro de divisão por 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 4 + spam*3 # Erro de variável não declarada
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2 # Erro de concatenação de inteiro a caracter
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

Exceções surgem com diferentes tipos, e o tipo é exibido como parte da mensagem: os tipos no exemplo são ZeroDivisionError, NameError e TypeError.

Erro de divisão por 0 gerando a excessão ZeroDivisionError:

>>> 10 * (1/0) # Erro de divisão por 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

Erro de variável não declarada gerando a excessão NameError

>>> 4 + valor*3 # variável valor não foi declarada
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'valor' is not defined

Erro de concatenação de inteiro a caracter gerando a excessão TypeError

>>> '2' + 2 # Erro de concatenação de inteiro a caracter
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str

A última linha da mensagem de cada erro indica o que aconteceu.

A string exibida como sendo o tipo da exceção é o nome da exceção embutida que ocorreu.

Isso é verdade para todas exceções pré-definidas em Python, mas não é necessariamente verdade para exceções definidas pelo usuário (embora seja uma convenção útil).

Os nomes das exceções padrões são identificadores embutidos (não palavras reservadas).

O resto da linha é um detalhamento que depende do tipo da exceção ocorrida e sua causa.

A parte anterior da mensagem de erro apresenta o contexto onde ocorreu a exceção. Essa informação é denominada stack traceback (situação da pilha de execução). Em geral, contém uma lista de linhas do código-fonte, sem apresentar, no entanto, linhas lidas da entrada padrão.

Exceções embutidas lista as exceções pré-definidas e seus significados.

O parser repete a linha inválida e apresenta uma pequena ‘seta’ apontando para o ponto da linha em que o erro foi detectado.

O erro é causado (ou ao menos detectado) pelo símbolo que precede a seta: no exemplo, o erro foi detectado na função print(), uma vez que um dois-pontos (':') está faltando antes dela.

O nome de arquivo e número de linha são exibidos para que você possa rastrear o erro no texto do script.

Blocos podem ser aninhados dentro de outros blocos.

Uma matriz com duas dimensões pode ter blocos aninhados:

matriz = [[1,2,3],[4,5,6]]
for vetor in matriz:
    print("vetor:")
    for numero in vetor:
        print(numero)

vetor:
1
2
3
vetor:
4
5
6

As classes são esquemas com propriedades e métodos para os objetos das classes.

Os objetos são os dados alocados na memória com os tipos das classes.

As classes são declaradas com a cláusula class

class alguma_classe():
    def __init__(self, valor):
        self.valor = valor

Exemplo:

class Matematica:
    def soma(self,a,b):
        return a + b
    def sub(self,a,b):
        return a / b
    def mult(self,a,b):
        return a * b
    def div(self,a,b):
        return a / b
#
mat = Matematica()
#
print(mat.soma(mat.mult(2,3),mat.div(12,4)))

9.0

Exemplo:

class Matematica2:
    pi = 3.1416
#
mat = Matematica2()
#
print(mat.pi)

3.1416

As propriedades em classes Python são métodos especiais que permitem definir comportamentos personalizados para os atributos de uma classe. Elas permitem encapsular um atributo e definir as regras para acessá-lo e modificá-lo.

Em outras palavras, as propriedades permitem que você defina como um atributo de uma classe deve ser obtido ou modificado, e podem ser úteis para garantir a integridade dos dados da sua classe, evitando que atributos sejam acessados ou modificados de forma incorreta.

Um exemplo de como usar propriedades em uma classe Python é o seguinte:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    @property
    def nome_completo(self):
        return self.nome
    @nome_completo.setter
    def nome_completo(self, novo_nome):
        if not isinstance(novo_nome, str):
            raise TypeError('O nome precisa ser uma string')
        self.nome = novo_nome
    @property
    def idade_em_anos(self):
        return self.idade
    @idade_em_anos.setter
    def idade_em_anos(self, nova_idade):
        if not isinstance(nova_idade, int):
            raise TypeError('A idade precisa ser um número inteiro')
        self.idade = nova_idade

Nesse exemplo, a classe Pessoa tem dois atributos, nome e idade. Em seguida, definimos duas propriedades para essa classe: nome_completo e idade_em_anos.

A propriedade nome_completo usa o decorador @property para indicar que ela é uma propriedade somente de leitura (ou seja, não pode ser modificada diretamente). O método nome_completo retorna o valor do atributo nome.

Já o método nome_completo.setter é usado para definir a lógica de como a propriedade nome_completo pode ser modificada. Nesse caso, ele recebe um novo nome como argumento e verifica se esse nome é uma string. Se não for, levanta um erro do tipo TypeError. Caso contrário, atualiza o valor do atributo nome.

A propriedade idade_em_anos segue o mesmo padrão, mas é uma propriedade que pode ser lida e escrita. O método idade_em_anos retorna o valor do atributo idade, enquanto o método idade_em_anos.setter verifica se o novo valor passado para idade_em_anos é um número inteiro e atualiza o valor do atributo idade se for.

Assim, usando propriedades em classes Python, podemos definir comportamentos personalizados para atributos e garantir a integridade dos dados da nossa classe.

Os métodos em classes Python são funções definidas dentro de uma classe que podem acessar e manipular seus atributos. Eles são semelhantes a funções normais em Python, mas são chamados através de uma instância da classe.

Os métodos em classes Python são geralmente usados para realizar operações específicas na classe e podem receber argumentos como qualquer outra função em Python. Os métodos em classes também podem ser usados para modificar ou acessar os atributos da classe, e podem ser definidos com os modificadores @staticmethod, @classmethod ou @property para terem comportamentos especiais.

Exemplo de como usar métodos em uma classe Python é o seguinte:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    def nome_completo(self):
        return self.nome
    def idade_em_anos(self):
        return self.idade

Outro exemplo:

class Retangulo:
    def __init__(self, altura, largura):
        self.altura = altura
        self.largura = largura
    def area(self):
        return self.altura * self.largura
    def perimetro(self):
        return 2 * (self.altura + self.largura)

Nesse exemplo, a classe Retangulo possui dois métodos, area e perimetro. O método area calcula e retorna a área do retângulo, que é dada pela multiplicação de sua altura pela largura. Já o método perimetro calcula e retorna o perímetro do retângulo, que é dado pela soma de todos os seus lados.

Esses métodos podem ser chamados a partir de uma instância da classe Retangulo, como no exemplo abaixo:

r = Retangulo(5, 10)
print(r.area())
print(r.perimetro())

50
30

Nesse exemplo, criamos uma instância da classe Retangulo com altura 5 e largura 10. Em seguida, chamamos os métodos area e perimetro dessa instância para calcular a área e o perímetro do retângulo.

Dessa forma, métodos em classes Python nos permitem definir comportamentos específicos para uma classe, permitindo que possamos realizar operações em seus atributos e trabalhar com instâncias dessa classe.

1.14.3.1 - Construtores

Construtores em classes Python são métodos especiais que são chamados automaticamente quando uma instância da classe é criada. O construtor geralmente é usado para inicializar os atributos da classe com valores padrão ou com base nos argumentos passados durante a criação da instância.

Em Python, o construtor é definido usando o método especial __init__, que é executado automaticamente quando a instância da classe é criada. O método __init__ é responsável por receber os argumentos passados para a classe e inicializar seus atributos de acordo.

Um exemplo de como usar um construtor em uma classe Python é o seguinte:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade

Nesse exemplo, a classe Pessoa tem dois atributos, nome e idade. O método __init__ é usado como o construtor da classe e recebe dois argumentos, nome e idade. Esses argumentos são usados para inicializar os atributos nome e idade da instância da classe.

Agora, podemos criar uma instância da classe Pessoa e atribuir valores aos seus atributos usando o construtor:

p = Pessoa("João", 30)
print(p.nome)  # João
print(p.idade) # 30

João
30

Nesse exemplo, criamos uma instância da classe Pessoa com o nome "João" e a idade 30. O construtor __init__ é chamado automaticamente durante a criação da instância e inicializa os atributos nome e idade com esses valores. Em seguida, usamos os métodos de acesso (p.nome e p.idade) para obter os valores dos atributos da instância.

Assim, o construtor em classes Python é usado para inicializar os atributos de uma classe com valores padrão ou com base nos argumentos passados durante a criação da instância, permitindo que possamos criar instâncias da classe com valores diferentes para seus atributos.

Herança em classes é um conceito da programação orientada a objetos que permite que uma classe (conhecida como subclasse ou classe derivada) herde atributos e métodos de outra classe (conhecida como classe base ou superclasse). A subclasse é capaz de utilizar os atributos e métodos herdados da superclasse, além de adicionar seus próprios atributos e métodos específicos.

Em Python, a herança é definida por meio da declaração da classe e a referência à classe base entre parênteses. Por exemplo, suponha que temos uma classe base chamada "Pessoa" e queremos criar uma subclasse chamada "Aluno". Podemos definir a subclasse assim:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
class Aluno(Pessoa):
    def __init__(self, nome, idade, matricula):
        super().__init__(nome, idade)
        self.matricula = matricula

Nesse exemplo, a classe "Aluno" herda da classe "Pessoa", então todos os atributos e métodos definidos na classe "Pessoa" são utilizáveis na classe "Aluno". Além disso, a classe "Aluno" adiciona um atributo chamado "matricula".

A palavra-chave super() é utilizada para acessar métodos e atributos da classe base. No caso do exemplo, o método __init__() da classe base é chamado na subclasse utilizando super().__init__(nome, idade), passando os parâmetros necessários para o construtor da superclasse.

A sobreposição na herança em classes ocorre quando a subclasse redefine um método que já foi definido na classe base, com o objetivo de modificar o comportamento desse método específico na subclasse.

Em Python, a sobreposição é realizada simplesmente definindo o método na subclasse com o mesmo nome que o método na superclasse. Quando o método é chamado na subclasse, o interpretador do Python usa a versão definida na subclasse em vez da versão da superclasse.

Aqui está um exemplo de sobreposição em Python:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    def apresentar(self):
        print(f"Olá, meu nome é {self.nome} e tenho {self.idade} anos.")
class Aluno(Pessoa):
    def __init__(self, nome, idade, matricula):
        super().__init__(nome, idade)
        self.matricula = matricula
    def apresentar(self):
        print(f"Olá, meu nome é {self.nome}, tenho {self.idade} anos e minha matrícula é {self.matricula}.")
p = Pessoa("João", 30)
p.apresentar() # Output: Olá, meu nome é João e tenho 30 anos.
a = Aluno("Maria", 20, "1234")
a.apresentar() # Output: Olá, meu nome é Maria, tenho 20 anos e minha matrícula é 1234.

Olá, meu nome é João e tenho 30 anos.
Olá, meu nome é Maria, tenho 20 anos e minha matrícula é 1234.

Nesse exemplo, a subclasse "Aluno" redefine o método apresentar() da superclasse "Pessoa" para adicionar o atributo "matrícula" na mensagem de apresentação. Quando o método apresentar() é chamado na instância da classe "Aluno", a versão da subclasse é utilizada em vez da versão da superclasse.

A instanciação de classes em Python é o processo de criar um objeto a partir de uma classe. Em outras palavras, é a criação de uma instância de uma classe, que é um objeto que pode ter seus próprios atributos e métodos, além de herdar atributos e métodos da classe base.

A instanciação é realizada por meio da chamada do construtor da classe, que é um método especial chamado __init__(). O construtor é responsável por inicializar os atributos da instância e pode receber parâmetros que serão usados ​​para definir o estado inicial da instância.

Aqui está um exemplo de instanciação de classe em Python:

class Pessoa:
    def __init__(self, nome, idade):
        self.nome = nome
        self.idade = idade
    def apresentar(self):
        print(f"Olá, meu nome é {self.nome} e tenho {self.idade} anos.")
p = Pessoa("João", 30)
p.apresentar() # Output: Olá, meu nome é João e tenho 30 anos.

Olá, meu nome é João e tenho 30 anos.

Nesse exemplo, a classe "Pessoa" é definida com um construtor que recebe dois parâmetros: "nome" e "idade". O construtor inicializa os atributos "nome" e "idade" do objeto criado a partir da classe. Em seguida, um objeto "p" é criado a partir da classe "Pessoa" com os valores "João" e "30" passados para o construtor. Finalmente, o método "apresentar()" é chamado na instância "p", exibindo a mensagem "Olá, meu nome é João e tenho 30 anos." no console.

Existem diversos pacotes populares que estendem o Python com novos módulos.

Os pacotes são conjuntos de módulos que podem ser instalados na plataforma do Python.

Os módulos são os componenentes dos pacotes Python e disponibilizam novas propriedades e novos métodos.

Pacotes e módulos são importados nas instruções da cláusula import, assim como módulos indivisuais dentro dos pacotes.

• Matplotlib: pacote para criação de gráficos em 2D e 3D, apresentando uma série de possibilidades gráficas, como gráficos de barra, linha, pizza, histogramas, entre muitos outros.
• Numpy: pacote para suporte ao processamento de grandes arranjos e matrizes multi-dimensionais, disponibilizando vasta coleção de funções matemáticas de alto nível para operação dos arranjos e matrizes.
• Pandas: pacote para manipulação e análise de dados. Em particular, oferece estruturas e operações para manipular tabelas numéricas e séries temporais.
• Seaborn: pacote que usa o Matplotlib abaixo para plotar gráficos com uma apresentação de alto nível no desenho de gráficos estatísticos atraentes e informativos.
• Plotly: pacote com mais de 30 funções para criação de diferentes tipos de figuras.
• DJango: pacote com framework web full stack (que atende a todas as áreas no desenvolvimento de um sistema), open source (código aberto), baseado em Python, gratuito e de alto nível. Tem objetivo de resolver todos os problemas mais comuns do processo de desenvolvimento de aplicações web, como por exemplo autenticação, rotas, mapeamento relacional de objetos (Object Relational Mapper - ORM) e até migrações. Suporta projetos escaláveis e conta com um eficiente sistema de segurança.
• Flask: pacote com de aplicação web WSGI leve, projetado para tornar a introdução rápida e fácil, com a capacidade de escalar para aplicativos complexos e que tornou um dos pacotes mais populares. O Flask oferece sugestões, mas não impõe nenhuma dependência ou layout do projeto. Cabe ao desenvolvedor escolher as ferramentas e bibliotecas que deseja usar. Existem muitas extensões fornecidas pela comunidade que facilitam a adição de novas funcionalidades.

Os pacotes são instalados com o programa PIP no shell do OS e são importados para utilização dos módulos pelo Interpretador.

A instalação de pacotes é feita com o comando install com o programa PIP disponível no diretório de instalação do Python, executado a partir do shell do SO, digitando-se:

• pip install matplotlib
• pip install numpy
• pip install pandas
• pip install seaborn
• pip install plotly
• pip install django
• pip install flask

A importação de pacotes e módulos é realizada com o comando import.

• import matplotlib
• import numpy
• import pandas
• import seaborn
• import plotly
• import django
• import flask

Os dados podem ser carregados em coleções a partir de arquivos que podem estar armazenados em disco, na nuvem e outros dispositivos de armazenamento de dados, em formatos com extensões conhecidas como .csv e .json.

Streams são conexões de rede de alto-nível permitindo envios e recebimentos de dados (json, xml, html, csv etc) síncronos (pronta-espera) ou assincronos, sem usar retornos de chamadas ou protocolos de baixo nível.

O Python possue diferentes pacotes e módulos para acessar os dados com diversos SGBD (Sistema Gerenciador de Bancos de Dados):

• SQLite
• MySQL
• PostgreSQL
• MSSQL
• Oracle