Introdução à linguagem Python

Thiago Martins
Programação em Python

Um programa é uma sequência de instruções

# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
a, b = b, a
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

2
Programação em Python

Execução:
Inserir o conteúdo em um arquivo .py:

thiago@betelgeuse:~$ cat > programa.py

# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
a, b = b, a
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))
thiago@betelgeuse:~$

3
Programação em Python

Execução:
Invocar o interpretador:

thiago@betelgeuse:~$ python3 programa.py

Primeiro número: 125
Segundo número: 75
O máximo divisor comum é:25
thiago@betelgeuse:~$

4
Programação em Python

Execução:
Em ambientes -ux o próprio script pode ser executado diretamente!

5
Programação em Python

Execução:
Em ambientes -ux o próprio script pode ser executado diretamente!

6
Programação em Python

Execução:
Em ambientes -ux o próprio script pode ser executado diretamente!

thiago@betelgeuse:~$ ./programa.py
Primeiro número: 563
Segundo número: 221
O máximo divisor comum é:1
thiago@betelgeuse:~$

7
Programação em Python

Execução:
É possível inserir programas em células do jupyter:

8
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
a, b = b, a
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

9
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: ")) Comentários
# Para este algoritmo é necessário que a>b
(ignorados pelo
if a < b:
a, b = b, a interpretador)
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

10
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: ")) Chamadas a funções
# Para este algoritmo é necessário que a>b
(subprogramas)
if a < b:
a, b = b, a
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

11
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
Construtores de objetos
a, b = b, a
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

12
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
Controle de fluxo
a, b = b, a
if b<=0:
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

13
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
Blocos delimitados por
a, b = b, a
if b<=0: indentação
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

14
Programação em Python

Elementos do programa
# Este programa calcula o máximo divisor comum pelo alg. de euclides
a = int(input("Primeiro número: "))
b = int(input("Segundo número: "))
# Para este algoritmo é necessário que a>b
if a < b:
Blocos delimitados por
a, b = b, a
if b<=0: indentação
print("Os números devem ser positivos")
else:
while b!=0:
a, b = b, a % b
print("O máximo divisor comum é:" + str(a))

15
Comentários

São marcados pelo caractere # e vão até o final da linha

# Inicializa o valor de a
a = 1
Podem se seguir a instruções
a = 1 # Inicializa o valor de a
Atenção! Docstrings não são comentários
“”” Isso é uma docstring ”””
a = 1

16
Controle de fluxo

if... elif… else

if <condição 1>:
<bloco 1>
elif <condição 2>:
<bloco 2>
elif <condição 3>:
<bloco 3>
else
<bloco alternativo>

17
(não é)
Controle de fluxo

Expressão ternária em python, escolhe entre 2 valores

dependendo de uma condição.
<valor se verdadeiro> if <condição> else <valor se falso>

Exemplo: Uma expressão que vale o módulo de x.

x if x>=0 else -x

18
Controle de fluxo

while
while <condição>:
<bloco>

Executa o bloco enquanto a

condição for verdadeira.

19
Controle de fluxo
for
for <variável> in <coleção enumerável>
<bloco>

Executa o bloco atribuindo à variável valores sucessivos da

coleção
ex:
a = 0
for i in [1, 2, 3]:
a += i
print(a)

20
Controle de fluxo
for e range
A função range é particularmente apropriada para o
laço for:
a = 0
for i in range(3)
a += i
print(a)

21
Controle de fluxo
for e range
range(n) Enumera os inteiros de 0 a n-1
range(n,m) Enumera os inteiros de n a m-1
range(n,m,s)
Enumera os inteiros de n, n+2s, n+3s… até o maior
valor de n+ks < m

22
Controle de fluxo
for e range
range(n) Enumera os inteiros de 0 a n-1
range(n,m) Enumera os inteiros de n a m-1
range(n,m,s)
Enumera os inteiros de n, n+2s, n+3s… até o maior
valor de n+ks < m

23
Controle de fluxo
break, continue
break força a saída imediata do bloco.

continue força o encerramento imediato da execução atual do bloco

(mas próximas iterações podem continuar normalmente)
# mostra números ímpares
for i in range(n):
if x % 2 == 0:
continue
print(x)

24
Controle de fluxo
else em laços
O bloco else após um bloco é executado após a saída natural (sem
break) do bloco. # Encontra índice de primeiro elemento
negativo
for i in range(len(a)):
if a[i]<0:
print(i)
break
else:
print("Valor não encontrado")
pass
pass identifica um bloco vazio

# Laço vazio
for i in range(len(a)):
pass

25
Chamadas a funções/métodos

“Funções” em python são distintas do conceito

matemático (verdade para toda linguagem imperativa
estruturada)
a = iter([1, 2, 3, 4, 5])
next(a) 🡺 1
next(a) 🡺 2
next(a) 🡺 3
O antigo termo “subprograma” evita esta confusão, mas não é mais usual.

26
Chamadas a funções/métodos

“Funções” em python são distintas do conceito

matemático (verdade para toda linguagem imperativa
estruturada)
a = iter([1, 2, 3, 4, 5])
next(a) 🡺 1
next(a) 🡺 2
next(a) 🡺 3
O antigo termo “subprograma” evita esta confusão, mas não é mais usual.

27
Definindo uma Função
def mostra_fib(n):
"""Mostra a sequência de Fibonacci até n."""
a, b = 0, 1
while a < n:
print(a, end=' ')
a, b = b, a+b
print()

