INTRODUÇÃO À

PROGRAMAÇÃO EM
PYTHON
Apostila do aluno
Aline Gabriel de Almeida – Analista Desenvolvedora de Software
Autora da apostila

Larissa Jessica Alves – Analista de Suporte Pedagógico

Revisão da apostila

Fit Instituto de Tecnologia

Sorocaba, setembro de 2021
Autora

Aline possui graduação em Engenharia

de Controle e Automação pela
Universidade Estadual Paulista Júlio de
Mesquita Filho – UNESP.
Atualmente é Analista Desenvolvedora
de Software no FIT – Flextronics
Institute of Technology, na área de
Inteligência Artificial, e é mestranda em
Ciência da Computação com ênfase em
Robótica, na UFSCar – Universidade
Federal de São Carlos.
 APRESENTAÇÃO

A presente apostila é um instrumento teórico que complementa o curso

de capacitação de Introdução à Programação em Python, promovido pelo FIT-
Instituto de Tecnologia. Nela, veremos como criar e utilizar variáveis, operadores,
expressões, estruturas de decisão e repetição, funções, classes, métodos e
objetos em Python. É extremamente recomendável ao aluno que, ao final da
leitura de cada seção, realize os exercícios propostos para testar os
conhecimentos adquiridos.
Desejo a você, prezado aluno, que tenha um excelente curso!

Boa Leitura!
Índice
1 Introdução .......................................................................................... 6

1.1 Linguagem de programação Python ............................................... 6

1.2 Primeiros passos para a criação de um programa em Python ....... 7

1.3 Exercícios ..................................................................................... 10

2 Variáveis .......................................................................................... 11

2.1 O que são variáveis ...................................................................... 11

2.2 Tipos de variáveis ......................................................................... 12

2.3 Lendo valores de entrada ............................................................. 13

2.4 Exercícios ..................................................................................... 15

3 Comandos e operadores.................................................................. 16

3.1 Comentários ................................................................................. 16

3.2 Operadores Aritméticos e Expressões ......................................... 16

3.3 Operadores Relacionais ............................................................... 18

3.4 Operadores lógicos....................................................................... 19

3.5 Expressões ................................................................................... 20

3.6 Exercícios ..................................................................................... 21

4 Estruturas de Decisão ...................................................................... 22

4.1 Estrutura de decisão do tipo if ...................................................... 22

4.2 Estrutura de decisão do tipo else.................................................. 22

4.3 Estrutura de decisão do tipo elif.................................................... 23

4.4 Exemplo ........................................................................................ 23

4.5 Exercícios ..................................................................................... 24

5 Estruturas de Repetição................................................................... 25

5.1 Laço de repetição do tipo while .................................................... 25

5.2 Laço de repetição do tipo for ........................................................ 26

5.3 Exercícios ..................................................................................... 27

6 Estrutura de dados ........................................................................... 28

6.1 Listas ............................................................................................ 28

6.2 Tuplas ........................................................................................... 30

6.3 Dicionários .................................................................................... 31

6.4 Exercícios ..................................................................................... 32

7 Funções ........................................................................................... 33

7.1 Criação e utilização de funções .................................................... 33

7.2 Exercícios ..................................................................................... 35

8 Classes e objetos ............................................................................. 36

8.1 Criação e utilização de classes e objetos ..................................... 36

8.2 Exercícios ..................................................................................... 38

9 Bibliotecas........................................................................................ 39

Conclusão .............................................................................................. 40

Referências............................................................................................ 41
1 Introdução
1.1 Linguagem de programação Python
Python é uma linguagem de programação popular em diversas áreas tais
como Desenvolvimento de Software, Ciência de Dados, Business Intelligence,
entre outras. Idealizada e desenvolvida por Guido Van Rossum, matemático
holandês, em 1991, foi criada com o objetivo de otimizar a leitura de códigos e
estimular a produtividade de quem os cria, seja este um programador ou
qualquer outro profissional que faz uso desta ferramenta.
Após a criação da linguagem, várias novas versões foram lançadas e sua
evolução ao longo dos últimos anos pode ser observada na Figura 1- Diagrama
cronológico do lançamento das versões da linguagem de programação Python. Fonte: Stack
Overflow [2]. Figura 1. Hoje em dia a linguagem se encontra na versão 3.9.

Figura 1- Diagrama cronológico do lançamento das versões da linguagem de

