Python Básico
Carregando, aguarde alguns segundos.
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA
CIEDA

1 - Introdução ao Python

A linguagem de programação Python é muito popular, foi criada em 1991 por Guido van Rossum, é de uso geral, bastante fácil de programar e utilizar.

Após instalado, você roda o programa CLI (Command-Line-Interface) do Python, a partir da linha de comando do SO (Sistema-Operacional), disponibilizando uma interface de linha de comando para o programador interagir com o Python.

A linguagem Python tem uma sintaxe fácil, que usa uma série de palavras e simbolos reservados, em conjunto com diferentes tipos de operações, para executar instruções da linguagem.

Você pode criar variáveis atribuindo valores literais a elas: 

a = 1
b = 2

Você pode usar o operador print para mostrar o valor das variáveis: 

print("a =", a)
print("b =", b)

Você pode usar o operador + para somar os valores de variáveis com literais ou outras variáveis: 

c = a + 10
d = a + b
print("c =", c)
print("d =", d)

você pode usar diversos tipos de operações aritméticas: 

print("10 + 20 =", 10 + 20)
print("10 - 20 =", 10 - 20)
print("10 * 20 =", 10 * 20)
print("10 / 20 =", 10 / 20)
print("10 // 3 =", 10 // 3)
print("10 % 3 =", 10 % 3)
print("10 ** 2 =", 10 ** 2)

você pode usar diversos tipos de operações de atribuição: 

a = 8; b = 3; print(f"a = {a}, b = {b}")
a += b; print(f"a += b, a = {a}")
a *= b; print(f"a *= b, a = {a}")
a -= b; print(f"a -= b, a = {a}")
a //= b; print(f"a //= b, a = {a}")
a %= b; print(f"a %= b, a = {a}")
a /= b; print(f"a /= b, a = {a}")
a **= b; print(f"a **= b, a = {a}")

Você pode criar e manipular variáveis com texto: 

a = 'AbCdE'
print("a =", a, "tem tamanho =", len(a))

A variável a contém o texto AbCdE, que é um vetor de caracteres que vai do índice 0 ao 4 (correspondente a len(a)-1).

As letras nos índices são os seguintes: 

i = 0
while i < len(a):
    print(f"a[{i}] = {a[i]}")
    i += 1

Vamos inovar e criar uma função que retorna uma mensagem com o texto de uma expressão e o resultado da sua avaliação com a função eval(): 

def print_eval(expressao):
    print( f"{expressao} = {eval(expressao)}")

você pode usar os índices para fatiar o texto: 

print_eval("a[2]")
print_eval("a[:4]")
print_eval("a[1:]")
print_eval("a[2:3]")
print_eval("a[2:4]")
print_eval("a[2:5]")
print_eval("a[0:5:2]")
print_eval("a[0:5:3]")
print_eval("a[1:5:2]")
print_eval("a[2:4:2]")
print_eval("a[::-1]")

Neste tipo de construção 'a[2:5:2]', o primeiro número é o indice inicial, o segundo o indice final, e o terceiro o passo.

você pode usar diversos tipos de métodos de texto: 

b = "TíTuLo De AlGuMa CoIsA!"
print(f"b = '{b}'")
print(f"b.upper() = '{b.upper()}'")
print(f"b.lower() = '{b.lower()}'")
print(f"b.capitalize() = '{b.capitalize()}'")
print(f"b.title() = '{b.title()}'")
print(f"b.swapcase() = '{b.swapcase()}'")
print(f"b.center(30) = '{b.center(30)}'")
print(f"b.startswith('TiT') = {b.startswith('TíT')}")
print(f"b.startswith('tit') = {b.startswith('tit')}")
print(f"b.endswith('sA!') = {b.endswith('sA!')}")
print(f"b.endswith('sa!') = {b.endswith('sa!')}")

Métodos de texto que fazem a contagem e localizam ocorrências de caracteres, da esquerda para a direita e vice-versa: 

c = '?01234567890123456789012$345678901234567890123456789@'
print(f"c = '{c}'")
print("c.count('5') =", c.count('5'))
print("c.count('5', 10) =", c.count('5', 10))
print("c.count('5', 10, 35) =", c.count('5', 10, 35))
print("c.find('7') =", c.find('7'))
print("c.find('@', 10) =", c.find('@', 10))
print("c.find('@', 10, 35) =", c.find('@', 10, 35))
print("c.rfind('9') =", c.rfind('9'))
print("c.rfind('$', 20) =", c.rfind('$', 10))
print("c.rfind('?', 10, 35) =", c.rfind('?', 10, 35))

Neste tipo de construção '"c.rfind('?', 10, 35)', o primeiro argumento será o texto que será procurado em c, o segundo o indice inicial, e o terceiro o indice final.

Você pode trabalhar com listas: 

frutas = ['mamão', 'banana', 'cereja', 'laranja', 'kiwi', 'manga']
print(f"a lista frutas = {frutas} tem tamanho = {len(frutas)}")
print(f"'laranja' in frutas = {'laranja' in frutas}")

Você pode trabalhar com tuplas, que são listas imutáveis com poucos elementos: 

numeros = (1,2,3)
print(f"a tupla numeros = {numeros} tem tamanho = {len(numeros)}")
print(f"2 in numeros = {2 in numeros}")

Você pode declarar as tuplas sem os parênteses: 

numeros = 1,2,3
print(f"numeros = {numeros} tem tipo = {type(numeros)}")

Você pode declarar conjuntos como na matemática, sem repetições: 

numeros = {1,2,2,3,3,3,4,4,4,4,5,5,5,5,5}
print(f"numeros = {numeros} tem tipo = {type(numeros)} e tamanho = {len(numeros)}")

Conjuntos têm métodos próprios: 

a = {1,2,3,4,5}
b = {4,5,6,7,8}
print(f"A união de 12345 com 45678 = {a.union(b)}")
print(f"A interseccão de 12345 com 45678 = {a.intersection(b)}")
print(f"A diferença de 12345 com 45678 = {a.difference(b)}")
print(f"A diferença de 45678 com 12345 = {b.difference(a)}")
print(f"A diferença simétrica de 12345 com 45678 = {a.symmetric_difference(b)}")

você pode usar diversos tipos de operações de comparação: 

a = 10; b = 5; print(f"a = {a}, b = {b}")
print_eval("a < b")
print_eval("a <= b")
print_eval("a > b")
print_eval("a >= b")
print_eval("a == b")
print_eval("a != b")

você pode usar diversos tipos de operações de logica: 

a = 10; b = 5;
print(f"a = {a}, b = {b}")
print_eval("(a > 11 or b <= 5)")
print_eval("(a > b and b < 15)")
print_eval("(a > 11 and b < 11)")

você pode usar diversos tipos de operações bitwise: 

binario = lambda x : bin(x)[2:].zfill(4)
a = 10; ba = binario(a)
print(f"a = {a} (base 10) = {ba} (base 2)")
b = 12; bb = binario(b)
print(f"b = {b} (base 10) = {bb} (base 2)")
print("----")
print(ba, "(a)")
print(bb, "(b)")
print("----")
print(binario(a & b), "(&)")
print(binario(a | b), "(|)")
print(binario(a ^ b), "(^)")
print("----")
print_eval("a & b")
print_eval("a | b")
print_eval("a ^ b")
print_eval("~a")
print_eval("a << 2")
print_eval("a >> 2")

Você pode alterar o fluxo de execução do programa com a estrutura de seleção if: 

a = 10; b = 5;
print(f"a = {a}, b = {b}")
if a > b:
    print("a > b")
else:
    print("a <= b")

você pode usar a estrutura de seleção match para comparar os valores de variáveis com literais ou outras variáveis: 

a = 2
print(f"a = {a}")
match a:
    case 1:
        print("a igual a 1")
    case 2:
        print("a igual a 2")
    case _:
        print("a desconhecido")

Você pode usar a estrutura de repetição while até que uma condição seja atendida: 

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

Você pode usar a estrutura de repetição for para percorrer iteráveis: 

for i in range(-1,-4,-1):
    print(i)

Você pode usar a estrutura de excessão try... except para tratar erros: 

try:
    print(xyz)
except:
    print("xyz não existe")

Talvez você precise de realizar uma tarefa inúmeras vezes, como por exemplo imprimir uma mensagem na tela.

Então você pode criar uma função para isso: 

def imprimir_mensagem(mensagem):
    print(mensagem)

imprimir_mensagem("Esta é uma mensagem")
imprimir_mensagem("Esta é outra mensagem")
imprimir_mensagem("Mensagens usando a função 'imprimir_mensagem'")

As funções podem receber e retornar valores. 

def somar_numeros(a, b):
    return a + b

soma = somar_numeros(1, 2)
print("soma =", soma)

Você pode criar classes para agrupar dados e comportamentos em um mesmo objeto. 

class Animal:
    def __init__(self, nome='indeterminado', tipo='indeterminado', patas=0, asas=0):
        self.nome = nome
        self.tipo = tipo
        self.patas = patas
        self.asas = asas
    def imprimir(self):
        print(f"{self.nome} é um {self.tipo}")
        print(f"Tem {self.patas} patas" if self.patas > 0 else "Não tem Patas")
        print(f"Tem {self.asas} asas" if self.asas > 0 else "Não tem Asas")

class Humano(Animal):
    def __init__(self, nome):
        super().__init__(nome, 'humano', 2)

class Gato(Animal):
    def __init__(self, nome):
        super().__init__(nome, 'gato', 4)

class  Cachorro(Animal):
    def __init__(self, nome):
        super().__init__(nome, 'cachorro', 4)

class Passaro(Animal):
    def __init__(self, nome):
        super().__init__(nome, 'pássaro', 2, 2)

roberto = Humano("Roberto")
roberto.imprimir()

print()

felix =  Gato("Felix")
felix.imprimir()

print()

scooby = Cachorro("Scooby")
scooby.imprimir()

print()

piupiu = Passaro("Piupiu")
piupiu.imprimir()

A classe Animal herda a classe object.

Os métodos das classes objects e Animal podem ser obtidos com a função dir(). 

metodos_object = dir(object)
print("Metodos da classe 'object'")
print(metodos_object)
print()
metodos_animal = dir(Animal)
print("Metodos da classe 'Animal'")
print(metodos_animal)

Os métodos da classe Animal que não existem na classe object podem ser obtidos com o uso da função intersection() dos conjuntos set(). 

an = set(dir(Animal))
ob = set(dir(object))
dif = [x for x in an.difference(ob)]
print(dif)

Os métodos da classe Animal que não existem na classe object podem ser obtidos na diferença em dif que não são métodos dunder, iniciados e terminados por "__". 

dif = [x for x in dif if not (x.startswith('__') and x.endswith('__'))]
print(dif)

A linguagem Python é vasta, principalmente porque você poderá agregar dezenas ou mesmo centenas de novos pacotes aos seus aplicativos, descobrindo e assimilando os comandos de que precisará para executar cada uma das instruções necessárias à medida que for evoluindo em seus programas e sistemas, absorvendo mais instruções e recursos.

A linguagem Python é interpretada e existem diferentes Programas-Interpretadores da linguagem, como o Python Oficial (www.python.org) e o Anaconda (www.anaconda.com).

O Programa-Interpretador é arquivo-executável chamado a partir da linha de comando do CLI do SO (Sistema-Operacional) e que roda o interpretador da linguagem Python.

Os diferentes Programas-Interpretadores rodam, mantendo total compatibilidade de sintaxe e semântica da linguagem, na maioria dos SOs de computadores clientes e servidores existentes: Windows, Linux, Mac etc.

Os Programas-Interpretadores têm dois modos de funcionamento: Modo-Interativo e Modo-Lote.

  • No Modo-Interativo o programa não carrega um arquivo-texto e o Programa-Interpretador disponibiliza uma CLI (Command-Line-Interface) para o programador, na qual pode escrever e executar instruções Python.
  • No Modo-Lote o Programa-Interpretador abre e executa um arquivo-texto com extensão ".py", passado como argumento na chamada para execução do Python, finalizando sua execução após o final da execução do arquivo.

Os Scripts-Python são os programas escritos em Python, geralmente disponibilizados a partir de arquivos-texto com extensão ".py". Estes scripts funcionam com todos Programas-Interpretadores de modo uniforme, sem a necessidade de adaptações específicas.

Também, existem programas GUI (Graphical User Interface, ou Interface Gráfica de Usuário) que permitem grande interatividade do programador com o Python, como o MS Visual Studio, MS VSCode, o Jupyter-Lab, o Jupyter Notebook e sites como o Kaggle.

Termos-chave Utilizados

Utilizaremos alguns termos-chave no curso a fim de facilitar a compreensão do conteúdo.

  • Python: Linguagem de programação interpretada e de uso geral.
  • Programa-Interpretador: Programa executável que interpreta a linguagem Python.
  • Arquivo-Python: Arquivo de texto com extensão ".py", contendo um conjunto de Instruções-Python compondo os algoritmos de um aplicativo.
  • Extensão-Python: Extensão do Arquivo-Python contendo o script da linguagem Python, normalmente ".py".
  • Sistema-Operacional: Sistema operacional em que roda o interpretador da linguagem Python.
  • SO: Sistema-Operacional.
  • CLI: Command-Line-Interface (interface de linha de comando).
  • Prompt-SO: Prompt no CLI para entrada e execução de comandos do SO.
  • Prompt-Python: Prompt do CLI para entrada e execução de comandos (com Instruções-Python) do Programa-Interpretador.
  • Script-Python: Texto contendo uma ou mais instruções compondo os algoritmos e aplicativos interpretados pelo Python.
  • Modo-Interativo: Modo interativo de execução do Programa-Interpretador em que o programador pode executar instruções na CLI do Python.
  • Modo-Lote: Modo de execução do Programa-Interpretador em que o programador pode executar as instruções Python presentes no Script-Python de um Arquivo-Python.
  • GUI-Python: Interface gráfica para interpretação e programação da linguagem Python.
  • Instruções-Python: Instruções da linguagem Python.
  • Console-Python: Console de apresentação de resultados durante a execução de Instruções-Python, que pode ser o console da CLI do Programa-Interpretador, ou o console da CLI do SO se o Programa-Interpretador estiver em execução no sistema operacional usando o Modo-Lote.
  • Ambiente-Contextual: Ambiente de execução do Python, normalmente referido como Context ou Contexto. Novos contextos locais podem ser criados com a palavra-reservada with.
  • Máquina-Virtual: A porção nativa central de código do Programa-Interpretador, sem considerar códigos adicionados ao Ambiente-Contextual com o uso de pacotes e módulos importados, e códigos agregados pelo programador.
  • Biblioteca-Padrão: Conjunto de pacotes nativos do Python.

Autores

Roberto Teixeira

Betobyte

Cientista de Dados

CIEDA

cieda.com.br

roberto@cieda.com.br

Autor

Carlos Delfino

Arduino

Cientista de Dados

Basicão da Eletrônica

www.carlosdelfino.eti.br

consultoria@carlosdelfino.eti.br

Coautor

1.1 - Breve história

O Python foi concebido no final de 1989 por Guido van Rossum no CWI - Research Institute for Mathematics and Computer Science in the Netherlands (Instituto de Pesquisa Nacional para Matemática e Ciência da Computação nos Países Baixos), como um sucessor da linguagem ABC, capaz de tratar exceções e prover interface com o sistema operacional Amoeba através de scripts.

Python foi feita com base na linguagem ABC, possui parte da sintaxe derivada do C, compreensão de listas, funções anônimas e função map de Haskell. Os iteradores foram baseados na Icon, tratamentos de exceção e módulos na Modula-3, expressões regulares na Perl.

Também da CWI, a linguagem ABC era mais produtiva que C, ainda que com o custo do desempenho em tempo de execução. Mas ela não possuía funcionalidades importantes para a interação com o sistema operacional, uma necessidade do grupo. Um dos focos primordiais de Python era aumentar a produtividade do programador.

Em fevereiro de 1991, Van Rossum publicou o código do Python, rotulado com a versão 0.9.0, para alt.sources.

Já estavam presentes neste estágio de desenvolvimento classes com herança, tratamento de exceção, funções e os principais tipos de dados (list, dict, str etc).

O sistema de módulos emprestado do Modula-3, uma linguagem-conceito da época, tornou-se uma das principais unidades de programação do Python.

Em 1994 comp.lang.python, o principal fórum de discussão de Python, foi formado, marcando um marco no crescimento da base de usuários do Python.

1.1.1 - Python 1.0

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.

1.1.2 - Python 2.0

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.

1.1.3 - Python 3.0

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.

1.2 - Instalação

A linguagem de programação Python é conhecida por sua simplicidade e versatilidade, sendo amplamente utilizada tanto para desenvolvimento de aplicativos desktop quanto para aplicações em servidores-web. Este texto oferece um guia conciso sobre a instalação do Python e explora suas funcionalidades básicas, bem como as possibilidades ampliadas por meio da importação de pacotes adicionais.

O processo de instalação do Python é bastante simples e fácil, começa com o download do instalador oficial disponível no site Python.org, no endereço https://python.org/downloads. Utilizaremos o Python Oficial como base de produção. O que serve ao Python Oficial, serve a outros Programas-Interpretadores.

A instalação é direta, guiada por um conjunto de instruções claras que acompanham o instalador.

Um dos passos cruciais durante a instalação é a adição do diretório do Python ao "PATH" do sistema operacional. Esta ação é fundamental porque permite que os aplicativos sejam localizados e executados pelo sistema operacional sem a necessidade de especificar o caminho completo para o executável do Python.

Após a instalação, o usuário se depara com o Python em sua forma mais básica, que apesar de limitada em termos de interação com o usuário (suportando basicamente os comandos input para entrada de dados e print para saída), serve como um ponto de partida robusto para programação geral. Essas funcionalidades são adequadas para Scripts-Python simples e automações que não requerem interfaces gráficas complexas ou manipulação avançada de dados.

Para executar o Python inicie o Prompt-SO (operating system shell, ou concha do sistema operacional), como por exemplo o cmd do Windows.

Para aqueles que necessitam de mais recursos, o Python oferece a possibilidade de estender suas capacidades por meio da importação de pacotes. Esses pacotes podem ser facilmente adicionados e integrados ao Python, enriquecendo a linguagem com novas funcionalidades para entrada, operação e saída de dados. Com esses pacotes, desenvolvedores podem criar interfaces mais ricas e interativas, que são essenciais para aplicações mais complexas.

Além do desenvolvimento de Aplicativos-Desktop, o Python também se destaca no desenvolvimento de back-end para sistemas web. Com frameworks como Django e Flask, o Python permite o desenvolvimento de aplicativos servidores robustos, capazes de gerenciar a retaguarda de sistemas-web complexos. Esses frameworks oferecem ferramentas poderosas que facilitam o desenvolvimento rápido e seguro de aplicações web, incluindo funcionalidades como autenticação de usuários, gestão de sessões, e interação com bases de dados.

Python é uma ferramenta extremamente versátil e acessível para programadores de todos os níveis. Desde tarefas de programação básica até o desenvolvimento de sistemas complexos para a web, o Python se adapta às necessidades do usuário. A facilidade de instalação e a vasta gama de pacotes disponíveis permitem que qualquer um comece rapidamente e expanda suas habilidades conforme necessário. Graças à sua natureza aberta e sua comunidade ativa, Python continua a ser uma escolha popular entre programadores ao redor do mundo.

1.3 - Python

Python é uma linguagem interpretada e por isso você pode economizar um tempo considerável durante o desenvolvimento, uma vez que não há necessidade de compilação e vinculação (linking).

Programa-Interpretador

O programa principal do Python é o Programa-Interpretador, o próprio Python, presente na pasta de instalação e responsável pela executação de instruções e scripts da linguagem.

Inicie o Prompt-SO. 

C:\>

Vá para o diretório de trabalho. 

C:\>cd cieda [ENTRA]

Para executar o Python no Modo-Interativo, digite "Python" sem argumentos no Prompt-SO e pressione a tecla [ENTRA]. 

C:\cieda>Python [ENTRA]

Quando o Python é executado sem argumento entra no Modo-Interativo, disponibilizando o Prompt-Python, para entrada e execução interativa das instruções digitadas pelo programador no prompt. 

>>>

O Prompt-Python funciona de modo semelhante ao Prompt-SO, você comandas as instruções e pressiona [ENTRA].

Repare nas 3 setas >>> utilizadas para navegação no prompt.

Modo-Interativo

No Modo-Interativo o programador digita no Prompt-Python os comandos com instruções da linguagem e pressiona a tecla [ENTRA] para executá-los. 

>>>10 + 5 [ENTRA]
15

No exemplo acima, o Prompt-Python é usado como simples calculadora, onde o programador digita a instrução de soma dos valores 10 e 5 e pressiona [ENTRA] para executá-la, apresentando o resultado de 15 logo abaixo no Console-Python.

Como o Programa-Interpretador pode ser usado interativamente, é fácil experimentar diversas características da linguagem, como o programador escrever programas “descartáveis”, ou testar funções em um desenvolvimento de baixo para cima (bottom-up). É também uma calculadora bastante útil quando você precisa realizar cálculos matemáticos, principalmente os mais complexos.

As instruções dos comandos do programador, digitadas no Prompt-Python, são interpretadas em tempo real, assim que são digitadas e executadas com a tecla [ENTRA]. O resultado é impresso no console de saída do Python, ou armazenado em uma variável para uso nas instruções seguintes.

Modo-Lote

No Modo-Lote o Programa-Interpretador é chamado e executado acompanhado com o nome de um Arquivo-Python (com extensão ".py"), que é aberto, lido e o Script-Python carregado, interpretado e executado. Ao término do Script-Python, o Programa-Interpretador é finalizado, sem que o modo interativo seja disponibilizado ao utilizador.

As instruções contidas nos Arquivos-Python são interpretadas sequencialmente, linha por linha, executadas na ordem em que estão declaradas no arquivo.

Se o programador tiver carregado o Python no Modo-Interativo, poderá executar um programa a partir do Prompt-Python, em Modo-Lote, retornando o controle ao Prompt-Python após o programa ser executado.

Linguagem extensível com pacotes

Python é extensível! É fácil adicionar pacotes com módulos contendo métodos e atributos para serem utilizados diretamente no Programa-Interpretador no Modo-Interativo ou no Modo-Lote, seja para desempenhar operações críticas em máxima velocidade com código C integrado, ou para vincular programas Python a bibliotecas que só estejam disponíveis em formato binário (como uma biblioteca gráfica de terceiros).

Você pode vincular o Programa-Interpretador a uma aplicação escrita em outra linguagem, como C, e utilizá-la como linguagem de comandos ou extensão para esta aplicação.

Máquina-Virtual

O Programa-Interpretador, presente no diretório de instalação, ao ser executado, carrega uma Máquina-Virtual que disponibiliza o Prompt-Python em Modo-Interativo, onde o programador digita seus comandos com instruções da linguagem, ou roda um Arquivo-Python em Modo-Lote.

A Máquina-Virtual é a camada de código-executável do Python com as funcionalidades básicas da linguagem, abaixo da camada do interpretador, rodando as instruções comandadas em lote em programas contidos nos Arquivos-Python, no Modo-Lote, ou com o programador digitando as instruções no Prompt-Python, no modo-interativo.

O fluxo a seguir é do Prompt-SO (prompt do sistema operacional), passando pelo inicializador do Python, que direciona para o Modo-Interativo ou Modo-Lote, e depois para o interpretador, que executa os comandos na máquina virtual.

flowchart TD MC[Máquina-virtual] MI[Modo-Interativo] --> |Executando arquivo '.py'?|MB I[Programa-Interpretador]-->|Modo-Interativo?|MI PSO[Prompt-SO] PSO-->PY[Python] PY-->MI PY-->|Tem arquivo '.py'?|MB MI-->|Tem comando?|I MB[Modo-Lote]-->I I-->MC I-->PI[Pacotes Instalados] I-->|Instrução Quit?|FIM I-->|Modo-Lote sem modo interativo?|FIM

Vamos analisar cada passo:

  • Prompt-SO: O processo começa no prompt do sistema operacional, onde o usuário pode iniciar o Python.
  • Python: Após ser iniciado, o Python pode ser iniciado para operar em dois modos principais:
    • Modo-Interativo: Este é o modo que permite aos usuários inserir comandos Python diretamente no Prompt-Python e receber respostas imediatas. Aqui, o diagrama verifica se o Python está operando em modo interativo. Se estiver em modo interativo, o sistema verifica se há comandos sendo inseridos pelo usuário.
    • Modo-Lote: Neste modo, Python executa um arquivo ".py", processando todo o script de uma só vez. Se o Python estiver executando um arquivo ".py", ele seguirá para o Modo-Lote, onde o script inteiro é processado de uma vez, da primeira instrução para a última.
  • Programa-Interpretador: Tanto no modo interativo quanto no modo lote, os comandos ou scripts são enviados para o interpretador Python.
  • Máquina-virtual: Os comandos são processados pela máquina virtual Python, que é onde o código é efetivamente executado.
  • Pacotes Instalados: Os comandos são processado por funções e variáveis presentes nos módulos dos pacotes instalados.

Se o Programa-Interpretador for executado recebendo como argumento o nome de um arquivo com Extensão-Python, irá rodar as instruções presente neste arquivo e encerrar a execução do Python.

Se não receber argumentos, a Máquina-Virtual do Programa-Interpretador irá iniciar o Modo-Interativo, disponibilizando o Prompt-Python para entrada de Instruções-Python pelo programador.

O Programa-Interpretador pode ser executado no Modo-Interativo simplesmente clicando-se no ícone presente no diretório de instalação do Python, usando a interface gráfica do SO, ou sendo iniciado a partir do prompt-SO.

Usando o cmd do Windows: 

> python [ENTRA]

O símbolo > indica o Prompt-SO.

O Programa-Interpretador do Python é executado pelo SO, a Máquina-Virtual é carregada, disponibilizando o Prompt-Python para o programador digitar os comandos com Instruções-Python. 

>>>

O símbolo >>> indica que o prompt-Python está disponível e pronto para entrada de comandos com as instruções da linguagem pelo programador.

Prompt-Python

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

Assim, o programador pode desenvolver interativamente seu aplicativo, incorporando posteriormente os comandos digitados em um Arquivo-Python, formando o Script-Python final.

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 ser 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]

