Python1

Prévia do material em texto

lPython
Data Science: Primeiros passos
· Por que programamos? Por preguiça! Com a programação podemos automatizar tarefas, passando receitas para que o sistema (PC) possa seguir, além disso melhora nosso raciocino, pois estamos ensinando/criando algo para o PC, que acaba se tornando um pupilo, onde deve passar o passo a passo. 
· Por que programar em Python? Pela facilidade de inscrita, pois foi criando para atender a necessidade de pessoas não programadoras e que precisavam de algo mais simples. Traz uma sintaxe de fácil compreensão, utilizando muito do inglês.
· Python é uma lingarem de propósito geral, podendo utilizada para diversas coisas.  
Colaboratory, do Google. Trata-se de uma versão dos notebooks no cloud, sem a necessidade de baixar ou instalar algo localmente., onde escrevermos o código que analisará nossos dados. 
Atalhos:
Ctrl M B – Abrir novo código 
Ctrl M D - excluir 
Ctrl enter – Rodar código 
Shift enter – Colocar texto 
	Variáveis
Variáveis são pedacinhos de memória onde armazenamos valores. Sempre que referenciamos o nome de uma variável, o valor é acessado. Definimos uma variável dando um nome a ela e usando o sinal de igual (=) para atribuir um valor:
Tipos de variáveis:
Int (Inteiro): é um número inteiro Ex: idade = 23 
Float (Ponto flutuante ou Real): Números de ponto flutuante nada mais são que números com vírgula, ou como costumamos dizer "números quebrados". 
Ex : altura = 1.63 
Para determinar número de casas depois da virgula em uma operação usar:
:.1f
Str (String) São letras, palavras e frases, endereçada de forma que você possa ter acesso a qualquer valor dessa sequência. As aspas são usadas para mostrar o início e o fim de uma string. Ex.: Nome = ‘Ayra’
Booleana - Essas variáveis nada mais são do que uma forma de se armazenar um valor lógico, ou seja, verdadeiro ou falso, que, em Python, são representados como True e False, respectivamente 
Ex: primeiraAula = True 
<https://algoritmosempython.com.br/cursos/programacao-python/tipos-basicos/>
Note que o operador igual (=) NÃO possui ‘o mesmo comportamento da matemática. Na matemática, ele é um operador bidirecional: x = 2y seria a mesma coisa que 2y = x. No Python, ele é o que chamamos de um operador de ATRIBUIÇÃO: A expressão à direita do sinal é resolvida e seu resultado é armazenado na variável à esquerda.
· Linhas iniciadas com # são comentários.
· Comentários são ignorados pelo Python e servem para explicar o código.
· O símbolo # é um comentário de apenas 1 linha.
· Usando 3 aspas simples (‘’’) consecutivas é possível abrir um bloco de comentário de múltiplas linhas. O bloco se encerra com outras 3 aspas simples.
· Toda função tem que ter parênteses e todo texto tem que estar acompanhado de aspas simples ou dupla.  *Números não precisam estar acompanhados de aspas, pois não são mensagens, são números (usados para cálculos, enquanto as mensagem para aparecer na tela) → ('Olá Mundo') 
Print → Escreva/ imprima na tela, é uma função de saída (output) ***
Nome = 'Ayra' → Nome recebe Ayra.
Print(nome) → imprima na tela a função nome = Ayra
· .Função input() → Leia.  É uma função de entrada, onde retorna um valor inserido pelo usuário. Tudo que lido por input() é considerado uma str.
Nome = input (“Qual é o seu nome?”) → Nome recebe o resultado do input qual é o seu nome (deixando o usuário colocar o resultado) 
Ex.: 
Função Type – Para verificar um tipo de variável
	O Python é executado linha a linha, escrever um código python é como seguir uma receita de bolo, onde precisamos explicar passo a passo para que dê certo, por isso é importante estruturar bem seu código. 
E isso é o Algoritmo: É a sequência de passo a passo para resolver um problema. Uma sequência finita de ações executáveis que visa obter uma solução para um determinado tipo de problema 
Como tudo que é lido por input() é considerado uma string (str), para tratar como outros tipos de dados é necessário realizar a conversão.
Para isso colocamos o Type que desejamos na frente da função: 
	peso = float(input('Digite o seu peso: ')) # lê o peso como número real
idade = int(input('Digite a sua idade: ')) # lê a idade como número inteiro
print(nome, 'pesa', peso, 'kg e tem', idade, 'anos de idade.')
Para converter para o tipo Boleano, uma string vazia (‘ ‘) vai se converter a valor falso, caso tenha qualquer outro valor vai ter saída verdadeira. No caso de números, o 0 vai ter saída falsa e qualquer outro valor, saída verdadeira.
Print(‘A Soma é {}’.format()]
O colchete é uma máscara e você define o que vai aparece no lugar dela no .format(): 
	Operadores matemáticos / aritméticos
Os operadores são comandos que aplicamos as expressões que escrevemos em nossos programas para executar uma ação (a operação).
Um exemplo é uma operação de soma (+), que utilizamos em nossas calculadoras: nós recebemos dois operandos, uma operação e o programa nos retorna o resultado da execução dessa expressão.
1+1 = 2
Operando 1, operação +, operando 1. Isso retornaria um 2, pois a calculadora executa suas instruções internas a fim de analisar a expressão e rodar os comandos e depois nos retorna este resultado.
Operadores matemáticos são os já conhecidos comandos para fazermos contas em linguagens de programação.
	Operadores simples
	+
	Soma
	
	-
	Subtração
	
	*
	Multiplicação
	
	/
	Divisão
	Realiza a divisão dos operandos
Ex: 5/2 = 2.5
	//
	Divisão inteira
	Retorna o valor inteiro da divisão
