Introdução à Programação em Python

Nesse Notebook aprenderemos:

operações básicas do Python,
tipos básicos de variáveis,
entrada e saída de dados e,
bibliotecas extras auxiliares.

Operações Aritméticas

O computador é essencialmente uma máquina de calcular. Para tanto temos diversas operações aritméticas disponíveis no Python:

soma (+): 1+2
subtração (-): 2-1
multiplicação (*): 3*5
divisão (/): 7/2
divisão inteira (//): 7//2
exponenciação (**): 2**3
resto da divisão (%): 5%2



In [5]:

    
# todo texto escrito após "#" é um comentário e não é interpretado pelo Python
1+2  # realiza a operação 1+2 e imprime na tela









    Out[5]:





3



In [8]:

    
2-1









    Out[8]:





1



In [9]:

    
3*5









    Out[9]:





15



In [3]:

    
7/2









    Out[3]:





3.5



In [4]:

    
7//2









    Out[4]:





3



In [11]:

    
2**3









    Out[11]:





8



In [12]:

    
5%2









    Out[12]:





1

A ordem que as operações são executadas seguem uma ordem de precedência:

- primeiro as operações de divisão e multiplicação,

- em seguida adição e subtração.



In [14]:

    
1 + 2 * 3









    Out[14]:





7

A ordem pode ser alterada com o uso de parênteses.



In [15]:

    
(1+2)*3









    Out[15]:





9



In [16]:

    
1 + (2*3)









    Out[16]:





7

Além das operações básicas temos algumas operações mais complexas disponíveis.

Precisamos indicar que queremos usar tais funções com o comando:

import math

Nota: As funções matemáticas disponíveis podem ser consultadas na documentação.



In [2]:

    
import math

math.sqrt(2.0) # raiz de 2









    Out[2]:





1.4142135623730951



In [19]:

    
math.log(10)   # ln(10)









    Out[19]:





2.302585092994046



In [18]:

    
math.exp(1.0) # e^1









    Out[18]:





2.718281828459045



In [21]:

    
math.log(math.exp(1.0)) # ln(e)









    Out[21]:





1.0



In [22]:

    
math.cos(math.pi) # cos(pi)









    Out[22]:





-1.0

Os tipos numéricos em Python são chamados de:

- `int`, para números inteiros e,

- `float`, para números reais.

Complete os códigos abaixo e aperte SHIFT+ENTER para verificar se a saída é a esperada.



In [29]:

    
# Exercício 01

# Vamos fazer algumas operações básicas: escreva o código logo abaixo das instruções, ao completar a tarefa aperte "shift+enter"
# e verifique se a resposta está de acordo com o esperado

# 1) A razão áurea é dada pela eq. (1 + raiz(5))/2, imprima o resultado
# resultado deve ser 1.61803398875



In [ ]:

    
# 2) A entropia é dada por:   -p*log(p) - (1-p)*log(1-p), 
# Note que o logaritmo é na base 2, procure na documentação como calcular log2.
# Calcule a entropia para:

# p = 0.5, resultado = 1.0



In [ ]:

    
# p = 1.0, resultado = nan



In [ ]:

    
# p = 0.0, resultado = nan



In [ ]:

    
# p = 0.4, resultado = 0.970950594455

Quando uma operação tem resultado indefinido o Python indica com o valor `nan`.

Variáveis

No exercício anterior, para calcular cada valor de entropia foi necessário digitar toda a fórmula para cada valor de p.

Além disso o valor de p era utilizado duas vezes em cada equação, tornando o trabalho tedioso e com tendência a erros.

Seria interessante criar uma célula do Notebook customizável para calcular a entropia de qualquer valor de p.

Da mesma forma que na matemática, podemos utilizar variáveis para generalizar uma expressão e alterar apenas os valores de tais variáveis.

No computador, tais variáveis armazenam valores em memória para uso posterior.

Para utilizarmos variáveis no Python basta dar um nome a ela e, em seguida, atribuir um valor utilizando o operador "=".

Uma vez que tal variável tem um valor, podemos realizar qualquer operação com ela:



In [23]:

    
x = 10 # o computador armazena o valor 10 na variável de nome x
x + 2









    Out[23]:





12



In [24]:

    
x * 3









    Out[24]:





30

Dessa forma o calculo da entropia poderia ser feito como:



In [26]:

    
p = 0.4
-p*math.log(p,2) - (1.0-p)*math.log(1.0-p,2)









    Out[26]:





0.9709505944546686

Ao alterar o valor de `p`, o programa retorna o resultado da nova entropia.

Podemos pedir que o usuário entre com os valores utilizando o comando `input()`.

Esse comando vai esperar que o usuário digite algum valor e o atribuirá em uma variável.

Nota: precisamos especificar ao comando input o tipo de variável desejada, no nosso caso `float`.



In [3]:

    
p = float(input("Digite o valor de p: "))
-p*math.log(p,2) - (1.0-p)*math.log(1.0-p,2)









    



Digite o valor de p: 0.45






    Out[3]:





0.9927744539878084

O nome das variáveis deve:

- começar com uma letra e,

- conter apenas letras, números e o símbolo "`_`".

Além disso existem alguns nomes já utilizados pelo Python e que não devem ser utilizados:

and, as, assert, break, class, continue, def, del, elif, 
    else, except, exec, finally, for, from, global, if, 
    import, in, is, lambda, not, or, pass, print, raise,
    return, try, while, with, yield

O Python determina automaticamente o tipo que a variável vai conter, de acordo com o que é atribuído a ela.

Podemos utilizar o comando `type()` para determinar o tipo atual da variável:



In [29]:

    
x = 1
type(x)









    Out[29]:





int



In [28]:

    
x = 1.0
type(x)









    Out[28]:





float

Outros tipos de dados

Booleanos

Além dos tipos numéricos temos também os tipos lógicos que podem conter o valor de verdadeiro (`True`) ou falso (`False`).

Esses valores são gerados através de operadores relacionais:

- Igualdade: `1 == 2` => `False`

- Desigualdade: `1 != 2` => `True`

- Maior e Maior ou igual: `1 > 2`, `1 >= 2` => `False`

- Menor e Menor ou igual: `1 < 2`, `1 <= 2` => `True`

E compostos com operadores booleanos:

- E: `True and False` => `False`

- Ou: `True or False` => `True`

- Não: `not True` => `False`



In [35]:

    
True and False









    Out[35]:





False



In [34]:

    
True and True









    Out[34]:





True



In [33]:

    
True or False









    Out[33]:





True



In [32]:

    
True or True









    Out[32]:





True



In [31]:

    
not True









    Out[31]:





False



In [30]:

    
not False









    Out[30]:





True



In [36]:

    
x = 1
y = 2
x == y









    Out[36]:





False



In [37]:

    
x != y









    Out[37]:





True



In [38]:

    
x > y









    Out[38]:





False



In [39]:

    
x <= y









    Out[39]:





True



In [41]:

    
x <= y and x != y    # x < y?









    Out[41]:





True



In [40]:

    
x <= y and not (x != y)   # x >= y e x == y ==> x == y?









    Out[40]:





False

Strings

Temos também a opção de trabalhar com textos, ou strings.

Esse tipo é caracterizado por aspas simples ou duplas.



In [6]:

    
texto = "Olá Mundo"
type(texto)









    Out[6]:





str



In [7]:

    
len(texto)









    Out[7]:





9

Podemos usar os operadores `+` e `*`, representando concatenação e repetição:



In [8]:

    
ola = "Olá"
espaco = " "
mundo = "Mundo"
ola + espaco + mundo









    Out[8]:





'Olá Mundo'



In [9]:

    
(ola + espaco) * 6 + mundo









    Out[9]:





'Olá Olá Olá Olá Olá Olá Mundo'

Podemos também obter um caractere da string utilizando o conceito de indexação.

Na indexação, colocamos um valor entre colchetes após o nome da variável para indicar a posição do elemento que nos interessa naquele momento.

A contagem de posição inicia do 0.



In [13]:

    
texto = "Olá Mundo"
texto[0]









    Out[13]:





'O'



In [14]:

    
texto[2] # terceira letra









    Out[14]:





'á'

Podemos também usar a indexação para pegar faixas de valores:



In [15]:

    
texto[0:3]









    Out[15]:





'Olá'



In [16]:

    
texto[4:]  # omitir o último valor significa que quero ir até o fim









    Out[16]:





'Mundo'



In [17]:

    
texto[:3] # nesse caso omiti o valor inicial









    Out[17]:





'Olá'



In [18]:

    
texto[-1]  # índice negativo representa uma contagem de trás para frente









    Out[18]:





'o'



In [19]:

    
texto[-1:-6:-1]  # o último valor, -1, indica que quero andar de trás para frente.









    Out[19]:





'odnuM'

Listas

Listas de valores são criadas colocando elementos de quaisquer tipos entre colchetes e separados por vírgulas.

As listas podem ser úteis para armazenar uma coleção de valores que utilizaremos em nosso programa.



In [20]:

    
coordenadas = [1.0, 3.0]
coordenadas









    Out[20]:





[1.0, 3.0]



In [21]:

    
lista = [1,2,3.0,'batata',True]
lista









    Out[21]:





[1, 2, 3.0, 'batata', True]



In [22]:

    
len(lista)









    Out[22]:





5

O acesso aos elementos da lista é feito de forma similar às strings:



In [23]:

    
lista[0]  # imprime o primeiro elemento da lista









    Out[23]:





1



In [24]:

    
lista[0:3] # imprime os 3 primeiros elementos









    Out[24]:





[1, 2, 3.0]



In [25]:

    
lista[-1] # último elemento









    Out[25]:





True

Existem outros tipos mais avançados que veremos ao longo do curso.

Complete o código abaixo para realizar o que é pedido:



In [21]:

    
#Exercício 02
import math
# 1) entre com o numero do mes do seu nascimento na variavel 'mes' e siga as instruções abaixo colocando o resultado
# na variável 'resultado'.
mes = int(input('Digite o mes do seu nascimento: '))
resultado = 0

# 1) multiplique o número por 2 e armazene na variavel de nome resultado

# 2) some 5 ao resultado e armazene nela mesma

# 3) multiplique por 50 armazenando em resultado

# 4) some sua idade ao resultado
idade = int(input('Digite sua idade: '))

# 5) subtraia resultado por 250

# o primeiro digito deve ser o mês e os dois últimos sua idade
print(resultado)









    



Digite o mes do seu nascimento: 28
Digite sua idade: 34
0



In [ ]:

    
#Exercício 03

# 1) Peça para o usuario digitar o nome e imprima "Ola <nome>, como vai?"
# não esqueça que o nome deve ser digitado entre aspas.
nome = 
print()



In [ ]:

    
# 2) Crie uma lista com 3 zeros peça para o usuário digitar 2 valores, armazenando nas 2 primeiras
# posicoes. Calcule a media dos dois primeiros valores e armazene na terceira posição.

# utilize input() para capturar os valores
lista =

print(lista)

Entrada e Saída de Dados

Entrada de Dados

Durante essa primeira aula vimos sobre os comandos `input()` para capturar valores digitados pelo usuário e `print()` para imprimir os valores dos resultados.

O comando `input()` captura uma string digitada pelo usuário, essa string deve ser convertida de acordo com o que se espera dela:



In [26]:

    
x = float(input("Entre com um valor numérico: ")) # o valor digitado será um número em ponto flutuante
x/2









    



Entre com um valor numérico: 10






    Out[26]:





5.0

Alguns dos comandos de conversão disponíveis são: `int()` para inteiros, `float()` para ponto flutuante e `str()` para strings.



In [81]:

    
x = 10
int(x) + 2









    Out[81]:





12



In [82]:

    
float(x) * 2









    Out[82]:





20.0



In [83]:

    
str(x) * 2









    Out[83]:





'1010'

Saída de Dados

A função `print()` permite escrever o valor de uma variável ou expressão na tela pulando para a próxima linha ao final.

Esse comando permite a impressão de diversos valores na mesma linha separando-os por ",".

Adicionalmente, se o último argumento da função for `end=" "` ele não pula para a próxima linha após a impressão.



In [3]:

    
print(2) # imprime 2 e vai para a próxima linha
print(3, "ola", 4+5) # imprime múltiplos valores de diferentes tipos e vai para a próxima linha
print(1, 2, end=" ")   # imprime os dois valores mas não pula para a próxima linha
print(3,4) # continua impressão na mesma linha

A função `print()` permite o uso de alguns caracteres especiais como:

- '\t': adiciona uma tabulação

- '\n': pula uma linha

Podemos complementar a formatação da string com o comando `format()`:



In [8]:

    
m = 1
n = 6
d = 1/float(n)
print('{}: {}/{} = {:.4}'.format("O valor da divisão", m, n, d)) 
# {} indica que as lacunas devem ser preenchidas e .4 é o número de casas decimais para o número.









    



O valor da divisão: 1/6 = 0.1667



In [9]:

    
print("Elemento 1 \t Elemento 2 \nElemento 3 \t Elemento 4")









    



Elemento 1 	 Elemento 2 
Elemento 3 	 Elemento 4

Bibliotecas Extras

O Python conta com diversas bibliotecas que automatizam muitas tarefas e permitem realizarmos experimentos interessantes.

Usualmente as bibliotecas, ou módulos, são importados através do comando:

import NOME

e as funções das bibliotecas são chamadas precedidas pelo NOME do módulo.

Vimos isso anteriormente com a biblioteca math:



In [85]:

    
import math
math.sqrt(2)









    Out[85]:





1.4142135623730951

Se soubermos exatamente as funções que iremos utilizar do módulo, podemos importá-los seletivamente com a sintaxe:

from NOME import FUNCAO

Nesse caso não precisamos preceder a função com NOME para executá-la:



In [3]:

    
from math import sqrt, exp
print(sqrt(2), exp(3))









    



1.41421356237 20.0855369232

Finalmente podemos apelidar o nome do módulo para facilitar a chamada de funções:



In [4]:

    
import math as mt
print(mt.sqrt(2), mt.exp(3))









    



1.41421356237 20.0855369232

O comando `dir` lista todas as funções disponíveis em uma biblioteca:



In [86]:

    
print(dir(math))









    



['__doc__', '__file__', '__name__', '__package__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'hypot', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'modf', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'trunc']

E o comando `help` imprime uma ajuda sobre determinada função:



In [87]:

    
help(math.sin)









    



Help on built-in function sin in module math:

sin(...)
    sin(x)
    
    Return the sine of x (measured in radians).

A biblioteca `matplotlib` permite plotar gráficos diversos.

Para usá-la no Jupyter Notebook primeiro devemos importar os comandos de plotagem:

%matplotlib inline 
import matplotlib.pyplot as plt

O comando `%matplotlib inline` indica para o Jupyter que todos os gráficos devem ser mostrados dentro do próprio notebook.

Vamos plotar alguns pontos de uma função quadrática utilizando o comando:

plt.plot(x,y)

onde x e y são listas com valores correspondentes a abscissa e ordenada, respectivamente.

Basicamente temos que:

- x será uma lista de pontos que queremos plotar e,

- y a aplicação da função $f(x) = x^2$ em cada ponto de x.



In [29]:

    
%matplotlib inline
import matplotlib.pyplot as plt

x = [-5,-4,-3,-2,-1,0,1,2,3,4,5]
y = [25,16,9,4,1,0,1,4,9,16,25]

plt.figure(figsize=(8,8))   # Cria uma nova figura com largura e altura definida por figsize
plt.style.use('fivethirtyeight') # define um estilo de plotagem: # http://tonysyu.github.io/raw_content/matplotlib-style-gallery/gallery.html

plt.title('Eq. do Segundo Grau') # Escreve um título para o gráfico
plt.xlabel('x') # nome do eixo x
plt.ylabel(r'$x^2$') # nome do eixo y, as strings entre $ $ são formatadas como no latex

plt.plot(x,y, color='green') # cria um gráfico de linha com os valores de x e y e a cor definida por "color"

plt.show() # mostra o gráfico

# Leiam mais em: http://matplotlib.org/users/pyplot_tutorial.html



In [ ]:

Introdução à Programação em Python

Nesse Notebook aprenderemos:

Operações Aritméticas

O computador é essencialmente uma máquina de calcular. Para tanto temos diversas operações aritméticas disponíveis no Python:

A ordem que as operações são executadas seguem uma ordem de precedência:

- primeiro as operações de divisão e multiplicação,

- em seguida adição e subtração.

A ordem pode ser alterada com o uso de parênteses.

Além das operações básicas temos algumas operações mais complexas disponíveis.

Precisamos indicar que queremos usar tais funções com o comando:

Nota: As funções matemáticas disponíveis podem ser consultadas na documentação.

Os tipos numéricos em Python são chamados de:

- int, para números inteiros e,

- float, para números reais.

Complete os códigos abaixo e aperte SHIFT+ENTER para verificar se a saída é a esperada.

Quando uma operação tem resultado indefinido o Python indica com o valor nan.

Variáveis

No exercício anterior, para calcular cada valor de entropia foi necessário digitar toda a fórmula para cada valor de p.

Além disso o valor de p era utilizado duas vezes em cada equação, tornando o trabalho tedioso e com tendência a erros.

Seria interessante criar uma célula do Notebook customizável para calcular a entropia de qualquer valor de p.

Da mesma forma que na matemática, podemos utilizar variáveis para generalizar uma expressão e alterar apenas os valores de tais variáveis.

No computador, tais variáveis armazenam valores em memória para uso posterior.

Para utilizarmos variáveis no Python basta dar um nome a ela e, em seguida, atribuir um valor utilizando o operador "=".

Uma vez que tal variável tem um valor, podemos realizar qualquer operação com ela:

Dessa forma o calculo da entropia poderia ser feito como:

Ao alterar o valor de p, o programa retorna o resultado da nova entropia.

Podemos pedir que o usuário entre com os valores utilizando o comando input().

Esse comando vai esperar que o usuário digite algum valor e o atribuirá em uma variável.

Nota: precisamos especificar ao comando input o tipo de variável desejada, no nosso caso float.

O nome das variáveis deve:

- começar com uma letra e,

- conter apenas letras, números e o símbolo "_".

Além disso existem alguns nomes já utilizados pelo Python e que não devem ser utilizados:

O Python determina automaticamente o tipo que a variável vai conter, de acordo com o que é atribuído a ela.

Podemos utilizar o comando type() para determinar o tipo atual da variável:

Outros tipos de dados

Booleanos

Além dos tipos numéricos temos também os tipos lógicos que podem conter o valor de verdadeiro (True) ou falso (False).

Esses valores são gerados através de operadores relacionais:

- Igualdade: 1 == 2 => False

- Desigualdade: 1 != 2 => True

- Maior e Maior ou igual: 1 > 2, 1 >= 2 => False

- Menor e Menor ou igual: 1 < 2, 1 <= 2 => True

E compostos com operadores booleanos:

- E: True and False => False

- Ou: True or False => True

- Não: not True => False

Strings

Temos também a opção de trabalhar com textos, ou strings.

Esse tipo é caracterizado por aspas simples ou duplas.

Podemos usar os operadores + e *, representando concatenação e repetição:

Podemos também obter um caractere da string utilizando o conceito de indexação.

Na indexação, colocamos um valor entre colchetes após o nome da variável para indicar a posição do elemento que nos interessa naquele momento.

A contagem de posição inicia do 0.

Podemos também usar a indexação para pegar faixas de valores:

Listas

Listas de valores são criadas colocando elementos de quaisquer tipos entre colchetes e separados por vírgulas.

As listas podem ser úteis para armazenar uma coleção de valores que utilizaremos em nosso programa.

O acesso aos elementos da lista é feito de forma similar às strings:

Existem outros tipos mais avançados que veremos ao longo do curso.

Complete o código abaixo para realizar o que é pedido:

Entrada e Saída de Dados

Entrada de Dados

Durante essa primeira aula vimos sobre os comandos input() para capturar valores digitados pelo usuário e print() para imprimir os valores dos resultados.

O comando input() captura uma string digitada pelo usuário, essa string deve ser convertida de acordo com o que se espera dela:

Alguns dos comandos de conversão disponíveis são: int() para inteiros, float() para ponto flutuante e str() para strings.

Saída de Dados

A função print() permite escrever o valor de uma variável ou expressão na tela pulando para a próxima linha ao final.

Esse comando permite a impressão de diversos valores na mesma linha separando-os por ",".

Adicionalmente, se o último argumento da função for end=" " ele não pula para a próxima linha após a impressão.

A função print() permite o uso de alguns caracteres especiais como:

- '\t': adiciona uma tabulação

- '\n': pula uma linha

Podemos complementar a formatação da string com o comando format():

Bibliotecas Extras

O Python conta com diversas bibliotecas que automatizam muitas tarefas e permitem realizarmos experimentos interessantes.

Usualmente as bibliotecas, ou módulos, são importados através do comando:

e as funções das bibliotecas são chamadas precedidas pelo NOME do módulo.

Vimos isso anteriormente com a biblioteca math:

Se soubermos exatamente as funções que iremos utilizar do módulo, podemos importá-los seletivamente com a sintaxe:

- `int`, para números inteiros e,

- `float`, para números reais.

Quando uma operação tem resultado indefinido o Python indica com o valor `nan`.

Ao alterar o valor de `p`, o programa retorna o resultado da nova entropia.

Podemos pedir que o usuário entre com os valores utilizando o comando `input()`.

Nota: precisamos especificar ao comando input o tipo de variável desejada, no nosso caso `float`.

- conter apenas letras, números e o símbolo "`_`".

Podemos utilizar o comando `type()` para determinar o tipo atual da variável:

Além dos tipos numéricos temos também os tipos lógicos que podem conter o valor de verdadeiro (`True`) ou falso (`False`).

- Igualdade: `1 == 2` => `False`

- Desigualdade: `1 != 2` => `True`

- Maior e Maior ou igual: `1 > 2`, `1 >= 2` => `False`

- Menor e Menor ou igual: `1 < 2`, `1 <= 2` => `True`

- E: `True and False` => `False`

- Ou: `True or False` => `True`

- Não: `not True` => `False`

Podemos usar os operadores `+` e `*`, representando concatenação e repetição:

Durante essa primeira aula vimos sobre os comandos `input()` para capturar valores digitados pelo usuário e `print()` para imprimir os valores dos resultados.

O comando `input()` captura uma string digitada pelo usuário, essa string deve ser convertida de acordo com o que se espera dela:

Alguns dos comandos de conversão disponíveis são: `int()` para inteiros, `float()` para ponto flutuante e `str()` para strings.

A função `print()` permite escrever o valor de uma variável ou expressão na tela pulando para a próxima linha ao final.

Adicionalmente, se o último argumento da função for `end=" "` ele não pula para a próxima linha após a impressão.

A função `print()` permite o uso de alguns caracteres especiais como:

Podemos complementar a formatação da string com o comando `format()`:

O comando `dir` lista todas as funções disponíveis em uma biblioteca:

E o comando `help` imprime uma ajuda sobre determinada função:

A biblioteca `matplotlib` permite plotar gráficos diversos.

O comando `%matplotlib inline` indica para o Jupyter que todos os gráficos devem ser mostrados dentro do próprio notebook.