IBM SkillsBuild | Introducción a Python

Noções básicas e
sintaxe de Python
Funções e variáveis

1
IBM SkillsBuild | Introducción a Python

Índice
Introdução 3
Vantagens da utilização das funções 4
Aumenta a reusabilidade do código e minimiza a redundância (repetição) 4
Habilitar a decomposição de procedimentos 4
Sintaxe da função básica em Python 4
Funções e polimorfismo 5
Funções aninhadas 6
Recurssão 6
Retorno de múltiplos valores simultaneamente 6
Experimente 6
Escopo de uma função 7
Escopos e suas propriedades 7
Resolução do nome. A regra LEGB 8
Parâmetros e argumentos 11
Argumentos sobre as funções 11
Uma visão geral das diferentes formas de passagem de argumentos 12
Considerações de projeto ao programar com funções 16
Acoplamento 16
Coesão 17
Experimente 17
Definindo Variáveis 18
Atribuição de um valor a uma variável em Python 18

2
IBM SkillsBuild | Introducción a Python

Introdução

Nesta unidade, vamos aprender como criar

funções em Python. Uma função é um grupo de
declarações agrupadas de tal forma que podem
ser invocadas com o mesmo nome. As funções
podem retornar um resultado e podem ser
parametrizadas para permitir que o resultado da
função seja diferente, dependendo de como ela é
chamada.

As funções são também a unidade estrutural mais

básica que maximiza a reusabilidade do código,
permitindo-nos avançar para noções mais
ambiciosas de projeto de software do que vimos
até agora. Isto porque as funções nos permitem
separar nossos programas em blocos menores,
mais gerenciáveis, que podem ser reutilizados em
várias partes de nosso software. A implementação
de nosso código em funções torna nosso código
mais reutilizável, mais fácil de programar e permite
que outros programadores entendam nosso código
mais facilmente.

3
IBM SkillsBuild | Introducción a Python

Vantagens da utilização Sintaxe da função básica

das funções em Python

Aumenta a reusabilidade do código e A sintaxe necessária para declarar uma função é a

seguinte:
minimiza a redundância (repetição)
def nombre_de_la_función(arg1, arg2, ...a
As funções são a maneira mais simples e fácil de rgN):
empacotar funcionalidades para que possam ser sentencias
usadas em diferentes partes de um programa sem ter return #El return es opciona
l
que repetir o código. Eles nos permitem agrupar e
generalizar o código para que possamos usá-lo
arbitrariamente com a freqüência necessária. Isto A declaração começa com a declaraçao def seguido
torna as funções um elemento essencial de do nome que queremos dar à função. Em seguida,
fatorização do código, permitindo-nos reduzir a escrevemos uma lista de argumentos de 0 a N
redundância e, portanto, reduzir o esforço necessário (também chamados de parâmetros da função)
para manter nosso código. encapsulados entre parênteses e terminamos a
declaração com o caracter “:”.

Habilitar a decomposição de
Depois disso, e em uma nova linha, escreveremos o
procedimentos corpo de nossa função, que consistirá em um grupo
de frases a serem executadas, terminando com a
Ou seja, eles permitem que os programas sejam
declaraçao opcional return acompanhado do valor a
divididos em pequenas partes onde cada parte tem
ser devolvido.
um papel bem definido. Geralmente é mais fácil
programar pequenos pedaços de código e compô-los
Para chamar a função simplesmente digitamos o
em programas maiores do que escrever todo o
nome da função seguido dos argumentos que
processo de uma só vez.
queremos passar a ela, encapsulados entre
Nesta unidade, aprenderemos a sintaxe necessária parênteses. Vamos ver alguns exemplos:
para operar com funções, aprenderemos o conceito
def suma(a, b): # Definimos la función
de área (scope) e veremos como parametrizar nossas "suma". Tiene 2 parámetros.
funções para torná-las mais genéricas. Com tudo return a+b # "return" devuelve
isso, estaremos prontos para iniciar um caminho el resultado de la función.
muito mais ambicioso no mundo da programação
suma(2, 3) # Llamada a la función.
Python, que continuaremos nas próximas unidades e Hay que pasarle dos parámetros.
cursos desta especialização.
# Resultado: 5

def en_pantalla(frase1, frase2):

print(frase1, frase2) # "return" no
es obligatorio

