Tutorial Básico sobre a

Linguagem Python
04/09/2020

PET - Tecnologia em Eletrônica e Computação

Universidade Federal de Itajubá - UNIFEI

Itajubá Minas Gerais

 1

Introdução
Neste tutorial será apresentado os conceitos básicos da linguagem de programação
Python. Não é necessário possuir nenhum conhecimento prévio em outras linguagens de
programação.

Python é uma linguagem de alto nível criada com o intuito de ser uma linguagem
simples de se aprender, fácil de ler e concisa. Foi criada em 1992 por Guido van Rossum e
desde então é desenvolvida de forma comunitária com a liderança da Python Software
Foundation.

É uma linguagem interpretada, ou seja, o código é executado linha a linha por um

interpretador, isso permite uma rapidez em testar e corrigir programas. Python também
possui tipagem dinâmica, o que permite que variáveis no programa possam mudar de tipo
durante a execução do programa.

Configurando o ambiente
Para este tutorial será utilizado a plataforma online repl.it que pode ser encontrada
no seguinte site: ​https://repl.it/​. Ao acessar a página deve-se clicar em ​start coding. Em
seguida será pedido que você crie uma conta, faça isso e siga os passos que o próprio site
fornece. Na hora de escolher as linguagens deve-se escolher a linguagem python e mais
outras duas de sua preferência pois o site exige que se escolha ao menos três. No meu
caso ficou como na figura a seguir:
 2

Em seguida será pedido que você verifique sua conta e faça uma introdução sobre
você mesmo, mas isso é opcional. Para os objetivos deste tutorial você deve selecionar a
opção Python logo após a linha “or start coding” como indicado na próxima figura.
 3

Você será levado para uma nova página destinada a programação em Python.
No painel mais à esquerda são mostrados os nomes dos arquivos que estão sendo
editados. Ao se abrir pela primeira vez provavelmente haverá apenas o arquivo ​main.py​.
No painel do meio é a área de edição, onde pode-se escrever ou modificar o código
Python. Por fim, no painel mais à direita fica o terminal contendo o REPL da linguagem e
também onde aparecem os resultados da execução do programa.
 4

REPLs são utilizados para executar pequenos comandos da linguagem, geralmente

com o propósito de realizar testes simples. O leitor pode experimentar digitar alguma
expressão simples no REPL, como por exemplo “2 + 2” e pressionar a tecla ​Enter​.

> ​2​ + ​2
4

Hello World
Na programação é comum que ao se iniciar o aprendizado de alguma linguagem o
primeira programa escrito seja um “Hello World”, e é exatamente isso que será realizado
neste tutorial. O programa em Python pode ser escrito da seguinte forma:

print(​"Hello world"​)
 5

Escreva isso no painel de edição de texto, o do meio. Em seguida pressione o botão

Run localizado na barra superior da página. Se tudo ocorrer bem a mensagem Hello World
deverá aparecer no painel à direita, isto é, no REPL.

Para facilitar a leitura do código pode-se adicionar comentários ao código que serão
ignorados pelo interpretador. Para isso deve-se usar o símbolo ​# em alguma posição da
linha, tudo escrito entre esse símbolo e o final da linha será considerado um comentário.
# Isso é um comentário
print(​"Oi amigo"​) ​# Outro comentário
# Isso também é um comentário

Variáveis
Uma das coisas mais básicas que um programa de computador deve ser capaz de
realizar é armazenar e modificar valores em memória. Para isso é feito uso das chamadas
variáveis. Uma variável pode ser criada em Python a partir do seguinte código:

a = ​15
print(a)

No trecho de código cria-se uma variável chamada ​a e atribui-se a ela o valor 15. Na
linha seguinte usa-se o comando ​print para exibi-la. O nome de uma variável pode ter
qualquer comprimento desde que comece com uma letra, ou _, e não utilize nenhum
símbolo não alfanumérico. ​rato1​, ​grafenó​, ​Aphex_Twin e ​x_ são exemplos de nomes
válidos, ​pão quadrado​, ​123gameplays,​ ​tatu#mola? e ​comando-vermelho exemplos de
nomes inválidos.

