{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Introdução à Lógica de Programação\n",
"### Um curso prático para estudantes das Ciências da Vida\n",
"---\n",
"## Aula 5. Estruturas de Repetição\n",
"##### Instrutor: Pedro C. de Siracusa"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Computadores são muito eficientes em realizar tarefas bem definidas e repetitivas. E muito menos suscetíveis a cometer erros de cálculo do que nós humanos.\n",
"Nesta aula vamos aprender a inserir **automação** em nossos programas utilizando **estruturas de repetição**.\n",
"**Loops** (em português \"laços de repetição\") são estruturas que garantem que uma parte do código seja repetida várias vezes. Existem dois tipos fundamentais de loops: (i) ***for* loops** e (ii) ***while* loops**. Por simplicidade, veremos apenas o primeiro tipo neste curso."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Objetivos. \n",
"\n",
"Após esta aula você deverá ser capaz de:\n",
"* Escrever trechos de código repetitivos usando estruturas de repetição;\n",
"* Compreender o conceito de iteração;\n",
"* Reconhecer casos de uso de variáveis de iteração e variáveis contadoras;\n",
"* Percorrer programaticamente elementos em listas."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Loops e Iterações"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"No jargão da computação, chamamos de **loop** uma estrutura contendo código que será executado múltiplas vezes. Cada repetição do loop é chamada **iteração**.\n",
"\n",
"A estrutura de um loop do tipo \"**for**\" é composta por:\n",
"\n",
"* uma **variável de iteração** (normalmente chamada `i` ou `j`, mas poderia ser qualquer outro nome, como por exemplo `dinossauro`);\n",
"* uma **lista** com os elementos que desejamos percorrer. \n",
"\n",
"Para exemplificar, vamos construir uma estrutura que imprima no console a frase \"nova iteração\" algumas vezes.\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Antes do loop...\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Nova iteração\n",
"Depois do loop\n"
]
}
],
"source": [
"print(\"Antes do loop...\")\n",
"\n",
"for i in range(10):\n",
" print(\"Nova iteração\")\n",
"\n",
"print(\"Depois do loop\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Uma característica da variável de iteração é que ela, a cada iteração, assumirá o valor seguinte na lista percorrida. Podemos então imprimir no console o número de cada nova iteração."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Antes do loop...\n",
"Iteração 0\n",
"Iteração 1\n",
"Iteração 2\n",
"Iteração 3\n",
"Iteração 4\n",
"Iteração 5\n",
"Iteração 6\n",
"Iteração 7\n",
"Iteração 8\n",
"Iteração 9\n",
"Depois do loop\n"
]
}
],
"source": [
"print(\"Antes do loop...\")\n",
"\n",
"for i in range(10):\n",
" print(\"Iteração\",i)\n",
"\n",
"print(\"Depois do loop\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos também percorrer listas com elementos não-numéricos por meio de loops."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Nova iteração: elemento Olá\n",
"Nova iteração: elemento Dinossauro\n",
"Nova iteração: elemento True\n",
"Nova iteração: elemento False\n",
"Nova iteração: elemento ['a', 'b', 'c']\n",
"Nova iteração: elemento 42.5\n"
]
}
],
"source": [
"minhaLista = [\"Olá\", \"Dinossauro\", True, False, [\"a\", \"b\", \"c\"], 42.5 ]\n",
"\n",
"for el in minhaLista: # neste caso a variável `el` é a variável de iteração\n",
" print(\"Nova iteração: elemento\", el)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Variáveis contadoras** (normalmente chamadas `ctr`) podem ser usadas para armazenar resultados de forma gradativa durante as iterações. Elas são usualmente inicializadas com valor zero e, a cada iteração, são atualizadas (normalmente somando-se 1).\n",
"Usando variáveis contadoras podemos, por exemplo, calcular a soma de números em uma lista."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Antes do loop\n",
"Valor inicial de ctr: 0\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 0\n",
"Somando 1\n",
"Novo valor de ctr: 1\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 1\n",
"Somando 2\n",
"Novo valor de ctr: 3\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 3\n",
"Somando 3\n",
"Novo valor de ctr: 6\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 6\n",
"Somando 4\n",
"Novo valor de ctr: 10\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 10\n",
"Somando 5\n",
"Novo valor de ctr: 15\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 15\n",
"Somando 6\n",
"Novo valor de ctr: 21\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 21\n",
"Somando 7\n",
"Novo valor de ctr: 28\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 28\n",
"Somando 8\n",
"Novo valor de ctr: 36\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 36\n",
"Somando 9\n",
"Novo valor de ctr: 45\n",
"\n",
"Dentro do loop: nova iteração\n",
"Valor anterior de ctr: 45\n",
"Somando 10\n",
"Novo valor de ctr: 55\n",
"\n",
"Fora do loop\n",
"Valor final de ctr: 55\n"
]
}
],
"source": [
"minhaLista = [ 1,2,3,4,5,6,7,8,9,10 ]\n",
"\n",
"ctr = 0\n",
"print(\"Antes do loop\")\n",
"print(\"Valor inicial de ctr:\", ctr)\n",
"print(\"\")\n",
"\n",
"for i in minhaLista:\n",
" print(\"Dentro do loop: nova iteração\")\n",
" print(\"Valor anterior de ctr:\",ctr)\n",
" print(\"Somando\", i)\n",
" ctr = ctr + i # é assim que atualizamos o valor de uma variável usando como base seu valor antigo\n",
" print(\"Novo valor de ctr:\",ctr)\n",
" print(\"\")\n",
"\n",
"print(\"Fora do loop\")\n",
"print(\"Valor final de ctr:\", ctr)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Podemos também usar loops para percorrer strings, como se fossem uma lista de caracteres."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Nova iteração: caractere L\n",
"Nova iteração: caractere u\n",
"Nova iteração: caractere k\n",
"Nova iteração: caractere e\n",
"Nova iteração: caractere \n",
"Nova iteração: caractere S\n",
"Nova iteração: caractere k\n",
"Nova iteração: caractere y\n",
"Nova iteração: caractere w\n",
"Nova iteração: caractere a\n",
"Nova iteração: caractere l\n",
"Nova iteração: caractere k\n",
"Nova iteração: caractere e\n",
"Nova iteração: caractere r\n"
]
}
],
"source": [
"meuNome = \"Luke Skywalker\"\n",
"\n",
"for caractere in meuNome: # neste caso a variável `caractere` é a variável de iteração\n",
" print(\"Nova iteração: caractere\", caractere)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercícios."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 1.** Escreva a função `conta_sup` que recebe: uma lista `l` contendo valores numéricos; e um número `limite`. A função deve contar quantos elementos na lista `l` têm valor maior ou igual a `limite`."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"def conta_sup(l, limite):\n",
" ctr=0\n",
" for i in l:\n",
" if i >= limite:\n",
" ctr = ctr + 1\n",
"\n",
" return ctr"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"minhaLista = [42, 52,6,30,42,68,28,48,2,100,29,172,0,-1,-50]\n",
"\n",
"# Existem 2 elementos com valor maior ou igual a 100 na lista\n",
"conta_sup(minhaLista, 100)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 2.** Escreva a função `busca_max` que recebe uma lista `l` contendo valores numéricos e retorna o valor máximo encontrado nela. O comportamento dessa função é equivalente ao da função `max`. No entanto, não use a função `max` neste exercício."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"def busca_max(l):\n",
" elem_max = l[0] # a princípio assumiremos que o primeiro elemento da lista é o máximo\n",
"\n",
" # agora no loop vamos atualizar o valor em `elem_max` sempre que encontrarmos algum com valor maior\n",
" for el in l:\n",
" if el > elem_max:\n",
" elem_max = el\n",
" \n",
" return elem_max"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"172"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"minhaLista = [42, 52,6,30,42,68,28,48,2,100,29,172,0,-1,-50]\n",
"\n",
"# O elemento de valor máximo na lista é o 172\n",
"busca_max(minhaLista)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 3.** Escreva uma função `busca_primeiro_sup` que recebe: uma lista `l` contendo valores numéricos; e um número `limite`. A função deve retornar imediatamente assim que encontrar um elemento na lista `l` com valor maior que `limite`. Caso encontre um valor maior que o limtie, este valor deve ser retornado como resultado. Caso contrário, a função deve retornar uma string `\"Não encontrado\"`."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [],
"source": [
"def busca_primeiro_sup(l, limite):\n",
" for el in l:\n",
" if el > limite:\n",
" return el\n",
"\n",
" return \"Não encontrado\""
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"minhaLista = [42, 52,6,30,42,68,28,48,2,100,29,172,0,-1,-50]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"172"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"busca_primeiro_sup(minhaLista, 100)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'Não encontrado'"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"busca_primeiro_sup(minhaLista,200)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 4.** Escreva uma função `complementaBases` que recebe como input uma sequência de bases de um fragmento de DNA e retorna as bases complementares."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"def complementaBases(dna):\n",
" complemento = \"\"\n",
"\n",
" for base in dna:\n",
" if base==\"A\":\n",
" complemento = complemento + \"T\"\n",
" elif base==\"T\":\n",
" complemento = complemento + \"A\"\n",
" elif base==\"G\":\n",
" complemento = complemento + \"C\"\n",
" elif base==\"C\": \n",
" complemento = complemento + \"G\"\n",
"\n",
" return complemento"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"'CTAATGT'"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"complementaBases(\"GATTACA\")"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.6.5"
},
"toc": {
"base_numbering": 1,
"nav_menu": {},
"number_sections": false,
"sideBar": true,
"skip_h1_title": false,
"title_cell": "Table of Contents",
"title_sidebar": "Contents",
"toc_cell": false,
"toc_position": {},
"toc_section_display": true,
"toc_window_display": false
}
},
"nbformat": 4,
"nbformat_minor": 2
}