1

Sumário

UNIDADE I................................................................................................................................. 4
Introdução ............................................................................................................................ 4
Instalação ............................................................................................................................. 5
A Linguagem De Programação Python ................................................................................... 6
Sintaxe Para Programação Python ....................................................................................... 11
Conclusão ........................................................................................................................... 16
UNIDADE II.............................................................................................................................. 17
Introdução .......................................................................................................................... 17
Tipos e Estruturas De Dados ................................................................................................ 18
Manipulação De Strings....................................................................................................... 22
Conclusão ........................................................................................................................... 32
UNIDADE III............................................................................................................................. 33
Introdução .......................................................................................................................... 33
Expressões e Operadores Aritméticos ................................................................................. 34
Operadores Relacionais....................................................................................................... 36
Operadores Lógicos............................................................................................................. 37
Operadores Compostos De Atribuição................................................................................. 39
Entrada e Saída ................................................................................................................... 42
Conclusão ........................................................................................................................... 47
UNIDADE IV ............................................................................................................................ 48
Introdução .......................................................................................................................... 48
Arquivos De Texto ............................................................................................................... 49
Estruturas De Controle De Fluxo De Execução ..................................................................... 52
Estrutura De Decisão ........................................................................................................... 52
Estrutura De Repetição ....................................................................................................... 56
Funções .............................................................................................................................. 60
Conclusão ........................................................................................................................... 65
UNIDADE V ............................................................................................................................. 66
Introdução .......................................................................................................................... 66
Orientação a Objetos .......................................................................................................... 67
Herança em Orientação a Objetos ....................................................................................... 69
Métodos Complementares .................................................................................................. 72

2
Módulos.............................................................................................................................. 75
Conclusão ........................................................................................................................... 82

3
UNIDADE I

Introdução

Python é uma linguagem de propósito geral capaz de atender a diversos tipos

de demandas no desenvolvimento de software. É uma linguagem interpretada,
ou seja, depende de um software instalado capaz de executar toda a sequência
de código escrita após verificação da semântica e sintaxe dos códigos.

Pode ser aplicada para desenvolvimento de aplicações web usando Django ou

Bottle, por exemplo, programação matemática e computacional utilizando
Orange, SymPy ou NumPy, por exemplo), aplicativos comuns para desktop
usando PyQt ou PyWidgets, por exemplo, e jogos com Pygame e Panda3D, por
exemplo.

Por ser uma linguagem com licença do tipo open source (aberta), existe uma
grande comunidade de desenvolvedores que auxiliam no desenvolvimento
constante da linguagem, sua difusão e desenvolvimento de bibliotecas.

A biblioteca padrão da linguagem possui centenas de módulos divididos em

diversas categorias, podendo ser utilizada para o desenvolvimento de aplicações
tanto comerciais como não comerciais. Além da biblioteca padrão, existem
milhares de pacotes contidos no gerenciador de pacotes chamado “pip” para
todas as áreas de desenvolvimento permitidas pela linguagem.

Desenvolvida nos anos 1980, e publicada em 1991, foi desenvolvida por Guido
van Rossum e se baseou num show de comediantes ingleses dos anos de 1970
(Monty Python’s Flying Circus) para batizar a linguagem criada.

4
Instalação

A linguagem Python, como as demais linguagens em geral é gratuita, e existe

uma IDE (interface integrada de desenvolvimento) própria e também gratuita que
pode ser obtida gratuitamente na forma de simples download nas diferentes
plataformas compatíveis como ilustrado na figura 1.1 a seguir.

Figura 1.1: Versões para diferentes plataformas para instalação.

Fonte: O autor

Para instalar a IDE em cada plataforma, há um resumo dos procedimentos a

serem efetuados em algumas plataformas disponíveis na figura 1.2.

Windows

Baixe e instale o bundle Anaconda (https://www.continuum.io/downloads,

também disponível para outras plataformas).

Ubuntu

sudo apt install python3-scipy python3-matplotlib

MacOS

5
Instale o Homebrew: https://brew.sh

brew install python3

pip3 install numpy matplotlib

Figura 1.2: Procedimentos para instalação da IDE Python.

Fonte: https://docs.python.org/3/

Na página do site https://docs.python.org/3/ é possível obter documentação

oficial complementar para os estudos desta versão da linguagem.

A Linguagem De Programação Python

Sendo uma linguagem de programação dita de “alto nível”, não há necessidade

de manipulação direta de hardware, e assim, a programação em si se torna mais
fácil por muitos pontos que necessitariam de atenção em uma linguagem de
“baixo nível” em relação a uso e compatibilidades com hardware são
dispensadas, pois são ajustadas automaticamente.

Em função disto, programas criados em linguagens de alto nível necessitam

etapas intermediárias entre a digitação de seu código e sua efetiva execução
sobre o sistema operacional de um hardware.

Este processo gera um tempo extra para que uma aplicação possa ser
executada, o que pode representar um peso maior em algumas aplicações que
em outras, mas o fato de o código poder ser escrito muito mais rapidamente e
sem a necessidade de conhecimento profundo da arquitetura do hardware onde
será executada a aplicação é muito importante.

Outro fato é que um código escrito em linguagens de alto nível acaba tendo
menores quantidades de linhas e sendo mais fáceis de interpretar, tornando
estas, opções preferidas pela maioria dos desenvolvedores.

6
Outra característica da linguagem é sua capacidade de trabalhar com diferentes
paradigmas de programação, ou seja, a estrutura dos códigos criados na
linguagem podem ser implementados de diferentes formas, de forma a oferecer
variadas formas de se desenvolver soluções computacionais.

Um dos paradigmas que podem ser utilizados se chama imperativo, que é o mais
comum e tradicional onde a execução do código segue um fluxo normal, mas
que pode ser desviada sem problemas com estruturas de controle de fluxo. O
objetivo principal deste paradigma é o processamento de dados através de
instruções que mudam os estado das estruturas de dados que contém estes
dados.

Outro paradigma aceito pela linguagem se chama orientado a objetos que se

baseia na definição de objetos que servem como abstrações de problemas reais
a serem computacionalmente implementados e que possam ser modelados em
classes com suas principais características divididas em atributos para os dados
e métodos para processá-los.

Outro paradigma aceito pela linguagem Python é o paradigma funcional que

realiza o processamento computacional com base em funções dinâmicas que
contrastam com as mudanças de estado da programação imperativa, tendo
como base a construção de funções seguindo a lógica matemática na
estruturação de códigos.

Um último paradigma aceito pela linguagem é o procedural que se baseia no

paradigma imperativo, mas que utiliza sub-rotinas para dividir o problema todo
em partes menores que podem ser acionadas a qualquer instante e realizar
processamentos sobre dados como nos demais paradigmas.

Outro tipo de aspecto característico da linguagem Python é que a linguagem

reduz redundâncias e busca a melhor ortogonalidade possível, ou seja, evita que
comandos aceitem muitas exceções, tornando a codificação mais complexa
como na linguagem C, por exemplo, mas isto a torna mais limitada em alguns
aspectos.

7
A linguagem também possui código aberto (open-source), e com isto, foi
adaptada para variadas plataformas como Windows, Android e MacOS, com seu
uso permitido, tanto para uso educacional e científico, quanto comercial.

Através de sua expansibilidade, aplicações podem ser desenvolvidas não

apenas integralmente em Python, mas partes podem ser desenvolvidas em
linguagens como C para melhoria de desempenho e interação com hardware
que é mais completa na linguagem C.

Possui uma grande biblioteca padrão com funcionalidades prontas para uso no
desenvolvimento de interfaces gráficas, trabalho com bases de dados e redes,
por exemplo, assim como bibliotecas desenvolvidas pela comunidade de
desenvolvedores que também adicionam outra grande variedade de código
pronto e livremente utilizável.

Outra característica da linguagem é o fato de ser interpretada, ou seja, não gera

software executável diretamente, e assim, diferencia-se neste aspecto de
linguagens como C que geram aplicações compiladas para serem utilizadas em
sistemas operacionais compatíveis com o compilador.

Uma diferença importante neste caso é que um código compilado em linguagem

C, por exemplo, que gere um software executável, pode ser levado a outro
hardware contendo o mesmo sistema operacional e poderá ser executado sem
que neste outro equipamento haja a necessidade de haver o compilador ou
algum software para auxiliar na execução, a menos que este tenha sido
projetado para funcionar em conjunto com outro software.

Em Python, em função de ser interpretado, este não é compilado e um software

executável não é gerado. Assim, o código, para ser executado, necessita que
todos os outros equipamentos de hardware onde o mesmo deva ser executado
tenham instalados, interpretadores Python compatíveis com o sistema
operacional em uso.

Isto aumenta a portabilidade do código, pois o interpretador é quem se adequa

ao funcionamento do sistema operacional, mas linguagens compiladas também
podem gerar código com alta portabilidade, necessitando apenas serem

8
compiladas em compiladores de cada sistema operacional onde devam ser
executados.

Assim, é perceptível que softwares gerados em linguagens compiladas tendem

a ser mais rápidos em sua execução por funcionarem sozinhos depois de
compilados, e códigos interpretados, tendem a ser mais lentos por terem sua
execução dependente de interpretadores instalados e que para serem
executados antes das aplicações, consomem recursos de hardware.

Para que seja possível a geração de um executável, é preciso que seja instalado
um complemento para a IDE Python chamado de Pyinstaller através do comando
“pip install pyinstaller”. Este comando irá agregar a funcionalidade ao Python na
máquina e assim, é possível gerar um executável a partir de um código usando
o comando “pyinstaller código.py”.

Pelo prompt do Windows ou terminal Linux, por exemplo, é só abrir o arquivo

executável contido na subpasta dist criada na pasta onde foi gravado o arquivo
contendo o código. Em Windows os arquivos executáveis levam uma extensão
.EXE,mas em Linux, a sintaxe muda para “./” seguido do nome do software sem
extensão.

Para gerar um executável compilado em Python, basta chamar a ferramenta de

compilação Python através do comando “pyinstaller” e depois o nome do arquivo
.py que contém o código.

Vantagens e desvantagens de ambos os tipos de formas de execução de

códigos são perceptíveis, e cabe aos desenvolvedores, à escolha pela melhor
opção em cada caso, avaliando custo e benefício, mas não apenas este aspecto
é relevante, pois a ortogonalidade maior ou menor de cada linguagem, sua
biblioteca de funções, recursos da linguagem como criação de aplicações web,
interfaces gráficas, manipulação de hardware e gerenciamento de dados são
aspectos também importantes e com pesos variados em cada tipo de aplicação
a ser desenvolvida.

Em relação à interpretação de código em Python, um aspecto muito importante

é que seu funcionamento permite que seja interativo, e assim, o processo de
interpretação de um código pode ser controlado em tempo real, ou ao invés de

9
um código todo ser fornecido de antemão, e através de um prompt de comandos
fornecido por uma interface do tipo shell (>>>) pode-se ir inserindo um a um os
comandos se desejado como mostrado na figura 1.3.

Figura 1.3: Interface Shell para interpretação de código Python.

Fonte: O autor.

A linguagem permite a criação de aplicações web com ou sem interfaces

gráficas, softwares matemáticos e estatísticos, software para gerenciamento de
dados, aplicações matemáticas complexas e científicas, computação gráfica,
etc.

Graças a esta grande variedade, áreas como Big Data, inteligência artificial e
aprendizado de máquina são altamente exploráveis e ajudaram a impulsionar o
uso da linguagem no mercado de desenvolvimento de software.

A linguagem já sofreu alterações para se adaptar às mudanças na área de

desenvolvimento, como o surgimento e evolução da web, e como a linguagem
conseguiu se desenvolver nas últimas décadas de forma conseguir ser vista
como uma boa opção no mercado.

Com as mudanças e evoluções diferentes versões e atualizações destas versões

foram implementadas e puderam se manter ativas como a versões 2 e 3 e que
certamente continuarão evoluindo por um tempo ainda.

O fato de duas versões estarem ativas ainda é por causa de alguma

incompatibilidade que pode ocorrer entre aplicações desenvolvidas na versão 2

10
para ser executada em um interpretador da versão 3, ou vice-versa, pois a
sintaxe básica e adição ou exclusão de comandos pode ser ajustada por
interpretadores próprios para tal função, mas as bibliotecas podem ou não terem
sido ajustadas, e assim, há o risco do não funcionamento de algumas funções
que poderiam inviabilizar a execução de aplicações.

Existem interpretadores alternativos como Jython e PyPy implementados em

Java e Python, mas a versão oficial CPython é a indicada por garantir maior
compatibilidade com bibliotecas, mesmo não disponibilizando um interpretador
JIT (Just in Time – em tempo real) que gera um código intermediário antes da
primeira execução.

Sintaxe Para Programação Python

A programação em linguagem Python possui algumas particularidades em

relação a sua sintaxe, assim como todas as demais linguagens de programação
possuem, desde sua estruturação de código, símbolos utilizados, e até sua
formatação de código em relação à endentação.

Como não é exclusivamente procedural ou orientada a objetos, não possui uma