Ex: 5/2 =2
	%
	Resto de divisão
	Retorna o resto da divisão entre operandos
Ex: 5%2 = 1
Pois o 1 é o resto da divisão?
 
	**
	Potência e 
Razão n ** (1/2)
	Retorna um número elevado a potência de outro
Ex: 52 = 25
Razão = 18 ** (1/2) = 4,24
Podemos fazer operações dentro do print:
Podemos fazer operações com variáveis não inteiras:
Ordem de precedência
	Condições Python e instruções If 
Operadores de comparação e lógicos
 Python suporta as condições lógicas usuais da matemática, podendo usar operadores de comparação:
· Igual a (Is): a == b
· Diferente de (Is not): a != B
· Menor que: a < b
· Menor ou igual a: a <= b
· Maior que: a> b
· Maior ou igual a: a >= b
E operadores lógicos:
	Op.
	Conceito
	Exemplo
	And &&
	Retorna True se todas as condições forem verdadeiras, caso contrário retorna false
	a > 2 and b < 5 a > 2 && b < 5
	OR ||
	Retorna True se uma das condições for verdadeira, caso contrário retorna false
	a > 2 or b < 5 a > 2 || b < 5
	Not 
	Inverte o resultado: se o resultado da expressão for True, o operador retorna false
	Not(a > 2 and b <5)
	in
	Retorna True caso o valor seja encontrado na sequência 
	2 in x (2 está em x)
	not in
	Retorna True caso o valor não seja encontrado na sequência
	2 not in x
IF, Else , Else if e exemplos:
Essas condições podem ser usadas de várias maneiras, mais comumente em "instruções if" e loops. Essas operações sempre trarão como resultado True ou False (ou seja, são booleanas). 
Uma "declaração if" é escrita usando a palavra-chave if.:
	a = 33
b = 200
if b > a:
 print("b is greater than a")
Porém o python depende de uma identificação (espaço da abertura de parágrafo) para definir o espaço do código, outras linguagens costumam usar chaves para essa finalidade.
Ou seja, se utilizar o print direto sem o espaço no início retornara como erro. 
A palavra-chave else captura qualquer coisa que não seja capturada pelas condições anteriores.
	a = 200
b = 33
if b > a:
  print("b is greater than a")
elif a == b:
  print("a and b are equal")
else:
  print("a is greater than b")
	
Se b for maior que a apareça "b is greater than a" porém se a é igual a b, traga "a and b are equal", se não for nada disso, traga “a is greater than b traga” 
Se você tem apenas uma instrução para executar, uma para if e outra para else você pode colocar tudo na mesma linha:
	a = 2
b = 330
print("A") if a > b else print("B")
	
Apareça “A” se a for maior que b, se não apareça “B”
Também é possível utilizar mais de uma condicional, como fazemos no excel, utilizandoif dentro de if, junto também a outras cond..
	a = 330
b = 330
print("A") if a > b else print("=") if a == b else print("B")
A palavra-chave elif é a maneira do python dizer "se as condições anteriores não eram verdadeiras, tente esta condição".
	a = 33 
b = 33
if b > a: 
  print("b is greater than a”) 
elif a == b:
  print("a and b are equal")
	
Se b for maior que a apareça "b is greater than a" porém se a é igual a b, traga "a and b are equal"
A palavra-chave and é um operador lógico e é usada para combinar declarações condicionais:
	a = 200
b = 33
c = 500
if a > b and c > a:
  print("Both conditions are True")
Isso também vale para a palavra-chave or :
	a = 200
b = 33
c = 500
if a > b or a > c:
  print("At least one of the conditions is True")
As condições If não podem ser vazias, pois irá gerar erro, mas caso necessário por algum motivo basta usar o pass no lugar de print (que retornará vazio)
Exemplo not, or e and:
	
	Curiosidade aleatória
Sabia que os sabiás podem prever com mais exatidão a intensidade da temporada de furacões, mesmo meses antes deste evento? Para mais assista a Era dos dados, ep 1;
O Python usa o espaçamento para delimitar o que pertence ou não ao bloco de código. 
. Estruturas de Repetição – While
While – Enquanto tal coisa não ocorre (ou seja é falso) o passo continua a ocorrer. 
Por exemplo, enquanto você não coloca a senha certa, continuará aparecendo “senha invalida”, até que coloque a senha correta.
Com o While não precisa definir um range, mas precisa definir uma condição, para que não entre em um loop infinito. 
Enquanto não chegar na maçã
· se for bloco, andar para frente
· se for espaço vazio, pula, 
· se por moeda, pega
Se chegar na maçã pega (fechou o ciclo). 
Porém se não houvesse a condição, entraria em um loop infinito: Se for bloco anda, se for espaço vazio, pula, se for moeda pega, se for bloco anda, se for espaço vazio, pula, se for moeda pega, se for bloco anda, se for espaço vazio, pula, se for moeda pega......
Enquanto houver louça, continue a lavar:
O contador serve de condição, assim como a maçã do exemplo anterior. No caso de número serve para especificar quantas vezes uma tarefa será executada. 
Quando trabalhamos com o while e um contador deve se atentar há:
· Incremento – se condicionou que o código será executado até um determinado limite, precisa atualizar sempre o valor do contador para chegar próximo ao valor deste limite: 
while contador < 10; 
contador = contador + 1
caso contrário vai cair no loop infinito pois o contador será sempre zero. 
Diferença de If e While:
Observe que o if assim que identifica que a condição é atendida já trás uma única resposta, o while não, repete até o limite (6).
Assim repetirá até chegar a condição 0.
No caso de uma frase, é mais fácil determinar o ponto de parada para sair do loop.
Break – Para forçar um loop ser interrompido.
For
Um tipo especial de loop feito para percorrer elementos de uma coleção. Funciona como um laço interligando o código. O for eliminar a necessidade de inicializarmos um contador, incrementarmos e verificar a condição de parada. 
	for (variável temporária) in (lista):
 # instruções..
O for se repete uma vez para cada elemento da lista. A cada repetição, a variável temporária assume o valor de um elemento da lista, na ordem da lista.
	fib = [1, 1, 2, 3, 5, 8, 13]
for elemento in fib:
 print(elemento)
O for pode ser usado, junto com a função range(), para gerar sequências numéricas e contagens. Existem 3 meios de usar o range(): especificando 1, 2 ou 3 parâmetros.
a) Com 1 parâmetro, ele será interpretado como valor final (exclusivo).
	for numero in range(10):
 print(numero)