en_pantalla('Me gusta', 'Python')

# Resultado: Me gusta Python

4
IBM SkillsBuild | Introducción a Python

Como você pode ver, não é necessário usar return. suma('Me gusta', 'Python') # Función con
Em funções que não têm return, retornan None. strings

def suma(a, b): # Definimos la

función "suma". Tiene 2 parámetros. Isto porque em Python as funções não têm nenhum
return a+b # "return" devuelve tipo (lembre-se da unidade de digitação dinâmica).
el resultado de la función. Em um grande número de casos, o tipo de saída de
uma função dependerá do tipo dos parâmetros que
x = suma (2, 3)
print(x) # Guardamos el passamos para ela (há exceções a esta regra, por
resultado en x exemplo, se estamos forçando o tipo de saída na
declaração return). Esta é uma idéia central na
linguagem que a torna muito flexível e fácil de
reutilizar ao programar.

Funções e polimorfismo Em Python, uma função não tem que se preocupar

com os tipos de entrada e saída. É o próprio
intérprete que verificará se os tipos que passamos
Mencionamos que uma das vantagens de utilizar para a função suportam os protocolos que
funções é que elas permitem a reusabilidade do codificamos dentro dela. Na verdade, se não os
código. Isto é ainda mais verdadeiro em Python, suportar, o intérprete gerará uma exceção, o que
onde muitos tipos de dados suportam o nos poupa de ter que fazer a verificação de erros
polimorfismo, ou seja, cada tipo de dado sabe como em nossa função. Se o fizéssemos, estaríamos
se comportar quando confrontado com uma grande reduzindo a flexibilidade da função, o que
variedade de operadores. Isto é diretamente normalmente não é desejável, a menos que seja
aplicável ao uso de funções, por isso podemos uma decisão de projeto.
encontrar casos como os seguintes:

def suma(a, b): # Definimos la

función "suma". Tiene 2 parámetros.
return a+b # "return" devuelve
el resultado de la función.

suma (2, 3) # Función con ints

# Resultado = 5

suma(2.7, 4.0) # Función con floats

# Resultado = 6.7

5
IBM SkillsBuild | Introducción a Python

Funções aninhadas Retorno de múltiplos

valores simultaneamente
É possível criar funções dentro das funções.

def f1(a): # Función que "encierra" As funções podem retornar qualquer objeto com a
a f2 (enclosing)
declaração return. Assim, se combinarmos o retorno
print(a)
b = 100 de uma tupla, com o desempacotamento prolongado
def f2(x): # Función anidada que Python permite, podemos simular o retorno de
print(x) # Llamamos a f2 desde múltiplos valores:
f1
f2(b)
def maxmin(lista):
f1('Python') # Llamamos a f1 return max(lista), min(lista) #
Devielveuna tupla de 2 elementos

Resultado: l = [1, 3, 5, 6, 0]
maximo, minimo = maxmin(l) #
Desempaqueta la tupla en 2 variables

print(minimo, maximo, sep= ' ')

Resultado:
Como podemos ver, é possível criar funções dentro
de outras funções.

Recurssão

Como em outras linguagens de programação, em