programação Python. Fonte: Stack Overflow [2].

A Figura 2 mostra uma representação dos dados referentes à quantidade

de visualizações de perguntas e respostas sobre Python e outras linguagens de
programação gerados pelo fórum Stack Overflow [3], que é um dos fóruns mais
populares na comunidade de desenvolvedores ao redor do mundo. Pelo gráfico
pode-se observar como o interesse pela linguagem vem aumentando e que ela
tem se tornado a linguagem mais popular entre os usuários do fórum.

FIT-F.24.1.01-04Rev. C
 Figura 2 - Evolução do interesse pela linguagem de programação Python representada pelas
porcentagens de visualizações de perguntas e respostas no fórum Stack Overflow a cada mês
dos últimos anos. Fonte: Stack Overflow [4].

Um dos principais motivos dessa popularidade é que, além da facilidade

de se aprender a utilizar a linguagem, Python é predominantemente a linguagem
mais utilizada no desenvolvimento de algoritmos de Inteligência Artificial e
Aprendizado de Máquinas.

1.2 Primeiros passos para a criação de um programa

em Python
A seguir estão descritos os primeiros passos para a criação de um
programa em Python que tem a função de exibir a mensagem “Olá, Mundo!” na
tela.
Para a criação deste programa, será utilizada a plataforma Google Colab
[5]. Esta plataforma permite a execução em tempo real dos comandos em
FIT-F.24.1.01-04Rev. C
Python, sem que seja necessário instalar nenhum software no computador.
Dessa forma, o primeiro passo para a criação do programa é acessar a
plataforma através do link “https://colab.research.google.com/#create=true”.
Ao ser acessada, a plataforma exibe uma interface do tipo Jupyter
Notebook, dentro da qual é possível inserir células de comandos e executá-las.
Para introduzir uma célula de código, deve-se utilizar o menu Insert e
escolher a opção Insert Cell, como mostra a Figura 3.

Figura 3 - Inserção de uma célula de código usando a plataforma Google Colab.

Agora é possível inserir e executar um trecho de código em Python nesta

célula. Para a exibição de um texto na tela, será utilizado o comando mostrado
na Figura 4.

FIT-F.24.1.01-04Rev. C
 Figura 4 - Comando em Python utilizado para exibir um texto na tela.

Para executar o código deve-se utilizar o botão Run cell localizado no

início da célula ou utilizar o conjunto de teclas Ctrl+Enter, conforme a Figura 5.

Figura 5 - Botão utilizado para executar o código da célula.

O resultado esperado é mostrado na Figura 6.

FIT-F.24.1.01-04Rev. C
 Figura 6 - Resultado esperado da execução do código.

1.3 Exercícios
Altere o código em Python anterior e escreva sua própria versão do
programa. Você pode alterar a mensagem que está entre aspas, executar o
código e verificar o novo resultado na tela.

FIT-F.24.1.01-04Rev. C
2 Variáveis
2.1 O que são variáveis
As variáveis são um dos principais recursos na programação e permitem
que um programa armazene informações na memória do computador e que leia
essas informações com facilidade a partir de um nome definido.
As variáveis em Python podem ser usadas para manipular palavras ou
cadeias de caracteres, conhecidas como strings, números inteiros ou números
reais, por exemplo.
Para criar uma variável, basta definir um nome e atribuir-lhe um valor
usando o símbolo “=”. A criação de algumas variáveis é exemplificada na Figura
7.

Figura 7 - Exemplo de criação de variáveis.

Estas variáveis estão agora na memória do computador e podem ser

acessadas a qualquer momento pelo comando print, por exemplo, como pode
ser visto na Figura 8.

FIT-F.24.1.01-04Rev. C
 Figura 8 - Exibindo os valores de variáveis.

2.2 Tipos de variáveis

Durante a criação de uma variável, um espaço na memória do computador
é automaticamente associado a elas. Em Python, existem diferentes tipos de
variáveis, e de acordo com cada tipo, elas podem ser organizadas de maneira
distinta e podem também requerer diferentes espaços de armazenamento na
memória.
Os tipos básicos de variáveis em Python são:
• “Int”: armazenam números inteiros, tanto positivos quanto negativos,
tais como 2, 453, -12 ou 0.
• “Float”: armazenam números reais, tais como 2.34, -12.9, 0.04 ou 1E-
7.
• “Complex”: armazenam números complexos do tipo a + jb, onde a e b
são números reais e j = √−1 é a unidade imaginária.
• “Strings”: armazenam um ou mais caracteres, tais como ‘a’, ‘abc’ ou
‘era uma vez uma garotinha chamada chapeuzinho vermelho...’, sendo
que são sempre declaradas utilizando aspas simples ’ ou duplas " no
início e final.
• “Bool”: armazena os valores lógicos True (verdadeiro) ou False (falso).
FIT-F.24.1.01-04Rev. C
 A Figura 9 mostra o código utilizado para identificar qual é o tipo de uma