O Prompt-Python 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 acima, com uma instrução apenas, será executado e imprimirá o resultado no console: 

1
2
3

1.4 - Linguagem

Python é uma linguagem de programação de alto nível, amplamente conhecida por sua simplicidade e legibilidade do código.

Foi projetada por Guido van Rossum e lançada pela primeira vez em 1991, e suporta múltiplos paradigmas de programação, incluindo programação imperativa, orientada a objetos e funcional.

Python é conhecida por sua filosofia de "Zen of Python", que enfatiza a importância da legibilidade do código e a simplicidade.

Com uma grande biblioteca padrão e suporte extensivo para módulos e pacotes externos, a linguagem Python é utilizada em uma ampla gama de aplicações, de scripts simples a sistemas.

Vamos explorar os principais tipos de comandos e instruções nativos que compõem a linguagem:

Literais

Em linguagens de programação, literais são notações no código fonte que representam valores fixos, nativos dos tipos primitivos da linguagem, chamados de constantes e usados para valores independentes de função.

Os literais são usados para inicializar variáveis ou constantes com valores específicos diretamente no código.

Aqui está uma explicação sobre como literais são definidos em geral e os tipos comuns de literais que você pode encontrar na maioria das linguagens de programação:

  • Literais inteiros: Representam valores numéricos sem uma parte fracionária. Podem ser especificados em diferentes bases, como decimal, hexadecimal (prefixado com 0x ou 0X), ou octal (tradicionalmente prefixado com 0). Exemplo: 10, 0xFF, 075.
  • Literais de ponto flutuante: Usados para representar números com partes fracionárias ou em formato de notação científica. Exemplos: 3.14, 2.5e3 (o que representa 2.5 × 10³ ou 2500).
  • Literais de caracteres: Representam um único caractere dentro de aspas simples. Exemplo: 'a', '1', '%'. Em algumas linguagens, caracteres especiais podem ser representados usando escape, como '\n' (nova linha) ou '\t' (tabulação).
  • Literais de textos: Sequências de caracteres usados para representar textos (strings), geralmente envoltos em aspas duplas ou simples. Exemplos: "Olá, mundo!", 'Python é legal'.
  • Literais Booleanos: Representam verdadeiro ou falso. Em muitas linguagens como Python, Java e C++, os valores booleanos são true e false. No Python, eles são True e False.
  • Literal Nulo: O literal nulo é usado para representar a ausência de um valor ou um ponteiro nulo. Dependendo da linguagem, podem ser representados como null, NULL, None, ou até mesmo nil. No Python é None.