função ou outro tipo de sub-rotina obrigatória para a inicialização de seus
códigos, e trabalha em forma de scripts que dispensam ao interpretador a busca
pelo código de um ponto específico para iniciar a interpretação e execução.

Um aspecto fundamental para a construção de códigos em linguagem Python é

que diferentemente da maioria das linguagens de programação tradicionais, a
endentação é fundamental na sintaxe das instruções, e tem ligação direta com a
semântica do código, pois é através deste espaçamento que são indicados
blocos de instruções inclusas em outras instruções, por exemplo.

Se um código não for endentado, não haverá a indicação de blocos de instruções

e todas serão tratadas sequencialmente e estruturas de controle de fluxo da
execução perdem seu sentido nos códigos. Com isto o escopo de cada instrução
se baseia em níveis indicados pela endentação do código. Lembre-se que é

11
preferível o uso de espaços ao invés de tabulações, e o uso conjunto dos dois
tipos de espaçamento num mesmo código pode gerar problemas.

Outro detalhe relevante é que em ambientes Linux e MacOS, por exemplo, é

comum que a primeira linha de um código seja uma shebang (#!/usr/bin/env
python) que indica a estes sistemas operacionais o script possa ser executado
sem que seja necessária uma prévia execução do interpretador.

Códigos em linguagem Python, por recomendação, terminam sem caracteres

especiais, como o ponto e vírgula, muito comum em diversas linguagens, mas
pode ser utilizado. A recomendação é que o código seja baseado em quebras
de linha para finalização linhas de comando.

Mantendo linhas de código com até 79 caracteres por linha, um código se torna
mais fácil de ser interpretado e editado, mas alguns comandos mais longos, ou
que estejam com uma endentação muito a direita podem não caber e para dividir
linhas de comando em mais de uma linha de texto, pode-se encerrar uma linha
com o caractere “\” e continuando um comando na linha de baixo. Outro recurso
é que expressões em parenteses, colchetes e chaves podem ser divididas em
linhas sem o uso da barra invertida. Observe o exemplo da figura 1.4.

Figura 1.4: Exemplo de quebra de linha de código em Python.

Fonte: O autor.

Palavras reservadas são comuns em todas as linguagens de programação e

representam comandos que realizam ações específicas como controle de fluxo

12
ou entrada e saída de dados, por exemplo. A seguir, segue a lista de palavras
reservadas da linguagem Python na figura 1.5.

COMANDO DESCRIÇÃO
and Operador lógico e.
as Cria nome alternativo.
assert Para depuração e validação de condições.
break Interromper laço.
class Definição de classe.
continue Pular para próxima iteração de laço.
def Declaração de função.
del Exluir objeto.
elif Alternativa complementar ao comando if
else Alternativa complementar aos comandos if e elif.
except Complemento do comando try e finally.
False Valor lógico para falso.
finally Complemento do comando try e except.
for Laço de repetição condicional contado.
from Importação de parte de um módulo.
global Declara variável global.
if Comando para estrutura condicional.
import Importar módulo.
in Verificação de presença de conteúdo em listas e dicionários.
is Testa se duas variáveis são iguais.
lambda Declarar função anônima.
None Valor nulo.
nonlocal Declarar variável não-local.
not Operador lógico para não.
or Operador lógico ou.
pass Ignora erro de função vazia sem código, por exemplo.
raise Tratamento pontual de exceção.
return Retorno de uma função.

13
 True Valor lógico para verdadeiro.
try Para tratamento de exceções pelo código.
while Laço de repetição condicional.
with Fechamento de arquivos abertos.
yield Semelhante a return, mas pode haver mais de um retorno.
Figura 1.5: Palavras reservadas da linguagem Python.

Fonte: O autor.

É importante observar que como em outras linguagens, Python é considerada

case sensitive, ou seja, letras maiúsculas e minúsculas são tratadas como
diferentes e comandos devem ser escritos como é o padrão da linguagem, ou o
interpretador as trata como identificadores de estruturas de dados, por exemplo.

Os chamados identificadores são usados para nomear elementos definidos pelo

desenvolvedor e abrangem nomes em geral para estruturas de dados e funções,
por exemplo. Estes identificadores podem iniciar com caracteres maiúsculos e
minúsculos ou com o sublinhado (_ ou underline), e depois, podem conter além
destes caracteres, números no restante dos caracteres do identificador.

Identificadores são nomes em geral utilizados para identificar elementos criados

pelo desenvolvedor durante a implementação de um código para nomear
estruturas de dados, funções e outros elementos que não sejam componentes
padrões da própria linguagem como palavras reservadas, por exemplo.

Assim, seguindo as regras padronizadas de nomenclatura da maioria das

linguagens de programação e garantir maior portabilidade de código, os
identificadores devem ser formados por letras ou pelo caractere “_” como
primeiro caractere do identificador, lembrando que pela linguagem Python ser
case sensitive, maiúsculas e minúsculas são considerados caracteres distintos.

Nomes como: nome, Nome, DADO, Tipo1, valor2, tipo_de_dado e _1 são todos
exemplos válidos de identificadores, mas #dado, 123dado, valor% e ?!@, por
exemplo, são exemplos de identificadores inválidos para a linguagem Python.

14
É interessante seguir padrões de nomenclatura para facilitar a interpretação de
scripts mais longos e manter código dentro de uma regra padrão de digitação de
identificadores, palavras-chave, etc., mas estas regras podem variar quando se
programa em um paradigma ou outro, pois há elementos que constam em um
paradigma e não em outro.

Nomes como “dado”, “Dado” e “DADO” são todos considerados diferentes como
identificadores e podem ser todos os três utilizados num mesmo programa sem
problemas, tirando o fato de poderem confundir o desenvolvedor pela
semelhança.

A partir do segundo caractere, a regra de ser case sensitive se mantém, podem

ser usadas letras maiúsculas ou minúsculas, “_” e números a partir deste
caractere, mas acentuação não é permitida nos caracteres e devem ser omitidos,
mesmo em nomes que no idioma natural do desenvolvedor existam.

Como já citado na linha especial chamada shebang, o sinal de # indica início

para comentários em finais de linhas para facilitar a interpretação de linhas de
comandos, instruções completas, blocos de instruções, etc.

15
Conclusão

Nesta primeira unidade foi possível conhecer alguns aspectos básicos iniciais da
linguagem Python como sua instalação de diferentes formas para preparação
dos estudos.

Também é estudada a forma como são executados os scripts gerados em

Python e conceitos iniciais para compreensão da linguagem, paradigmas aceitos
de programação e pontos de atenção em relação à forma como são estruturados
códigos na linguagem.

A sintaxe básica para implementação de código em linguagem Python também

é comentada para permitir que o estudante possa ter uma noção básica antes
de se aprofundar nos detalhes do desenvolvimento na linguagem.

Foram apresentadas as palavras-chave da linguagem e uma breve descrição de

suas funções, assim como conceitos sobre definição de identificadores a partir
de regras para elaboração de nomes.

Na próxima unidade, iniciam os estudos de detalhes mais técnicos como tipos

de dados e sua manipulação, tendo certo destaque para a manipulação de dados
do tipo texto.

16
UNIDADE II

Introdução

Nesta segunda unidade, conceitos ligados ao uso de dados simples como

números inteiros e decimais, e como devem ser definidas estruturas mais
complexas como listas compostas por dados simples.

Também são diferenciadas as estruturas mais complexas citando tuplas, listas,

conjuntos e dicionários que possuem todas formas mais adequadas de uso de
acordo com o uso dos dados que podem ser contidos nestas.

Um tipo especial de estrutura de dados que possui atenção especial nesta

unidade é a string que representa texto em geral que pode ser manipulado e
possui muitas aplicações em Python.

17
Tipos e Estruturas De Dados

Os dados são tratados em todas as linguagens de programação, pois o

processamento de dados é base da computação e praticamente todos os
softwares são desenvolvidos com o intuito de lidar com dados.

Os dados, ao longo do tempo, foram ganhando cada vez mais importância,

devido ao que representavam para o mercado e para a sociedade. À medida que
mais e mais dados foram sendo acumulados em sistemas e na Internet, sua
relevância e consequentemente, sua importância foi crescendo rapidamente, ao
ponto de hoje haverem estudos de como lidar com estes imensos volumes de
dados acumulados e disponíveis.

Até algum tempo, este acúmulo todo de dados era pouco explorado e tinha um
caráter mais de registro histórico, mas com o passar do tempo, foi percebido o
grau de informação que mesmo dados históricos poderiam trazer ao mercado, e
complementar estratégias mercadológicas em geral.

A chamada ciência de dados trata de como trabalhar dados de diferentes formas

e volumes com o objetivo de extrair deles novas informações relevantes e que
podem ser obtidas de forma simples ou complexa. Sistemas especialistas
buscam dados em bases isoladas ou unificadas de forma a trazer, através de
pesquisas mais profundas, resultados antes quase impossíveis em função da
menor especialização dos mecanismos de tratamento de dados.

Assim, cada linguagem trata dados de acordo com suas características e

propósito, variando em quantidade e complexidade em cada linguagem, mas
sempre tendo como básicos tipos capazes de lidar ao menos com caracteres
em geral e números inteiros ou decimais.

Em Python, existem os tipos mais simples como números inteiros, booleanos

para verdadeiro e falso, decimais que aceitam casas decimais e números
complexos. Os números booleanos são representados por 0 para falso e 1 para
verdadeiro, não se utilizando de palavras reservadas, por exemplo nesta
representação.

18
Os números inteiros aceitam quaisquer números sem casas decimais não tendo
limitações pré-definidas, mas apenas o esgotamento dos recursos de hardware
como limite, e assim, a linguagem pode lidar com números inteiros com muitos
dígitos.

Os números decimais ou de ponto flutuante permitem a inclusão de casas

decimais nos números a serem utilizados, e que por aceitarem altos valores e
muitas casas decimais, podem sofrer com algumas imprecisões nos cálculos
devido ao método de cálculo realizado pelos computadores com base em bits.

Os números complexos que são reconhecidos pela letra j ao final de cada

número. Este tipo de número é usado em casos onde não seja possível uma
representação de um valor em termos de números inteiros ou decimais.

Um caso pode ocorrer, por exemplo, em equações do segundo grau do tipo Ax 2

- Bx + C = 0 onde resultados podem terminar com uma parte representada pela
raiz quadrada de -1, por exemplo, e isto não pode ser calculado, sendo então
substituído pela letra “j” como uma representação imaginária do que poderia
valer esta raiz, e considera-se a letra e esta nunca será substituída por valor
alguma, a menos que numa operação, o significado da letra não seja mais
relevante.

Outro tipo de dado é chamado de coleção e engloba estruturas de dados que

podem armazenar outras do mesmo tipo, ou de tipos diferentes como listas com
elementos indicados entre colchetes, tuplas com elementos não alteráveis
indicados por parênteses, conjuntos com elementos que podem ser alterados
com operações de conjuntos e indicados por chaves.

Finalmente, um tipo importante de coleção é o tipo dicionário que permite tipos

mais complexos em forma de sequência não ordenada e com cada elemento
podendo conter mais de um dado de tipos variados, por exemplo. A seguir, a
figura 2.1 traz alguns exemplos de uso de coleções em Python.

lista = ['A', 'B', 5, 6]

lista = lista + [8, 9]

19
tupla = ( 1, 2, 3, 4)
conjunto = {1, 2, 3, 4, 5}
dicionário = {1:’A’, 2:’B’, 3:’C’}
Figura 2.1: Exemplos de coleções de dados em Python.

Fonte: O autor.

O primeiro e segundo exemplos da figura 2.1 são complementares, e no primeiro,

uma lista é criada com quatro elementos, e no segundo exemplo, a mesma é
ampliada com o acréscimo de mais 2 elementos. Neste tipo de estrutura, a
mesma pode ser ampliada, reduzida e ter seus elementos modificados.

No terceiro exemplo, uma tupla é definida com quatro elementos, e estes não
podem ser modificados e nem a estrutura da tupla pode ser modificada, sendo
assim uma espécie de constante, que por este motivo possui desempenho mais
rápido em operações de busca, por exemplo.

No quarto exemplo, um conjunto é definido com cinco elementos e estes não

podem ser repetidos, tendo também um acesso mais rápido em operações, além
de permitir operações matemáticas de conjuntos como união, diferença e
intersecção, por exemplo.

Por fim, o quinto exemplo traz um dicionário contendo 3 pares de elementos,

onde um elemento serve como chave para o outro de cada par de dados que
representa uma unidade na estrutura. Assim, neste exemplo, 1 é chave para ‘A’,
e assim por diante.

As strings representam outro tipo importante de dado e são representadas por

sequências de um ou mais caracteres que sempre devem ser indicadas com o
uso de aspas simples ou duplas. Em Python as strings são consideradas
constantes e por isto, não podem ser alteradas, mas podem ser ter seus
caracteres acessados por meio de índices de 0 até o número de caracteres
menos um. Assim, há diferentes formas de se trabalhar com o acesso de
caracteres em strings.