A partir da linha em que se declara uma variável é possível modificar o seu valor,
veja a seguir.

var1 = ​15
print(var1)
var1 = ​23
print(var1)
var1 = var1 + ​1
print(var1)
 6

Nesse último exemplo declara-se a variável ​var1 com o valor 15, exibe-a, altera-se
seu valor para 23 e a exibe novamente. Na linha seguinte, ​var1 = var1 + 1, a variável é
modificada tal que seu novo valor é o valor antigo somado de 1, ou seja, 24. Lembrando
que só se pode usar uma variável do lado direito do sinal de igualdade se a mesma tiver
sido declarada anteriormente.

Também pode-se declarar variáveis com valores não numéricos como, por exemplo,
texto. Esses valores de texto devem ser escritos entre parênteses e são chamados de
strings​.

b = ​"Hello World"
print(b)

No trecho acima é apresentado uma forma alternativa do programa ​Hello World​, em

vez de usar diretamente a string no comando ​print​, salva-a primeira em uma variável que
depois é passada para o comando.

Trabalhando com Números

Em Python existem dois tipos principais de números, inteiros e reais. Os inteiros, ou
ints, ​são representados por números sem casas decimais como no exemplo a seguir.

a = ​12
b = 1​ 23432
c = 9 ​ 9999

Já os números reais, também chamados de ponto flutuante ou ​floats​, são escritos

com casas decimais. Deve-se usar o ponto e não a vírgula para separar a parte inteira da
fracionária. Alguns exemplos são:

a = ​12.3
b = 0​ .6
c = 0 ​ .0000001

Entre números e variáveis contendo números, diversas operações matemáticas são

suportadas.

a = ​5​ + ​7​ ​# soma

b = ​3.5​ - ​1​ ​ # subtração
c = a * ​10​ ​ # multiplicação
d = b/​2​ ​ # divisão
e = ​2​ ** ​64​ ​ # exponenciação
 7

f = ​5​ % ​2​ ​# resto da divisão

Tentar realizar uma operação matemática entre tipos não numéricos causará um
erro e o programa não será executado.

a = ​"oi"
b = 1​
c = a + b ​# causa um erro

Trabalhando com Strings

Como mencionado anteriormente ​strings são valores que representam texto. Esse
tipo de dado suporta também algumas operações como, por exemplo, o operador ​+ pode
ser utilizado para concatenar (unir) ​strings​.

nome = ​"Zbigniew"
sobre_nome = ​"Preisner"
nome_completo = nome + sobre_nome
print(nome_completo)

Ao executar esse código será exibido ​ZbigniewPreisner tudo junto. Isso ocorre
porque ambas as ​strings foram simplesmente unidas sem um espaço entre elas. Para
contornar esse problema, pode-se modificar a terceira linha para

nome_completo = nome + ​" "​ + sobre_nome

As vezes também pode ser necessário converter um valor numérico para ​string e
vice-versa. Para isso é muito simples, basta usar os comandos ​int()​ ​float()​ e ​str().​

Para converter um valor inteiro ou real para string:

inteiro = ​12
versao_texto = str(inteiro)
print(​"o numero é "​ + versao_texto)

Na segunda linha a variável ​versao_texto recebeu o valor de ​inteiro convertido

para ​string​. Dessa forma pode-se concatenar essa variável com a string ​"o numero inteiro é"
sem problemas, o que não poderia ser feito diretamente com a variável ​inteiro​. É
importante ressaltar que o comando ​str() não modifica a variável original apenas cria
uma cópia de seu valor convertido para string. Por isso, mesmo após e execução do
comando s ​ tr(),​ ​ a variável ​inteiro​ continua com um valor do tipo numérico.
 8

O contrário também é válido, pode-se converter uma variável de tipo ​string para um
valor inteiro ou real.