Tipos de Dados Básicos

No Python os dados são objetos de diferentes tipos.

Objetos são instâncias na memória do computador, de diferentes classes.

As classes são estruturas contendo atributos e métodos.

Os tipos de dados básicos integrados ao Python são:

  • Númerico: Objetos numericos do tipo int (números inteiros), float (números de ponto flutuante) e complex (números complexos).
  • Texto: Objetos do tipo str com caracteres declarados entre aspas simples ou duplas.
  • Booleano (bool): Objeto do tipo bool de valores lógicos verdadeiro (True) ou falso (False).
  • Nulo: None, usado para representar a ausência de valor.

Python oferece coleções incorporadas aos tipos de dados nativos:

  • Listas: Objetos do tipo list de coleções ordenadas e mutáveis de itens.
  • Tuplas: Objetos do tipo tuple de coleções ordenadas e imutáveis de itens.
  • Dicionários: Objetos do tipo dict de pares chave-valor sem ordem fixa.
  • Conjuntos: Objetos do tipo set de coleções não ordenadas de itens únicos, não repetidos.

Os dados de diferentes tipos são normalmente atribuidos a variáveis.

Variáveis

As variáveis são identificadores que são usadas para armazenar valores de diferentes tipos de dados, criadas no momento em que valor são atribuidos a elas.