variável utilizando o comando type e como mostrá-lo na tela utilizando o
comando print.

Figura 9 - Identificando o tipo de cada variável em Python.

2.3 Lendo valores de entrada

As informações armazenadas em variáveis podem ser determinadas no
próprio código, como foi demonstrado no exemplo da Figura 9, ou podem ser
recebidas pelo programa, usando, por exemplo, o comando input.
Um exemplo de utilização do comando input é mostrado na Figura 10. Na
figura pode-se observar que a execução deste código gera uma caixa de texto
para que o usuário digite a informação que deve ser armazenada e que a
informação recebida pelo comando input fica armazenada em uma variável do
tipo string.

FIT-F.24.1.01-04Rev. C
 Figura 10 - Recebendo e armazenando informações usando o comando "input".

É possível alterar o tipo da variável recebida através do comando input,

para isso utiliza-se as funções que levam o nome do tipo de variável desejado.
A Figura 11 ilustra um exemplo de transformação de uma variável do tipo string
para uma variável do tipo int e uma variável do tipo float.

FIT-F.24.1.01-04Rev. C
 Figura 11 - conversão de variáveis do tipo "string" para os tipos "int" e "float".

2.4 Exercícios
1. Escreva um programa em Python que solicita ao usuário que digite seu
nome, e em seguida armazena em uma variável o que foi digitado,
exibindo uma mensagem personalizada na tela.

2. Escreva um programa em Python que recebe dois números e mostra

o resultado da soma e a diferença entre os dois.

FIT-F.24.1.01-04Rev. C
3 Comandos e operadores
Além de criar e informar valores para as variáveis, é possível usar as
variáveis para fazer comentários, operações aritméticas e lógica, por exemplo.

3.1 Comentários
Comentários não são levados em consideração na execução do código e,
portanto, não influenciam o seu funcionamento. Entretanto, podem ser uma
ferramenta útil para fazer explicações sobre o código que foi escrito para que
seja mais facilmente entendido por outros programadores.
Em Python é possível criar comentários ao longo do código com o auxílio
do símbolo “#”. O uso de comentários é exemplificado na Figura 12.

Figura 12 - Uso de comentários ao longo do código.

3.2 Operadores Aritméticos e Expressões

Operadores aritméticos são símbolos que representam as operações
aritméticas, tais como: soma, subtração, multiplicação e divisão. A Figura 13
mostra o conjunto de operadores aritméticos usados em Python.

FIT-F.24.1.01-04Rev. C
 Figura 13 - Operadores aritméticos.

Alguns exemplos de operações aritméticas em Python são mostrados na

Figura 14.

FIT-F.24.1.01-04Rev. C
 Figura 14 - operações aritméticas usadas em Python.

3.3 Operadores Relacionais

Operadores de comparação ou relacionais são utilizados em expressões
lógicas, isto é, expressões que fazem comparações entre variáveis lógicas ou
booleanas. Admitem apenas dois valores como resultados: True (verdadeiro) ou
False (falso).
A Figura 15 mostra um exemplo de uma operação lógica em Python entre
duas variáveis: a variável “a”, que armazena o valor 3, e a variável “b”, que
armazena o valor 5. A comparação lógica é dada pela expressão “a > b” e,
quando é executada, informa o resultado da comparação. No exemplo, o valor
FIT-F.24.1.01-04Rev. C
da variável “a” não é maior que o valor da variável “b”, por isso o resultado da
comparação é False indicando que a condição é falsa.

Figura 15 - Operação lógica em Python.

A Figura 16 mostra o conjunto de operadores relacionais usados em

Python.

Figura 16 - Operadores relacionais usados em Python.

3.4 Operadores lógicos