var1 = ​"12"
var2 = "​ 23.1"

a = int(var1)
b = float(var2)

print(a + b)

Para converter uma ​string para inteiro usa-se o comando ​int() e uma ​string para
real, ​float()​. Uma ​string só pode ser convertida para um desses valores se ela contiver
um texto que represente um número, caso contrário será gerado um erro.

a = ​"123/3"
b = "​ 2321a"
c = " ​ zero"

​ Erro
x = float(a) #
y = int(b) ​ Erro
#
c = int(c) ​ Erro
#

Entrada de Dados
Uma outra tarefa muito importante que os programas de computador devem
realizar é a leitura de dados inseridos pelo usuário. Para isso existe o comando ​input()
que ao ser executado pausa o programa e exibe uma mensagem pedindo que seja
digitado algo. Após ser digitado e ser pressionado ​Enter o comando retornará uma string
contendo o que foi digitado. Um exemplo deixará mais claro:

a = input(​"digite algo"​)
print(​"Eu digitei isso: "​ + a)

Após iniciar a execução desse programa, no terminal será exibido a mensagem

"digite algo". Por exemplo digite "privada polonesa giratória" e pressione Enter. O
programa terminará sua execução e será exibido a mensagem "Eu digitei isso: privada
polonesa giratória".

O próximo exemplo estima o ano de nascimento do usuário baseado em sua idade.

 9

idade_str = input(​"digite sua idade"​)

idade_int = int(idade_str)
ano_nascimento = ​2020​ - idade_int
print(​"Você nasceu em "​ + ano_nascimento)

Observe que como o valor retornado por ​input() é uma string, é necessário
converter para um tipo inteiro antes de usá-lo em uma expressão matemática. Também
vale ressaltar que se o usuário digitar um valor não numérico o programa irá ser abortado
com um erro.

Expressões Booleanas
Expressões booleanas são expressões cujo valor resultante é verdade ou falso. Por
exemplo, a expressão a seguir gera um valor falso.

2​ > ​4

Em Python valores falsos são representados pela palavra chave ​False e os

verdadeiros por T
​ rue​. Várias operações podem ser realizadas sobre esses valores.

● and
○ Resulta em verdadeiro se ambos operandos são verdadeiros, falso caso
contrário.
● or
○ Resulta em falso se ambos operandos são falsos, verdade caso contrário.
● not
○ Inverte o valor do operador.

Operadores relacionais também geram valores booleanos:

operador descrição

> Maior que

< Menor que

>= Maior ou igual que

 10

<= Menor ou igual que

== Igual

!= Diferente

A seguir alguns exemplos do uso desses operadores na linguagem.

a = ​True​ ​and​ ​False​ ​# Resulta em False

b = ​True​ ​or​ ​False​ ​ Resulta em True
#
c = ​2​>​4​ ​# Resulta em False
d = ​True​ ​and​ (​5​>​3​) ​# Resulta em True
e = ​False​ == ​True​ ​# Resulta em False

Condicionais

if e else
Em certos casos pode querer-se executar um trecho de código apenas quando um
certa condição for satisfeita. Para isso se faz uso das expressões condicionais através das
palavras-chave ​if​ e e
​ lse​.

if​ ​2​ > ​4​:

print(​"2 é maior que 4"​)

No código acima a segunda linha só será executada se a expressão booliana após o

if​ for verdadeira. Nesse caso nada será executado pois 2 não é maior que quatro.

a = ​12
if​ a == ​12​:
print(​"a é igual a 12"​)

Nesse outro exemplo, a linha 3 só será executada se a variável ​a for igual a 12, o
que é verdade nesse caso. Logo, a mensagem “a é igual a 12” será exibida. Lembrando que,
para realizar-se comparação de igualdade, deve-se usar dois sinais de igual, isto é, ​==​.

Todo o código que será executado pertencente ao ​if deve estar indentado em
relação ao comando, ou seja, deve-se adicionar um carácter ​Tab​. Por isso o código a seguir
apresenta um erro.
 11