No Python são normalmente escritas com nomes significativos e descritivos, com grafia usando letras minúsculas e sem espaços, algumas vezes utilizando o caracter _ (traço baixo ou underline).

Operações, Operandos e Operadores

O python suporta uma variedade de operações aritméticas, de comparação, lógica e atribuição, envolvendo operandos conectados por operadores.

Os operandos são os termos unitários ou compostos de uma expressão utilizando os operadores.

Python suporta uma variedade de operadores:

  • Aritméticos: +, -, *, /, //, % e **, para operações de soma, subtração, multiplicação, divisão, divisão inteira, resto (módulo) e potenciação.
  • Comparação: ==, !=, >, <, >= e <=, para comparações de igualdade, desigualdade, maior que, menor que, maior ou igual que e menor ou igual que.
  • Lógicos: and, or e not, para operações lógicas de e, ou, negação.
  • Atribuição: =, +=, -=, *=, /=, //=, %=, **=, &=, |=, ^=, >>= e <<=, para operações de atribução e atualização de valores de variáveis.

Controle de Fluxo

Os controles de fluxo permitem que o Python execute instruções condicionais e loops:

  • Instruções condicionais: Blocos if... elif... else e match... case... case _ para execução condicional de código.
  • Laços de repetição(loops): Blocos for para iterar sobre sequências e while para repetir enquanto uma condição for verdadeira.
  • Controles de laço: instruções break para sair de um laço e continue para pular para a próxima iteração do laço, pass como uma operação nula.