Operadores lógicos possibilitam as operações entre valores lógicos ou
booleanos. Os principais operadores lógicos utilizados em programação são and
(e), or (ou) e not (não).
• and: é utilizado quando ambas as variáveis lógicas devem ser
verdadeiras para que o resultado seja verdadeiro. A Figura 17 ilustra o
comportamento deste operador.

FIT-F.24.1.01-04Rev. C
 Figura 17 - Tabela verdade do operador lógico "and".

• or: é utilizado quando pelo menos uma das variáveis lógicas deve ser
verdadeira para que o resultado seja verdadeiro. A Figura 18 ilustra o
comportamento deste operador.

Figura 18 - Tabela verdade do operador lógico "or".

• not: é utilizado para inverter o valor de uma variável. Se ela for verdadeira,
torna-se falsa; se for falsa, torna-se verdadeira. A Figura 19 ilustra o
comportamento deste operador.

Figura 19 - Tabela verdade do operador lógico "not".

3.5 Expressões
As expressões podem ser formadas por variáveis, operadores relacionais
e operadores lógicos. Caso envolvam apenas operadores aritméticos, o
resultado será um número. No entanto, no caso mais geral, quando envolvem
também operadores lógicos, o resultado será do tipo lógico ou booleano.

FIT-F.24.1.01-04Rev. C
 Um expressão lógica, é, por exemplo, a expressão: (x < y) and (y < z),
que relaciona as variáveis “x” e “y” e “z” utilizando operadores relacionais “<” e
“>” e o operador lógico “and”.

3.6 Exercícios
1. Armazene três números nas variáveis “a”, “b” e “c” e resolva as
seguintes equações utilizando a linguagem de programação Python:
•r=a+b-c
• r = a * (b + c)
• r = (a + b) / c
• r = (a + b + c) / 3

2. Utilize os valores de n1 = 2, n2 = 3, n3 = -1 e n4 = 8 e verifique se as

expressões lógicas a seguir resultam em True ou False.
a. n1 < n3
b. n3 == n4
c. n1 + n2 > n3
d. n3 / n1 < n4
e. n1 + n2 < 10 and n3 - n4 == n1
f. n3 / n2 > 0 or n1 + n3 > n4

FIT-F.24.1.01-04Rev. C
4 Estruturas de Decisão
Estruturas de decisão permitem que decisões sejam tomadas ao longo do
código. São compostas por uma condição que pode retornar os valores True ou
False. Por exemplo, a condição “valor > 10”, retornaria o valor True se a variável
valor fosse maior que 10, e False, caso contrário.
Em Python as estruturas de decisão são formadas com auxílio dos
comandos if, else,ou elif.

4.1 Estrutura de decisão do tipo if

As estruturas de decisão são definidas de acordo com o formato:

O comando if indica que o bloco de instruções que está na sequência será

executado somente se a expressão for verdadeira, ou seja, se o resultado for
True. Note que o bloco de instruções é precedido por um espaço no começo da
linha; este espaçamento é conhecido como identação e é utilizado para indicar
o código que deve ser considerado como parte da estrutura de decisão.

4.2 Estrutura de decisão do tipo else

O comando else é utilizado para fazer uma estrutura de repetição
complementar. É utilizado depois de uma condição que faz uso do comando if e
e indica que o bloco de instruções que está na sequência será executado
somente se a expressão for verdadeira, e se a condição if anterior for falsa. É
definida de acordo com o formato:

FIT-F.24.1.01-04Rev. C
 4.3 Estrutura de decisão do tipo elif
O comando elif é utilizado de maneira similar ao comando else, mas
permite fazer condições intermediárias e é definida de acordo com o formato:

4.4 Exemplo
O exemplo mostrado na Figura 12 mostra o código usado para informar
ao usuário se ele está apto a tirar a carteira de motorista de acordo com a sua
idade de maneira que, inicialmente, armazena a idade do usuário na variável
idade e, em seguida, verifica, usando o comando if, se a idade do usuário é maior
que 18 anos. Em caso afirmativo, mostra na tela uma mensagem informando
que o usuário já pode tirar a carteira de motorista; em caso negativo, ou seja,
caso a idade do usuário não seja maior que 18 anos, o programa exibe uma
mensagem informando que o usuário ainda não pode tirar a careteira de
motorista.

Figura 20 - Exemplo de estrutura de decisão

FIT-F.24.1.01-04Rev. C
 4.5 Exercícios
1. Escreva um programa que decide se um número é par ou ímpar.

2. Escreva um programa que classifique um atleta em uma categoria