a = ​"zig"
if​ a == ​"zig"​:
print(​"zag"​)

No próximo exemplo as linhas 3 e 4 só serão executadas se ​x for negativo, e a

última linha será executada independentemente do i​ f​.

x = ​-10
if​ x < ​0​:
x = -x;
print(​"módulo de x é "​ + str(x))
print(​"Essa linha é sempre executada"​)

Em outras ocasiões pode ser útil ter um trecho de código que só será executado se
a expressão no ​if não for verdadeira. Para isso faz-se uso da palavra-chave ​else​. Importante
ressaltar que para todo ​else​ deve haver um ​if​.

x = int(input(​"digite um numero "​))

if​ x % ​2​ == ​0​:
print(​"x é par"​)
else​:
print(​"x é impar"​)

Nesse exemplo é verificado se x é ímpar ou par. Para isso, lê-se x como um número
digitado pelo usuário e no ​if é verificado o resultado do resto da divisão de ​x por 2​. Se for 0,
quer dizer que o número é par, caso contrário o código do bloco ​else será executado,
indicando que o número é ímpar.

elif
Outra palavra chave importante é ​elif que representa uma condição alternativa ao ​if​,
um exemplo deixará mais claro.

idade = int(input(​"digite sua idade "​))

if​ idade < ​20​:
print(​"VOCÊ É MOLEQUE!"​)
elif​ idade < ​40​:
print(​"você é adulto"​)
elif​ idade < ​90​:
print(​"você é velho"​)
elif​ idade < ​120​:
print(​"nossa..."​)
else​:
 12

print(​"para de mentir"​)

O trecho de código funciona da seguinte forma. Primeiro a variável é lida como uma
entrada do usuário. Em seguida, na linha 3, é verificado se o valor de ​idade é menor que
20. Caso seja, a linha 3 é executada e o programa se encerra. Caso não seja verdade, na
linha 5 é verificado se é menor que 40. Se for menor, então a próxima linha é executada e
o programa se encerra, caso contrário, passa-se ao ​elif seguinte e assim por diante. Caso
nenhum dos e​ lifs sejam satisfeitos então o else​ será executado.

Laços de Repetição
Outra funcionalidade básica que uma linguagem de programação deve fornecer é a
capacidade de que um mesmo código possa ser executado repetidas vezes. Os principais
tipos de laços são o ​while​ e o f​ or​.

while
O laço ​while executa repetidamente um trecho de código enquanto uma expressão
booleana for verdadeira. No exemplo a seguir, a variável ​x é exibida enquanto seu valor for
menor que 10.

a = ​0
while​ a < ​10​:
print(a)
a = a + ​1
print(​"fim"​)

Quando a execução do código atinge pela primeira vez a linha a 3, é verificado se ​a

é menor que 10. Isso é verdade, então o bloco de código pertencente ao ​while é executado.
Ao se chegar ao final do bloco, a execução do programa retorna para a linha 3 e verifica
novamente se ​a é menor que 10. Mais uma vez é verdade, o corpo do while é executado e
retorna à linha 3, e assim sucessivamente. Quando ​a é igual a 10 a verificação falha e a
execução ignora o corpo do w​ hile​ indo direto para a linha 7.

for
O laço ​for é parecido com o laço ​while​, porém ele é utilizado, de forma simplificada,
para um número fixo de repetições. Ele é formado pela palavra chave ​for seguido de um
nome uma variável, palavra chave i​ n​ e o comando ​range​.

for​ a ​in​ range(​10​):

 13

print(a)

Nesse trecho, a linha 2 é executada 10 vezes com ​a assumindo os valores ​0, 1, 2, 3,

4, 5, 6, 7, 8​ e ​9​ (o 10 não faz parte) a cada repetição.

É possível também indicar diferentes faixas de valores para a

​ ​ modificando o ​range()​.

for​ a ​in​ range(​12​):