Funções e Gerenciamento de Escopo

As funções permitem que o Python execute código com diferentes argumentos e retornos:

  • Definição de função: palavra-reservada def seguido pelo nome da função e argumentos e funções anônimas (lambda).
  • Escopo de variável: local, envolvente, global e integrado (LEGB - Local, Enclosing, Global, Built-in).
  • Retorno de função: palavra-reservada return para retornar um valor.

Tratamento de Exceções

O tratamento de exceções permite que o Python execute código para tratar erros:

  • Bloco try... except: o bloco try... except é uma estrutura que captura e trata exceções que possam ocorrer dentro do bloco try.
  • Bloco else: o bloco else executa o código se nenhuma exceção for levantada.
  • Bloco finally: o bloco finally executa o código independente da ocorrência de exceções.
  • Raise: a palavra-reservada raise permite que o Python gere e lance uma exceção intencionalmente.

Importações

As importações de pacotes permitem que o Python importe módulos e bibliotecas:

  • Importação de pacotes: a diretiva "import " importa um pacote e seus módulos.
  • Importação de módulos: a diretiva "from import nome-do-módulo" importa um módulo específico de um pacote, ou "from import *" para importar todos os módulos de um pacote.
  • Importação de todos módulos: a diretiva "from import *" importa todos os módulos de um pacote.