def <nome da funcao> (<parâmetros>):

<bloco da função>

Exemplo adaptado da documentação de Python 3

28
Definindo uma Função
Funções podem retornar valores
def gcd(a, b):
"""Calcula GCD(a,b) com a>b>0."""
while b != 0:
a, b = b, a % b
return a

return <expressão>
def procura(a, b):
"""Encontra índice i tal que a[i]=b."""
for i, x in enumerate(a):b != 0:
if x == b:
return i

return encerra imediatamente a execução da função.

Return é opcional!

29
Funções

Funções também são objetos.

gcd(125, 121) 🡺 1
gcd 🡺 function at xxxx
a = gcd
a(30, 36)🡺 6
Como mencionado, a docstring não é um comentário:
help(gcd)🡺 Calcula GCD(a, b) com a>b>0

30
Funções e escopo
Os parâmetros são variáveis definidas dentro do bloco da
função.
a = 10
Os nomes de parâmetros podem def mostra(a):
print(a)
sobrepor-se a nomes já definidos!
print(a)
mostra(20)

Isso se aplica a toda variável criada dentro do bloco da função

Variáveis criadas dentro de blocos
de funções são ditas locais. def soma(a, b):
s = a + b
Tais variáveis são invisíveis return s

fora do bloco de sua criação print(soma(2,2))

print(s)

31
Funções e escopo
Os parâmetros são cópias de referências.
Uma função não pode alterar uma referência original.

def zera_variavel(a):
a = 0

teste = 1
zera_variavel(teste)
print(teste)

32
Funções e escopo
Os parâmetros são cópias de referências.
Mas objetos mutáveis podem ser alterados.

def zera_posicao(a, i):

a[i] = 0

teste = [1, 2]
zera_variavel(teste, 0)
print(teste)

33
Funções e escopo
Variáveis globais são visíveis dentro de funções.
var = “teste”
def func():
print(var)
func()
var = “teste2”
func()

34
Funções e escopo
Variáveis globais são visíveis dentro de funções.
MAS atribuições criam novas variáveis!
var = “teste”
def func():
var = “novo valor”
print(var)
func()
print(var)

35
Funções e escopo
A palavra-chave “global” atrela um símbolo ao escopo
global.
var = “teste”
def func():
global var
var = “novo valor”
func()
print(var)

36
Funções e escopo
Funções podem ser definidas dentro do escopo de outras funções.
def segundo_grau(vetor, a, b, c):
“”” Aplica ax²+bx+c em cada elemento de vetor”””
def valor(x):
return a*x*x + b*x + c
for i, x in vetor:
vetor[i] = valor(x)

Este recurso é mais poderoso do que parece! Mais sobre isso em clausuras.

37
Funções e escopo
nonlocal permite escrever no escopo externo (como global funciona
com o escopo global).
def func1():
a = 1
def func2():
nonlocal a
a += 1
func2()
print(a)

Novamente, a utilidade disso ficará mais clara adiante...

38
Funções e escopo

O escopo é reentrante (cada chamada gera seu próprio

escopo). Mesmo quando a função é chamada dentro de si
mesma. Isso permite recursão.

def gcd(a, b):

return a if b==0 else gcd(b, a%b)

gcd(8,5) = gcd(5,3) = gcd(3,2) = gcd(2,1) = gcd(1,0) = 1

Cada chamada recursiva tem seus valores próprios para a e b!

39
Funções – Mais sobre parâmetros

Valores padrão de parâmetros.

def fatorial(x, y=1):
if x==1:
return y
else:
return fatorial(x-1, x*y)

40
Funções – Mais sobre parâmetros

Valores padrão de parâmetros.

a = 1
def soma(x, y=a):
return x+y

a = 2
soma(2)
O valor de atributos padrão é avaliado somente na definição da função.

41
Funções – Mais sobre parâmetros

Parâmetros rotulados.
def segundo_grau(vetor, c=0, b=0, a=0):
“”” Aplica ax²+bx+c em cada elemento de vetor”””
def valor(x):
return a*x*x + b*x + c
for i, x in vetor:
vetor[i] = valor(x)

segundo_grau(vetor, a=1)

42
Funções – Mais sobre parâmetros

Parâmetros rotulados.
def segundo_grau(vetor, c=0, b=0, a=0):
…

Parâmetros rotulados sempre aparecem depois de

posicionais!

segundo_grau([1,2,3], a=1) → Ok!

segundo_grau(a=1, [1,2,3]) → Errado!

43
Funções – Mais sobre parâmetros
Funções variádicas
def soma_parametros(*x):
soma=0
for i in x:
soma += i
return soma

x é uma tupla com todos os parâmetros não-declarados e não-rotulados

E parâmetros não rotulados?

def mostra_parametros(*posicionais, **rotulados):
print(posicionais)
print(rotulados)

rotulados é um dicionário com todos os parâmetros rotulados

44
Funções – Mais sobre parâmetros
“Desempacotando” agregados iteráveis com *

def soma_parametros(*x):
soma=0
for i in x:
soma += i
return soma

a = [1,2,3,4,5]
print(soma_parametros(*a))

Isso é o mesmo que:

print(soma_parametros(1,2,3,4,5))

45
Funções – Mais sobre parâmetros
“Desempacotando” agregados iteráveis com *
Pode-se desempacotar parâmetros rotulados em
dicionários com **:

def soma_valores(x, y):

return x + y

soma_valores(**{‘x’:1,’y’:2})

Todas as chaves do dicionário devem ser strings!

46