print(a) ​# a assume valores de 0 a 11
for​ a ​in​ range(​3​, ​10​):
print(a) ​# a assume valores de 3 a 9
for​ a ​in​ range(​4​, ​13​, ​2​):
print(a) ​# a assume valores de 4 a 12, porém de 2 em 2.

No exemplo abaixo é feito um programa que soma 4 números digitados pelo

usuário.

soma = ​0
for​ x ​in​ range(​4​):
valor = float(input(​"digite um número: "​))
soma += valor
print(​"A soma é "​ + str(soma))

break
Em algumas ocasiões pode-se querer sair de uma laço antes que o mesmo termine.
Para isso é usado a palavra-chave ​break​. A seguir um exemplo de um programa que exibe
a raiz de um número digitado pelo usuário caso este seja positivo e caso contrário o
programa interrompe a sua execução.

while​ ​True​:
a = float(input(​"Entre com com um número: "​))
​if​ a < ​0​:
​break
​else​:
print(a**​0.5​)
 14

Escopos
Um conceito muito importante em linguagens de programação é o de escopo. O
papel dele é indicar, basicamente, onde pode-se utilizar uma variável declarada. Considere
o seguinte exemplo.

a = ​12
if​ ​True​:
print(a)

Observe que a foi declarado fora de qualquer tipo de estrutura como ​if ou ​for​.
Nesse caso pode-se usar a variável em qualquer lugar do programa, pois ela foi declarada
no que é conhecido como Escopo Global. Porém observe o próximo exemplo.

if​ ​True​:
a = ​12
print(a)

Esse código resultará em um erro, pois ​a foi declarado em um escopo interno e está
tentando-se usá-la no escopo global. Porém a variável poderia ser utilizada em um escopo
mais interno:

if​ ​True​:
a = ​12
​for​ i ​in​ range(​4​):
print(a)

A variável foi declarada em um escopo interno, porém foi utilizada em um escopo

mais interno ainda, logo, nesse caso não há problema

Listas
Muitas vezes pode ser útil ter a capacidade de representar um conjunto de valores
em uma única variável. Para isso existem as listas, que consistem em vários valores entre
colchetes e separados por vírgula.

lista1 = [​1​, ​2​, ​3​, ​4​]

lista2 = [​"oi"​, ​"meu"​, " ​ chapa"​]
lista3 = [​"beringela"​, " ​ maionese"​, ​12.3​, ​True​]
 15

print(lista1)
print(lista2)
print(lista3)

Para acessar um único elemento de uma lista faz-se uso de índices, isto é, o nome
da variável seguido de um número entre colchetes. Este número indica a posição do
elemento que se quer acessar. Ressaltando que a posição começa a ser contada a partir do
zero.

lista1 = [​10​, ​8​, ​3​, ​12​]

a = lista1[​0​] ​# acessa o primeiro elemento

b = lista1[​1​] ​ acessa o segundo
#
c = lista1[​3​] ​ acessa o quarto e ultimo elemento
#

Pode-se usar também um número negativo como índice, nesse caso, a contagem
ocorre de trás para frente com -​1​ sendo o último elemento.

compras = [​"leite"​, ​"tomates"​, ​"cebola"​, ​"ceifadeira de cabine dupla"​]

a = compras[​-1​] ​# acessa o último

b = compras[​-2​] ​ acessa o penúltimo
#
c = compras[​-3​] ​ acessa o antepenúltimo
#

Também é possível modificar listas de forma semelhante a variáveis.

compras = [​"leite"​, ​"tomates"​, ​"cebola"​, ​"ceifadeira de cabine dupla"​]

compras[​0​] = ​"suco"
compras[​1​] = ​"beterraba"
compras[​2​] = ​"batata"
compras[​-1​] = ​"curso de guerrilha"

print(compras)

Um comando muito útil que pode ser utilizado sobre listas é o ​len que retorna a sua
quantidade de itens. Com ele é possível percorrer listas da seguinte forma:

compras = [​"leite"​, ​"tomates"​, ​"cebola"​, ​"ceifadeira de cabine dupla"​]

for​ i ​in​ range(len(compras)):

print(​"Na posição "​ + str(i) + ​" temos o elemento: "​ + compras[i])
 16

Na linha 3 ​len(compras) retorna o tamanho da lista que nesse caso é 4. Logo o a

variável do ​for​, ​i,​ assumirá os valores de 0 a 3 que serão utilizados para acessar os
elementos da lista.

O laço ​for também pode ser usado para percorrer os elementos de uma lista
diretamente.

lista = [​4​, ​2​, ​1​, ​3​]

for​ a ​in​ lista:

print(a)

Nesse exemplo a cada repetição a variável ​a assume um dos valores da variável ​lista
em ordem, nesse caso, 4
​ , 2, 1​ e ​3​.

Na verdade a única coisa que o comando ​for faz é iterar sobre os elementos de uma
lista. O ​range​, apresentado na seção anterior, não faz nada além de criar uma lista de
números. Experimente digitar o seguinte no REPL da linguagem:

list(range(​10​))

Isso resultará em uma lista dos números de 0 até 9.

O programa do exemplo a seguir soma todos os elementos de uma lista de inteiros.

lista = [​67​, ​68​, ​69​, ​70​, ​71​, ​72​, ​73​, ​75​, ​77​, ​79​, ​83​, ​87​, ​88​, ​94​]
soma = ​0
for​ i ​in​ lista:
soma += i
print(soma)

Já o trecho de código a seguir verifica se duas listas de mesmo tamanho são iguais.

listaA = [​5​, ​1​, ​2​, ​4​]

listaB = [​5​, ​1​, ​2​, ​4​]
iguais = ​True
for​ i ​in​ range(len(listaA)):
​if​ listaA[i] != listaB[i]:
iguais = ​False
break
if​ iguais == ​True​:
print(​"As listas são iguais"​)
else​:
print(​"As listas são diferentes"​)
 17

No trecho, a variável ​iguais indica se as listas são iguais, e por padrão ela foi definida
como ​True​. No laço ​for​, a cada iteração, a variável i ​assume um dos valores de 0 até 3 e o
usa para acessar uma dada posição das listas e compará-las. Caso uma das comparações
resulte em falso, a variável ​iguais assume o valor ​False e o laço é interrompido. Já quando
todas as comparações são verdadeiras, o laço é completado e ​iguais​ mantém o valor T​ rue​.

Métodos de Listas
A linguagem Python oferece alguns comandos, chamados métodos, capazes de
realizar determinadas operações sobre listas. Eles são acessados colocando um ponto
após o nome da variável e em seguida o nome do método terminado em abre e fecha
parênteses. Alguns métodos recebem parâmetros os quais devem ficar no interior dos
parênteses. No código a seguir são apresentados alguns.

lista = [​12​, ​3​, ​1​, ​6​, ​7​]

lista.sort() ​# Ordena os elementos de uma lista
lista.append(​4​) ​# Adiciona o elemento 4 a lista
lista.remove(​12​) ​# Remove o elemento com valor 12
lista.reverse() ​# Reverte a ordem da lista
lista.clear() ​# Remove todos os elementos

Compreensão de Listas
Listas podem ser criadas também através das denominadas compreensão de listas,
uma forma semelhante a notação de conjuntos encontrado na matemática.

[x ​for​ x ​in​ [​1​, ​2​, ​3​, ​4​, ​5​, ​6​] ​if​ x % ​2​ == ​0​]

Essa linha pode ser expressa matematicamente por:

A parte do ​if​ pode ser omitida e um r​ ange​ pode usado também:

[x*x | x ​in​ range(​10​, ​20​)]

Matematicamente:
 18

Tuplas
Tuplas são semelhantes a listas, porém uma vez criadas não podem ser
modificadas. São declaradas como listas porém se utilizando parênteses.

tupla = (​1​, ​2​, ​3​, ​4​, ​5​, ​10​)