Programação Orientada a Objetos

A programação orientada a objetos (POO) permite que o Python construa classes e objetos:

  • Classes e Objetos: a palavra-reservada class inicia a criação de novas classes.
  • Herança: derivação de novas classes a partir de classes ancestrais existentes, com sobreposição de métodos existentes nas classes ancestrais.
  • Métodos Especiais (Métodos Mágicos, Dunder Methods): Sobreposição de métodos especiais como __init__(), __str__() etc, para operações de inicialização, representação da classe etc.

Compreensões

As compreensões permitem que o Python construa listas, dicionários e conjuntos usando-se coleções de listas, tuplas, dicionários e conjuntos:

  • Compreensões de Lista: programação funcional para construção de listas, usando-se coleções.
  • Compreensões de Dicionário: programação funcional para construção de dicionários, usando-se coleções.
  • Compreensões de Conjunto: programação funcional para construção de conjuntos, usando-se coleções.

Iteradores e Geradores

Os iteradores permitem a criação de objetos que permitem iteração sobre sequências de itens, e geradores que possam operar sem a necessidade de armazená-los completamente na memória.

  • Iteradores: uso das palavras-reservadas iter e next para iterações sequenciadas.
  • Geradores: funções com a palavra-reservada yield para criação de geradores que permitem iteração sobre sequências de itens sem a necessidade de armazená-los completamente na memória.