etária, de acordo com a tabela a seguir:

FIT-F.24.1.01-04Rev. C
5 Estruturas de Repetição
Estruturas de repetição permitem que um mesmo trecho de código seja
executado várias vezes enquanto uma condição for verdadeira, até que ela se
torne falsa.
Em Python as estruturas de repetição são formadas com auxílio dos
comandos while e for.

5.1 Laço de repetição do tipo while

A estrutura de repetição do tipo while repete o bloco de instrução
subordinado a ela enquanto alguma condição for verdadeira e segue a estrutura
geral:

O exemplo da Figura 21 cria uma variável n com o valor inicial igual a 10

e utiliza o comando while para mostrar uma mensagem na tela a cada vez que
o código for executado. Note que o valor da variável n é utilizado na condição do
comando while e também é alterado dentro do bloco de comandos, de forma que
após uma quantidade finita de iterações a condição se torne falsa.

FIT-F.24.1.01-04Rev. C
 Figura 21 - Exemplo de uma repetição do tipo while.

5.2 Laço de repetição do tipo for

A estrutura de repetição do tipo for repete o bloco de instrução
subordinado a ela por um número de vezes pré-determinado e segue a estrutura
geral:

O exemplo da Figura 22 utiliza o laço de repetição for para mostrar uma

mensagem na tela 10 vezes. Utiliza uma variável auxiliar i cujo valor inicial é zero
e tem seu valor aumentado em 1 unidade automaticamente a cada vez que o
laço de repetição é executado, sem que seja necessário alterar seu valor
explicitamente dentro do bloco de comandos.

FIT-F.24.1.01-04Rev. C
 Figura 22 - exemplo de repetição do tipo for.

5.3 Exercícios
1. Faça um algoritmo que mostre na tela todos os números ímpares de 0
a 100.

2. Escreva um programa em Python que solicita que o usuário digite o

nome e a idade, e imprime uma mensagem na tela. O programa deverá então
repetir a pergunta até que o usuário digite a palavra ‘fim’ no lugar do nome.

FIT-F.24.1.01-04Rev. C
6 Estrutura de dados
Estruturas de dados podem ser utilizadas para armazenar, em uma
mesma variável, mais de um valor. Em Python as principais estruturas de dados
são as listas, tuplas e dicionários.

6.1 Listas
Listas são estruturas capazes de agrupar elementos em uma determinada
sequência. Em Python, uma lista pode ser criada utilizando-se colchetes para
delimitar o conjunto de elementos, que devem ser separados por vírgula. É
interessante notar que os elementos não precisam ser do mesmo tipo. A Figura
23 ilustra a criação de uma lista contendo elementos do tipo string, int e float.

Figura 23 - criação de uma lista.

Os elementos de uma lista podem ser acessados utilizando-se a posição

de cada elemento. A Figura 24 exemplifica a criação de uma lista com 6
elementos e, em seguida, acessa o primeiro elemento da lista (índice 0) e o
quinto elemento da lista (índice 4).

FIT-F.24.1.01-04Rev. C
 Figura 24 - Acessando elementos de uma lista pelo índice.

Adicionalmente, pode-se selecionar uma parte da lista, indicando a

posição do elemento inicial e a posição do elemento final. A Figura 25 mostra a
criação de uma lista e a seleção dos elementos desta lista desde o segundo
elemento (índice 1) até o quarto elemento (índice 4).

Figura 25 - Seleção de um intervalo de elementos uma lista.

Note que a nova lista contém o elemento inicial do intervalo (índice 1) e

não contém o elemento final (índice 4). Essa é uma característica desta
operação.
Além de uma nova lista poder ser criada a partir de um trecho de uma
outra lista, também é possível criar uma lista através da união de duas listas
utilizando-se o símbolo “+”, como mostra o exemplo da Figura 26.
FIT-F.24.1.01-04Rev. C
 Figura 26 - Criação de uma lista a partir de duas listas.

6.2 Tuplas
Tuplas são estruturas capazes de agrupar elementos em uma
determinada sequência, assim como as listas. Em Python, uma tupla pode ser
criada utilizando-se parênteses para delimitar o conjunto de elementos, que
devem ser separados por vírgula. Em tuplas, os elementos também podem ser
de tipos diferentes, mas os elementos não podem ser alterados. A Figura 27
ilustra a criação de uma tupla contendo elementos do tipo int.

