Lista de Exercícios - WEDER CASEMIRO DE SOUZA

Os exercícios valem 30% da nota final.

Data Entrega: 18/09/2016
Formato da Entrega: .ipynb - Clique em File -> Download as -> IPython Notebook (.ipynb)
Enviar por email até a data de entrega, onde o assunto do email deve ser: Exercícios PosMBA Turma2 - SEU NOME

O cálculo da nota final é dado por: NF = (lista * 0.3) + (prova * 0.7)

Exercício 1

(0.5 ponto) Crie uma função chamada soma_tres_num que irá receber 3 parâmetros(sendo o último com valor padrão 10) e retorne a soma desses três valores.



In [ ]:

    
def soma_tres_num (valor1, valor2, valor3=150):
    total = valor1 + valor2 + valor3
    return(total)

Teste para as seguintes situações:



In [ ]:

    
print(soma_tres_num(0, 10))



In [ ]:

    
print(soma_tres_num(1,2,3))



In [ ]:

    
print(soma_tres_num(10, 10, 0))

Exercício 2

(0.5 ponto) Crie uma função chamda qtde_caracteres que receba um parâmetro e retorne a quantidade de caracteres. Se o valor recebido pelo parâmetro não for uma String, utilizar a função str() para converter o argumento.



In [ ]:

    
def qtde_caracteres(texto):
    try:
        qtd = len(texto)
    except:
        qtd = len(str(texto))
    return (qtd)

Teste as seguintes situações:



In [ ]:

    
print(qtde_caracteres(12345))
print(qtde_caracteres(', -'))
print(qtde_caracteres('python'))
print(qtde_caracteres('fia e big data'))

Exercicío 3

(1.5 ponto) Carregue o arquivo chamado funcionarios.txt. Esse arquivo contém nome e o salário anual de cada funcionário.

alexandre,42000
rose,50000
anderson,30000
antonio,60000
maria,120000
carlos,86000
cesar,48000

Faça os seguintes exercícios:

a) Crie uma função chamda carregar_dados_dic que deve receber um parâmetro(no caso o arquivo funcionarios.txt) e retorne um dicionário, onde a chave será o nome e o valor será o salário anual.



In [ ]:

    
def carregar_dados_dic(arquivo):
    arq = open(arquivo,'r')
    linhas = arq.readlines()
    dici = {}
    for linha in linhas:
        linha = linha.strip()
        linha = linha.split(',')
        dici[linha[0]] = int(linha[1])
    return (dici)
    arq.close()



In [ ]:

    
salarios = carregar_dados_dic('funcionarios.txt')



In [ ]:

    
print(salarios)

b) Crie uma função chamada calcular_salario_mensal que irá calcular quanto o funcionário ganha por mês. Verifique o tipo do campo do valor do dicionário. Utilize a função float() para converter o valor.



In [ ]:

    
def calcular_salario_mensal(salario_anual):
    try:
        mes = float(salarios[salario_anual]/12)
    except KeyError:
        mes = "Este funcionário não existe"
    return (mes)



In [ ]:

    
mensal = calcular_salario_mensal('carlos')
print(mensal)

c) Por fim, imprima para cada funcionário o nome, salário anual e mensal no seguinte formato:

Rose --- R$ 50000 --- R$ 4166.66

Dica: Lembre-se do .format para formatar uma string. Utilize a função round para arredondar para 2 casas decimais.

>>> round(7166.67555, 2)
7166.67



In [ ]:

    
for key in salarios:
    print ("{} --- R$ {} --- R$ {}".format(key,salarios[key],round(calcular_salario_mensal(key),2)))

Exercício 4

(1 ponto) Crie um programa que deve ler as informações do usuário (nome, idade e salário) através da função input. É necessário validar as informações com os seguintes critérios:

O nome deve ter tamanho maior que 3
A idade deve ser entre 18 e 65
O salário deve ser maior que R$ 788

Caso as informações não estejam nos critérios definidos anteriormente, será necessário solicitar ao usuário para digitar novamente. Por fim o programa deverá imprimir o seguinte texto:

NOME tem YY anos, recebe R$ SSS e seu nome tem CC caracteres.

Onde,

NOME deve ser substituído pelo nome digitado.
YY deve ser a idade
SSS deve ser substituído pelo valor do salário.
CC deve ser substituído pela quantidade de caracteres.

Lembre-se de formatar o salário para duas casas decimais.



In [ ]:

    
#Tratamento do Nome
nome = (input('Digite o Nome: '))
sucesso = 0
while (sucesso == 0):
    if len(nome) > 3:
        sucesso = 1
    else:
        nome = (input('O Nome deve ter mais que 3 dígitos, Digite novamente: '))
        
#Tratamento da idade
yy = (input('Digite a Idade: '))
sucesso = 0
while (sucesso == 0):
    try:
        newyy = int (yy)
    except:
        newyy = yy

    if type(newyy) == int:
        if 18 < newyy < 65:
            sucesso = 1
        else:
            yy = (input('A idade deve ser entre 18 e 65 anos, Digite novamente: '))
    else:
        yy = (input('A idade deve ser de formato inteiro, Digite novamente: '))