20
Alguns caracteres especiais podem ser incluídos em strings para
complementação e os principais estão indicados na figura 2.2.

Marcador Caractere
\\ Barra invertida
\’ Aspas simples
\” Aspas Duplas
\n Nova Linha (Enter)
\t Tabulação horizontal
\v Tabulação vertical
\b Retorno de carro
\a Beep ou sinal sonoro padrão do hardware
Figura 2.2: Caracteres especiais e sua representação em Python.

Fonte: O autor.

Em Python, assim como em outras linguagens, strings são sequências de

caracteres simples que formam uma lista ou vetor com uma quantidade finita de
elementos.

A indicação básica de uma string nesta e em muitas outras linguagens é a

indicação da mesma entre aspas. Em linguagem Python, ainda é possível o uso
de aspas simples e aspas triplas para a manipulação de strings de diferentes
formas.

Um recurso útil que pode ser utilizado é a conversão forçada para dados
(casting) que pode inclusive alterar dados e ajustá-los de acordo com alguma
solicitação realizada. Para isto, basta utilizar um dos tipos padrão de dados
simples para forçar o dado em questão a ser adequado ao tipo definido como
pode ser observado nos exemplos da figura 2.3.

valor1 = int (10.5)

21
valor2 = int ("10")
valor3 = 15.5
print (valor1 + valor2 + int (valor3))

35
15.5
Figura 2.3: Exemplo de uso de conversão forçada de tipo.

Fonte: O autor.

Neste exemplo da figura 2.3, são utilizadas três variáveis, mas apenas duas têm
seus dados convertidos para inteiros logo na sua inicialização. A terceira tem seu
valor convertido apenas para utilização como um dos operadores passados
como parâmetro para a expressão da função print(). Depois, em posterior
exibição do valor da variável valor3 sem conversão, pode-se observar que seu
valor original foi mantido.

Manipulação De Strings

As strings são consideradas dados, e por isto, necessitam de estruturas de

dados para serem armazenadas para uso durante a execução de um código. O
uso das aspas simples é o método mais simples e dentro do conteúdo das aspas
não se podem utilizar aspas duplas para evitar confusão pelo compilador ao
interpretar a linha de comando. As aspas duplas são as mais utilizadas e
permitem o uso de aspas simples dentro de seu conteúdo para indicar termos
destacados, por exemplo.

As aspas triplas permitem o uso de aspas duplas e formatação com quebras de

linhas no conteúdo da string, e assim, se torna uma opção mais completa em
termos de utilização de strings, sendo esta, uma opção não presente na maioria
das linguagens.

22
Observe o exemplo de código a seguir na figura 2.4 contendo formas de uso das
aspas em funções de saída de dados e atribuições.

texto = 'Teste'
print ("\nString indicada por aspas simples: ")
print (texto)
texto = "Teste do uso de ‘aspas simples’"
print ("\nString indicada por aspas duplas: ")
print (texto)
texto = '''Teste de uso de "aspas duplas"'''
print ("\nString indicada por aspas triplas: ")
print (texto)
texto = '''Texto utilizando quebras
de linha'''
print ("\nString indicada por aspas simples: ")
print (texto)
Figura 2.4: Exemplos de uso das aspas em strings.

Fonte: O autor.

Estes exemplos da figura 2.4 servem para ilustrar diferentes usos das aspas
simples, duplas e triplas indicando as possibilidades de uso de outros tipos de
aspas dentro das strings a serem exibidas ou formatação diferenciada permitida
com as aspas triplas.

As strings funcionam como listas de caracteres, e por isto, seus elementos

podem ser referenciados individualmente através da indicação da posição na
lista com colchetes. Isso pode ser muito útil quando se realiza análise de
conteúdo de strings para buscar ou alterar caracteres em algoritmos diversos.
Observe o exemplo da figura 2.5 onde é exibido apenas o quarto caractere da
palavra, lembrando que os índices de listas iniciam sua contagem em zero, e por
isto o valor 3 é utilizado para este quarto caractere.

23
texto = "Teste"
print ("\nQuarto caractere da string: ")
print (texto[3])
print (texto[1:3])
texto[0] = "t"
print (texto)
del texto
print (texto)
Figura 2.5: Exemplos de uso das aspas em strings.

Fonte: O autor.

Uma variação na indicação de índices para uso de strings é que é possível

indicar uma faixa de índices a serem trabalhados, onde o elemento inicial e final
da sequência deve ser informado nos colchetes, separados por sinais de dois
pontos como indicado no exemplo da figura 2.5 que exibe os caracteres “est”
relativos à faixa de dados do índice 1 ao 3 da string.

A atribuição pode ser utilizada tanto para se incluir dados em variáveis, por
exemplo, e esta inclusão normalmente ocorre com dados que preenchem as
variáveis, mas no caso das strings, como representam listas de dados, estas
podem ter dados atribuídos de forma a preenche-las por completo como na linha
texto = "Teste", ou parcialmente através do uso de índice como foi feito na linha
texto[0] = "t" que ajustou apenas um caractere da string.

Excluir caracteres de uma string é algo que pode ser feito, mas não de forma tão
direta. Existe o comando del que apaga o conteúdo todo de uma string de uma
vez apenas como mostrado na figura 2.5 pela linha del texto, mas a exclusão
de um ou mais caracteres separadamente é algo que deve ser realizado por um
processo que deve ser implementado através de uma varredura na string e
posterior deslocamento dos caracteres seguintes para posições anteriores
sucessivamente de forma a dar a impressão do caractere ter sido suprimido.

24
Uma string também pode ser composta por strings que unidas, formam uma nova
cadeira de caracteres e pode ser um recurso bastante útil na manipulação de
dados deste tipo. Casos como nomes de pessoas obtidos separadamente
podem ser unidos, partes de um endereço, etc. A seguir seguem alguns
exemplos de uso de strings compostas por partes nos exemplos da figura 2.6.

texto = "{} {} {}".format ('Parte 1', 'Parte 2', 'Parte 3')