Figura 27 - Criação de uma tupla.

FIT-F.24.1.01-04Rev. C
 Os elementos de uma tupla também podem ser acessados utilizando-se
a posição de cada elemento ou um intervalo de elementos. Além disso, uma
nova tupla pode ser criada a partir de outras duas tuplas, como mostra o exemplo
da Figura 28.

Figura 28 - Acessando elementos de uma tupla pelos indices e criando uma nova tupla
a partir de duas tuplas.

6.3 Dicionários
Na linguagem de Python os dicionários são uma outra estrutura de dados
utilizada para armazenar um conjunto de elementos. Um dicionário pode ser
criado utilizando-se chaves para delimitar o conjunto de elementos.
Os dicionários obedecem à seguinte sintaxe:

FIT-F.24.1.01-04Rev. C
 Note que os elementos de um dicionário são compostos de pares
“chave:elemento”. A ideia é que se possa referenciar os elementos do dicionário
através de suas chaves e não mais seus índices. A Figura 29Figura 27 ilustra a
criação de um dicionário e o acesso ao elemento correspondente à “chave1”;
além disso, também mostra como é possível adicionar um novo elemento à um
dicionário.

Figura 29 - estrutura de dados do tipo dicionário.

6.4 Exercícios
1. Construa duas listas e mostre as listas na tela. Depois, crie uma lista
a partir da junção das duas listas anteriores e mostre o valor da
posição 0.

2. Construa um dicionário cujas chaves sejam as palavras em inglês for,

in, if, else, True, False e while e os valores sejam as traduções para
o português.

FIT-F.24.1.01-04Rev. C
7 Funções
Uma função consiste em um trecho de código que resolve um problema
específico, geralmente parte de um problema maior.
Algumas vantagens na utilização de funções em programação são:
o Redução do código duplicado em um programa;
o Possibilidade de reutilizar o mesmo código em um ou mais
programas;
o Decomposição de um problema grande em problemas menores
mais específicos;
o Melhorar a interpretabilidade de um programa por parte de outros
programadores;
o Permite que se torne oculta uma parte de um programa, mantendo
o restante do código alheio à lógica implementada pela função.

7.1 Criação e utilização de funções

De um modo geral, uma função é composta pelos seguintes componentes
básicos:
o Protótipo: onde se encontra o nome da função e os parâmetros que
são passados à função quando a utilizamos. Em Python esta
informação se encontra na primeira linha da função, logo após a
palavra reservada def;
o Corpo, ou o bloco de código: código que realiza a tarefa da função;
o Valores de retorno: podem ser utilizados no programa principal ou
armazenados em memória.

Uma função apresenta a estrutura básica do tipo:

Note que assim como em outras estruturas, o código referente ao corpo

da função deve ser identado.

FIT-F.24.1.01-04Rev. C
 Uma vez que a função seja criada, pode-se chamá-la a partir do programa
principal usando a sintaxe do tipo:

Em que as variáveis a, b, e c são as variáveis do programa principal e

servirão como parâmetros para a função que está sendo chamada e a variável v
assumirá o valor retornado pela função.
Os parâmetros passados pela função são opcionais, ou seja, é possível
chamar uma função sem passar nenhum parâmetro. Da mesma forma, o valor
retornado pela função também é opcional, de forma que uma função pode ser
chamada, executada sem que retorne valores para o programa a partir do qual
foi chamada.
A Figura 30 mostra um exemplo da declaração de uma função chamada
minha_função que recebe como parâmetro um valor, identificado pela variável
numero. No corpo da função, duas novas variáveis são criadas, a variável x que
armazena o valor do parâmetro multiplicado por 2, e a variável y que armazena
o resultado do parâmetro recebido dividido por 2. A função retorna os valores de
x e y.

FIT-F.24.1.01-04Rev. C
 Figura 30 - Declaração e uso de funções em Python.

7.2 Exercícios
1. Escreva uma função que recebe dois números e calcula sua média.

2. Escreva uma função que recebe uma lista de números e calcula a sua
média.

Desafio: Escreva uma função que recebe um número e retorna True se ele for
primo ou False se ele não for primo.

FIT-F.24.1.01-04Rev. C
8 Classes e objetos
Python é uma linguagem orientada a objetos, isto significa que ela faz uso
de classes e objetos.
Para ilustrar o uso de classes e objetos, pode-se imaginar que uma classe
seja um molde que fornece as características de alguma coisa que se quer
modelar, enquanto um objeto seja a escultura criada a partir deste molde.