Python uma função pode chamar-se a si mesma, Experimente
gerando recursividade. É importante levar em conta Fazer uma função que decomponha um número em
que não se gera uma recorrência infinita, ou seja, a fatores. Ele deve retornar uma lista dos fatores desse
função deve ter uma condição de saída. Um exemplo número. Lembre-se de que a decomposição em
muito comum de recorrência na programação é a fatores de um número consiste em encontrar o
função que calcula o fatorial de um número (lembre- conjunto de números primos cuja multiplicação dá
se que o fatorial de x é igual a x * (x-1) * (x-2) * … * 1 como resultado esse número.

def factorial(x): Dica: A primeira coisa que a função deve fazer é

if x>1:
return x*factorial(x-1) encontrar todos os números primos menos do que o
else: número em questão.
return 1

factorial(5)
Nesta função, vemos que a condição de saída de
recorrência é satisfeita quando x é igual a 1.

6
IBM SkillsBuild | Introducción a Python

Escopo de uma função

Aqui está um exemplo:
a = 'Python' #Scope global
(al módulo)
print('Valor fuera:', a)
Agora que começamos a operar com funções, é hora
de ir um pouco mais longe com o conceito de nomes def funcion():
a=33
em Python. Quando usamos um nome em um
print('Valor dentro', a) #Scope
programa, o intérprete Python procura por esse local a la función
nome em um namespace, que chamamos namespace.
Um namespace é um local onde reside um conjunto funcion()
de nomes. Se você vem de outras linguagens de print('Valor fuera', a)
programação, você estará familiarizado com este
conceito.
Resultado:
Quando atribuímos um nome em Python, ele está
associado ao espaço de nomes ao qual pertence. O
namespace em que reside um nome define seu
escopo (scope), ou seja, a visibilidade que este nome
terá em relação a outras variáveis. Por exemplo,

Nomes atribuídos dentro do escopo de uma função

só são visíveis para códigos que residem dentro
dessa função. Isto significa que um nome declarado
Escopos e suas
dentro de uma função não pode ser referenciado de propriedades
fora da função.

O escopo de uma variável depende de onde ela é Como podemos ver, as funções permitem que você
atribuída. Em outras palavras, dependendo do local crie namespaces âmbitos aninhados que limitam os
onde atribuímos uma variável, estaremos definindo o âmbitos de acesso e evitam colisões de nomes
escopo em que ela pode ser utilizada. As variáveis variáveis. Assim, em funções criamos escopos locais
podem ser atribuídas em três âmbitos: que contrastam com o escopo global dos módulos.
Estes escopos têm as seguintes propriedades:
• Se uma variável é atribuída dentro de uma
função, ela é local para essa função.
• As variáveis que são criadas no escopo do
• Se uma variável é atribuída dentro de uma
módulo são variáveis globais para aquele
função, ela é não-local para todos os escopos de
arquivo. Quando importamos um módulo de
função aninhados dentro dela.
outro módulo, estas variáveis se tornam atributos
• Se uma variável é atribuída fora de qualquer
do módulo importado, de modo que podem ser
função, ela é global ao arquivo no qual ela é
acessadas como variáveis simples do módulo.
criada.
Por exemplo, a variável math.pi é global para o
módulo math, mas se importarmos o módulo
math, podemos acessá-lo como se fosse um
atributo do mesmo (por isso, acessamo-lo por
meio de math.pi).

7
IBM SkillsBuild | Introducción a Python

O escopo global é na verdade um escopo de

Resolução do nome. A
•
arquivo. Ou seja, o escopo global afeta apenas o
módulo (arquivo) no qual suas variáveis estão
localizadas. Em Python escopo global significa
regra LEGB
escopo do módulo.
• Os nomes atribuídos dentro de uma função são Todas as regras acima podem ser resumidas pela
locais por padrão. Todos os nomes definidos regra LEGB (Local, Enclosing, Global, Builtin). Esta regra
dentro de uma função têm como escopo o dita a ordem na qual procuramos um nome quando
namespace local para essa função. Entretanto, é tentamos acessá-lo. Ao tentar acessar um nome, o
possível fazer atribuições a variáveis fora do intérprete Python procura apenas 4 escopos
escopo local da função. Isto é feito utilizando diferentes. Além disso, esta busca é sempre feita na
declarações globais e não locais dentro da mesma ordem.
função. No entanto, esta prática geralmente não
é recomendada. • L: Primeiro, olhamos para o nível local de nossa
• Todos os outros nomes são locais para as função.
funções que envolvem nossa função (funções nas • E: Analisamos então as funções que encerram
quais nossa função está aninhada), globais ou nossa função (enclosing)
built-ins. Nomes não atribuídos em nossa função • G: O escopo global do módulo é então procurado.
ou são locais para funções em um nível mais alto • B: Finalmente, é procurado no módulo builtins.
de aninhamento (chamadas enclosing), globais
para o módulo, ou pertencem ao módulo built- A Figura 1 mostra um exemplo desta busca e como
ins, um escopo de nível mais alto onde todos os estes campos de busca são englobados. Note que
tipos básicos de Python são definidos. esta busca termina no primeiro lugar onde o nome
• Cada vez que uma função é chamada, um escopo procurado é encontrado. No caso em que o nome
local é criado para essa função. Ou seja, um não é encontrado nestes escopos, Python retorna um
namespace onde todos os nomes dessa função erro.
são armazenados.

8
IBM SkillsBuild | Introducción a Python

Escopos de busca da LEGB. Quando uma variável é referenciada, Python realiza uma busca começando no
nível local e trabalhando até builtins. A busca termina no primeiro campo onde o nome referenciado é
encontrado.

9
IBM SkillsBuild | Introducción a Python

Aqui está um exemplo de tal busca. G = 'Esta variable es de ámbito Global'

def f1():
G = 'Esta variable es de ámbito Global' E='Esta variable es local a f1.
def f1(): Enclosing a f2'
E='Esta variable es local a f1. def f2():
Enclosing a f2' L = 'L es local a f2'
def f2(): E = 'E también es local a f2'
L = 'Esta variable es local a f2' G = 'G también es local a f2'
print(L, E, G, sep = '\n') print(L, E, G, sep = '\n')
f2() def f3():
print(L) # DEVUELVE ERROR
f1() f2()
f3()

Esta variable es local a f2

f1()
Esta variable es local a f1. Enclosing a f2
Esta variable está en ámbito Global (de
módulo) Resultado:

Como podemos ver, f2 é capaz de referenciar as

variáveis E y G. Agora vamos ver o que acontece se
declararmos essas mesmas variáveis no escopo do
f2.

G = 'Esta variable es de ámbito Global'

def f1():
E='Esta variable es local a f1.
Enclosing a f2'
def f2():
L = 'L es local a f2'
E = 'E también es local a f2'
G = 'G también es local a f2'
print(L, E, G, sep = '\n')
f2()

f1()

Desta vez, quando tentamos acessar uma variável

L es local a f2 local a f2 de f3, obtemos um erro de nome. Isto
E también es local a f2
porque a busca do nome é feita a partir do escopo
G también es local a f2
local de f3 para cima, passando primeiro para o
escopo local de f1, depois para o escopo global e,
Neste caso, a busca pára na área de local de f2 como finalmente, para builtins. Em nenhum caso
declaramos variáveis com o mesmo nome no mesmo pesquisamos o escopo da f2. Observe, entretanto,
escopo (E e G). Finalmente, vamos ver o que que a f3 tem acesso aos escopos global e builtins:
acontece quando tentamos acessar desde o escopo
de uma função até o escopo de outra função. G = 'Esta variable es de ámbito Global'
def f1():

10
IBM SkillsBuild | Introducción a Python

E='Esta variable es local a f1. Algumas coisas a ter em mente ao passar

Enclosing a f2' argumentos para as funções Python:
def f2():
L = 'L es local a f2' • Ao passar um argumento para uma função,
E = 'E también es local a f2' estamos criando uma atribuição a uma variável
G = 'G también es local a f2' com o nome do argumento no escopo local da
print(L, E, G, sep = '\n') função.
def f3(): • Atribuir um novo valor ao argumento a partir de
print(E, G, sep = '\n') dentro da função não afeta o exterior.
f2()
• Se passarmos um objeto mutável para uma
f3()
função, e ele o modifica dentro da função, pode
afetar o exterior.
f1()
Isto porque os argumentos em Python são passados
Resultado:
por referência. Se nos lembrarmos do que vimos na
unidade Dynamic Typing, entenderemos melhor o
que isto significa.

• Se passamos um objeto imutável, é como se o

estivéssemos fazendo por valor. Ou seja, como
não podemos modificar o objeto, é como se o
estivéssemos copiando para o escopo local da
função.
• Se passarmos um objeto mutável, ao fazê-lo por
Parâmetros e argumentos referência, qualquer mudança dentro do objeto
que for feita dentro da função será observada de
fora da função.
Argumentos sobre as funções
Aqui estão alguns exemplos. Vamos começar
Quando definimos uma função, podemos passando objetos imutáveis:
parametrizá-la pelos argumentos que passamos a
def suma(a, b): # Modificamos a y b
ela. Por exemplo, a função a seguir é capaz de
en el scope de suma()
multiplicar quaisquer dois números, uma vez que a = 3
estamos definindo por meio de dois parâmetros de b = 4
entrada (argumentos): return a+b

def suma(a, b): a, b = 5, 10

print(suma(a, b))
return a+b print(a, b) # a y b no han
cambiado fuera de la función
suma(2, 3)

suma(40, 30) Por outro lado, quando passamos um objeto mutável

Resultado: para uma função que o modifica internamente, a
mudança afeta o exterior da função:

11
IBM SkillsBuild | Introducción a Python

def minimo(l): Uma visão geral das diferentes formas

l[0] = 1000 # Modificamos la
lista en el interior de passagem de argumentos
return min(l)
Por padrão, os argumentos são passados por
posição. Ou seja, os argumentos de uma chamada de
l = [1, 2, 3]
função devem ser passados na mesma ordem em
print(l)
que a função foi definida.
print(minimo(l)) # Modifica la lista
Entretanto, uma das grandes vantagens do Python é
aquí
que ele nos permite passar argumentos para funções

print(l) de várias maneiras diferentes.

Resultado:
Por posição.
A forma padrão de passar argumentos, da esquerda
para a direita.

def f(a, b, c):

print(a, b, c)

Lembre-se que para evitar este comportamento f(1, 2, 3)

Resultado:
podemos fazer uma cópia da lista que passamos
para a função:

def minimo(l):
l[0] = 1000 # Modificamos la
lista en el interior
return min(l)
Por keywords (palavras-chave)
l = [1, 2, 3]
Ao invés de chamar a função com seus argumentos
print(minimo(l[:])) # minimo modifica la
lista aquí em ordem, a função é passada especificando o nome
print(l) do argumento seguido do valor a ser passado. O
Resultado: nome da sintaxe=valor é usado. Como você está
especificando o nome dos argumentos
explicitamente, não é necessário ordená-los por
posição.

def f(a, b, c):

print(a, b, c)

f(c=12, a=10, b=100)

Resultado:

12
IBM SkillsBuild | Introducción a Python

Especificação de valores padrão na definição da Resultado:

chamada
É possível definir quais são os valores padrão que os
argumentos de uma função têm. Assim, se ao chamar
a função, não passarmos nenhum dos argumentos
que têm um valor padrão, esse valor será utilizado.

def f(a, b=10, c=30):

print(a, b, c)
Se utilizarmos a sintaxe de duplo risco,
f(1) especificamos que passaremos os argumentos pelo
nome:
f(1, 12)
def f(**Kargs): # Acepta número de
f(1, 12, 19) argumentos por nombre
print(Kargs)
Resultado:
f() # Si no hay
argumentos, Kargs es un diccionario vacío

f(a=1)

f(a=1, b=2)

f(a=1, c=3, b=2)

Resultado:

Ao especificar na função que um conjunto de

argumentos lhe será transmitido

A definição da função indica que um número

arbitrário de argumentos será passado para a função,
que será classificado por posição da esquerda para a
direita (indicado por um asterisco * imediatamente
antes do nome) ou por keywords (indicado por um Desempacotar uma coleção de argumentos
asterisco duplo ** imediatamente antes do nome). posicionais ou keyword

def f(*args): # Acepta número Ao chamar uma função você pode usar a sintaxe de *
arbitrario de argumentos para desembalar uma coleção em uma série de
print(args) argumentos separados por posição.

f() # Si no hay
argumentos, args es una tupla vacía

f(1)

f(1, 2)

f(1, 2, 3, 4, 5, 6)

13
IBM SkillsBuild | Introducción a Python

Resultado: Resultado:

Da mesma forma, um dicionário pode ser

desempacotado usando a sintaxe de duplo asterisco
**.

def f(a, b, c, d):

print(a, b, c, d)
def f(a, *b, c): # Hay que pasar 'c'
argumentos = {'b':20, 'a':1, 'c':300, por clave obligatoriamente
'd':4000} print(a, b, c)
f(**argumentos) # Desempaquetando
f(1, c=2)
diccionario argumentos con **
f(1, 2, c=3)
argumentos = {'b':200, 'c':300, 'd':400}
f(10, **argumentos) # Podemos combinar f(1, 2, 3, 4, 5, c=10)
argumentos posicionales con dict

Resultado:
Resultado:

Usando argumentos que só podem ser passados

por código (keyword-only) Argumentos após "*" tornam-se keyword-only:

Este tipo de argumento só pode ser passado como

Veremos que há muitas funções escritas em Python
uma chave (keyword) e que nunca será preenchido
que tiram proveito dessas funcionalidades, tais como
por cargo. Isto é útil em funções que podem aceitar
as funções builtin zip e print.
qualquer número de argumentos e ainda permitir
configurações opcionais. la = [1, 2, 3, 4, 5]
lb = list('abcde')
def f(a, *, b, c): # Define 'b' y lc = list('ABCDE')
'c' como keyword-only con el *
print(a, b, c)
zlist = list(zip(la, lb, lc)) # zip
f(1, b=10, c=100) soporta cualquier número
# de
f(1, 10, 100) # Error al no argumentos posicionales
pasar argumentos Keyword-only

14
IBM SkillsBuild | Introducción a Python

zlist

a, b, c = zip(*zlist) # El * en
zip desempaqueta lista de tuplas

print(la, lb, lc, sep = '\n')

print(la, lb) #
Seperador por defecto es espacio

Resultado:

Como podemos ver, este tipo de passagem de

argumentos dá às funções Python uma grande
flexibilidade. Além disso, o uso de argumentos
padrão e keyword-only promover a simplicidade e a
legibilidade de nosso código.

15
IBM SkillsBuild | Introducción a Python

Considerações de projeto Acoplamento

• Crie funções que só aceitam entrada para
ao programar com funções argumentos e só usam o return para sua saída.
Isto reduz as dependências externas das
funções. Uma função f(args) que cumpre este
Para concluir esta unidade sobre funções,
critério sempre retorna o mesmo resultado para
terminaremos com algumas considerações de
os mesmos argumentos. Ou seja, a função se
projeto que você deve ter em mente ao programar
torna mais previsível e, portanto, mais fácil de
com elas. Para isso, é necessário entender quais
entender e manter.
entradas e saídas são possíveis para qualquer
• Usar variáveis globais somente quando
função. Você tem uma explicação detalhada no
realmente necessário. Variáveis globais criam
Figura 2.
dependências entre funções e tornam os
programas difíceis de debugar, modificar e
reutilizar.
• Evite mudar os argumentos mutáveis, a menos
que o código de chamada o espere. O problema é
o mesmo que com as variáveis globais, mas
também cria um forte acoplamento entre a
função chamada e a função chamada.
• Não altere diretamente os atributos de outros
módulos. Isto cria um forte acoplamento entre
módulos, assim como as variáveis globais criam
um forte acoplamento entre funções. Se você
precisar alterar um atributo de um módulo, utilize
A figura descreve os principais mecanismos pelos as funções fornecidas pelo próprio módulo. Se
quais uma função interage com o mundo ao seu não o fizer, então mudar seus atributos pode ser
redor. Ao programar funções, é importante ter em uma péssima idéia.
mente dois importantes aspectos de projeto que
ajudam a tornar um código mais utilizável e de fácil
manutenção. Estes aspectos são:

• Coesão: refere-se a como um programa é

dividido em pequenas tarefas individuais.
• Acoplamento: refere-se a como as funções se
comunicam e dependem umas das outras.

O bom código é altamente coeso e tem pouco

acoplamento. Ou seja, todas as funções em seu
código ajudam na mesma tarefa, mas não dependem
uma da outra. Abaixo está uma lista de diretrizes que
o ajudarão a aumentar a coesão e reduzir o
acoplamento.

16
IBM SkillsBuild | Introducción a Python

Coesão Experimente
• Cada função deve ter um único propósito. O
código bem projetado é composto de funções
Crie uma função de registro que aceite qualquer
que fazem apenas uma coisa. Normalmente o
número de argumentos e os imprima na tela em uma
objetivo de uma função deve ser resumido em
única linha. A linha deve começar com o prefixo
uma frase curta. Se a frase que descreve sua
‘LOG:’.
função for muito genérica (p. ex. “esta função
resolve meu problema”) ou se tiver muitas Modifica a função log para permitir que o usuário
conjunções (p. ex. “esta função calcula X e especifique qualquer prefixo desejado.
processa Y”), considerar dividi-lo em partes mais
simples. Modificar a função log para que o prefixo tenha um
• Todas as funções devem ser relativamente valor padrão ‘LOG: ’.
pequenas. Este ponto está relacionado com o
Modificar a função log para permitir ao usuário definir
anterior. Tenha em mente que o código escrito
tanto o prefixo quanto o separador entre os
em Python é muito conciso. Se sua função tem
argumentos. Ambos devem ser passados somente
mais de uma dúzia ou duas linhas ou contém
pelos nomes (não pela posição) 'sep' e 'prefix'. Estes
vários níveis de aninhamento, é provável que
não precisam ter um valor padrão.
você tenha um problema de projeto..
Modifica a função log para que agora 'sep' e 'prefix'
Em resumo, tente fazer com que seu código consista
tenham um valor padrão.
em muitas pequenas funções que são independentes
umas das outras. Modifique a função log para aceitar o seguinte
dicionário. Lembre-se de passá-lo desembalado com
a sintaxe de asterisco duplo (**).

17
IBM SkillsBuild | Introducción a Python

Definindo Variáveis
Suponha que queremos exibir o resultado da adição
de 1 + 2. Para exibir o resultado, devemos dizer ao
programa onde esses dados estão na memória e,
para isso, fazemos uso de uma variável:
As variáveis são um dos dois componentes básicos
de qualquer programa.

# Guardamos en la variable suma el

Em sua essência, um programa é composto de dados
resultado de 1 + 2
e instruções que manipulam esses dados.
suma = 1 + 2
Normalmente, os dados são armazenados na
# Accedemos al resultado de 1 + 2 a
memória (RAM) para que possamos acessá-los. través de la variable suma
print(suma)
Então, o que é uma variável? Uma variável é uma
forma de identificar, de maneira simples, um dado
que é armazenado na memória do computador ou,
em outras palavras, um espaço na memória do
computador onde é armazenado um valor que pode Atribuição de um valor a
mudar durante a execução do programa. Imaginemos
que uma variável é um recipiente no qual um pedaço
uma variável em Python
de dado é armazenado, o qual pode mudar durante o
fluxo do programa. Uma variável nos permite acessar Como vimos no exemplo anterior, para atribuir um
facilmente esses dados para serem manipulados e valor (dados) a uma variável, usamos o operador de
transformados. atribuição =.

Uma variável é um conceito fundamental em Três partes estão envolvidas na operação de cessão:
qualquer linguagem de programação. É um local
reservado de memória que armazena e manipula os • O operador de cessão =
dados. Em algumas linguagens de programação, as • Um identificador ou nome variável, à
variáveis podem ser pensadas como "caixas" nas esquerda do operador.
quais os dados são armazenados, mas em Python, as • Uma literal, uma expressão, uma chamada
variáveis são "etiquetas" que permitem que você se de função, ou uma combinação de todas elas
à direita do operador de atribuição.
refira aos dados (que são armazenados em "caixas"
chamadas objetos). Ejemplos:

Ao contrário de outras linguagens de programação,

# Asigna a la variable <a> el valor 1
Python não tem comandos para declarar uma
a = 1
variável. Uma variável é criada assim que lhe é dado # Asigna a la variable <a> el resultado
um nome e lhe é atribuído um valor. de la expresión 3 * 4
a = 3 * 4
# Asigna a la variable <a> la cadena de
x = 15 caracteres 'Pythonista'
y = "Ana" a = 'Pythonista'
print(x) Quando atribuímos um valor a uma variável pela
print(y) primeira vez, é onde a variável é definida e rubricada.
Em um roteiro ou programa escrito em Python,
podemos definir variáveis em qualquer parte do
18
IBM SkillsBuild | Introducción a Python

roteiro. No entanto, é uma boa prática definir as

variáveis que você vai usar no início.

Se tentarmos usar uma variável que não tenha sido

previamente definida/inicializada, o intérprete nos
mostrará um erro:

print(a)

Estreitamente relacionado às variáveis está o

conceito de tipo de dados. Quando um valor é
atribuído a uma variável, esse valor pertence a um
conjunto de valores conhecido como um tipo de
dado. Um tipo de dado define uma série de
características sobre esses dados e as variáveis que
os contêm, tais como as operações que podem ser
realizadas sobre eles. Em Python, os tipos de dados
básicos são numéricos (inteiro, real e complexo),
booleanos (True, False) e cadeias de caracteres.

Os tipos de dados, sua declaração e como trabalhar

com eles serão abordados em profundidade no
próximo tópico.

A variável de lista que acabamos de declarar nada

mais é do que uma lista de números. Este é outro dos
tipos básicos de Python que veremos mais adiante.
Por enquanto, basta entender que as listas são
coleções de objetos encomendados.

19