# este exemplo imprime os números de 0 a 9, de um em um
b) Com 2 parâmetros, o primeiro será o valor inicial (inclusivo) e o # segundo será o final (exclusivo).
	for numero in range(1,11):
 print(numero)
 # este exemplo imprime os números de 1 a 10, de um em um
c) Com 3 parâmetros, o terceiro será interpretado como incremento.
	for numero in range(1,20,2):
 print(numero)
#este exemplo imprime os ímpares positivos menores do que 20
#ele começa valendo 1 e salta de 2 em 2 até atingir ou passar 20
d) O incremento pode ser também um decremento (incremento negativo).
	for numero in range (10,0,-1):
 print(numero)
 #Imprimindo os números de 1 a 10 em ordem decrescente
	Estruturas avançadas
Variáveis compostas:
Toda variável simples é um espaço na memória, porém só recebe uma atribuição, na sua gaveta você só pode guardar uma coisa. 
Exemplo
Lanche = hamburguer. 
Se em seguida eu colocar no meu código
Lanche = suco
O suco vai substituir o hamburguer, pois na varável simples, é como se você tivesse apenas um vagão de trem disponível para armazenar a informação.
Variável simples: Só tem um vagão, carrega só um item em sua memória
Lanche = ‘Hamburguer’
Variável composta: Dá para colocar muito mais coisas em sua memória (vagões) sem excluir o item anterior:
Indexação de base 0 – começa a se contar as posições do 0. 
Listas
Listas são coleções de objetos em Python. Ao invés de declarar 1 variável para cada valor que gostaríamos de armazenar, podemos criar uma lista para armazenar vários valores.
O delimitador é os colchetes [ ] e o separador a virgula. 
	nome_paises = ['Brasil','Argentina','China','Canadá','Japão']
print(nome_paises)
 ['Brasil', 'Argentina', 'China', 'Canadá', 'Japão']
Len – Para ver o tamanho da lista:
*Obs: tamanho da lista é 5, porém a contagem começa no 0!
Para fazer a chamada do item ou fatiamento (slice) basta colocar o nome da variável no caso nome_paises e seu índice dentre de colchete que pode ser positivo (o Japão está na 4 posição) ou negativo (O Japão está na penúltima posição):
Listas são mutáveis: podemos alterar o valor de seus itens. Para isso basta identificar logo após o nome da variável dentro de colchetes, a posição do item que quer alterar e sua nova atribuição:
Para delimitar a amostra da lista pode usar os colchetes:
Para mostrar até o final da lista deve deixar o ultimo colchete vazio:
O mesmo pode ser feito com o índice inicial. 
Para pular de forma padronizada podemos incrementar 2 pontos e o número de casas a pular:
Ao usar com o sinal negativo faz a lista inverter. 
Para encontrar valores na lista usamos o in:
Também pode adicionar o Not:
Nome_lista.append() - Coloca um elemento novo ao final da lista.
Ex:
	resposta = 's'
while resposta == 's' or resposta == 'S':
    resposta = input('Deseja adicionar um país na lista? [S/N] ')
    if (resposta == 's' or resposta == 'S'):
        pais = input('Digite o nome do País: ')
        nome_paises.append(pais) # adiciona o novo país a lista
print(nome_paises)
R Deseja adicionar um país na lista? [S/N] s
Digite o nome do País: Noruega
Deseja adicionar um país na lista? [S/N] n
['Brasil', 'Argentina', 'China', 'Canadá', 'Colombia', 'Coreia', 'Noruega']
.remove() deleta um elemento da lista. (mas dá erro se o elemento não existir).	
	pais = input('Digite o animal a ser deletado da lista: ')
nome_paises.remove(pais)
print('Lista:', nome_paises, 'país removido:', pais)
R Digite o animal a ser deletado da lista: Brasil
Lista: ['Argentina', 'Canadá', 'Coreia', 'Noruega'] país removido: Brasil
.pop(x) - deleta um item a partir de sua posição. 
.count() - conta quantas vezes um elemento aparece.
.index() - busca em um elemento e fala em qual posição ele aparece.
.sort() – Ordena uma lista:
	nome_paises.append('India')
nome_paises.append('Peru')
nome_paises.append('México')
nome_paises.append('Uruguai')
nome_paises.append('Alemanha')
nome_paises.append('Paraguai')
nome_paises.append('Bolivia') #Adicionei novos itens na lista
print(nome_paises)
R ['Argentina', 'Canadá', 'Coreia', 'Noruega', 'India', 'Peru', 'México', 'Uruguai', 'India', 'Peru', 'México', 'Uruguai', 'Alemanha', 'Paraguai', 'Bolivia', 'India', 'Peru', 'México', 'Uruguai', 'Alemanha', 'Paraguai', 'Bolivia'] 
 #Veiona ordem que adicionei os itens
 _______________________________________________________________________________