1.5 - Pacotes e Módulos

Pacotes são basicamente um conjunto de módulos com programas contidos em Arquivos-Python (arquivos arquivos-texto com extensão ".py") contendo objetos de classes com atributos e métodos próprios, provendo alguma funcionalidade comum, e que podem ser usados em outros programas. Um pacote (framework ou biblioteca) é basicamente um módulo que contém um conjunto de módulos e recursos.

Os pacotes são uma maneira de estruturar o “espaço de nomes” dos módulos Python, usando “nomes de módulo com pontos”. Por exemplo, o nome do módulo A.B designa um submódulo chamado B, em um pacote chamado A. Assim como o uso de módulos evita que os autores de módulos diferentes tenham que se preocupar com nomes de variáveis globais, o uso de nomes de módulos com pontos evita que os autores de pacotes com muitos módulos, como NumPy ou Pillow, tenham que se preocupar com os nomes dos módulos uns dos outros.

Ao sair e entrar de novo no Programa-Interpretador, as definições de funções e variáveis são perdidas e, portanto, para escrevermos um programa maior, será mais eficiente usar um editor de textos para preparar as instruções em um script e executá-lo usando o arquivo como entrada para o Programa-Interpretador.

O Interpretador, ao ser executado recebendo como argumento o nome de um Arquivo-Python, rodará as instruções contidas no script do arquivo.