8.1 Criação e utilização de classes e objetos

Considere, por exemplo, um programa que utiliza uma classe para
classificar um conjunto de colaboradores em uma empresa e o relacionamento
entre estes colaboradores. O programa pode começar com a criação de uma
classe e instanciando-se alguns objetos dessa classe.
Esse exemplo é ilustrado na Figura 31, em que uma classe Pessoa é
criada com as propriedades nome, cargo e salario. Em seguida, dois objetos do
tipo Pessoa são criados: o objeto gerente e o objeto engenheiro. Note que todos
os objetos têm as mesmas propriedades nome, cargo e salario, no entanto as
informações das propriedades de cada objeto são diferentes.

FIT-F.24.1.01-04Rev. C
 Figura 31 - Criação de classes e objetos.

Além de propriedades, as classes podem acomodar métodos. Métodos

são funções que utilizam ou alteram os valores das propriedades.
A Figura 32 mostra um exemplo em que a classe Pessoa tem um método
chamado calcula_salario. Note a estrutura da criação de um método, que deve
iniciar com a palavra def e deve ter seu código identado para que faça parte do
bloco de código referente à classe.

FIT-F.24.1.01-04Rev. C
 Figura 32 - Criação de um método em Python.

8.2 Exercícios
1. Crie uma classe Animais com as propriedades nome, raça e ano de
nascimento. Instancie os objetos gato, cachorro e passarinho e crie um
método para calcular a idade dos animais.

FIT-F.24.1.01-04Rev. C
9 Bibliotecas
Bibliotecas são compostas por funções que executam tarefas específicas.
Em Python, por exemplo, as bibliotecas math e numpy foram criadas e estão
disponíveis para quaisquer pessoas que queiram usá-las.
Para utilizar uma biblioteca padrão é preciso importá-la usando o
comando import. A Figura 33 mostra como importar e usar a biblioteca math para
calcular a raiz quadrada do número 9.

Figura 33 - Importanto a biblioteca math.

FIT-F.24.1.01-04Rev. C
 Conclusão

A abordagem desta apostila permite ao leitor uma interação ativa com as

principais características e comandos em Python. Foram abordados temas
como, criar e utilizar variáveis, rotinas de decisão e repetição, funções, classes,
métodos e bibliotecas em Python, para dar ao aluno autonomia, estímulo, senso
crítico e contribuir para uma aprendizagem mais efetiva.
Assim, o conteúdo do curso de Introdução à programação em Python
familiariza o leitor com o mundo tecnológico, onde a virtualização ganha, cada
vez mais, espaço. Obrigada por fazer parte do curso e ter realizado a leitura
desta apostila. Espero que o seu interesse por programação em Python esteja
aguçado, para que você pratique e conheça ainda mais as maravilhas desta
linguagem de programação.

FIT-F.24.1.01-04Rev. C
 Referências

[1] Padilha, Antonio C. Introdução ao Python. Jaguariúna, 2020.

[2] Vicki Boykis. Stack Overflow Blog: Why is the Migration to Python
3 Taking so Long? Disponível em: https://stackoverflow.blog/2019/11/14/why-
is-the-migration-to-python-3-taking-so-long. Acessada em 13/08/2021.

[3] Stack Overflow. Disponível em: https://stackoverflow.com/. Acessada

em 13/08/2021.

[4] David Robinson. Stack Overflow Blog: The Incredible Growth of

Python Disponível em: https://stackoverflow.blog/2017/09/06/incredible-growth-
python. Acessada em 13/08/2021.

[5] Plataforma Google Colab. Disponível em:

https://colab.research.google.com/notebooks/intro.ipynb. Acessada em
13/08/2021.

FIT-F.24.1.01-04Rev. C
 CONTROLE DE REVISÃO DO DOCUMENTO / DOCUMENT REVISION CONTROL
Revisão Descrição Razão Autor Data
Review Description Reason Author Date
A - Revisão inicial Larissa Alves 17/08/21
B Troca de template oficial Troca de template Larissa Alves 15/09/21
Revisão do modelo
C Alteração de logotipia do rodapé do documento do formulário FIT- Adson Alves 01/07/2022
F.24.1.01-04Rev. C

FIT-F.24.1.01-04Rev. C
FIT-F.24.1.01-04Rev. C