nome_paises.sort()
print(nome_paises)
['Alemanha', 'Alemanha', 'Argentina', 'Bolivia', 'Bolivia', 'Canadá', 'Coreia', 'India', 'India', 'India', 'México', 'México', 'México', 'Noruega', 'Paraguai', 'Paraguai', 'Peru', 'Peru', 'Peru', 'Uruguai', 'Uruguai', 'Uruguai'] 
 #Ordenou os itens em ordem alfabética.
Tirar duplicadas:
	nome_paises = list(dict.fromkeys(nome_paises))
print(nome_paises)
R ['Alemanha', 'Argentina', 'Bolivia', 'Canadá', 'Coreia', 'Haiti', 'India', 'México', 'Noruega', 'Paraguai', 'Peru', 'Uruguai']
.
 .insert() – Também serve para inserir um item na lista., porém você indicará a posição. 
	nome_paises.insert(1,"Haiti")
print(nome_paises)
R ['Alemanha', 'Haiti', 'Argentina', 'Bolivia', 'Canadá', 'Coreia', 'Haiti', 'India', 'México', 'Noruega', 'Paraguai', 'Peru', 'Uruguai']
max() – Encontrar maior numero em uma lista
min() – Encontrar menor numero em uma lista. 
Caractere de escape – serve para alterar um sentido padrão de um caractere na frase usa a barra invertida \ antes do sinal e no fim.
	frase = "O professor Pietro da Let's Code disse: \"Hoje a pizza é por minha conta\""
print(frase)
R O professor Pietro da Let's Code disse: "Hoje a pizza é por minha conta"
Tuplas	
Uma tupla é uma coleção de objetos que lembra muito as listas. Porém são imutáveis. Depois que definida uma tupla, não poderá adicionar, retirar ou alterar itens dela, sendo menos flexível.
Uma vez definida, não poderá fazer qualquer alteração. 
- A tupla contém algumas operações especiais que a lista não atende
- Devido a sua rigidez ocupa menos espaço para armazenamento.
# Ao invés de colchetes (), usamos parênteses para declarar as tuplas (como as strings) ou sem delimitador, apenas listando os valores:
Também podemos fazer tuplas de um elemento. 
Unpacking – “despacotar” a tupla. Pegar todos os valores que estão juntos em uma tupla só e colocar cada um desses valores em variáveis deferentes:
Pode criar um unpacking com * para delimitar todo o resto, ou separar toda a tupla incial:
	estados_nordeste =  'Alagoas', 'Bahia', 'Ceará', 'Maranhão', 'Paraíba', 'Piauí', 'Pernambuco', 'Rio Grande do Norte', ' Sergipe'
a, b,*c = estados_nordeste
print('Estados separados no Unpackinh:', a,b,'Delimitação de todo o restante:',c)
print('Separando toda a tupla:', *estados_nordeste)
R Estados separados no Unpackinh: Alagoas Bahia Delimitação de todo o restante: ['Ceará', 'Maranhão', 'Paraíba', 'Piauí', 'Pernambuco', 'Rio Grande do Norte', ' Sergipe']
Separando toda a tupla: Alagoas Bahia Ceará Maranhão Paraíba Piauí Pernambuco Rio Grande do Norte Sergipe
	Resumo 
	[x]
	L&T
	Para ver qual valor está em determinada posição
	[1:5] 
	L & T
	Lista com começo e fim definido
	[1:]
	L & T
	Apenas começo definido
	[:2]
	L & T
	Apenas final definido
	[:]
	L & T
	Sem começo ou fim definido, ou seja trará toda a lista
	[::x]
	L & T
	Para definir um intervalo de casas a pular
	[::-x]
	L & T
	Para inverter a ordem da lista
	In
	L & T
	Para pesquisar valores dentro da listra, sempre retornará um valor bool
	/
	L & T
	No texto para mudar o sentido de caractere
	.append()
	Lista
	Para adicionar novo item na lista
	.insert()
	Lista
	Insere um item na lista, porém deve indicar a posição.
	.remove()
	Lista
	Para remover um item da lista
	.pop()
	Lista
	Remove um item da lista mas deve indicar a posição
	.count()
	L & T
	Conta quantas vezes o elemento aparece
	.Index 
	L & T
	Busca um elemento e mostra sua posição 
	.sort() 
	L & T
	Ordena a lista
	list(dict.fromkeys())
	Lista
	Tirar duplicadas.
	Len
	L & T
	Para ver tamanho da lista
	
	
	
	Aprofundando nas Strings
É possível quebrar as strings assim como as listas e tuplas com o auxilio dos colchetes, podendo acessar individualmente cada caracter em uma frase.
.split() - divisão, é um método utilizado para dividir o conteúdo de uma string. O resultado dessa divisão, que na opção padrão é feita sempre que a função encontrar um caractere de espaço, mas também posso delimitar o marcador dentro do colchetes com aspas, é retornado no formato de uma lista com uma ou mais substrings.
list() – Para converter strings para listas:
listafrase = list(frase)
Formatação de strings
.strip – serve para tirar espaços excessivos no inicio e final de uma frase ou qualquer valor textual. 
.capitalize() - a primeira letra maiúscula, restante minúscula
.title() - todo início de palavra em maiúscula, resto minúscula
.upper() - string inteira em maiúscula
.lower() - string inteira em minúscula
.replace('x', 'y') - substitui a primeira substring pela segunda.
Funções de edição:
	.split()
	Divisão da string
	.list()
	Conversão em lista
	.strip
	Tirar espaços em excesso
	.captalize()
	Primeira letra maiscula
	.title()
	Todo inicio de palavra maiscula
	.upper()
	Tudo maisculo
	.lower()
	Tudo minúsculo
	‘\n’
	Quebra de linha
	‘\t’
	Tabulação
	\\
	\ na frase
	+
	Concatena strings
	*y
	Repete a string conforme um valor definido (y)- no caso de número deve converter para str()
	.format()
	Também serve para a str, usando {} e colocando o valor a ser preenchido dentro do format.
	{.x}
	Numero de casas depois da virgula
	{:d}
	Parâmetro de numero inteiro
	{:0xd}
	forçar que os espaços em branco sejam preenchidos com o número 0, útil para datas
	end=’’
	No meio da frase serve para que não pule a linha.