print(tupla)

Tentar modificar um dos elementos gera um erro:

tupla = (​1​, ​2​, ​3​, ​4​, ​5​, ​10​)

tupla[​5​] = ​6

Funções
Funções servem para evitar repetição de código além melhorar a organização e
clareza do código. Uma função é declarada com a palavra-chave ​def seguido do nome da
função, abre e fecha parênteses, dois pontos e, na próxima linha indentada, o corpo da
função.

def​ ​saudacao​():
print(​"Hello"​)

No código acima foi definido uma função chamada saudacao que ao ser executada
exibirá a mensagem "Hello". Note que, ao executar esse código nada acontece, pois a
função foi apenas declara e não chamada.

Para chamar uma função deve-se escrever o nome dela seguido de abre e fecha
parênteses.

def​ ​hello​():
print(​"Hello"​)
hello()

Agora sim, como o código acima, a mensagem será exibida.

 19

Funções também podem receber parâmetros que permitem modificar o que a

função fará quando chamada. Por exemplo, podemos querer que a função ​hello diga
"Hello" seguido do nome de alguém.

def​ ​hello​(nome):
print(​"Hello "​ + nome)
hello(​"Krzysztof Penderecki"​)

Pode-se passar quantos parâmetros quiser separando-os por vírgula.

def​ ​hello​(nome, idade):

print(​"Hello "​ + nome + ​" você tem "​ + str(idade) + ​" anos"​)
hello(​"Krzysztof Penderecki"​, ​87​)

É possível que funções retornem valores. Para isso deve-se usar palavra-chave
return​ seguido do valor a ser retornado.

def​ c​ ubo​(x):
​return​ x*x*x
a = cubo(​3​)
print(a)

Nesse exemplo ​cubo retorna o cubo de um número e esse valor retornado foi
armazenado em uma variável.

def​ p ​ rimo​(n):
​for​ i ​in​ range(​2​, n​-1​):
if​ n % i == ​0​:
​return​ ​False
​return​ ​True

A função acima verifica se um número é primo. Um número é primo somente se é

divisível por 1 e por ele mesmo. Essa função passa por todos os números entre 2 e o
próprio número menos 1, se algum desses números for divisor de ​n significa que ​n não é
primo. Agora, se passar por esses números e nenhum deles for divisor significa que ​n é
primo.

O exemplo a seguir calcula as raízes de uma equação do segundo grau a partir de

seus coeficientes.

​ askara​(a, b, c):
def​ b
delta = b**​2​ - ​4​*a*c
x1 = (-b + (delta**​0.5​)) / (​2​*a)
x2 = (-b - (delta**​0.5​)) / (​2​*a)
 20

​return​ (x1, x2)

Observe que essa função retorna uma tupla, isto deve ser levado em conta ao
utilizar os valores retornados:

t = baskara(​-1​, ​7​, ​11​)

print(​"x1 = "​ + str(t[​0​]))
print(​"x2 = "​ + str(t[​1​]))

Funções também podem ser recursivas, isto é, podem chamar si mesmas. Uma
função recursiva muito conhecida é o fatorial que pode ser definido matematicamente por:

Em Python pode ser escrito da seguinte forma:

def​ f ​ at​(n):
​if​ n <= ​1​:
return​ ​1
​else​:
return​ n*fat(n​-1​)

Funções Lambda
Existe uma forma alternativa de declarar funções mais simples. Essa forma é
chamada de funções lambda. Um exemplo é apresentado a seguir.

quad = ​lambda​ x : x*x

Esses tipos funções não possuem nome e devem ser armazenadas em uma
variável. Os parâmetros vêm logo depois de ​lambda e separados por vírgula, e após os dois
pontos vem o corpo da função que deve ser uma expressão e é automaticamente
retornada. A função lambda do último exemplo retorna o quadrado de um número ​x.​ Já o
próximo exemplo retorna a média entre dois números.

media = ​lambda​ x, y: (x+y)/​2