#Tratamento do salário
sss = (input('Digite o Salário: '))
sucesso = 0
while (sucesso == 0):
    try:
        newsss = round(float (sss),2)
    except:
        newsss = sss

    if type(newsss) == float:
        if newsss > 788:
            sucesso = 1
        else:
            sss = (input('O salário deve ser maior que R$ 788, Digite novamente: '))
    else:
        sss = (input('O salário deve ter valor numérico, Digite novamente: '))

print ('{} tem {} anos, recebe R$ {} e seu nome tem {} caracteres.'.format(nome,newyy,newsss,len(nome)))

Exercicio 5

(1.5 ponto) Crie uma função que deverá receber dois parâmetros, sendo um o arquivo e o outro a quantidade de palavras que aparecem com mais frequência. O retorno deverá ser uma lista, sendo que cada elemento dessa lista, deve ser uma tupla (chave-valor), sendo chave o nome da palavra e o valor a quantidade de vezes que ela apareceu no texto.

Por exemplo,

palavras_frequentes('texto1.txt', 10) - pesquisa no arquivo texto1.txt as 10 palavras mais frequentes.
palavras_frequentes('texto2.txt', 5) - pesquisa no arquivo texto2.txt as 5 palavras mais frequentes.

Lembre-se de tratar possíveis erros!

Exemplo de uso e saida:

>>> palavras10mais = palavras_frequentes('texto1.txt', 10)
>>> print(palavras10mais)
[('programas', 662), ('codigos', 661), ('dinheiro', 661), ('fia', 586), ('python', 491), ('data', 434), ('big', 434), ('velocidade', 133), ('Moneyball', 113), ('dados', 95)]

Dica: Verifique o funcionamento da função sorted para ordernar um dicionário com base no valor.



In [ ]:

    
def palavras_frequentes(arquivo, palavras_freq):
    arq = open(arquivo,'r')
    linhas = arq.readlines()
    arq.close()
    for linha in linhas:
        linha = linha.strip()
        linha = linha.replace('  ',' ') #trata o erro de duplo espaço na separação
        linha = linha.split(' ')
    lista = []
    disti = set(linha) #pega apenas as palavras distintas
    for word in disti: 
        x = (word,linha.count(word)) #Cria a tupla com palavra e contador
        lista.append (x) # coloca a tupla na lista
    listasort = sorted(lista, key=lambda palavra: palavra[1], reverse = True)
    topN = listasort[:palavras_freq]
    return (topN)

Faça o teste para as seguintes situações:



In [ ]:

    
palavras_frequentes('texto1.txt', 10)



In [ ]:

    
palavras_frequentes('texto2.txt', 10)



In [ ]:

    
palavras_frequentes('texto1.txt', 5)



In [ ]:

    
palavras_frequentes('texto2.txt', 5)



In [ ]:

    
palavras_frequentes('texto1.txt', 30)

Exercício 6

(2 pontos) Utilizando o exemplo dado em aula sobre a Streaming API (Desafio 3 da Aula 5), recupere os tweets durante 10 minutos com os seguintes parâmetros:

fluxo.filter(track=['Big Data', 'Hadoop', 'Spark', 'Python', 'Data Science'], languages=['en', 'pt'])

Salve os tweets em um arquivo chamado tweets_10min.json.

Importe os módulos necessários



In [ ]:

    
import tweepy
from time import time

Crie as chaves de acesso



In [ ]:

    
consumer_key = 'U8tDrebFQkzdMLIvyljut6LSA'
consumer_secret = 'rHhLLB16nroyXlyZi4GTAE5Gg8hBo4PC7mI8ebTLuIcOpdn76O'
access_token = '259907386-gyiTNCFVbosGkUinOAx2vP63o8obXhNxO57ZiDUO'
access_token_secret = 'JJ8D2oJpaNMNi7cj1n6lepT9gl08vVIVQ5eMkETpWdvpG'

Realize a autorização e defina a token de acesso



In [ ]:

    
autorizar = tweepy.OAuthHandler(consumer_key, consumer_secret)
autorizar.set_access_token(access_token, access_token_secret)

Crie a classe DadosPublicosTwitter herdando da classe tweepy.StreamListener para rodar durante 10 minutos e salvar os tweets no arquivo.



In [ ]:

    
class DadosPublicosTwitter(tweepy.StreamListener):
    def __init__(self, nome_arq, limite):
        self.tempo_inicial = time()
        self.limite = limite # 10 minutos == 600 segundos
        self.salvar_arquivo = open(nome_arq, 'a', newline='')
        
    def on_data(self, dados):
        if(time() - self.tempo_inicial < self.limite):
            self.salvar_arquivo.write(dados)            
            return True
        else:
            self.salvar_arquivo.close()
            return False

Crie a instância da classe, o fluxo e realize a filtragem com os parâmetros definidos no enunciado.



In [ ]:

    
nome_arq = 'tweets_10min.json'
dados_twitter = DadosPublicosTwitter(nome_arq, 600)



In [ ]:

    
fluxo = tweepy.Stream(autorizar, dados_twitter)