print ("\nString completa na ordem natural das partes da string: ")
print (texto)
texto = "{1} {0} {2}".format ('Parte 1', 'Parte 2', 'Parte 3')
print ("\nString completa na ordem indicada pelas chaves para as partes da
string: ")
print (texto)
texto = "|{:<10}|{:^10}|{:>10}|".format ('Parte 1', 'Parte 2', 'Parte 3')
print ("\nExemplos de alinhamento independente em partes da string: ")
print (texto)
texto = "{0:.2f}".format (1/3)
print ("\nExemplo de formatação de casas decimais com arredondamento
para : ")
print (texto)
Figura 2.6: Exemplos de uso das aspas em strings.

Fonte: O autor.

Nos exemplos trazidos na figura 2.6, o primeiro trecho utiliza as strings 'Parte 1',
'Parte 2', 'Parte 3' como elementos para compor uma nova string armazenada
na variável texto. A exibição ocorre nesta ordem, pois as chaves que
representam índices para cada parte, estão em branco, e assim, prevalece a
ordem de inserção, mas no segundo trecho, a indicação "{1} {0} {2}" faz com
que a ordem de exibição se altere e o elemento 'Parte 2' seja exibido antes do
elemento 'Parte 1'.
No terceiro trecho do código do exemplo da figura 2.6 é mostrado como se pode
utilizar alinhamento na exibição através dos parâmetros "|{:<10}|{:^10}|{:>10}|"

25
que permitem a exibição dos elementos da string alinhados respectivamente a
esquerda, centralizado e a direita.
Na sequência, o último trecho de código traz um exemplo de número formatado
com duas casas decimais através do parâmetro "{0:.2f}" utilizado juntamente
com o método format para ajustar o resultado da divisão entre 1 e 3 que resulta
em dízima periódica e é reduzida a 0,33.
Complementarmente ao que foi citado até o momento sobre a manipulação de
strings utilizando recursos próprios da linguagem Python, existem muitos
métodos desenvolvidos para proporcionar funcionalidades adicionais
importantes para a manipulação de strings.
Alguns exemplos de métodos que podem ser utilizados com maior ou menor
frequência aplicados em uma string qualquer indicada por “s” são descritas a
seguir na tabela 2.1.

s.capitalize() Manipula uma string de forma a transformar apenas

seu primeiro caracteres em maiúscula se possível.
s.center(width, char) Modifica uma string original adaptando-a a uma nova
quantidade de caracteres centralizando a string
original na quantidade de caracteres e preenchendo os
caracteres excedentes com o caractere indicado como
parâmetro.
s.ljust(width, char) Modifica uma string original adaptando-a a uma nova
quantidade de caracteres alinhando à esquerda a
string original na quantidade de caracteres e
preenchendo os caracteres excedentes com o
caractere indicado como parâmetro.
s.rjust(width, char) Modifica uma string original adaptando-a a uma nova
quantidade de caracteres alinhando à direita a string
original na quantidade de caracteres e preenchendo os
caracteres excedentes com o caractere indicado como
parâmetro.

26
s.count(t) Devolve a quantidade de ocorrências de um caractere
especificado pelo parâmetro “t” na string.
s.find(t, start, end) Retorna a posição para um caractere “t” encontrado na
string. Se nada for encontrado retorna -1.
s.isalnum() Devolve verdadeiro (True) se a string não estiver vazia
e apenas com caracteres alfanuméricos.
s.isalpha() Devolve verdadeiro (True) se a string não estiver vazia
e apenas com letras.
s.isdecimal() Devolve verdadeiro (True) se a string não estiver vazia
e apenas com números no padrão Unicode.
s.isdigit() Devolve verdadeiro (True) se a string não estiver vazia
e apenas com números no padrão ASCII.
s.islower() Retorna verdadeiro (True) se todos os caracteres de
uma string são considerados minúsculos.
s.isuper() Retorna verdadeiro (True) se todos os caracteres de
uma string são considerados maiúsculos.
s.join(t) Insere o caractere “t” entre cada caractere da string.
s.lower() Converte e retorna todos os caracteres da string
minúsculos.
s.upper() Converte e retorna todos os caracteres da string
maiusculas.
s.partition(t) Retorna a string fracionada em três partes, sendo a
parte antes do caracteres “t”, o próprio caractere e a
parte posterior.
s.split(t) Retorna uma série de strings fracionadas da string
original utilizando o caractere “t” como separador, ou
espaços em branco se não for indicado um caractere
específico.
s.swapcase() Retorna nova string invertendo caracteres maiúsculos
e minúsculos.
s.title() Devolve nova string onde todos os primeiros
caracteres da string original são convertidos em
maiúsculos.

27
 s.zfill(n) Retorna nova string onde, caso a string seja menor que
“n”, os caracteres mais a esquerda são preenchidos
com zeros.
Tabela 2.1: Exemplos de métodos para manipulação de strings.

Fonte: O autor.

Para testar estes métodos é interessante criar scripts com código contendo estes
métodos para manipular e atuar em strings diversas aplicando estes métodos
para compreender como podem ser utilizados, assim como é mostrado no
exemplo de script da figura 2.7.

texto = "Exemplo de string"

letra = "e"
print ("\n", texto)

print ("A letra 'e' está inicialmente na posição: ", end="")

print (texto.find( letra, 1)+1 )
print ("A letra 'e' está por último na posição: ", end="")
print ( texto.rfind( letra, 1)+1 )

texto1 = texto.lower();
print ("Todos os caracteres em minúsculo: " + texto1)
texto2 = texto.upper();
print ("Todos os caracteres em maiúsculo: " + texto2)
texto3 = texto.swapcase();
print ("Inversão entre maiúsculas e minúsculas: " + texto3)
texto4 = texto.title();
print ("Primeira letra maiúscula: " + texto4)

print ("\nTamanho do texto: ", len(texto));

print ("O caractere 'e' aparece: ",end="x")

28
print (texto.count("e",0,15))

print ("Exemplo de alinhamento centralizado usando '-': ",end="")

print ( texto.center(30,'-'))
print ("Exemplo de alinhamento à esquerda: ",end="")
print ( texto.ljust(30,'-'))
print ("Exemplo de alinhamento à direita: ",end="")
print ( texto.rjust(30,'-'))
Figura 2.7: Exemplço de script para manipulação de string.

Fonte: O autor.

Nos exemplos do script da figura 2.7, inicialmente são declaradas duas variáveis
texto e letra. Na sequência a string é exibida apenas para conferência do que
está contido na variável texto.

O trecho de código a seguir utiliza os métodos find e rfind para buscar o

caractere “e” contido na variável texto e indicar sua posição na string. Um
detalhe é que foi somado 1 ao resultado da busca, pois como a busca retorna
um índice na string, é mais intuitivo a um usuário que a contagem seja iniciada
em 1 ao invés de 0, padrão na linguagem.

O trecho seguinte de código realiza conversões dos caracteres utilizando os

métodos lower, upper, swapcase e title para que as variáveis texto1, texto2,
texto3 e texto4 contenham a mesma string, mas com as string alteradas
respectivamente, para todos os caracteres em minúsculos, maiúsculos,
invertidos em relação à string original, e apenas com o primeiro maiúsculo.

Na sequência, o trecho de código seguinte informa a quantidade de caracteres

da string original contida na variável texto, e depois informa a quantidade de
vezes que ocorrem o caractere “e” na string.

Por fim, o último trecho de código exemplifica o posicionamento de texto com

alinhamentos variados (esquerdo, centralizado e direito) inserindo a string em

29
uma sequência de 30 traços, de acordo com o alinhamento indicado em cada
comando com os métodos center, ljust e rjust.

O uso de texto em programação é bastante variado e útil, pois muitas aplicações

desenvolvidas se baseiam em texto como base de dados a trabalhar, e este texto
pode estar todo desestruturado em termos de estrutura de dados como num
texto de um documento, por exemplo.

Existem muitos recursos disponíveis em bibliotecas disponíveis que podem

facilitar a manipulação destes textos e strings quaisquer. Bibliotecas como a
re.py (regular expression) possui uma série de expressões para realização de
buscas a partir da construção de expressões regulares elaboradas a partir de
uma sintaxe própria que utiliza símbolos combinados a caracteres para definir
alfabetos e strings que podem ser construídas com este alfabeto.

Observe o exemplo da figura 2.8 que mostra como se pode extrair valores
numéricos de uma string qualquer.

import re
def buscaNumeros (texto):
resultado = re.findall (r'[0-9]+', texto)
return resultado
texto = "abc12def34fgh56ij78kl90"
resultado = buscaNumeros (texto)
print (*resultado)
Figura 2.8: Exemplo de uso de expressões regulares.

Fonte: O autor.

Neste exemplo da figura 2.8 é possível observar alguns aspectos novos e

relevantes como a adição do comando de importação da biblioteca para uso de
expressões regulares import re.Em seguida, é implementada uma pequena
função que utiliza o método findall () para realizar uma busca por valores entre
0 e 9 dentro da string contida em texto. Todos os valores encontrados são

30
armazenadas na variável resultado que é devolvida como retorno da função para
o código principal.

O código principal que vem na sequência contém a inicialização da variável texto

com uma string de exemplo qualquer contendo letras e números. Em seguida, a
variável resultado é inializada com a própria função para execução da busca a
partir da regra da expressão regular aplicada na variável texto. Por fim, o
resultado obtido apenas com valores numéricos é exibido ao usuário.

Assim como existe a biblioteca re.py, há outras alternativas de bibliotecas, além

de que o próprio desenvolvedor pode criar suas próprias bibliotecas .py e utilizá-
las livremente em diversos scripts que vá desenvolver.

31
Conclusão

Ao final dos estudos desta unidade, pode-se concluir que houve uma evolução
no aprendizado e elementos mais técnicos da linguagem estão sendo tratados
de forma a aumentar a compreensão da linguagem e suas particularidades.

Os tipos de dados vistos são a base da programação Python e precisam ser

conhecidos para que se possa desenvolver soluções computacionais partindo
do correto uso de dados que representam a base do uso de software.

Os dados podem ser organizados de forma simples, mas também podem ser
agrupados em estruturas mais complexas como as que foram tratadas, mas uma
delas teve um enfoque maior nesta unidade devido às suas muitas aplicações.

As strings representam a base dos dados em Python e possuem muitos recursos

de manipulação, sendo que várias foram trabalhadas nesta unidade.

Na unidade seguinte, os operadores e seu uso, assim como funções de entrada

e saída de dados serão tratados para a continuidade dos estudos.

32
UNIDADE III

Introdução

Após o estudo da base da linguagem Python em relação a sua sintaxe e

posteriormente, as possibilidades de uso de dados simples ou em estruturas
mais complexas, segue o avanço nos estudos.

A seguir, os operadores que são muito utilizados em programação, são divididos

em categorias para estudos e posterior aplicação na construção de expressões
matemáticas e lógicas, por exemplo.

Na sequência, são trabalhados os conceitos essenciais de entrada e saída de

dados que são simples, mas essenciais para o desenvolvimento de software,
pois além do processamento de dados, é preciso adquirir dados e exibir
resultados a usuários normalmente.

33
Expressões e Operadores Aritméticos

A matemática é a área que mais se adequa a linguagem Python devido a

algumas particularidades da linguagem como variáveis numéricas que aceitam
valores de qualquer tamanho e poderem assim, realizar cálculos muito precisos
com estes valores, por exemplo.

O interpretador da linguagem pode realizar cálculos diretamente sem que um

script completo com funções e outros comandos seja desenvolvido, e assim,
acaba se tornando uma ferramenta bastante versátil na sua funcionalidade.

Existem detalhes que são perceptíveis durante o uso do prompt do shell de

execução de comandos e scripts Python como a forma como valores atribuídos
a variáveis são exibidos ao usuário e alguns exemplos simples são ilustrados na
figura 3.1.

>>> 2 + 2
4
>>> 1/3
0.3333333333333333
>>> 1//3
0
>>> 5 % 4
1
>>> 2 % 3
2
>>> 2*3
6
>>> 2**3
8
>>> 2 + (3 * 2) ** 2
38
>>> 2 + 3 * 2 ** 2

34
14
Figura 3.1: Exemplos de expressões e comandos no shell Python.

Fonte: O autor.

Observando os exemplos da figura 3.1, tem-se inicialmente uma simples soma

com seu resultado exibido logo a seguir. Depois, é utilizada a barra de duas
maneiras diferentes para mostrar a diferença entre dois operadores gerados com
o mesmo caractere. Usando-se uma barra, é realizada uma divisão simples que
gera um resultado exato com casas decimais se necessário, ao passo que
usando barras duplas, a divisão é realizada também, mas apenas a parte inteira
do resultado é exibida e a parte decimal excluída sem que seja feito qualquer
arredondamento.

Outro operador utilizado se baseia no símbolo % e realiza um cálculo chamado

de módulo e complementa o cálculo realizado pelo operador //, pois enquanto
este traz como resultado a parte inteira do resultado, o módulo traz o resto da
divisão inteira que geraria na sequência dos cálculos, a parte decimal como
mostrado no exemplo da figura 3.1 onde o módulo de 5 por 4 retorna 1,
representando o resto da divisão inteira.

Na sequência, a figura 3.1 traz o uso do operador asterisco simples e duplo para
demonstrar as operações de multiplicação e exponenciação que são,
respectivamente realizadas com estes operadores.

Por fim, a figura 3.1 traz um exemplo de expressão usando diferentes operadores
e estabelecendo precedência forçada em uma das operações com o uso de
parênteses. Sem eles, o resultado da operação seria diferente, como mostrado
também na figura 3.1, e assim os resultados variam entre 38 com parênteses
que força a soma ser realizada primeiro, e 14, sem os parênteses.

Os operadores possuem regras de uso e precedência de operadores, e estas

precisam ser seguidas, pois erros de sintaxe serão identificados em expressões
mal elaboradas. É preciso estar atento às regras e precedência de operadores,
pois isto afeta diretamente resultados, e em usos matemáticos mais complexos,

35
um pequeno equívoco na elaboração de expressões pode não gerar erros de
sintaxe, mas pode comprometer toda a validade do código implementado.

Como regra geral da linguagem Python e várias outras, os parênteses são a

maior prioridade, e depois vem o operador ** (exponenciação). Na sequência, os
operadores * (multiplicação) e / (divisão) são os próximos em precedência. Por
fim, os que são realizados por último, são os cálculos utilizando os operadores +
(soma) e – (subtração). No caso de operadores de mesmo nível, vale a regra
base de expressões serem calculadas da esquerda para a direita no caso de
operadores de mesmo nível de precedência.

Em strings podemos usar dois operadores normalmente usados com números o

+ de soma que em strings significa concatenação e o * de multiplicação que para
string significa replicação. Isto já foi exemplificado anteriormente, e complementa
o uso de operadores e expressões.

Operadores Relacionais

Além dos operadores aritméticos utilizados em expressões, existem os

operadores relacionais que permitem validações em comparações entre dados
que pode ser simplesmente informados ou estarem inclusos em estruturas de
dados.

Os operadores relacionais são == (igual), != (diferente), > (maior), < (menor), >=
(maior ou igual), e <= (menor ou igual), e são utilizados com um operando a
esquerda do operador e outro a direita como mostrado nos exemplos da figura
3.2.

>>> 1 > 1
False
>>> 1 >= 1
True
>>> 2 == 2

36
True
>>> 3 >= 2
True
>>> print (5 < 6)
True
Figura 3.2: Exemplos de uso de operadores relacionais.

Fonte: O autor.

Nestes exemplos da figura 3.2, temos algumas comparações realizadas

diretamente no prompt de interpretação de comandos onde são colocados
alguns exemplos que resultam False (falso) ou True (verdadeiro) dependo dos
operando utilizados com cada operador. No último exemplo é utilizada a função
de saída de dados apenas para diferenciar o uso, mas resultando no mesmo tipo
de saída para o usuário.

Estes operadores são muito utilizados em comandos da linguagem que se

baseiam em condições para realizar suas ações e serão reutilizados ao longo
deste material em diversos exemplos para outros conceitos.

Operadores Lógicos

Muitas vezes são elaboradas expressões utilizando operadores relacionais para

comparar valores, por exemplo. Estas comparações podem ser simples na
maioria dos casos, mas às vezes é preciso realizar mais de uma comparação de
uma única vez para avaliar condições compostas.

Para elaborar estas composições, é preciso estar atento a regras para uso de
operadores lógicos que são capazes de integrar condições simples, pois seu uso
se baseia na teoria de tabelas-verdade e para analisar este funcionamento,
observe os exemplos da figura 3.3.

37
>>> (3 > 4) and (5 >= 2)
False
>>> (3 < 4) and (5 >= 2)
True
>>> (3 > 4) or (5 >= 2)
True
>>> (3 < 4) or (5 >= 2)
True
>>> (3 > 4) or (5 <= 2)
False
Figura 3.3: Exemplos de uso de operadores lógicos e relacionais.

Fonte: O autor.

Nestes exemplo da figura 3.3 é possível avaliar o que ocorre com as

combinações de situações colocadas de variação de operadores relacionais e
lógicos “and” equivalente ao “e” da língua portuguesa, e “or” equivalente ao “ou”
da língua portuguesa.

Nos dois primeiros exemplos, o que acontece é que a primeira condição (3 > 4)
é falsa, e por isto, o operador “and” automaticamente já retorna falso, pois para
que este operador retorno verdadeiro, é preciso que todas as condições sejam
verdadeiras, como ocorre no exemplo seguinte onde (3 < 4).

Nos três exemplos finais, utiliza-se o operador “or” para avaliar combinações das
condições utilizadas nos dois primeiros exemplos. No exemplo (3 > 4) or (5 >=
2), como pelo menos a segunda condição é verdadeira, a expressão toda já
resulta verdadeiro.

No exemplo (3 < 4) or (5 >= 2), como as duas condições são verdadeiras, basta
a primeira ter sido verdadeira para que a expressão também retorne verdadeiro.
Apenas na última expressão onde ambas as condições são falsas, o resultado
foi também falso. Observe a tabela 3.1 a seguir contendo os resultados possíveis
para os operadores “and” e “or”.

38
 CONDIÇÃO 1 CONDIÇÃO 2 AND OR
V V V V
V F F V
F V F V
F F F F
Tabela 3.1: Combinações de resultados para os operadores AND e OR.

Fonte: O autor.

A partir desta tabela 3.1, é possível observar que para uma expressão “and”
resultar verdadeiro, todas as condições precisam também ser verdadeiras, e no
caso do operador “or”, apenas será falsa uma expressão onde todas as
condições resultarem também falsas.

Operadores Compostos De Atribuição

Uma combinação que é possível na linguagem Python e representam

simplificações de atribuições realizadas a partir de pequenas expressões se
baseiam nos operadores +=, -=, *=, /=, %=, //=, **= e outros mais específicos .
Observe os exemplos a seguir na figura 3.4 para compreender seu uso e
finalidade.

>>> x = 5
>>> x = x + 5
>>> x += 5
>>> print (x)
15
>>> x -= 3
>>> print (x)

39
12
>>> x *= 2
>>> print (x)
24
>>> x /= 3
>>> print (x)
8.0
>>> x %= 3
>>> print (x)
2.0
Figura 3.4: Exemplos de operadores compostos de atribuição.

Fonte: O autor.

Nestes exemplos da figura 3.4 são realizadas atribuições simples e compostas

em sequência com exibição dos valores sendo atualizados da variável x para
mostrar como agem estes operadores.

Inicialmente, após a atribuição do valor 5 à variável, logo em seguida é realizada

uma soma para aumentar o valor de x. Depois, é utilizado o operador += para
que a mesma soma seja novamente realizada, mas com esta nova sintaxe,
sendo então o valor das duas somas confirmado com a exibição do valor da
variável atualizado para 15.

Depois são realizadas sucessivas atribuições compostas para ir alterando o valor

da variável utilizando os demais operadores de atribuição compostos para que o
valor da variável seja alterado e seu valor exibido novamente como comprovação
do cálculo e atribuição realizados em conjunto.

Ao final, a última atribuição composta realiza uma operação de módulo de 8 com

3 que resulta em resto 2 que fica armazenado como novo valor para a variável
x.

Assim, conhecendo os operadores e podendo então estar apto a lidar com dados
básicos em Python, é possível seguir adiante com os estudos.

40
Dois operadores importantes e não muito comuns em muitas linguagens são os
operadores “is” e “in” que representam operações de comparação entre objetos
e entre elementos e objetos. Observe o exemplo de uso dos operadores na figura
3.5.

x = [1, 2]
y = [1, 2]
z=x
print (x is z)
print (x is y)
print (x == y)
print (2 in x)

True
False
True
True
Figura 3.5: Exemplos de uso de operadores para objetos.

Fonte: O autor.

Neste exemplo da figura 3.5 de uso de operadores “is” e “in” são declarados dois
objetos x e y contendo listas de dados numéricos. Depois é associado ao objeto
z, o objeto x. A partir destas atribuições, as funções print() exibem diferentes
resultados True ou False em função do uso dos operadores para objetos.

A primeira função print() retorna True, pois como x foi atribuído a z, ambos são
considerados o mesmo objeto pela atribuição feita, ao passo que a segunda
função retorna False, pois mesmo tendo os mesmos elementos, não
representam o mesmo objeto.

41
Depois, a terceira função retorna True, pois os dois objetos x e y possuem os
mesmos objetos, e a última função retorna True também, pois o elemento 2 está
contido nos dados do objeto x.

Entrada e Saída

Na linguagem Python, duas funções são disponibilizadas para realizar interação

de entrada e saída padrão com usuários. A função input() é responsável pela
entrada de dados e a função print() pela saída de dados.

As duas funções podem utilizar parâmetros para que suas funcionalidades

possam ser utilizadas, e no caso da função input(), o parâmetro é opcional que
aceita a inclusão de uma string (cadeia de caracteres em forma de texto) que
pode ser adicionada para melhorar a interface com o usuário exibindo a
mensagem que possui o intuito de auxiliar no preenchimento do dado esperado.

Já no caso da função de saída, além de strings que posem ser inseridas

sequencialmente, separadas por vírgulas, também podem ser incluídos
identificadores de variáveis para que seus conteúdos possam ser exibidos aos
usuários.

A função print() aceita uma maior variedade de parâmetros, e recursos adicionais

podem ser aceitos como indicações de inserção de valores em partes de strings,
por exemplo como exibido nos exemplos da figura 3.6 a seguir.

print (' Texto Exemplo')

print ("Primeira linha\nSegunda linha")

print (r'Caractere \n anulado com o uso de r antes da string')

print ('Exemplo', 'de String', 'Fracionada')

Figura 3.6: Exemplo de código de saída de dados.

Fonte: O autor.
42
No primeiro exemplo da figura 3.6, uma exibição simples da string ‘Texto
Exemplo’ ao usuário, lembrando que as strings em Python são identificadas com
aspas simples ou duplas, mas as simples são mais comumente usadas no
desenvolvimento de software. Outro detalhe relevante é que na versão 2 da
linguagem, não se utilizam parênteses na função print() para indicar seus
parâmetros.

No segundo exemplo, um detalhe importante é a possibilidade de uso de

caracteres especiais para realizar ações com strings, como o uso do caractere
especial “\n” que permite a inserção de quebras de linha dentro de strings para
melhor formatação do texto.

Um detalhe curioso exibido no terceiro exemplo da figura 3.6 é o uso da letra “r”
como parâmetro logo à esquerda da string no comando para que o caractere
especial “\n” seja tratado como texto simples a ser exibido, perdendo assim,
naquele comando, a função de quebra de linha. Este recurso é utilizado quando
se deseja que a própria representação do caractere seja exibida numa string.

Por último, no quarto exemplo da figura 3.6, o uso da vírgula permite que mais
de um parâmetro seja passado à função print() e todos sejam processados
sequencialmente pela função, observando que não apenas strings podem ser
utilizadas como parâmetros na função print().

A função input() permite a entrada de dados em Python e por ser uma função,
necessita que um dado retornado seja armazenado em uma estrutura de dados
para que este dado seja armazenado em memória temporária e esteja
posteriormente disponível para processamento durante a execução do
programa.

A função input() em si é bastante simples e possui menor variação de uso em

relação à função print(), facilitando seu aprendizado. Observe os exemplos da
figura 3.7 para análise do seu uso.

dado = input()

43
nome = input ('Digite seu nome: ')

valor = float ( input ('Digite um valor: '))

Figura 3.7: Exemplos de entrada de dados.

Fonte: O autor.

No primeiro exemplo da figura 3.7, a forma básica da função onde a mesma é

apenas atribuída a uma variável simples sem uso de parâmetro algum. Um
detalhe é que como na linguagem não é necessária declaração tipada de
estruturas de dados, a variável terá um tipo definido a partir do momento que
algum dado for atribuído a ela.

No segundo exemplo, um parâmetro é informado à função input() para que a

mensagem indicada seja exibida ao usuário de forma a auxiliar na correta
digitação de dados, pois como não foi definido um tipo, se não for indicado ao
usuário um auxílio sobre o tipo de dado desejado, este pode não ter ideia do que
é esperado pelo software e assim, fornecer entradas de dados inadequadas.

No terceiro exemplo da figura 3.7, uma funcionalidade complementar é inserida,

onde é especificado através da função float() que o dado retornado pela função
input() deve ser convertido, se necessário em valor do tipo decimal antes de ser
atribuído à variável “valor”. Isto permite uma validação da entrada de dados e
melhora a robustez e funcionalidade do programa em execução.

Existem muitas variações de uso de funções de saída de dados, e uma das

particularidades da linguagem é a possibilidade do uso da elaboração de certo
tipo de expressões como parâmetro combinando valores, operador e strings, por
exemplo. Observe os exemplos da figura 3.8 para compreender a ideia de uso.

>>> print (10 * 'É possível usar operadores em strings\n')

É possível usar operadores em strings
É possível usar operadores em strings
É possível usar operadores em strings

44
É possível usar operadores em strings
É possível usar operadores em strings
É possível usar operadores em strings
É possível usar operadores em strings
É possível usar operadores em strings
É possível usar operadores em strings
É possível usar operadores em strings

>>> print (3 * '#', 'Teste com String', 3 * '#')

### Teste com String ###
>>> print (3 * '#', '5 + 5 = ', 5+5, 3 * '#')
### 5 + 5 = 10 ###
Figura 3.8: Exemplos de constrção de função de saída com expressão.

Fonte: O autor.

Nos exemplos da figura 3.8, o primeiro contém uma multiplicação de uma string
como parâmetro da função de saída que faz com que como resultado, a string
seja repetida certo número de vezes, assim como no exemplo seguinte onde o
símbolo “#” é multiplicado duas vezes para gerar um simples efeito de destaque
em conjunto com o texto a ser exibido, e por fim, o último exemplo une os
componentes variados que podem ser combinados como parâmetros.

Além desse tipo de expressão, a função de saída de dados print() aceita

parâmetros como quebras de linha representados pelo marcador \n já citado, e
espaços em branco para separar cada parâmetro na função, por exemplo, mas
além de parâmetros mais simples como estes, esta função permite que se
manipule arquivos de texto usando a saída padrão como destino (monitor).

Um detalhe importante é não confundir o símbolo “#” utilizado no exemplo com

sua finalidade na elaboração de scripts em linguagem Python. Observe os
exemplos da figura 3.9 de uso de comentários em linguagem Python para
compreender este importante recurso de documentação de código.

45
# Exemplo de comentário de apenas uma linha
''' Comentários com mais de uma linha
podem ser divididos em blocos utilizando-se
o limitador '''
Figura 3.9: Exemplos de uso de comentários em linguagem Python.

Fonte: O autor.

Nos exemplos da figura 3.9, como o próprio texto do exemplo cita, o símbolo “#”
é utilizado para comentários curtos de apenas uma linha no editor, e os
comentários utilizando o delimitador de três aspas simples pode se dividir em
várias linhas para que parágrafos inteiros possam ser utilizados como
comentários.

46
Conclusão

Após os estudos de como trabalhar com a grande quantidade de operadores

disponíveis na linguagem Python e compreender como se pode aplicar estes
operadores nos diferentes tipos de expressões que podem ser elaborados com
estes operadores, desde cálculos matemáticos a condições que podem utilizar
mesclas de operadores para compor avaliações lógicas que são a base de
estruturas que serão trabalhadas na sequência dos estudos.

Para completar os conceitos desta unidade, foram estudadas formas básicas de

obtenção de dados junto a usuários para armazenamento em estruturas de
dados.

Também foram vistos conceitos de saída de dados envolvendo a construção de

mensagens a serem exibidas a usuários mesclando elementos e utilizando
caracteres especiais.

Na sequência dos estudos, a próxima unidade trata da manipulação de arquivos

de texto, e estruturas de controle de fluxo durante a execução de aplicações.

47
UNIDADE IV

Introdução

Após conhecer mais sobre a linguagem Python através do estudo de operadores

e a construção de expressões, além do uso de recursos de entrada e saída de
dados, é a hora de trabalhar mais forte com a parte lógica da linguagem.

Primeiramente, para complementar os estudos sobre o uso de dados e

implementação de estruturas de dados, é importante conhecer como se pode
armazenar dados de forma permanente em disco e sempre que necessário,
manipulá-los.

Depois, são conhecidas as principais formas de organização lógica do

processamento de dados e demais ações durante a execução de uma aplicação
utilizando estruturas de controle que se dividem em estruturas de decisão e de
repetição que necessitam de atenção a sua elaboração, pois utilizam de
raciocínio lógico na elaboração de expressões lógicas e no controle de suas
ações.

48
Arquivos De Texto

Para se trabalhar com arquivos do tipo texto, mais comuns e que representam
um tipo de dado bom para se complementar o uso da função print() de saída de
dados.

Esta manipulação de arquivos em Python não é complexa e se mostra um

recurso bastante útil, pois permite que dados sejam gravados em disco e assim,
uma aplicação possa ser executada em momentos distintos tendo como base os
dados gravados na execução anterior, por exemplo.

Basicamente, o processo de uso de arquivos se baseia na associação de um

arquivo a um objeto instanciado como arquivo com file e aberto para leitura,
gravação ou adição de dados com a função open(), usando uma string para
indicação do nome do arquivo e um parâmetro adicional que define o modo de
abertura do arquivo.

Os modos básicos de abertura de arquivos para a função open() são r apenas

para leitura, w para escrita, mas substituindo o conteúdo anterior, a para
adicionar dados novos ao final do arquivo já existente, x para criar um novo
arquivo vazio para escrita, b para arquivos binários (não texto), t para arquivos
de texto (é o padrão em Python), e + para que possam ser atualizados os dados
de um arquivo já existente.

Um detalhe sobre arquivos de texto, é que este tipo de arquivo contém dois
caracteres especiais que significam EOL que representa o final de cada linha de
texto, e EOF que representa o final do arquivo em si. Para o final de linha, pode-
se utilizar \n como em strings normais da função de saída de dados.

Além da função open(), há métodos que são acionados com o objeto de arquivo
instanciado para funcionalidades de manipulação do arquivo como write() para
adicionar texto ao arquivo, seek() para posicionamento no arquivo, read() para
leitura de dados, e close() para fechamento do arquivo de forma adequada,
reduzindo a chance de se corromper o arquivo.

49
Observe o exemplo de script da figura 4.1 para compreender o processo de
abertura de um arquivo de texto, a inserção de dados neste, a busca pelo texto
inserido e sua exibição ao usuário.

file = open ('arquivo.txt', 'w+t')

file.write ('Linha 1\nLinha 2\nLinha 3'\nLinha 4'\nLinha 5')
file.seek (0)
print (file.read() )
file.close ()

Linha 1
Linha 2
Linha 3
Linha 4
Linha 5
Figura 4.1: Exemplo de abertura de dados

Neste exemplo da figura 4.1, primeiramente, um objeto file é instanciado com o

nome de arquivo “arquivo.txt” e seu modo de abertura é “w+t” que significa que
o arquivo deve ser sobrescrito toda vez que for executado o script, seus dados
possam ser atualizados e seu conteúdo seja do tipo texto. Se fosse utilizado
apenas “w” também funcionaria, pois este modo já abre e sobrescreve um
arquivo permitindo a inserção de dados, e como padrão, como não indicado, o
arquivo seria do tipo texto, neste caso.

Em seguida, o método write() associado ao objeto file realizará a inserção da

string com quebras de linha no arquivo como se pode observar no resultado final
da string onde a string é dividida em 5 linhas.

Depois, o método seek(0) representa uma quantidade de avanço de caracteres

no conteúdo do arquivo para sua manipulação. Depois, a função print() contém
como parâmetro o método read() associado ao objeto file para leitura dos dados

50
do arquivo todo e posterior exibição destes. Por fim, o método close() associado
ao objeto file fecha o arquivo.

Pode-se, ao invés de efetuar a leitura de todo o arquivo de dados, ler apenas

uma linha através do método readline() que lê caracteres até encontrar uma
marcação de EOL que avise do término do conteúdo a ser lido no momento. Este
método pode ser utilizado seguidas vezes para que linhas vão sendo lidas em
sequência ou até incluído em estruturas de repetição para esta finalidade.

Um recurso adicional para a manipulação de arquivos é a exclusão de arquivos

ou pastas baseando-se em uma biblioteca chamada “os” que representa acesso
à funcionalidades do sistema operacional para gerenciamento de arquivos, por
exemplo. Observe os exemplos da figura 4.2.

import os
os.remove("arquivo.txt")
os.rmdir("Dados")
Figura 4.2: Exemplos de uso de funcionalidades do sistema operacional.

Fonte: O autor.

Com este recurso de importação da biblioteca “os”, é possível utilizar métodos

como remove() e rmdir() para excluir, respectivamente, arquivos e pastas, como
é feito nas interfaces de modo texto nos sistemas operacionais geralmente.

Na instrução que utiliza o método remove(), o parâmetro indica o nome do

arquivo a ser excluído, se existir, pois o nome informado pode não se referir a
um arquivo existente na pasta onde se está sendo executado o script, e o método
rmdir() exclui a pasta indicada como parâmetro caso exista.

51
Estruturas De Controle De Fluxo De Execução

Avançando nos estudos de programação Python, inicia-se uma nova etapa onde
a lógica é utilizada para que se estruture scripts que possam tomar decisões de
forma automática a partir de condições que são implementadas no
desenvolvimento, mas que o fluxo de execução só é afetado durante a execução,
a partir da variação de dados em tempo real geralmente.

Estrutura De Decisão

Neste tipo de estrutura que envolve condições, é comum a elaboração de

expressões lógicas baseadas em dados simples, variáveis e operadores, por
exemplo e uma série de recursos estudados são úteis a partir desta etapa.

O comando if é a base deste tipo de estrutura e permite como parâmetros

condições que permitem ao comando optar entre realizar um bloco de instruções
(ou instrução simples), ou outro bloco de comandos (ou instruções simples).
Observe o exemplo da figura 4.3.

valor1 = input ('Digite um valor: ')

valor2 = input ('Digite outro valor: ')
if valor2 < valor1:
print("Entre", valor1, "e", valor2, "O primeiro valor é maior.")
elif valor2 == valor1:
print("Os valores são iguais.")
else:
print("Entre", valor1, "e", valor2, "O segundo valor é maior.")

Digite um valor: 5
Digite outro valor: 7
Entre 5 e 7 O segundo valor é maior.
Figura 4.3: Exemplo de estrutura de decisão ou condicional.
52
Fonte: O autor.

Neste exemplo da figura 4.3, os valores para duas variáveis são solicitados ao
usuário para depois, estes valores serem analisados pela estrutura da decisão.
Esta estrutura de decisão é composta por três etapas, onde cada etapa utiliza
um comando diferente e age de forma diferente.

Na primeira etapa, o comando if possui uma condição onde o dado contido em

valor2 é avaliado se menor que o dado de valor1. Se for verdadeira a condição,
executa a função print() que diz que o primeiro valor é maior, lembrando que as
demais etapas da estrutura de decisão são ignoradas se a primeira resulta
verdadeiro.

Na segunda etapa que é acionada apenas se a primeira etapa resultar falso é

verificado se os dois dados contidos nas duas variáveis são iguais. Para isto,
utiliza-se outro comando chamado elif. Caso seja verdadeira a condição nesta
etapa, a função print() exibirá a mensagem sobre os valores serem iguais.

O comando elif é usado tantas vezes quantas forem necessárias, variando-se

as condições em cada uso. Assim, se houverem 5 condições diferentes possíveis
a serem avaliadas numa mesma estrutura de decisão, é preciso utilizar um
comando if na primeira e mais quatro comandos elif nas demais.

Caso as etapas anteriores a última tenham todas valores falso para as condições
e nada seja executado até então, a última etapa utiliza o comando else para
exibir a mensagem de que o segundo valor é maior que o primeiro, pois seria
esta referente a qualquer situação não atendida pelas condições anteriores, e
assim, nem necessita de uma condição para este comando.

São possíveis variações de uso na elaboração de estruturas de decisão de forma

a simplificar a sintaxe da estrutura, mas também é possível aumentar a avaliação
lógica realizada pelos comandos através da criação de condições mais
complexas envolvendo duas ou mais condições agregadas a operadores lógicos
and ou or. Observe os exemplos da figura 4.4.

53
valor1 = input ('Digite um primeiro valor: ')
valor2 = input ('Digite um segundo valor: ')
valor3 = input ('Digite um terceiro valor: ')
# Análise apenas se valor1 > valor2
print (valor1, "é maior que", valor2) if valor1 > valor2 else print(valor2, "é
maior que", valor1)
# Análise mais completa verifica quem é maior ou se são iguais entre valor1
e valor2.
print (valor1, "é maior que", valor2) if valor1 > valor2 else print(valor1, "e",
valor2, "iguais") if valor1 == valor2 else print(valor2, "é maior que", valor1)

Digite um primeiro valor: 20

Digite um segundo valor: 10
Digite um terceiro valor: 30
20 é maior que 10
20 é maior que 10
Figura 4.4: Exemplos de variações com estruturas de decisão.

Fonte: O autor.

Observando os exemplos da figura 4.4, pode-se observar que são duas

estruturas de decisão distintas, onde a primeira mostra uma simplificação da
sintaxe da estrutura e realiza apenas uma verificação se o primeiro valor é maior
que o segundo.

O segundo exemplo mantém a estrutura simplificada, mas realiza uma análise

mais adequada dos dois valores, pois além de verificar se um é maior que o
outro, possui a alternativa de serem iguais.

Uma outra forma de se utilizar estruturas de decisão é inserindo uma dentro da

outra para que sejam realizadas análises complementares em sequência, mas é
muito mais complexa a lógica na elaboração destas estruturas chamadas de
“aninhadas”.

54
dado = int (input ('Digite um valor: '))
resto = dado % 2
if dado >= 0:
print("Este valor é positivo...")
if resto == 0:
print("e é par.")
else:
print("e é ímpar.")
else:
print (“Este valor é negativo.”)
Figura 4.5: Exemplo de estrutura de decisão aninhada.

Fonte: O autor.

Neste exemplo da figura 4.5 existem alguns pontos importantes a serem

observados e que com o tempo, a prática e a experiência permitirão que estas
situações que ocorrem no exemplo possam ser previstas pelo programador.

Um primeiro ponto é que se não for utilizado o método int() para conversão da
entrada de dados para a variável dado de forma a garantir o tipo desejado para
a condição, o interpretador pode acusar erro. Outro ponto de atenção é que a
operação que verifica se o valor contido na variável dado dividido por 2 gera
valor exato ou sobra 1 é feita antes da avaliação na condição, pois a linguagem
não aceita a operação na condição do comando if.

Observados os detalhes, a parte lógica é simples e este exemplo simplesmente

realiza duas avaliações e a primeira possui avaliações complementares. Se o
valor contido na variável dado for maior ou igual à zero, uma mensagem informa
que o valor é par, e em seguida, passa a uma nova avaliação que verifica se
pelo valor contido na variável resto, o valor digitado é par ou ímpar em uma
estrutura de decisão aninhada. Caso contrário, se o valor contido em dado for

55
menor que zero, apenas mostra ao usuário uma mensagem informando que o
valor é negativo.

Estrutura De Repetição

Neste segundo tipo de controle de fluxo, uma instrução ou bloco de instruções

pode ser executada repetidas vezes de acordo com condições determinadas na
implementação do código, mas que são avaliadas e executadas em tempo real,
como no caso das estruturas de decisão.

Um comando que pode ser utilizado para este tipo de situação é while que aceita
condições como parâmetros para sua estruturação, assim como os comandos if
ou elif, mas a forma como são elaboradas estas condições é diferente, pois a
finalidade do uso deste comando while é diferente. Observe o exemplo da figura
4.6.

i=1
while i <= 5 :
print(i)
i += 1
else:
print("Não há mais valores menores ou iguais a 5 para serem exibidos.")

1
2
3
4
Não há mais valores menores ou iguais a 5 para serem exibidos.
Figura 4.6: Exemplo de uso de estrutura de repetição com comando while.

Fonte: O autor.

56
Esta estrutura se baseia na evolução de iterações que vão ocorrendo em tempo
real, e dentro destas, algum valor deve ser alterado em algum momento para
que a condição de repetição deixe de ser satisfeita e o laço de repetição possa
ser encerrado, caso contrário, ele se tornará um laço de repetição infinita, não
desejado na maioria das vezes.

Nesse exemplo da figura 4.6, uma variável i que servirá como contadores é
iniciada com 1 (poderia ser qualquer valor inteiro) e ela é utilizada na condição
de controle de iterações do laço de repetição.

Seu valor a cada iteração é acrescentado em uma unidade após seu valor ser
exibido pela função print(). Ao final de cada iteração, a condição é verificada, e
nesse caso, enquanto o valor contido na variável i não for superior a 5, as
instruções do laço continuam sendo executadas.

No momento em que o valor de i atinge 6 em uma das iterações, a condição do

comando while não é mais satisfeita e as repetições são interrompidas. Um
detalhe é que após a estrutura de repetição é possível colocar um comando else
para complementar a execução de uma estrutura de repetição por dois motivos,
sendo um para alguma informação ou ação complementar ao que foi feito no
laço, ou para que no caso de o laço não ser executado nenhuma vez, algum
feedback possa ser informado para que se saiba que poderia ter sido executado
um laço.

Dois comandos podem ser utilizados em laços de repetição para interromper

uma iteração ou todo o processo de repetição da estrutura, utilizando-se,
respectivamente os comandos continue ou break. Observe o exemplo da figura
4.7.

i=1
while i < 10:
if i == 3:
i += 1
continue
if (i == 7):

57
 break
print(i)
i += 1

1
2
4
5
6
Figura 4.7: Exemplo de estrutura de repetição.

Fonte: O autor.

Neste exemplo da figura 4.7, é possível observar o uso dos dois comandos para
interrupções no laço. O uso do comando continue faz com que após este
comando, uma iteração seja interrompida e a próxima seja executada, e por isto,
como este comando é executado quando o valor da variável i é 3, ocorre o
incremento, mas os comandos posteriores a continue não são executados e o
valor não é exibido pela função print().

Quando o valor da variável i chega a 7, ocorre o comando break contido na

estrutura de decisão que é específica para este valor, e assim, toda a estrutura
de repetição é interrompida, e assim, o laço é encerrado antes da condição inicial
ser totalmente satisfeita.

Outra forma de se estruturar laços de repetição é através do comando for que

possui uma sintaxe interessante, pois é flexível e pode ser usada em situações
variadas. Observe o exemplo da figura 4.8.

for i in range (5):

print (i)

58
1
2
3
4
Figura 4.8: Exemplo de laço de repetição contado.

Fonte: O autor.

Neste exemplo da figura 4.8, é importante observar que o comando for também
se baseia em uma variável contadora i, mas de antemão já define que serão
efetuadas 5 iterações, e como é padrão da linguagem Python iniciar contagem
de laços deste tipo em zero, são efetuadas iterações de 0 a 4.

dados = [1, 2, 3, 4]
dados2 = ["A", "B", "C"]
for i in dados:
print (i)
for i in dados2:
print (i)

1
2
3
4
A
B
C
Figura 4.9: Exemplos de laços de repetição contados sem especificação prévia.
Fonte: O autor.

Este outro exemplo na figura 4.9 traz uma variação do uso do comando for,
deixando-o mais autônomo para definir quando encerrar as iterações, pois sem

59
ter um valor limite estabelecido, seguirá executando iterações até que algum fato
encerre a sequência.
Nesse caso, o primeiro laço encerra quando a lista de quatro elementos for toda
percorrida e os seus elementos exibidos, ao passo que o segundo laço terá três
iterações devido aos três elementos do objeto dados2.

Esta forma de laço pode ser utilizada para se percorrer um arquivo e todos os
seus dados lidos mudando-se apenas o objeto de lista para o que foi instanciado
com o nome do arquivo e depois aberto para manipulação.

Funções

Sub-rotinas são trechos de códigos agregados a um nome para reduzir repetição

de código, e todo código pode possuir uma ou mais sub-rotinas nomeadas para
possíveis chamadas por outras partes do código, inclusive por outras sub-
rotinas. As funções representam um tipo específico de sub-rotina usadas na
linguagem Python.

Toda função deve ser implementada de forma que seja até certo ponto
independente, pois seu código é contido em uma estrutura que só pode ser
acessada pela invocação da função através de seu nome.

Funções podem ter variáveis próprias, podem receber parâmetros de entrada e

podem retornar valores ao trecho de código que a chamou. Isso torna este
recurso extremamente útil, e se for bem implementado, em certos casos, funções
podem ser reaproveitadas em outros códigos. Para um exemplo, observe a figura
4.10.

def funcao (dado = 1):

print (dado * 2)
def funcao2 (dado = 1):
return dado * 2
def funcao3 (*dado):

60
 return dado[1] * 2

funcao ()
funcao (2)
print (funcao2(3))
print (funcao3(4, 5))

2
4
6
10
Figura 4.10: Exemplo de uso de funções em Python.

Fonte: O autor.

Neste exemplo da figura 4.10, são implementadas três função que são
declaradas através do comando def, um nome a escolha do desenvolvedor e a
indicação de parâmetros aceitos. A primeira função realiza a ação de exibição
do resultado sem retornar nenhum dado ao trecho de código que a chamou.

Já a segunda e terceira funções retornar valores após a efetuação de suas

ações, pois o trecho de código que as chama é uma função de saída de dados
print() que utiliza as funções como parâmetro para obter dados a serem exibidos
ao usuário.

Uma diferença entre a segunda e terceira funções é que a terceira não especifica
uma quantidade fixa de parâmetros e assim, utilizando o símbolo *, deixa a
critério do trecho de código que a chama especificar a quantidade de dados que
deseja informar como parâmetros de entrada para a função. Neste caso, o
código interno da função pode selecionar qual dos parâmetros informados será
utilizado através de um índice informado entre conchetes.

É por isso que o último valor obtido na execução do código foi 10 e não 8, pois
o índice 1 utilizado representa o segundo parâmetro recebido pela função (caso

61
tenha sido informado), lembrando que a contagem dos parâmetros inicia com o
índice 0.

Outro tipo de função se chama lambda é uma agregação do paradigma de

programação funcional que permite a definição de funções anônimas que podem
receber parâmetros, mas esta precisa ser definida em uma única expressão.
Observe os exemplos da figura 4.11 para poder avaliar a forma como se definem
estas funções lambda.

f = lambda valor1, valor2 : valor1 + valor2

dado1 = input()
dado2 = input()
print (f (dado1, dado2))

dado3 = int (input())

dado4 = int (input())
print (f (dado3, dado4))

2
3
23
4
5
9
Figura 4.11: Exemplo de função lambda.

Fonte: O autor.

No exemplo da figura 4.11, é definida uma função lambda que aceita dois
parâmetros e a partir deles, realiza uma soma simples. Para mostrar como é
importante tratar os dados a serem utilizados, um primeiro uso da função pede
dois dados sem definição de tipo para que o operador seja utilizado, mas como

62
é priorizado o tipo caractere por ser mais amplo, ao invés de uma soma, é
realizada a concatenação das strings “2” e “3”.

Na segunda chamada à função lambda, os dados a serem utilizados são

definidos como inteiros no momento da solicitação de entrada de dados, como é
especificado o tipo inteiro com o método int() de conversão, a operação realizada
é realmente a soma.

def f (dado1):
return lambda f2 : f2 * dado1
dobro = f (2)
quintuplo = f(5)

print (dobro(4))
print (quintuplo(4))

8
20
Figura 4.12: Exemplo de função lambda.

Fonte: O autor.

No exemplo da figura 4.12, a função lambda é definida, mas como valor de

retorno para uma função f que realiza multiplicações. Na sequência, duas
funções dobro() e quintuplo() são definidas para que uma determinada
quantidade de iterações da execução da função lambda sejam executadas
quando forem chamadas pelas funções print() para exibição dos resultados dos
cálculos.

fatorial = lambda i: 1 if i == 0 else i * fatorial (i-1)

dado = int (input())
print (fatorial (dado))

63
50
304140932017133780436126081660647688443776415689605120000000000
00
Figura 4.13: Exemplo de função lambda para cálculo de fatorial.

Fonte: O autor.

Em outro exemplo de aplicação da função lambda na figura 4.13. é possível

perceber como se pode reduzir a quantidade de linhas de código com
programação funcional, mas sua lógica se torna mais complexa que em um
paradigma estruturado, por exemplo.

Nesta função fatorial(), a função lambda possui uma estrutura de decisão simples
para verificar a condição de parada necessária para sucessivas repetições da
função. Nela é colocada a condição de parada quando a variável i contadora
chegue a 1, caso contrário, a função chama a si mesma reduzindo uma unidade
na variável contadora antes de reutilizá-la como parâmetro.

Uma curiosidade é o uso do valor 50 como dado para servir de parâmetro para
a função de cálculo. Como a base da cálculo do fatorial são sucessivas
multiplicações, é possível perceber que a linguagem aceita trabalhar com valores
grandes como já citado.

64
Conclusão

Nesta unidade, foram tratados os aspectos importantes relativos à manipulação

de dados armazenados em disco em arquivos de texto que podem ser muito
úteis em diversas aplicações.

Depois foram estudadas as mais importantes formas de se definir a lógica de

execução de uma aplicação através de estruturas de controle capazes de decidir
por si próprias, a partir de condições envolvendo expressões, os rumos da
execução do processamento e demais ações.

Também foram trabalhados conceitos relativos à construção de estruturas de

repetição para que conjuntos de instruções possam ser processados seguidas
vezes de forma controlada.

Para a unidade final, são trabalhados conceitos do paradigma orientado a

objetos e do uso de módulos criados pelo desenvolvedor ou por terceiros de
forma a facilitar o desenvolvimento de software a medida que se aprende a
trabalhar com estes módulos.

65
UNIDADE V

Introdução

Antes de iniciar os estudos desta unidade final, foram vistos aspectos muito
importantes relativos à manipulação de arquivos de texto e de estruturas de
controle de decisão e repetição durante a execução de scripts.

Nesta unidade, são tratados conceitos ligados à orientação a objetos como sua
estrutura básica de classes, métodos e atributos, e conceitos complementares
como de uso da técnica de herança entre classes.

Também serão tratados conceitos do uso de módulos prontos de código que

podem ser obtidos de terceiros contendo recursos para manipulação de dados
do próprio código ou obtidos em bancos de dados SQL e NoSQL.

Bons estudos.

66
Orientação a Objetos

Passando agora para um dos meios de programação mais utilizados na

atualidade, o paradigma orientado a objetos é a base para programação em
algumas linguagens que não aceitam que se programe sem o uso dos
fundamentos deste paradigma como Java, por exemplo.

Python aceita o desenvolvimento de código tanto em paradigma estruturado

quanto orientado a objetos, aceitando inclusive a inclusão de programação
funcional com funções lambda.

Basicamente, a orientação a objetos busca abstrair problemas reais e a partir de

pontos relevantes do que deve ser criado computacionalmente, elabora
estruturas chamadas de classes contendo as características delas chamadas de
atributos e os processos que manipulam estes atributos chamados de métodos.
Observe o exemplo da figura 5.1 para uma amostra do uso de classes, e
atributos.

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

pessoa = Pessoa ("Marcos", 20)

print (pessoa.nome)
print (pessoa.idade)

Marcos
20
Figura 5.1: Exemplo de criação de classe e seu uso.

Fonte: O autor.

67
No exemplo da figura 5.1, é declarada uma classe Pessoa (é de boa praxe
utilizar a primeira letra maiúscula em classes) que em sua definição possui um
método __init__() obrigatório para declaração de atributos.

Em seguida, um objeto pessoa (é de boa praxe utilizar a primeira letra minúscula

em objetos instanciados, métodos e atributos) é instanciado para que se possa
coletar dados e armazená-los nesta estrutura de dados.

Por fim, os dados incluídos na instância da classe Pessoa chamada de pessoa

pode ser acessada por funções como print() e seus dados podem ser utilizados.
Assim, pessoa.nome e pessoa.idade se referem aos dados específicos da
instância da classe Pessoa chamada de pessoa instanciada no script. Observe
o exemplo da figura 5.2 onde é adicionada uma função para realizar a ação de
exibição dos dados do objeto.

class Pessoa:
def __init__( self, nome, idade):
self.nome = nome
self.idade = idade
def f (self):
print ("Sr (a)", self.nome, "está com", self.idade, "anos.")

a = input()
b = input()
pessoa = Pessoa (a, b)
pessoa.f()

João
25
Sr (a) João está com 25 anos.
Figura 5.2: Exemplo de classe com função.

Fonte: O autor.

68
Neste exemplo da figura 5.2, é declarada uma função f dentro da classe Pessoa
que funciona como um método principal para manipular dados de atributos
chamado de __init__() onde são indicadas uma referência para estruturação da
classe instâncias de objetos e sua ligação com atributos da classe.

Também podem ser adicionados componentes adicionais como funções que

permitem que uma classe contenha, além de uma estrutura de dados modelo
para objetos, funcionalidades para manipulação de dados, por exemplo.

Uma função f é definida dentro da classe para realizar a manipulação de dados,

permitindo ao usuário, nesta função específica, visualizar uma frase composta
por strings e dados contidos em alguma instância gerada a partir da classe.

Fora da declaração da classe, duas variáveis a e b auxiliares são utilizadas para

receber dados de entrada que serão na sequência atribuídos a um objeto
pessoa instanciado a partir da classe Pessoa.

Por fim, a função f é invocada pelo objeto pessoa para que as funcionalidades
contidas nela sejam utilizadas, e neste caso específico, a string completa
contendo o texto e dados armazenados sejam compostos e exibidos ao usuário.

É possível utilizar, por exemplo, um comando del para eliminar dados de

atributos de um objeto ou até o próprio objeto se necessário durante a execução
do script, mas é um comando a ser utilizado com muita cautela. Para isto, basta
utilizar a instrução del pessoa.idade para excluir um dado contido em um
atributo específico, ou del pessoa para excluir toda a instância gerada em
pessoa.

Herança em Orientação a Objetos

Um aspecto muito importante aceito pela orientação a objetos em Python é a

herança que cria uma relação entre classes que permite a uma subclasse (ou
filha) utilizar atributos ou métodos de uma superclasse (ou pai/mãe), evitando
assim, duplicações desnecessárias de atributos e métodos comuns às duas
classes. Observe o exemplo da figura 5.3.

69
class Carro:
def __init__ (self, modelo, placa):
self.modeloCarro = modelo
self.placaCarro = placa

def exibeDados (self):

print (self.modeloCarro, self.placaCarro)

class Pendencias (Carro):

def __init__ ( self, modelo, placa, ipva):
super ().__init__ (modelo, placa)
self.ipvaCarro = ipva

def mensagem (self):

print ("O veículo", self.modeloCarro, ", placa: ", self.placaCarro, "está
com", self.ipvaCarro)

carro1 = Pendencias ("Monza", AAA9I99, "documentos em dia.")

carro2 = Pendencias ("Cruze", CCC1B11, "documentos atrasados.")
carro1.mensagem ()
carro2.mensagem ()

O veículo Monza , placa: AAA9I99 está com documentos em dia.

O veículo Cruze , placa: CCC1B11 está com documentos atrasados.
Figura 5.3: Exemplo de classe com métodos e herança.

Fonte: O autor.

No exemplo apresentado na figura 5.3, uma classe Carro é definida pela palavra
reservada class. As definições da classe para instâncias de objetos são
definidas no método __init__ (obj) onde o termo self é colocado como primeiro
parâmetro para referências à classe e aos dois atributos modeloCarro e

70
placaCarro da classe que obtém seus dados através dos parâmetros de entrada
(ou mensagens como se costuma dizer em orientação a objetos) modelo e
placa.

Assim, quando um objeto for instanciado a partir da classe Carro, deverão ser
passados os dados para modeloCarro e placaCarro através de mensagens
contidas em modelo e placa na chamada do objeto.

Um método adicional exibeDados (obj) é implementado para que algum

processamento possa ser realizado com os dados de um objeto instanciado
quando desejado.

Em seguida, é declarada outra classe Pendencias (Carro) que possui uma

particularidade em relação à classe Carro, pois Pendencias é uma subclasse
de Carro e isto é indicado pela utilização da indicação da superclasse Carro
entre parênteses.

Para esta classe Pendencias, um método __init__ () também é utilizado para

além dos atributos de Carro, um novo atributo ipvaCarro ser adicionado. Dentro
deste método, super() faz referência ao método __init__() da superclasse Carro
e define que os dados para o atributo ipvaCarro serão obtidos através do
parâmetro ipva.

Esta é base da chamada herança que é uma das mais importantes

características da orientação a objetos onde uma classe está ligada a uma
superclasse que permite o compartilhamento de sua estrutura com a classe,
lembrando que a classe é uma especialização da superclasse normalmente, e
por isto, pode possuir atributos e métodos adicionais mais específicos à
finalidade da classe.

Neste exemplo da figura 5.3, a classe Pendencias serve de base para instância
de objetos referentes à parte documental de veículos cadastrados em objetos
instanciados a partir da classe Carro, sendo que cada carro cadastrado, deve
ser adicionado a um objeto diferente que possui, pela herança, um objeto relativo
à sua documentação.

71
Um método mensagem (obj) é adicionado à classe Pendencias para exibir
justamente todos os dados relativos à união dos atributos da superclasse Carro
e da classe Pendencias instanciados em objetos.

Os objetos carro1 e carro2 são instanciados passando por mensagens os dados

a serem armazenados nos atributos de cada objeto. Por fim, os dados dos dois
objetos são exibidos ao usuário pela chamada do método informacao() em cada
um destes objetos carro1 e carro2.

Métodos Complementares

Um conceito complementar para a programação básica com orientação a objetos

é a ideia do uso dos métodos __iter__() para realizar iterações manuais em
dados de objetos como em laços de repetição, e __next__() também realiza
iterações, mas avança automaticamente para a próxima ocorrência do objeto.

Um detalhe importante é que a forma como os métodos funcionam depende da

forma como os dados estão armazenados nos objetos. Uma string têm seu
avanço ocorrendo caractere por caractere, ao passo que uma lista tem seu
avanço de elemento a elemento da lista. Observe os exemplos a seguir na figura
5.4.

tupla1 = ("Elemento 1", "Elemento 3", "Elemento 3", "Elemento 4")

texto1 = "Informação"

iterador1 = iter (tupla1)

iterador2 = iter (texto1)

print (next (iterador1))

print (next (iterador1))
print (next (iterador1), "\n")

72
print (next (iterador2))
print (next (iterador2))
print (next (iterador2), "\n")

Elemento 1
Elemento 3
Elemento 3

I
n
f
Figura 5.4: Exemplos de uso do método iter() e next().

Fonte: O autor.

No primeiro exemplo da figura 5.4, são instanciados um objeto tupla1 com quatro
elementos e um objeto texto1 com uma string. Duas variáveis iterador1 e
iterador2 são instanciados com os métodos iter() sendo acionados para que o
processo de avanço nos elementos ou caracteres de cada objeto seja acessado.

A partir desta preparação das iterações, são utilizadas funções print() em

sequência para exibir sequencialmente os elementos ou caracteres de dados
dos objetos, sendo que cada ocorrência da função utiliza o método next() para
avançar para o próximo elemento nos dados.

Um detalhe é que no segundo objeto, como contém uma string como dados, o
avanço ocorre em um caractere por vez, e três funções print() são utilizadas,
apenas três caracteres da string são exibidos. Para melhorar esta situação,
observe o exemplo da figura 5.5.

class Contador:
def __iter__(self):
self.numero = 1

73
 return self

def __next__(self):
if self.numero <= 5:
i = self.numero
self.numero += 1
return i
else:
raise StopIteration

obj = Contador()
iterador3 = iter(obj)

for i in iterador3:
print(i)

1
2
3
4
5
Figura 5.5: Exemplos de uso do método iter() e next().

Fonte: O autor.

Nesta versão do uso dos métodos iter() e next(), é definido um método

__iter__() para definir um atributo numero para a classe Contador que retorna
o valor do atributo a qual objeto o acesse.

Na sequência o método __next()__ é definido para ajustar a forma como devem

ocorrer as sucessivas iterações nos dados do atributo do objeto, de forma que a
cada iteração, seja incrementada uma unidade no valor do atributo até que atinja
um limite estabelecido de 5 a cada uso do método iter().

74
Esse controle de incremento do valor do atributo numero é controlado por uma
estrutura de decisão if que possui uma exceção controlada pelo comando else
que encerra as iterações através do comando raise StopIteration, impedindo
que sejam realizadas iterações indefinidamente.

Depois, é instanciado um objeto obj a partir da classe Contador, e sem seguida,

uma variável iterador3 recebe o resultado obtido pelo método iter(). Para
finalizar o código, um laço de repetição atualiza seguidamente os dados para
iterador3 a partir dos métodos iter() e next() da classe.

Módulos

Quando se desenvolve códigos durante um tempo em qualquer linguagem de

programação, é comum que em certas ocasiões, sejam implementados
pequenos ou grandes trechos de código repetidos ou muito parecidos com
praticamente as mesmas funcionalidades.

Em casos assim, é interessante que, aos poucos, sejam agrupadas funções e

classes contendo funcionalidades reaproveitáveis e arquivos de bibliotecas
sejam implementados. Um ponto importante é que um módulo pode conter
instruções e estruturas de dados como qualquer outro arquivo de código Python,
e por isto poderia ser implementado como um código completo executável, mas
não é esta a sua finalidade. A ideia é que contenha funcionalidades
compartilháveis em vários outros códigos sem que tenha que ser estruturado
para ser executável.

Em Python, o nome dado a uma biblioteca é módulo, e arquivos deste tipo são
nomeados com a extensão “.py”. Observe o exemplo da figura 5.6 de como
implementar um módulo para linguagem Python.

#Arquivo modulo.py
def quadrado (valor):
print ("Quadrado de", valor, "é", int(valor) * int(valor))

75
def cubo (valor):
print ("Cubo de", valor, "é", int(valor) * int(valor) * int(valor))

#Arquivo calcula.py
import modulo

num = input()
modulo.quadrado (num)
modulo.cubo (num)

3
Quadrado de 3 é 9
Cubo de 3 é 27
Figura 5.6: Exemplo de uso de módulo e script em arquivos separados.

Fonte: O autor.

No exemplo da figura 5.6 é importante observar que são gerados dois arquivos
separados gravados com os nomes indicados nos comentários, por exemplo. O
nome do segundo arquivo pode ser modificado livremente, mas caso seja
desejada a alteração do nome do primeiro arquivo, é preciso observar que este
nome deve ser substituído na linha da instrução de vínculo de módulos usando
o comando import. Outro ponto é não se esquecer de manter a extensão “.py”
padrão da linguagem.

Em relação à indicação de um módulo a ser importado, é importante que este

módulo seja gravado na mesma pasta do código a ser executado, ou em uma
pasta que conste como caminho padrão do sistema operacional (path), senão o
arquivo módulo não será localizado para uso de suas funcionalidades.

No arquivo modulo.py são adicionadas duas funções quadrado(valor) e

cubo(valor), sendo que ambas aceitam um parâmetro para uso na realização

76
de seus cálculos, e basicamente, cada função apenas possui a funcionalidade
de exibir uma mensagem com o resultado do cálculo respectivo de cada função.

O outro arquivo calcula.py possui o código principal a ser executado e

basicamente realiza o vínculo da biblioteca, recebe um valor informado pelo
usuário e o armazena em uma variável num que é então utilizada como
parâmetro para a chamada das funções do módulo. A execução exibida abaixo
dos códigos mostra o funcionamento da execução em conjunto do código e do
módulo exibindo o quadrado e o cubo do valor 3 usado como exemplo.

#Arquivo registros.py
dados1 = {
"nome": "João",
"fone": "98659-1200"
}
dados2 = {
"nome": "Marcos",
"fone": "98563-8989"
}

#Arquivo consulta.py
import registros

print (modulo.dados1["nome"], "-", modulo.dados1["fone"])

João - 98659-1200
Figura 5.7: Exemplo de uso de módulo e script em arquivos separados.

Fonte: O autor.

Neste outro exemplo da figura 5.7, é trazida a possibilidade de implementação

de bancos de dados simples com arquivos texto onde o módulo possui dados
armazenados em dicionários nomeados dados1 e dados2 e gravados num

77
arquivo registros.py que podem ser utilizados como registros para consulta e
manipulação utilizando os recursos vistos de manipulação de arquivos de texto
e estruturas de dados.

No segundo arquivo consulta.py contém apenas a importação do módulo

registros.py para acesso aos dados dos dicionários e exibição dos dados do
dicionário dados1 pela função print(). Como resultado, João - 98659-1200 é
exibido ao usuário.

Existem módulos prontos da linguagem Python como datetime que contém

funcionalidades específicas para manipulação de data e hora. O módulo re para
trabalho com expressões regulares muito utilizadas para lidar com bases de
dados textuais, por exemplo, permitindo buscas e manipulação de caracteres.

É preciso verificar se estes módulos todos estão instalados em sua versão de

Python e instalados se desejado. Para isto, existe uma ferramenta chamada PIP
que gerencia pacotes Python contendo módulos para adição de funcionalidades
à linguagem. É possível verificar módulos disponíveis através da opção File,
Module Browser no Shell Python ou com o comando pip list no terminal do
sistema operacional. Para instalar, basta usar o comando pip install indicando
o nome do módulo desejado após a palavra install.

Outro módulo que pode padrão que pode ser utilizado livremente é chamado
JSON que pode ser utilizado para ler e converter dados em padrão Python para
Javascript ou vice-versa. Nesta conversão, dicionários Python são convertidos
para objetos Javascript ou tipos Python (str e int, por exemplo) em Javascript
(String e Number respectivamente).

O módulo mysql.connector é utilizado para aplicações que lidem com bancos

de dados MySQL muito comuns no mercado, mas antes de qualquer teste com
este tipo de aplicação, é preciso verificar com a ferramenta PIP se está instalado
o módulo, e caso não esteja, utilize o comando python -m pip install mysql-
connector para instalação do pacote como mostrado na figura 5.8.

78
Figura 5.8: Exemplo de instalação do pacote mysql.connector.

Fonte: O autor.

Para se trabalhar com este módulo mysql.connector, é preciso também

conhecer a linguagem SQL de manipulação de bancos de dados, pois este
processo é realizado com o uso dos comandos desta linguagem para trabalho
de criação e manipulação desse tipo de banco de dados.

Um exemplo de uso é ilustrado na figura 5.9 que traz a simulação de acesso aos
dados de um banco de dados fictício já criado e contendo dados para uma
consulta a ser executada utilizando o comando SQL SELECT.

import mysql.connector

bancoCadastro = mysql.connector.connect (
host = "localhost",
user = "usuarioX",
passwd = "senhaX",
database = "cadastro"
)

79
base = bancoCadastro.cursor ()
base.execute ("SELECT * FROM PESSOA")
resultado = base.fetchall ()
print (“Listagem de todos os registros da tabela PESSOA”)
for i in resultado:
print (i)

Listagem de todos os registros da tabela PESSOA

(1, 'João', '98659-1200')
(2, 'Marcos', '98563-8989')
Figura 5.9: Exemplo de acesso e consulta a banco de dados.

Fonte: O autor.

Neste exemplo da figura 5.9, é importado o módulo mysql.connector para

acesso a recursos de manipulação de bases de dados MySQL. Em seguida,
utiliza-se o método connect() para acesso ao banco de dados indicado com seus
respectivos dados de login e senha de acesso.
Em seguida, é instanciado um objeto para representar o banco de dados e pelo
método execute(), é realizada a consulta com a indicação de um comando
apropriado da linguagem SQL como parâmetro, lembrando que não são
comandos Python que manipulam o banco de dados neste caso.
Depois de obtidos os resultados e associados ao objeto definido para o banco,
um laço de repetição exibe todos os dados retornados, onde, cada registro é
representado por uma iteração do laço for.
Uma outra opção de uso de banco de dados em Python também bastante
popular seria o módulo pymongo que permite a manipulação de bases de dados
NoSQL MongoDB que trabalha em formato padrão JSON. Caso o pacote não
tenha sido instalado, o comando python -m pip install pymongo pode ser
utilizado no terminal do sistema operacional para adicionar esta funcionalidade.
Observe a figura 5.10.

import pymongo

80
cliente = pymongo.MongoClient ("mongodb://localhost:99999/")
banco = cliente ["BASEDADOS"]
coluna = banco ["PESSOA"]

print (“Listagem de todos os dados da coluna PESSOA”)

for i in coluna.find():
print (i)

Listagem de todos os dados da coluna PESSOA

{'_id': 1, 'nome': ' João ', 'fone': '98659-1200'}
{'_id': 2, 'nome': ' Marcos', 'fone': '98563-8989'}
Figura 5.10: Exemplo de uso do modulo pymongo.

Fonte: O autor.

Neste exemplo da figura 5.10, após a importação do módulo pymongo, é feita a

conexão fictícia com um banco e indicados o banco de dados e coluna de dados
para manipulação. Depois, é utilizado um laço de repetição for para que todos
os conjuntos de dados da coluna PESSOA possam ser percorridos e os dados
exibidos.

81
Conclusão

Existem outros e recursos, módulos e funcionalidades da linguagem Python a

serem aprendidos a medida que se evolui o aprendizado, e fontes adicionais
podem ser utilizadas como as indicadas como referências bibliográficas e
material disponível na web, mas é fundamental que um aprendizado bem feito
da base da linguagem seja obtido através de prática dos exemplos de código
existentes no material e variações dos mesmos criadas e pesquisadas para
aquisição de conhecimento complementar ao que foi estudado e realização da
prática de implementação de código que é primordial ao aprendizado.
Que este material possa servir como uma referência base para estudos e
posterior consulta, lembrando que a linguagem e suas ferramentas podem sofrer
evoluções em novas versões e é interessante que se acompanhe estas
mudanças, pois em geral, uma base é mantida, mas novas funcionalidades,
paradigmas ou recursos podem ser adicionados, além de mudanças em como é
implementada a versão atual alteradas.
O campo de utilização desta linguagem é grande e está em crescimento devido
á novas tecnologias e áreas em desenvolvimento na tecnologia da informação,
permitindo que está linguagem, em função de suas características, tenha atraído
uma grande leva de desenvolvedores para a criação de aplicações para o
mercado atual e futuro.
Bons estudos.

82