"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## O que é programar?\n",
"\n",
"Programar é como brincar com *LEGO*. Seguindo esta analogia, o trabalho do **programador** é construir estruturas complexas (como um castelo) encaixando blocos. \n",
"Ele projeta as funcionalidades que deseja criar e planeja um passo-a-passo para chegar ate elas, partindo do pressuposto de que um conjunto de blocos fundamentais já estarão disponíveis para ele. \n",
"O conjunto de blocos fundamentais disponíveis para o programador é o que constituiria uma **linguagem de programação**. Em termos gerais ela reúne conjuntos de regras e estruturas que permitem que o programador expresse suas ideias na forma de **código**. Escrever código seria como encaixar blocos. Sendo assim, o programador não precisa se preocupar em construir os blocos do zero antes de começar a trabalhar.\n",
"\n",
""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Neste curso você trabalhará com a linguagem [*Python*](https://www.python.org/), uma linguagem de **propósito geral** que oferece **alto nível** de abstração. Isso faz de *Python* uma excelente primeira linguagem a ser aprendida, pois *(i)* você poderá aplicar seus novos conhecimentos em programação a vários projetos e contextos diferentes; e *(ii)* você trabalhará projetando suas ideias, sem ter que se preocupar com os mínimos detalhes sobre como seu código funciona.\n",
"\n",
"Um componente fundamental da linguagem *Python* que nos permite **executar** o código que escrevemos é o **interpretador**.\n",
"No fundo, o interpretador é um programa que executa programas! Ele lê as instruções que escrevemos na forma de código e as executa logo em seguida, sem antes precisar traduzi-lo para código de máquina. Quer ver um exemplo?\n",
"\n",
"Vamos começar construindo o [programa \"Hello World\"](https://www.wikiwand.com/en/%22Hello,_World!%22_program), uma tradição bem conhecida entre os programadores quando estão aprendendo uma linguagem nova.\n",
"Este pequeno programa é encarado como um primeiro teste, e simplesmente imprime uma mensagem com o texto *\"Hello World\"* no console.\n",
"Escrever o programa \"Hello World em *Python* é realmente muito simples. Veja na célula abaixo."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World\n"
]
}
],
"source": [
"print(\"Hello World\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"O que fizemos foi simplesmente executar uma **função**, que já faz todo o \"trabalho sujo\" para nós. Esta função, que se chama `print`, recebe um texto como **argumento**, entre parênteses, e o imprime no console. No caso, o texto que passamos é `\"Hello World\"`. As aspas envolvendo o texto servem para dizer ao interpretador que estamos construindo uma *string* (o tipo de dado que usamos para representar texto)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Por enquanto vamos focar no uso mais básico do interpretador *Python*, operando valores numéricos apenas.\n",
"Nesta aula vamos aprender a usar o interpretador como uma calculadora um pouco mais elaborada. \n",
"No fim você codificará um modelo de crescimento exponencial para estimar o tamanho populacional em uma cultura bacteriana."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Objetivos. \n",
"Após esta aula você deverá ser capaz de: \n",
"\n",
"* Reconhecer os principais **operadores numéricos**;\n",
"* Construir e computar **expressões** matemáticas;\n",
"* Armazenar e consultar resultados de computações em **variáveis**."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 1. Tipos"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Tipos** são abstrações fundamentais nas linguagens de programação que nos permitem representar elementos de informação. Cada linguagem possui um conjunto de *tipos primitivos* (ou fundamentais), a partir dos quais o programador pode construir *tipos compostos*.\n",
"Por enquanto vamos conhecer alguns dos tipos primitivos, que já vêm definidos na linguagem *Python*:\n",
"\n",
"* Tipos **numéricos**:\n",
" * **Integer** (inteiros): Permite representar números inteiros, por exemplo `4`.\n",
" * **Float** (ponto flutuante): Permite representar números com parte fracionária, por exemplo `42.5`.\n",
"\n",
"* **String**: Permite representar informação na forma de texto, por exemplo `\"Palavra\"` ou `\"C\"`. Usamos aspas (duplas ou simples) para representar informação textual. Em muitas outras linguagens de programação existe também o tipo caractere (ou char). Porém, em *Python* um caractere é uma string de comprimento 1.\n",
"\n",
"* **Boolean**: Representa informação em lógica binária, `True` ou `False`. "
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"42 \n",
"42.5 \n",
"Palavra \n",
"C \n",
"True \n",
"False \n"
]
}
],
"source": [
"print(42, type(42))\n",
"print(42.5, type(42.5))\n",
"print(\"Palavra\", type(\"Palavra\"))\n",
"print('C', type('C'))\n",
"print(True, type(True))\n",
"print(False, type(False))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Veja os [tipos nativos](https://docs.python.org/3/library/stdtypes.html#built-in-types) da linguagem *Python*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 2. Operadores e expressões"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Operadores** são os símbolos que especificam as computações mais fundamentais, como por exemplo soma, subtração, multiplicação e divisão. Sempre que aplicamos um operador sobre dois operandos, esperamos obter algum resultado imediatamente. Podemos combinar vários operadores e operandos, construindo assim **expressões**. Veja na tabela abaixo os principais operadores numéricos da linguagem *Python*."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"| Operação| Operador| Exemplo | Resultado\n",
"|:-|---|-:|--|\n",
"| Soma | `+` | `9 + 7` | `16` |\n",
"| Subtração | `-` | `9 - 7` | `2` |\n",
"| Multiplicação | `*` | `9 * 7` | `63` |\n",
"| Divisão | `/` | `5 / 2`| `2.5` | \n",
"| Exponenciação | `**` | `9**2` | `81` |\n",
"| Módulo | `%` | `9 % 2` | `1` |\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Experimente operar alguns números na célula abaixo"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"49"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"42 + 7"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"35"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"42 - 7"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"256"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2**8"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"6 % 3"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 % 2"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 % 5"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Você também pode criar expressões combinando valores e operadores!"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"48.7"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"42 + 7 - 3/10"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"6"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3*2 - 4%2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Cuidado! A ordem de avaliação dos elementos em uma expressão segue a mesma convenção de precedência utilizada na matemática. Elementos entre parênteses têm prioridade durante a avaliação."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Na célula abaixo, represente a seguinte expressão em código e obtenha seu resultado: "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$ \\frac{3+(3\\times5)}{2\\times(2+3)} $$"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.8"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(3+(3*5))/(2*(2+3))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"> **Comentários**: Está vendo este `#` na primeira linha da célula acima? Linhas de código precedidas por este símbolo são comentários, que funcionam como mensagens a quem está lendo seu código, normalmente outros programadores. \n",
"Qualquer coisa escrita na mesma linha **à direita** do símbolo é simplesmente ignorada pelo interpretador, ou seja, **não é executada**. \n",
"É comum utilizar comentários para documentar partes de um código, ou marcar regiões que devem ser trabalhadas futuramente. "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## 3. Variáveis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Quando estamos programando, frequentemente precisamos armazenar valores obtidos em etapas anteriores em memória.\n",
"Assim, podemos re-utilizar estes valores sem precisar repetir todo o código.\n",
"Linguagens de programação oferecem uma maneira bastante intuitiva para isso, por meio de **variáveis**.\n",
"O símbolo que usamos para **atribuir** valores a variáveis é o sinal de igual (`=`). Na linguagem *Python*, uma variável é criada assim que atribuimos algum valor a ela.\n",
"\n",
"**obs:** O nome da variável sempre deve ser escrito à esquerda do símbolo `=`, e o valor a ser atribuído à variável, à direita."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Por exemplo, podemos criar uma variável chamada `idade`, para armazenar sua idade. Assim, sempre que quisermos saber o valor atribuído a esta variável, basta escrever seu nome em uma célula e executá-la!"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [],
"source": [
"idade = 29"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"29"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"idade"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Declare uma variável chamada `semestre` que armazene o valor numérico do semestre que está cursando atualmente.\n",
"Em seguida, escreva o nome da variável para obter seu valor. "
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"semestre = 8"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"semestre"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Quando lidamos com expressões grandes e complexas pode ser interessante quebrá-las em várias sub-expressões. Veja o seguinte exemplo:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$ 2 \\bigg[ \\frac{3\\times(2+5)-20}{3} \\bigg]^2 + \\sqrt 2 + 1 $$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Para facilitar a codificação desta expressão, vamos escrevê-la nas seguintes etapas:\n",
"\n",
"1. Atribua o resultado de $\\frac{3\\times(2+5)-20}{3}$ a uma variável de nome `a`.\n",
"2. Atribua o resultado de $\\sqrt{2}+1$ a uma variável de nome `b`. Lembrando que $\\sqrt{2} = 2^{\\frac{1}{2}}$\n",
"3. Agora, compute o resultado da expressão inteira usando as variáveis que você acabou de criar. $2a^2 + b$ e atribua o resultado a uma variável de nome `c`.\n",
"4. Por fim, imprima no console o valor da variável `c`."
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.6364357845953172"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = (3*(2+5)-20)/3\n",
"b = 2**(1/2) + 1\n",
"c = 2*a**2 + b\n",
"\n",
"c"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercícios"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 1.** Associe o resultado da expressão $2(10+1) + \\frac{8}{3+1}$ a uma variável de nome `a`. \n",
"Em seguida, associe à mesma variável o valor $5$ e imprima seu valor no console, usando a função `print`.\n",
"Qual valor será mostrado? E se você quisesse imprimir o resultado do primeiro valor que a variável recebeu? "
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Primeiro valor de a: 24.0\n",
"Segundo valor de a: 5\n"
]
}
],
"source": [
"a = 2*(10+1) + (8/(3+1))\n",
"print(\"Primeiro valor de a:\",a)\n",
"a = 5\n",
"print(\"Segundo valor de a:\",a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 2.** Veja na célula abaixo a codificação da expressão $\\sqrt{\\frac{3(3+5)}{5+1}}$. Execute a célula e observe o resultado. O valor está correto? Caso não esteja, como corrigir a expressão?"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.0"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"( 3*(3+5) / (5+1) )**(1/2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ex 3.** Para valores de $x$ em $\\{ 1,5,8, 9\\}$, compute o valor da função $\\quad{}f(x) = \\beta_0 + \\beta_1 x \\quad{}$, com parâmetros $\\beta_0 = -1.3$ e $\\beta_1=3.5$."
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"x = 1 -> f(x) = 2.2\n",
"x = 5 -> f(x) = 16.2\n",
"x = 8 -> f(x) = 26.7\n",
"x = 9 -> f(x) = 30.2\n"
]
}
],
"source": [
"# Crie as variáveis b0 e b1\n",
"b0=-1.3\n",
"b1=3.5\n",
"\n",
"# Para cada print, armazene os valores de x e f(x) nas variáveis x e f_x \n",
"x = 1\n",
"f_x = b0+b1*x\n",
"print(\"x = 1 -> f(x) =\", f_x ) # res. esperado: 2.2\n",
"\n",
"x = 5\n",
"f_x = b0+b1*x\n",
"print(\"x = 5 -> f(x) =\", f_x ) # res. esperado: 16.2\n",
"\n",
"x = 8\n",
"f_x = b0+b1*x\n",
"print(\"x = 8 -> f(x) =\", f_x ) # res. esperado: 26.7\n",
"\n",
"x = 9\n",
"f_x = b0+b1*x\n",
"print(\"x = 9 -> f(x) =\", f_x ) # res. esperado: 30.2"
]
}
],
"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"
}
},
"nbformat": 4,
"nbformat_minor": 2
}