# Um modo mais simples de utilizar o .format()
. Acrescentamos o f para deixar as funções entre chaves.
nome = "Ayra"
print(f'o nome é {nome}')
· o nome é Ayra
	Dicionários
Um dicionário é uma coleção, assim como as listas e as tuplas. Porém, enquanto as tuplas eram indexadas por um índice, os dicionários são indexados por chaves. Todo elemento em um dicionário possui uma chave e um valor {‘x’:’y’}, e sempre que terminar um par valor, colocar a virgula. Chaves tipicamente são strings, valores podem ser qualquer tipo de dado. 
	dados_cidade = {
    'nome':'São Paulo',
    'estado': 'São Paulo',
    'area': 1521,
    'populacao_milhoes':12.18
}
print(dados_cidade)
R {'nome': 'São Paulo', 'estado': 'São Paulo', 'area': 1521, 'populacao_milhoes': 12.18}
· O dicionário não possui um .append, portanto adicionamos os valores diretamente:
dicionario['cat'] = 'gato'
· Dicionários, assim como as listas, são mutáveis, basta alterar o valor da chave:
dicionario['cat'] = 'Minzy’
· Para o print de uma chave especifica basta sinalizar com as chave:
print(dados_cidade[‘nome’]
Assim como nas listas, se você atribuir em outra variável o valor do dicionário e nessa segunda variável faça alguma alteração, essa alteração propagará para a variável original.
Para criar um dicionário independente porém com os dados de outra variável, preciso garantir que vou usar o .copy() 
Se não utilizo o copy, altero o dicionário original:
Ao utilizar o .copy() não altero os dados originais:
Mas caso queira atualizar os dados posso usar o .update():
	novos_dados = {'piriquito':'xerere', 'gato mais novo': 'Minzy'}
dicionario.update(novos_dados)
print(dicionario)
R {'cat': 'Pichano', 'dog': 'Bob', 'piriquito': 'xerere', 'gato mais velho': 'Pichanin', 'gato mais novo': 'Minzy'}
Para verificar se uma variável existe em sua base e não dar erro, podemos usar o .get()
As funções .keys() e .values() para obter listas com apenas as chaves ou apenas os valores do dicionário e a função .items(), retorna uma lista de tuplas (chave, valor) de um dicionário.
Função e Linguagem
Funções são uma espécie de "subprograma". Elas são como pequenos pedacinhos de programa que podem ser chamadas pelo nome. Para criar uma função usamos o comando def e o nome da função. Elas são um bloco de comando assim como if/elif/else, while e for.
Usamos as funções desde o princípio, a linguagem pyhton vem repleta de funções, porém nem sempre essas funções pré definidas nos satisfazem e por isso precisamos criar novas,
Ex:
Definição da função mostra linha é imprimir os traços. 
defcria comandos e parâmetros. 
A função pode receber vários parâmetros separados por vírgula.
	def dadosPessoais(nome, idade, cidade): 
print("Seu nome é {}, você tem {} anos e mora em {}.".format(nome, idade, cidade)) 
dadosPessoais("José", 30, "Maceió")
OU
print print(f'Seu nome é {nome}, você tem {idade} anos e mora em {cidade}.') 
dados(nome='José', idade=30, cidade='Maceió') 
## Precisamos explicitar qual parâmetro estamos passando, para evitar ambiguidade ou erros de interpretação do Python. ##
R Seu nome é José, você tem 30 anos e mora em Maceió.
Agrupando parâmetros
Podemos utilizar o operador * - que, neste caso, não será uma multiplicação. Ao colocarmos o * ao lado do nome de um parâmetro na definição da função, estamos dizendo que aquele argumento será uma coleção. Mais especificamente, uma tupla. Porém, o usuário não irá passar uma tupla. Ele irá passar quantos argumentos ele quiser, e o Python automaticamente criará uma tupla com eles:
Podemos utilizar o operador * na chamada da função também. Na definição, o operador * indica que devemos agrupar itens avulsos em uma coleção. Na chamada, ele indica que uma coleção deve ser expandida em itens avulsos:
Para criar parâmetros opcionais, usaremos **, os parâmetros passados serão agrupados em um dicionário: o nome do parâmetro será uma chave, e o valor será... O valor.
	Manipulação de Arquivos
O Python possui algumas funções prontas para manipular arquivos binários puros (onde, conhecendo a estrutura interna de qualquer formato, podemos salvar qualquer tipo de arquivo) e para manipular arquivos de texto (onde os binários são decodificados como strings).
Podemos criar arquivos novos ou abrir arquivos já existentes utilizando a função open. Ela possui 2 argumentos: o caminho do arquivo e o modo de operação.
	read
	r
	lê um arquivo existente
	write
	w
	cria um arquivo
	append 
	a
	abre um arquivo existente para adicionar informações ao seu final
	update 	
	+
	ao ser combinado com outros modos, permite alteração de arquivo já existente (ex: r+ abre um arquivo existente e permite modificá-lo)
Após abrirmos (ou criarmos) um arquivo, podemos realizar diversas operações. Ao final de todas elas, devemos fechar o nosso arquivo usando a função close. Essa etapa é importante por 2 motivos:
1. Se alteramos o arquivo, mas não o fechamos, as alterações não serão salvas;
2. Se esquecemos de fechar um arquivo, outros programas podem ter problemas ao acessá-lo.
Roteiro básico
Abrindo o arquivo:
Se o arquivo estiver na mesma pasta que seu notebook, pode chama-lo pelo nome. Caso precise chamar de outro diretoria acima (uma pasta antes do que você está utilizando) basta usar: ../ usar e adicionar os .../ conforme a necessidade. 
Por exemplo tenho as pastas:
Estudos > T.I > SantanderCoders> arquivos pyhton > notebooks > outros
Estou com o notebook aberto em “notebooks” e precisso acessar o arquivo que está na pasta anterior, “arquivos notebooks:
arquivo = open(../ 'nomedoarquivo.txt')
Caso o arquivo esteja por exemplo na pasta TI, e meu notebook em notebooks, adiciono mais ../
arquivo = open(../../../ 'nomedoarquivo.txt') 
*como está 3 pastas a cima adiciono 3 ../ 
Caso o arquivo abaixo, ou seja uma pasta depois temos que colocar o nome do diretório.
arquivo = open(outros/ 'nomedoarquivo.txt') 
Modo de abertura: leitura (r) ou escrita. (w)
Em caso mais simples como arquivos de texto (txt), usamos o read. No caso de arquivos binários usamos o write. Precisamos carregar o conteúdo do arquivo em algum formato que sabemos trabalhar. A read() carrega o conteúdo de um arquivo de texto em uma string. Sempre que abrimos um arquivo precisamos fechar e para isso usamos o close().
	arquivo = open('dom_casmurro_cap_1.txt','r',encoding='utf-8')
texto = arquivo.read()
print(texto)
arquivo.close()
*Precisamos adicionar o encoding='utf-8' caso retorne como erro, pode ocorrer dependo da versão do anaconda/jupter. 
Podemos fazer a leitura de linha por linha com o readline()
	arquivo = open('dom_casmurro_cap_1.txt','r',encoding='utf-8')
linha = arquivo.readline()
while linha != '': #enquanto a linha não for vazia
 print(linha, end='') print linha. 
 linha = arquivo.readline() nova linha 
arquivo.close() 
também é possível fazer com o for:
arquivo = open('dom_casmurro_cap_1.txt','r',encoding='utf-8')
for linha in arquivo:
 print(linha, end='')
arquivo.close()
Ps. O readline() funciona como um cursor também, ou seja uma vez que lemos a primeira linha, quando chamar o readline() novamente, ele vai de forma automática para a próxima linha. 
Em vez de usar o .close() no final de cada bloco podemos usar o with, ele garante que após a finalização do bloco, o arquivo será fechado. Para o with usaremos o as, para atribuir nome a nossa variável. 
	with open('dom_casmurro_cap_1.txt','r',encoding='utf-8') as arquivo:
 texto = arquivo.read()
 print(texto)
Manipular os dados do arquivo (escrita)
A escrita no python pode ser feita de duas maneiras, quando queremos criar um arquivo novo ou quando queremos adicionar texto em um arquivo já existente. 
	with open('dom_casmurro_cap_1.txt','w',encoding='utf-8') as arquivo:
 arquivo.write(‘Essa é uma linha que eu escrevi usando Python\n’)
 arquivo.write(‘Essa é a segunda linha que eu escrevi usando python\n’)
Para ler , precisamos abrir novamente com o r
with open('dom_casmurro_cap_1.txt','r',encoding='utf-8') as arquivo:
 print(arquivo.read(), end = '')
Para adicionar mais uma linha no meu texto, usamos o append() e a: 
Arquivos CSV
O formato CSV (Comma Separated Values, ou Valores Separados por Vírgula) é um arquivo de texto que representa dados em forma de tabela de forma simples.
Cada linha do arquivo de texto é uma linha da tabela, e as colunas são separadas por vírgulas.
1, 2, 3, 4
5, 6, 7, 8
9, 10, 11, 12
Poderíamos manipular estes arquivos diretamente usando as funções de arquivo vistas anteriormente. Um fator complicador é que o formato CSV não é bem padronizado: apesar do nome, é normal que outros separadores sejam usados ao invés de vírgula, como ";", para permitir que a vírgula seja usada em um campo. Idem para a separação entre linhas. Existe um módulo em Python para manipular arquivos CSV que nos ajuda a tratar essas diferenças. Todo programa que for utilizar o módulo CSV deverá importá-lo em seu início através do comando: import csv.
O import é sempre utilizado quando precisamos importar bibliotecas. E para ler o arquivo csv, usamos o csv.reader():
A primeira coluna é o cabeçalho.
Formas de leitura:
	import csv
with open('brasil_covid.csv', 'r',encoding='utf-8') as arquivo:
 leitor = csv.reader(arquivo)
 for linha in leitor:
 print(linha)
	with open('brasil_covid.csv', "r") as arquivo:
 leitor = csv.reader(arquivo, delimiter = ';', lineterminator = '\n') #criando um leitor
 print("O conteúdo do arquivo é:")
 print(leitor)
 for linha in leitor:
 print(linha)
	with open('brasil_covid.csv', 'r',encoding='utf-8') as arquivo_csv:
 leitor = csv.reader(arquivo_csv)
 header = next(leitor) 
 for linha in leitor:
 if float(linha[2]) > 1: 
 print(linha) 
Escrevendo um arquivo:
Para escrever escrever um arquivo csv usamo o csv.write()
E escrever sublistas da lista como uma linha o writerows().
Para ler o arquivo escrito, colocamos em seguida o reader()
	with open('user.csv','w', encoding='utf-8', newline='') as arquivo_users:
 escritor = csv.writer(arquivo_users)
 escritor.writerow(['nome','sobrenome','email', 'genero'])
 escritor.writerow(['Ayra','Sehenem','Ayra@email.com', 'feminino'])
newline=’’ – para que não deixe uma linha em vazio.
with open('user.csv','r', encoding='utf-8', newline='') as arquivo_users2:
 csv_reader = csv.reader(arquivo_users2, delimiter=',')
 for row in csv_reader:
 print(row)
Ex2:
	header = ['nome', 'sobrenome']
dados = []
pergunta = input('Oque deseja fazer?\n1 - Cadastrar\n0 - Sair\n')
while pergunta != '0':
 nome = input('Qual seu nome?')
 sobrenome = input('E seu sobrenome?')
 dados.append([nome,sobrenome])
 pergunta = input('O que deseja fazer?\n1 - Cadastrar\n0 - Sair\n')
print(dados)
with open('users.csv', 'w', newline = '') as arquivo_csv:
 writer = csv.writer(arquivo_csv)
 writer.writerow(header)
 writer.writerows(dados)
 
with open('users.csv', 'r', newline = '') as csv_file:
 csv_reader = csv.reader(csv_file, delimiter=',')
 for row in csv_reader:
 print(row)
DictReader e DictWriter
Podemos também trabalhar com dicionários, nos quais a primeira linha é lida como a chave e as demais são os respectivos valores.
	APIs
Application Programming Interface - API é um conjunto de rotinas e padrões de programação para acesso a um aplicativo de software ou plataforma baseado na Web.
Hoje em dia é muito comum que diferentes aplicações consumam dados pela internet, muitas vezes dados providenciados por terceiros. Por exemplo, um aplicativo de entrega de alimentos pode usar dados de geolocalização do Google para localizar restaurantes próximos ao usuário e exibir a rota percorrida pelo entregador.
Como as aplicações podem rodar em diferentes plataformas (Windows, Android, MacOS, iOS, um navegador de internet...), é importante estabelecer uma linguagem comum para que todos consigam consumir esses dados.
Essa "linguagem comum" é o que chamamos de API: Application Programming Interface. A organização que disponibiliza os dados estabelece algumas "regrinhas" para fazermos requisições, e em contrapartida ela garante que os recursos fornecidos também seguirão certos padrões, facilitando a vida dos programadores.
Portanto, quando decidimos utilizar uma API, a primeira coisa que precisamos fazer é estudar sua documentação. Vejamos alguns dos pontos mais relevantes para procurar.
URL base
Várias APIs fornecem um "endereço base". Todas as suas requisições incluirão esse endereço, e ao final dele nós colocamos detalhes específicos para cada um dos recursos disponíveis.
Por exemplo, na AlphaVantage, uma API de dados de bolsas de valores e criptomoedas, a URI base é:
https://www.alphavantage.co/query?
Após a interrogação nós colocaremos os campos para nossa consulta. Por exemplo, para fazer uma consulta sem autenticação para valores da IBM, de 5 em 5 minutos, o endereço completo fica:
https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol=IBM&interval=5min&apikey=demo
Note o formato com &NomeDoCampo=ValorDoCampo. Ele é bastante comum. Outro formato bastante comum é o de "subdiretórios".
Um exemplo é a PokéAPI. A URL base é:
https://pokeapi.co/api/v2/
Para procurar por pokémons, adicionamos pokemon/. Em seguida, podemos colocar números (índices) ou nomes de Pokémon, como:
https://pokeapi.co/api/v2/pokemon/ditto/
https://pokeapi.co/api/v2/pokemon/25
Se ao invés de pokémons estivéssemos interessados em tipos de pokémon, usaríamos types/ e o nome ou índice do tipo desejado:
https://pokeapi.co/api/v2/type/ghost
Formato
Tipo de dado
Algumas APIs possuem formatos fixos de dados. Outros permitem que você escolha. É comum, por exemplo, que uma API permita que você escolha entre JSON, XML, CSV e/ou outros formatos.
Caso você tenha entrado no AlphaVantage e se registrado para obter uma chave (falaremos mais adiante), você pode especificar, por exemplo, que gostaria de resultados no formato CSV:
https://www.alphavantage.co/query?function=TIME_SERIES_INTRADAY&symbol=IBM&interval=5min&dataformat=csv&apikey=demo
Substitua "demo" por sua chave no exemplo acima e ele funcionará.
Autenticação
Outro aspecto importante é a autenticação. Enquanto algumas APIs são grátis, outras são pagas. Ainda temos algumas híbridas: você pode gratuitamente acessar certos recursos, ou consumir um certo volume de dados, e acima disso você deverá pagar. Os dois modelos mais comuns de autenticação:
· Chave: ao fazer seu registro, você recebe uma chave que será inclusa na requisição, como é o caso do AlphaVantage.
· OAuth: um esquema um pouco mais complexo onde são combinados códigos de autorização, identificação do cliente e segredo do cliente em um POST, e o servidor cria uma sessão por um tempo limitado e fornece o ID da mesma. APIs de gigantes da internet (como Google e Facebook) costumam usar esse modelo.
Rate limiting
Um dado parcialmente relacionado ao item anterior. As APIs costumam limitar o número de requisições que você pode fazer em um instante de tempo (3 requisições por minuto, 10000 requisições por dia etc). Temos dois motivos:
· Segurança: evitar uma sobrecarga no servidor deles que possa indisponibilizar a API para todos os usuários.
· Venda de planos: várias APIs pagas possuem diferentes planos de pagamento. Os planos mais caros costumam permitir mais requisições do que os mais baratos ou gratuitos.
Wrappers
Algumas APIs possuem tantas buscas diferentes e os resultados podem ser tão complexos que mesmo vindo em 
formatos simples como JSON pode ser um pouco trabalhoso montar as requisições e isolar os dados que queremos. Por conta disso, frequentemente são fornecidas wrapper libraries: bibliotecas escritas em linguagens de programação específicas que já trazem classes e funções prontas para fazer requisições automaticamente e já quebrar o resultado em objetos fáceis de serem utilizados. Elas também costumam oferecer alguns benefícios adicionais, como caching: de tempos em tempos a base de dados é totalmente ou parcialmente baixada por completo e salva localmente, o que ajuda a economizar requisições e, consequentemente, uso de dados (bastante útil considerando em usuários de dispositivos móveis, por exemplo).
Schema
É uma representação visual ou um conjunto de regras que governa um banco de dados. É bastante comum que as APIs disponibilizem um "modelo" genérico de como será formatado o seu JSON, XML etc para que os desenvolvedores saibam quais campos esperar e quais tipos de dados serão possíveis para cada campo. 
Sandbox
Várias APIs possuem no mesmo site de sua documentação uma área conhecida como sandbox, onde você pode simular requisições no próprio navegador e ver não só a resposta formatada, como informações sobre como montar aquela requisição em software.	
Abaixo podemos observar a área de sandbox para fazer consultas de gastos por meio de cartão de pagamento do Portal da Transparência do governo federal. Note que ele mostra o schema e apresenta campos para preenchermos as buscas. 
Consumindo APIs em Python
As APIs são meios de nos conectarmos a recursos na internet. Você irá construir a lógica para decidir o que você irá buscar/consultar, montará uma string seguindo o formato indicado pela documentação da API (como todos os exemplos deste capítulo). Em seguida você tratará a resposta de acordo:
· Se for JSON, utilize o método json da própria requests.
· Se for CSV, utilize o módulo CSV estudado anteriormente.
· Se for XML, podemos utilizar o módulo BeautifulSoup.
Para outros formatos, provavelmente a solução mais fácil será baixar um módulo preparado para lidar com eles.
Descobrindo APIs: tem boas ideias e gostaria de saber se existe uma boa API para ajudar? Confira alguns bons repositórios de API organizados por categoria:
https://github.com/n0shake/public-apis
https://github.com/public-apis/public-apis
https://any-api.com/
Sites de governos costumam ter uma grande riqueza de dados também. Segue abaixo algumas sugestões (oficiais ou mantidas por voluntários) com dados do Brasil como um todo. Experimente buscar por bases de dados de sua cidade ou estado!
http://www.transparencia.gov.br/swagger-ui.html
http://www.dados.gov.br/
https://brasil.io/home/
Exemplo aplicação:
	!pip install requests 
import requests 
url = 'https://v6.exchangerate-api.com/v6/0f8064745f257a43948ecc03/latest/USD'
req = requests.get(url)
print(req.status_code)
R 200 #Quando o código retorna 404, significado não encontrado, 200 significa que está tudo OK 
!pip install para instalar uma biblioteca no Python.status_code – verificar o código da pagina. 404 = erro, 200 = OK	
O método .get() envia uma solicitação para receber o url especificado.
Json - JavaScript Object Notation, é o formato da api.
Exchangerate API é um API para conversão de moedas internacionais: 
https://www.exchangerate-api.com/ - Devemos fazer o cadastro para obter acesso. 
API: https://v6.exchangerate-api.com/v6/0f8064745f257a43948ecc03/latest/USD'
	dados = req.json()
print(dados)
R 'result': 'success', 'documentation': 'https://www.exchangerate-api.com/docs', 'terms_of_use': 'https://www.exchangerate-api.com/terms', 'time_last_update_unix': 1626566401, 'time_last_update_utc': 'Sun, 18 Jul 2021 00:00:01 +0000', 'time_next_update_unix': 1626652801, 'time_next_update_utc': 'Mon, 19 Jul 2021 00:00:01 +0000', 'base_code': 'USD', 'conversion_rates': {'USD': 1, 'AED': 3.6725, 'AFN': 80.2285, 'ALL': 103.7255, 'AMD': 494.8232, 'ANG': 1.79, 'AOA': 647.5899, 'ARS': 96.2745, 'AUD': 1.3481, 'AWG': 1.79, 'AZN': 1.7031, 'BAM': 1.6546, 'BBD': 2.0, 'BDT': 84.8471, 'BGN': 1.655, 'BHD': 0.376, 'BIF': 197........
Base code: Informa a moeda padrão utilizada. 
Conversion rate: taxa de conversão da moeda base, para cada uma das outras moedas computadas na API. 
valor_reais = float(input('Informe o valor em reais a ser convertido\n'))
cotacao = dados['conversion_rates']['BRL'] #posição rates, e dentro de rates será buscado a chave BRL
print(f' R${valor_reais} em dolar valem US${(valor_reais/cotacao):.2f}')
 
API DATETIME	
É uma API que já vem no python, portanto não é preciso instalação, apenas importar.
print(datatime.time(12, 6, 21, 7)) #Hora, minuto, segundo e microssegundo
print(datatime.date(2020, 4, 25)) #Ano, mês e dia.
print(datatime.datatime(2020, 4, 25, 12, 6, 25, 7)) # Anos, mês, dia, Hora: minuto, segundo, microssegundo
Também podemos usar: 
hoje = dt.date(2021,7,18)
aniversario = dt.date(2021,7,22)
print(aniversario - hoje)
print((aniversario - hoje).days)
print((aniversario - hoje).seconds)
print((aniversario - hoje).microseconds)
 
Matilda: Foi o Mickey que comeu o queijo! Remi: Não fui eu que comi! 
Mickey: Foi o Alexander que comeu, eu vi! Alexander: O Mickey está mentindo!