Warm-up#
Reflexão - Desafios da Ciência dos Dados#
Dados não são dados. Ou seja, não caem do céu, prontos e perfeitos para quem os consome. São o resultado, por vezes, de longos processos de construção que envolvem várias decisões metodológicas. Além disso, o consumo dos dados não é imediato. Quem lê ou analisa os dados precisa também estar capacitado para compreendê-los. Mesmo pesquisadores experimentados podem cair nas diversas armadilhas que uma nova e desconhecida base de dados geralmente apresenta.
— Guia brasileiro de análise de dados: armadilhas & soluções / Editores Claudio D. Shikida, Leonardo Monasterio, Pedro Fernando Nery. Brasília: Enap, 2021.
Reflexão - Qual linguagem trabalhar em Ciência dos Dados?#
Não nos interessa o martelo, e sim os pregos!
At the end of the day, the purpose of the programming language is to allow for the simplest and the most efficient code to be used for the job at hand.
When someone says “I want a programming language in which I need only say what I wish done”, give him a lollipop. – Alan Perlis
“If someone claims to have the perfect programming language, he is either a fool or a salesman or both” – Bjarne Stroustrup
Uma verdade sobre aprender algoritmos / aprender a programar.#
Não aprendemos algoritmos:
- Copiando algoritmos;
- Estudando algoritmos.
Só aprendemos algoritmos:
- Construíndo algoritmos;
- Testando algoritmos.
A Linguagem Python#
Podemos definir a linguagem de programação Python a partir de quatro características:
Python é uma linguagem de propósito geral, isto é, Python é uma linguagem de programação que permite a construção de programas de computador para os mais variados propósitos, tais como: aplicações front-end e back-end, apps, games, computação científica, modelos de inteligência artificial, etc.
Python é uma linguagem de alto-nível, isto significa que ela abstrai ao programador os detalhes de implementação computacional das rotinas. Você pensa mais no “o que quero fazer” do que “como será feito”;
Python é uma linguagem interpretada, o que permite que ela seja multiplataforma. Por meio de um interpretador o programa Python consegue ser executado nas mais diversas plataformas computacionais;
Python é dinamicamente tipada. Nós armazenamos os dados de nossas aplicações em espaços de memória denominados variáveis. Cada variável possui um tipo, o que está diretamente relacionado ao espaço alocado em memória para o armazenamento dos valores da variável. Por ser dinâmicamente tipada, Python não exige que você defina previamente o tipo de uma variável. Dessa forma, uma variável X, por exemplo, pode no instante t armazenar o valor 1 (inteiro), mas no instante t+1 armazenar o valor “Python é muito legal!” (cadeia de caracteres - string);
The Zen of Python#
import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!
Python - Environments#
Anaconda#
Variáveis#
Variáveis são espaços reservados na memória para armazenamento;
Variáveis podem armazenar qualquer valor, dinamicamente tipadas;
Variáveis são case-sensitive. Isto é, a variável A é diferente da variável a, assim como a variável Escola é diferente da variável escola;
Não é possível definir variáveis cujo nomes contenham espaço.
Armazenamento valores em variáveis#
Fazemos uso do operador de atribuição ‘=’ para armazenar valores nas variáveis:
varA = ‘casa’
varB = ‘escola’
varX, varY, varZ = 5, 2, 1 (declaração múltipla)
Python como uma calculadora#
Os números em python são armazenados em dois tipos de dados: inteiros e ponto flutuantes.
3
3
1.2
1.2
As operações matemáticas são executadas conforme o esperado.
1 + 3
4
6 - 2
4
2 - 3
-1
3 * 7
21
5 / 2 #neste caso não precisamos nem da variável
2.5
5 // 2 # divisão inteira
2
5 % 2 # resto da divisão de 5 por 2
1
5 ** 3 # 5 ao cubo
125
a = 5
b = 2
c = 3
d = a / b
print(d)
print('O valor de d é = ', d)
2.5
O valor de d é = 2.5
a // b
2
a % b
1
a ** c
125
Precedência#
A precedência de operadores segue as padronizações oficiais. Mas, aproveitando um caso polêmico (leia aqui) vamos praticar.
8 / 2 * (2 + 2)
16.0
8 / (2*(2+2))
1.0
Tipos de Dados: Booleanos#
São dados que representam valores lógicos: verdadeiro (True) e falso (False)
a = 1
print(a)
print(type(a))
a = 'Insper'
print(type(a))
1
<class 'int'>
<class 'str'>
True or False
True
not True
False
Operadores Relacionais#
É possível também fazer uso de operadores relacionais, os quais retornam valores booleanos
a = 10
print(a)
10
b = 2
b
2
a > b
True
a < b
False
a == b
False
a != b
True
1 < 2 < 3 # é como se fosse (1 < 2) and (2 < 3)
True
1 < 2 and 2 < 3
True
x = "insper"
"insper" == x
True
x == "Insper"
False
"ins" in x
True
a = 4
b = 4
a == b
True
Tipos de Dados: Strings#
String é um tipo de dado que armazena conjuntos de caracteres.
Podemos criar uma string usando aspas simples ou aspas duplas
E há um motivo para isso, pense no uso de apóstrofos …
Exemplo de Strings#
str_var = "esta é uma variável do tipo string"
print(str_var)
esta é uma variável do tipo string
str_var2 = 'aqui é uma nova string'
print(str_var2)
aqui é uma nova string
str_var3 = "João ficou espantando e disse: 'que coisa!'"
print(str_var3)
João ficou espantando e disse: 'que coisa!'
Muitos objetos Python podem ser convertidos em uma string com a função str
a = 5.6
type(a)
float
s_a = str(a)
s_a
'5.6'
type(s_a)
str
Estruturas de armazenamento#
Listas em Python são criadas fazendo uso de colchetes [ ] e podem armazenar tipos distintos de variáveis
lista = ['maça', 'banana', 'goiaba']
lista
['maça', 'banana', 'goiaba']
# Quantos elementos existem na lista
len(lista)
3
# há maça na lista?
'maça' in lista
True
lista.append(4.50)
lista
['maça', 'banana', 'goiaba', 4.5]
lista[0] # em python o primeiro elemento se inicia em 0
'maça'
lista[3]
4.5
xs = [3, 2, 1]
print(xs)
[3, 2, 1]
print(xs, xs[2])
[3, 2, 1] 1
print(xs[-1])
1
xs.append('elem')
xs
[3, 2, 1, 'elem']
x = xs.pop() # remove o último elemento da lista
x
'elem'
Outra estrutura em Python são as tuplas, que são listas imutáveis. Elas são caracterizadas por colchetes ( )
tupla = ('maça', 'banana', 'goiaba')
tupla[0]
'maça'
tupla[0] = 'abacate'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
Input In [60], in <cell line: 1>()
----> 1 tupla[0] = 'abacate'
TypeError: 'tuple' object does not support item assignment
Como strings são sequências de caracteres, estas podem ser tratatadas como outras sequências, tais como listas e tuplas:
s_a = 'casa'
type(s_a)
str
print(s_a[0])
c
Slicing#
nums = list(range(5))
nums
[0, 1, 2, 3, 4]
# exibindo toda a lista
print(nums)
[0, 1, 2, 3, 4]
# exibindo os primeiros três elementos
print(nums[:3])
[0, 1, 2]
# exibindo a partir do segundo elemento
print(nums[1:])
[1, 2, 3, 4]
# exibindo todos exceto o último
print(nums[:-1])
[0, 1, 2, 3]
Looping#
animals = ['cat', 'dog', 'monkey']
for animal in animals:
print(animal)
cat
dog
monkey
animals = ['cat', 'dog', 'monkey']
for idx, animal in enumerate(animals):
print('#%d: %s' % (idx + 1, animal))
#1: cat
#2: dog
#3: monkey
### loop comum
nums = [0, 1, 2, 3, 4]
squares = []
for x in nums:
squares.append(x ** 2)
print(squares)
[0, 1, 4, 9, 16]
for i in range(5):
print(i)
0
1
2
3
4
List Comprehensions#
List Comprehensions (abrangências de lista) é um dos recursos mais amados da linguagem Python.
Este recurso permite que você componha uma nova lista de modo consiso, na seguinte estrutura:
[expr for val in collection if condition]
O que é equivalente a:
result = []
for val in collection:
if condintion:
result.append(expr)
Não há necessidade de se utilizar sempre o filtro (if condition).
nums = [0, 1, 2, 3, 4]
squares = [x ** 2 for x in nums]
print(squares)
[0, 1, 4, 9, 16]
[x for x in range(20) if x %2 == 0]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
Dicionários#
São estruturas de armazenamento de dados que fazem uso do conceito chave - valor
Dicionários armazenam vários tipos de dados
my_dict = {'a': 1, 'b':2, 'c':3}
print(my_dict)
{'a': 1, 'b': 2, 'c': 3}
my_dict['a']
1
'b' in my_dict
True
my_dict.keys()
dict_keys(['a', 'b', 'c'])
my_dict_1 = {'Nome': 'Joao', 'Idade': 42, 'Sexo': 'M', 'Peso': 78.5}
my_dict_1
{'Nome': 'Joao', 'Idade': 42, 'Sexo': 'M', 'Peso': 78.5}
Loops com dicionários#
pernas = {'pessoa': 2, 'cão': 4, 'aranha': 8}
#for animal in pernas:
# print(f'Um(a) {animal} possui {pernas[animal]} pernas')
for animal in pernas:
#print('Um(a) ', animal, ' possui ', pernas[animal], ' pernas' )
print(f'Um(a) {animal} possui {pernas[animal]} pernas ')
Um(a) pessoa possui 2 pernas
Um(a) cão possui 4 pernas
Um(a) aranha possui 8 pernas
Controle de Fluxo#
São comandos/recursos que permitem modificar o fluxo de execução de uma aplicação;
Também são chamados de estruturas condicionais;
Implementam a lógica booleana do tipo SE - ENTÃO, SENÃO
Comando SE - ENTÃO#
a = 2
if a == 2:
print('a vale 2')
a vale 2
x = 0
if x < -1 or x > 1:
x = x * 2
print('O valor foi dobrado')
print("O valor de 'x' é :", x)
O valor de 'x' é : 0
Comando SE - ENTÃO, SENÃO#
x = int(input())
print('Você inseriu o valor ', x)
if x > 0:
print('É um número positivo')
print('Positivo!!!')
elif x < 0:
print('É um número negativo')
print('Negativo!!!')
else:
print('Zero')
4
Você inseriu o valor 4
É um número positivo
Positivo!!!
Exercícios de fixação#
1. Crie as seguintes variáveis:
Peso = 85.94
Altura = 1.73
Na sequência, calcule o IMC (\( IMC = Peso / Altura^2 \)) e exiba uma String com a seguinte formatação: “Para um peso de 85.9 Kg, e uma altura de 1.7 m, o IMC calculado é de 28.71
Dica: você pode fazer uso da função format do Python! Pesquise sobre ela!
2. A distância entre dois pontos na superfície da Terra (em Km) pode ser aproximada fazendo-se uso do cálculo abaixo, onde 6371,01 é o raio médio da terra em Km.
\(dist = 6371,01 \times arccos(sen(t_1) \times sen(t_2) + cos(t_1) \times cos(t_2) \times cos(g_1 - g_2))\)
onde \(t_1, g_1\) e \(t_2, g_2\) são pares de latitude e longitude de dois pontos de interesse.
Faça um programa que receba dois pontos \((t_1, g_1), (t_2, g_2)\) e devolva a distância aproximada entre estes dois pontos em Km.
Dicas: em Python as funções trigonométricas estão disponíveis na biblioteca Math. O arco cosseno é obtido por meio da função acos. Seno pela função sin e Cosseno pela função cos.
Atente-se ao fato de que estas funções trigonométricas trabalham em Radianos e você estará informado os valores em grau. Para converter-los para radianos faça uso da função Radians da biblioteca Math.
Para obter pontos de interesse, acesse o site https://www.latlong.net/
Para verificar se o seu programa está correto, você pode calcular a distância entre dois pontos no endereço eletrônico: https://www.geodatasource.com/distance-calculator
Exemplos de pontos para testes:
Brasília (-15.699244, -47.829556) Tókio (35.652832, 139.879478) Distância aproximada em Km entre Brasília e Tókio: 17669.24 Km.