Se o programa se torna ainda maior, é uma boa prática dividi-lo em arquivos menores, para facilitar a manutenção.

Também é preferível usar um arquivo separado para uma função que você escreveria em vários programas diferentes, para não copiar a definição de função em cada um deles.

Para permitir isso, o Python tem uma maneira de colocar as definições em um arquivo e então usá-las em um script ou em uma execução interativa do Interpretador.

Tal arquivo é chamado de pacote de módulos; definições de um módulo podem ser importadas para outros módulos, ou para o módulo principal (a coleção de variáveis a que você tem acesso num script executado como um programa e no modo interativo).

Um módulo é um arquivo contendo definições e instruções Python, onde o nome do arquivo é o nome do módulo acrescido do sufixo ".py".

Dentro de um módulo, o nome do módulo (como texto) está disponível como o valor da variável global __name__.

Digite no Prompt-SO: 

> python nome-do-app.py [ENTRA]

onde nome-do-app.py é o nome do Arquivo-Python contendo as instruções do programa.

Pacotes nativos

  • os: módulo com dúzias de funções para interagir com o sistema operacional.
  • glob: módulo com uma função para criação de listas de arquivos, a partir de buscas em diretórios, usando caracteres-curinga.
  • sys: pacote para processamento dos argumentos passados na linha de comando, armazenados como uma lista no atributo argv do módulo sys.
  • math: pacote com métodos e constantes matemáticas para calcular e resolver combinações e permutações usando fatoriais, funções trigonométricas, periódicas, exponenciais e hiperbólicas e equações quadráticas.

Pacotes populares

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 individuais 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 (ORM - Object Relational Mapper) 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.

Instalação com PIP

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

Importação

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
Arduino
Coautor
Betobyte
Autor
Autores
||| Áreas ||| Estatística ||| Python ||| Projetos ||| Dicas & Truques ||| Quantum ||| Python Básico || Python para Iniciantes || Python Básico || Matplotlib || Numpy || Seaborn || Pandas || Django || Estatística para Cientistas de Dados || Python com ML Básico || Python com ML Básico || Aulas | Introdução (sintaxe, comentários, variáveis, tipos) | Instalação (instalação, execução) | Sintaxe e semântica (sintaxe, semântica, variáveis, tipos de dados, blocos e recuos, comentários) | Tipos (números, strings, booleanos, datas, listas, tuplas, conjuntos, dicionarios, conversão) | Operadores (aritméticos, atribuição, comparação, lógicos, identidade, associação, bitwise) | Blocos (se-senão, laços, funções, classes, iteradores, escopo) | Funções (Funções nativas do Python) | Classes (Classes e Objetos no Python) | Entrada/Saída (teclado, tela, arquivo) | Módulos (pip, instalação, importação) |