In [ ]:

    
fluxo.filter(track=['Big Data', 'Hadoop', 'Spark', 'Python', 'Data Science'], languages=['en', 'pt'])

Exercício 7

(3 pontos) Com os dados salvos no tweets_10min.json, crie um DataFrame pandas com as seguintes colunas:

text - Texto do Tweet
created_at - Data da criação do Tweet
coordinates - Coordenadas
retweet_count - Quantidade de vezes que o tweet foi "retweetado".
favorite_count - Quantidade de vezes que o tweet foi "favoritado".
screen_name - Nome na tela (exemplo: @prof_dinomagri)
location - Localização
lang - Idioma
followers_count - Quantidade de seguidores
geo_enabled - Se tem a geolocalização habilitade
statuses_count - Quantidade de tweets postados.
lat - Recuperada através da função desenvolvida em sala
long - Recuperada através da função desenvolvida em sala
hashtags - Recuperada através da função desenvolvida em sala

Lembre-se de utilizar as funções desenvolvidas em sala de aula para recuperar a latitude, longitude e hastags.

No final salve o arquivo no formato CSV, utilizando o separador ponto e virgula (;) e com a codificação 'utf-8'.

Importe os módulos necessários



In [ ]:

    
import simplejson as json
import pandas as pd

Utilize o comando with para abrir o arquivo 'tweets_10min.json' e salvar em uma lista



In [ ]:

    
dados = []
with open('tweets_10min.json') as arquivo:
    for linha in arquivo:
        dados.append(json.loads(linha))

Crie o DataFrame com os dados e imprima apenas os 3 primeiros tweets (linhas)



In [ ]:

    
df = pd.DataFrame(dados)
df.head(3)

Crie uma lista, onde cada elemento será o nome da coluna



In [ ]:

    
colunas = ['text', 'created_at', 'coordinates', 'retweet_count', 
           'favorite_count', 'screen_name', 'location', 'lang', 
           'followers_count', 'geo_enabled', 'statuses_count',
          'lat', 'long', 'hashtags']

Crie um DataFrame auxiliar passando as colunas por parâmetro



In [ ]:

    
df_aux = pd.DataFrame(columns=colunas)
df_aux

Crie a função de pegar_lat_long(local)



In [ ]:

    
from geopy.geocoders import Nominatim
def pegar_lat_long(local):
    try:
        geolocalizador = Nominatim()
        localizacao = geolocalizador.geocode(local)
        if localizacao == None:
            return('','')
        else:       
            return (localizacao.latitude,localizacao.longitude)
    except:
        pass



In [ ]:

    
weder = pegar_lat_long(df['user'][219]['location'])
print(weder)

Crie a função para salvar_hashtags(texto)



In [ ]:

    
def salvar_hashtags(texto):
    aux = []
    for palavra in texto.split():
        if palavra.startswith('#'):
            aux.append(palavra)
        converter = ' '.join(aux)
    return converter

Certifique-se que o DataFrame auxiliar tem as 14 colunas necessárias



In [ ]:

    
len(df_aux.columns)

Por fim crie o laço que irá iterar em cada elemento do DataFrame original e salvar apenas o que queremos no DataFrame auxiliar.

Lembre-se de como queremos a latitude e longitude a localização tem que ser diferente de None.



In [ ]:

    
for i in range(215, len(df)):
    if df['user'][i]['location'] != None:
        lat_long = pegar_lat_long(df['user'][i]['location'])
        if lat_long != 0 and lat_long != None:
            dados = [
            df['text'][i],
            df['created_at'][i],
            df['coordinates'][i],
            df['retweet_count'][i],
            df['favorite_count'][i],         
            df['user'][i]['screen_name'],
            df['user'][i]['location'],
            df['user'][i]['lang'],
            df['user'][i]['followers_count'],
            df['user'][i]['geo_enabled'],
            df['user'][i]['statuses_count'],
            lat_long[0], #Latitude
            lat_long[1], #Longitude
            salvar_hashtags(df['text'][i])
            ]
            print(i,end=" ")
            series = pd.Series(dados,index=colunas)
            df_aux = df_aux.append(series, ignore_index=True)

Imprima o tamanho da DataFrame original e do auxiliar



In [ ]:

    
print(len(df))
print(len(df_aux))

Responda:

1) Qual foi a porcentagem de Tweets descartados?



In [ ]:

    
percentual = round((1-(len(df_aux)/len(df)))*100,2)
print ('{}% de Tweets descartados por não terem geolocalização'.format(percentual))

2) Qual a porcentagem de tweets que tinham habilitado o geo_enabled?



In [ ]:

    
verdadeiro = 0
falso = 0
for i in range(0, len(df)):
    if df['user'][i]['geo_enabled'] == True:
        verdadeiro = verdadeiro + 1
    else:
        falso = falso + 1
percentual = round((1-(verdadeiro/len(df)))*100,2)
print ('{}% de Tweets com geo_enable'.format(percentual))

Salve os dados em arquivos em arquivo CSV



In [ ]:

    
df_aux.to_csv('exercicio7_final.csv', sep=';', encoding='utf-8', index=False)