Essas funções são chamadas da mesma forma que as anteriores:

 21

a = quad(​4​)
b = media(a, ​5​)

Exemplo Final
Nesta seção será apresentado um exemplo para reforçar boa parte do que foi
abordado nesse tutorial. O exemplo consiste em um simples jogo da forca que rodará
diretamente do terminal. O código é apresentado a seguir e os principais pontos são
esclarecidos através de comentários.

# Essa função é responsável por desenhar a forca em si.

# Dependendo do número de erros, "e", partes do corpo
# São desenhadas na forca
def​ ​desenha_forca​(e):
print(​" __ "​)
print(​"| | "​)
​if​ e == ​0​:
print(​"|"​)
print(​"| "​)
print(​"| "​)
print(​"|"​)
​elif​ e == ​1​:
print(​"| O "​)
print(​"| "​)
print(​"| "​)
print(​"| "​)
​elif​ e == ​2​:
print(​"| O "​)
print(​"| |"​)
print(​"|"​)
print(​"| "​)
​elif​ e == ​3​:
print(​"| O "​)
print(​"| /|\\"​)
print(​"| "​)
print(​"| "​)
​elif​ e == ​4​:
print(​"| | "​)
print(​"| O "​)
print(​"| /|\\"​)
print(​"| / \\"​)
 22

print(​"| "​)
​elif​ e == ​5​:
print(​"| O "​)
print(​"| "​)
print(​"| /|\\"​)
print(​"| / \\"​)
print(​"-------------"​)
# Essa função verifica
# Se um elemento é membro de uma lista
def​ ​eh_elemento​(e, lista):
​for​ l ​in​ lista:
if​ e == l:
​return​ ​True
​return​ ​False
# Printa as lacunas da palavra a ser advinhada,
# exibindo apenas as lestras que foram faladas
def​ ​printa_palavra​(letras, palavra):
saida = []
​for​ l ​in​ palavra:
if​ eh_elemento(l, letras):
saida.append(l)
else​:
saida.append(​"_"​)
​for​ e ​in​ saida:
# O "end=1''" serve para que o print exiba uma mensagem
# sem pular linha
print(e,​" "​, end=​''​) ​# O "end=''" serve para que o print
# Verifica se todas as lestras da palavra ja foram faldas
def​ ​completou​(letras, palavra):
​for​ l ​in​ palavra:
if​ ​not​ eh_elemento(l, letras):
​return​ ​False
​return​ ​True
# É onde acontece o jogo
def​ ​jogo​():
fim_de_jogo = ​False​ ​# Indica se o jogo acabou ou não
erros = ​0​ ​# Quantidade de letras faladas
palavra_secreta = ​"couve"​ ​# Palavra que será advinhada
letras_inseridas = [] ​# Letras que foram faladas
​while​ fim_de_jogo == ​False​:
desenha_forca(erros)
printa_palavra(letras_inseridas, palavra_secreta)
 23

# Lê letra do usuário
letra_usuario = input(​"Entre com uma letra: "​)
# Verifica se a letra ja foi falada antes
if​ eh_elemento(letra_usuario, letras_inseridas):
erros += ​1
print(​"Essa letra ja foi"​)
# Verifica se a letra nao faz parte da palavra
elif​ ​not​ eh_elemento(letra_usuario, palavra_secreta):
erros += ​1
print(​"Essa letra não faz parte da palavra"​)
# Insere letra na lista de letras faladas
letras_inseridas.append(letra_usuario)
# Verifica se o jogador ganhou o jogo
if​ completou(letras_inseridas, palavra_secreta):
fim_de_jogo = ​True
print()
printa_palavra(letras_inseridas, palavra_secreta)
print()
print(​"PARABÉNS VOCÊ GANHOU"​)
# Verifica se o jogador perdeu
elif​ erros >= ​5​:
desenha_forca(erros)
fim_de_jogo = ​True
print(​"VOCÊ PERDEU"​)
jogo() ​# Inicia o jogo