<jupyter_start><jupyter_text>Pandas<jupyter_code>import pandas as pd
aluguel = pd.read_csv('dados/aluguel.csv', sep=';')
aluguel.head(2)
aluguel_residencial = pd.read_csv('dados/aluguel_residencial.csv', sep=';')
aluguel_residencial.head(2)<jupyter_output><empty_output><jupyter_text>1 - Leitura de fonte de dados  1) read_csv Leitura de arquivo csv<jupyter_code>notas = pd.read_csv("dados/ratings.csv")
notas.columns = ['usuarioId', 'filmeId', 'nota', 'tempo']
notas.head()<jupyter_output><empty_output><jupyter_text>a) sep Quando o arquivo não tem o divisor padrão, que é virgula(,), precisando utilizar o argumento *sep* para indicar o divisor das colunas do arquivo que está sendo importadosem argumento *sep* uma importação cujo o divisor das colunas não é (,).<jupyter_code>pd.read_csv('dados/aluguel.csv').head(2)<jupyter_output><empty_output><jupyter_text>Utilizando o argumento *sep*<jupyter_code>aluguel = pd.read_csv('dados/aluguel.csv', sep=';')
aluguel.head(2)<jupyter_output><empty_output><jupyter_text>2) read_json Leitura de dados no formato JSON<jupyter_code>df_json = pd.read_json('dados/aluguel.json')
df_json.head()<jupyter_output><empty_output><jupyter_text>3) read_table Leitura de arquivo txt<jupyter_code>df_txt = pd.read_table('dados/aluguel.txt')
df_txt.head(2)<jupyter_output><empty_output><jupyter_text>4) read_excel Leitura de arquivo do excel<jupyter_code>df_xlsx = pd.read_excel('dados/aluguel.xlsx')
df_xlsx.head(2)<jupyter_output><empty_output><jupyter_text>5) read_html Leitura de página web<jupyter_code>df_html = pd.read_html('dados/dados_html_1.html')
df_html[0]
df_html = pd.read_html('https://www.federalreserve.gov/releases/h3/current/default.htm')

len(df_html)
df_html[0].head()<jupyter_output><empty_output><jupyter_text>2 Exportação de dados 1) to_csv   Exporta os dados para formato csvO parâmetro *index* como *False* configura o método para não exportar também o índice do *DataFrame*.<jupyter_code>dados_residencial.to_csv('../dados/aluguel_residencial.csv', sep=';', index=False)<jupyter_output><empty_output><jupyter_text>3 Ordenação<jupyter_code>data = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
df = pd.DataFrame(data, list('321'), list('ZYX'))
df<jupyter_output><empty_output><jupyter_text>1) sort_index a) Ordena o *DataFrame* tendo como base o índice das linhas<jupyter_code>df.sort_index(inplace=True)
df<jupyter_output><empty_output><jupyter_text>b) Ordena o *DataFrame* tendo como base o índice das colunas<jupyter_code>df.sort_index(inplace=True, axis=1)
df<jupyter_output><empty_output><jupyter_text>2) sort_values Ordena o *DataFrame* tendo como base os valores levando em consideração o índice da linha ou coluna a) Ordenando pela colunaTemos como referência a coluna X<jupyter_code>df.sort_values(by='X', inplace=True)
df<jupyter_output><empty_output><jupyter_text>b) Ordenando o *DataFrame* por mas de uma coluna<jupyter_code>df.sort_values(by=['X', 'Y'], inplace=True)
df<jupyter_output><empty_output><jupyter_text>c) Ordenando o *DataFrame* pelo o índice da linhaNesse caso, temos como base a linha 3<jupyter_code>df.sort_values(by='3', axis=1, inplace=True)
df<jupyter_output><empty_output><jupyter_text>4 Seleção de dados<jupyter_code>data = [(1, 2, 3, 4),
        (5, 6, 7, 8),
        (8, 10, 11, 12),
        (13, 14, 15, 16)]
df = pd.DataFrame(data, 'l1 l2 l3 l4'.split(), 'c1 c2 c3 c4'.split())
df<jupyter_output><empty_output><jupyter_text>1) locO método *loc*, permite que realizemos seleções a partir do rótulo das linhas<jupyter_code>df.loc['l1']<jupyter_output><empty_output><jupyter_text>Podemos, ainda, selecionar mais de uma linha:<jupyter_code>df.loc[['l3', 'l2']]<jupyter_output><empty_output><jupyter_text>Outra possibilidade é selecionarmos uma linha e uma coluna, como uma notação matricial.<jupyter_code>df.loc['l1', 'c2']<jupyter_output><empty_output><jupyter_text>2) ilocOutro indexador disponível é o *iloc[]*, que utiliza os índices numéricos. Se quisermos coletar l1, precisaremos escrever 0; para coletar a coluna c1, escreveremos 1<jupyter_code>df.iloc[0,1]<jupyter_output><empty_output><jupyter_text>Esses recursos são interessantes, pois você pode realizar diferentes seleções no DataFrame, de acordo com as necessidades do seu projeto.<jupyter_code>df.loc[['l3', 'l1'], ['c4','c1']]<jupyter_output><empty_output><jupyter_text>Se formos utilizar o *iloc[]* para a construção do mesmo DataFrame, precisaremos utilizar o índice numérico:<jupyter_code>df.iloc[[2,0],[3,0]]<jupyter_output><empty_output><jupyter_text>5 Tratando valores faltante  1) isnullTal método irá gerar um DataFrame booleano, em que a observação marcada como `True` caracteriza um dado nulo, isto é, um missing<jupyter_code>aluguel_residencial.isnull()<jupyter_output><empty_output><jupyter_text>2) notnullO método *`notnull`*, que funciona exatamente da maneira inversa ao *isnull()*: se a informação for nula, será utilizada a notação `False`.<jupyter_code>aluguel_residencial.notnull()<jupyter_output><empty_output><jupyter_text>O método `info` além de mostrar outras informações relevante também mostrar a quantidade de valores `NaN` no DataFrame<jupyter_code>aluguel_residencial.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 22580 entries, 0 to 22579
Data columns (total 9 columns):
 #   Column      Non-Null Count  Dtype  
---  ------      --------------  -----  
 0   Tipo        22580 non-null  object 
 1   Bairro      22580 non-null  object 
 2   Quartos     22580 non-null  int64  
 3   Vagas       22580 non-null  int64  
 4   Suites      22580 non-null  int64  
 5   Area        22580 non-null  int64  
 6   Valor       22571 non-null  float64
 7   Condominio  20765 non-null  float64
 8   IPTU        15795 non-null  float64
dtypes: float64(3), int64(4), object(2)
memory usage: 1.6+ MB<jupyter_text>3) Métodos utilizados para o tratamento de valores `NaN`.  1) dropnaO método *`dropna`* elimina os registros nulos do DataFrame.<jupyter_code>aluguel_residencial.dropna()<jupyter_output><empty_output><jupyter_text>O método tem o argumento *`subset`* onde podemos indicar as colunas que serão levado em consideração para exclusão do registro caso tenha valores nulos.<jupyter_code>aluguel_residencial.dropna(subset=['Valor'])<jupyter_output><empty_output><jupyter_text>2) fillnaSubtitui os valores `NaN` do conjunto de dados<jupyter_code>aluguel_residencial.fillna(0)<jupyter_output><empty_output><jupyter_text>Podemos passar um dicionário para o método onde consta a variável e o valor da subtituição. Podemos, inclusive, inserir valores diferentes para ambas as variáveis.<jupyter_code>aluguel_residencial.fillna({'Condominio': 0, 'IPTU': 10})<jupyter_output><empty_output><jupyter_text>O método `fillna` tem um argumento onde podemos indicar a estratégia de subtituíção dos valores, que é `method`.<jupyter_code>data = [0.5, None, None, 0.52, 0.54, None, None, 0.59, 0.6, None, 0.7]
s = pd.Series(data)
s<jupyter_output><empty_output><jupyter_text>a) ffillEsse método, analisa a Series do primeiro elemento ao último, e uma vez que for encontrada um valor nulo, ele coletará o valor da última assinatura válida e utiliza para preencher os valores `NaN`.<jupyter_code>s.fillna(method = 'ffill')<jupyter_output><empty_output><jupyter_text>Esses métodos são muito válidos quanto estamos trabalhando com uma série de tempo, em que podemos encontrar dados nulos que podem ser preenchidos de forma rápida, tornando seu modelo executável. b) bfillO método `bfill` que por sua vez realiza a mesma análise das assinaturas em uma Series, mas dessa vez de baixo para cima, isto é, do último elemento da Series ao primeiro.<jupyter_code>s.fillna(method = 'bfill')<jupyter_output><empty_output><jupyter_text>c) limitO parâmetro `limit`, como nome diz, coloca um limite na intepolação nos métodos aceito no argumentos `method`. Os métodos irão fazer a interpolação agora respeitando o limite adicionado com o argumentos `limit`.<jupyter_code>s.fillna(method = 'ffill', limit = 1)
s.fillna(method = 'bfill', limit = 1)<jupyter_output><empty_output><jupyter_text>6) Estatística mean, median, stdMedida de tendencia central<jupyter_code>nota = notas['nota']
print('Média', nota.mean())
print('Mediana', nota.median())
print('Desvio padrão', nota.std())
print('Moda', nota.mode()[0])<jupyter_output>Média 3.501556983616962
Mediana 3.5
Desvio padrão 1.042529239060635
Moda 4.0<jupyter_text>6 Método<jupyter_code>notas = pd.read_csv("ratings.csv")<jupyter_output><empty_output><jupyter_text>1) headExib as primeiras linhas do data frame, tem como default o número de linha 5.<jupyter_code>notas.head()<jupyter_output><empty_output><jupyter_text>Podemos determinar o números de linhas para que o método exibe<jupyter_code>notas.head(2)<jupyter_output><empty_output><jupyter_text>2) columns Podemos renomear as colunas do data frame<jupyter_code>notas.columns = ['usuarioId', 'filmeId', 'nota', 'tempo']
notas.head()<jupyter_output><empty_output><jupyter_text>Exibindo os índice (nome) das colunas<jupyter_code>notas.columns<jupyter_output><empty_output><jupyter_text>name Renomeando o name da coluna<jupyter_code>tipo_dados = pd.DataFrame(data=notas.dtypes, columns=['tipo_dados'])
tipo_dados.columns.name='variavel'
tipo_dados<jupyter_output><empty_output><jupyter_text>3) unique Retorna os valores únicos de uma série<jupyter_code>notas['nota'].unique()<jupyter_output><empty_output><jupyter_text>4) values_counts Mostra quantidade de ocorrências para cada tipo ou valor em uma coluna<jupyter_code>notas['nota'].value_counts()<jupyter_output><empty_output><jupyter_text>6) describeRetorna um resumo descritivo dos dados<jupyter_code>notas['nota'].describe()<jupyter_output><empty_output><jupyter_text>7) to_frameTransforma Serie em DataFrame<jupyter_code>notas['nota'].value_counts().to_frame()<jupyter_output><empty_output><jupyter_text>8) queryFaz consulta no data frame<jupyter_code>notas.query('filmeId == 1')<jupyter_output><empty_output><jupyter_text>9) groupby<jupyter_code>notas.groupby("filmeId")
notas.groupby("filmeId").mean()['nota']<jupyter_output><empty_output><jupyter_text>10) info Informação do conjunto de dados<jupyter_code>notas.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 100836 entries, 0 to 100835
Data columns (total 4 columns):
 #   Column     Non-Null Count   Dtype  
---  ------     --------------   -----  
 0   userId     100836 non-null  int64  
 1   movieId    100836 non-null  int64  
 2   rating     100836 non-null  float64
 3   timestamp  100836 non-null  int64  
dtypes: float64(1), int64(3)
memory usage: 3.1 MB<jupyter_text>11) Series Criação 1) Lista<jupyter_code>data = [1, 2, 3, 4, 5]
s = pd.Series(data=data)
s<jupyter_output><empty_output><jupyter_text>2) Definindo o índice<jupyter_code>index = ['l'+str(i) for i in range(5)]
s = pd.Series(data=data, index=index)
s<jupyter_output><empty_output><jupyter_text>3) Dicionário<jupyter_code>data = {'l'+str(i): i for i in range(5)}
s = pd.Series(data=data)
s<jupyter_output><empty_output><jupyter_text>12) DataFrame Criação 1) Lista<jupyter_code>data = [[1, 2, 3], 
        [4, 5, 6], 
        [7, 8, 9]]
index = ['Linha' + str(i) for i in range(3)]
columns = ['Coluna' + str(i) for i in range(3)]
df1 = pd.DataFrame(data=data, index=index, columns = columns)
df1<jupyter_output><empty_output><jupyter_text>2) Dicionário<jupyter_code>data = {'Coluna0': {'Linha0': 1, 'Linha1': 4, 'Linha2': 7},
        'Coluna1': {'Linha0': 2, 'Linha1': 5, 'Linha2': 8},
        'Coluna2': {'Linha0': 3, 'Linha1': 6, 'Linha2': 9}}
df2 = pd.DataFrame(data=data)
df2<jupyter_output><empty_output><jupyter_text>3) Dupla<jupyter_code>data = [(1, 2, 3), 
        (4, 5, 6), 
        (7, 8, 9)]
df3 = pd.DataFrame(data=data, index=index, columns=columns)
df3<jupyter_output><empty_output><jupyter_text>13) concat União de dois DataFrame através:<jupyter_code>data = {'Coluna0': {'Linha0': 1, 'Linha1': 4, 'Linha2': 7},
        'Coluna1': {'Linha0': 2, 'Linha1': 5, 'Linha2': 8},
        'Coluna2': {'Linha0': 3, 'Linha1': 6, 'Linha2': 9}}
df1 = pd.DataFrame(data=data)
df2 = pd.DataFrame(data=data)
df1[df1 > 0] = 'A'
df2[df2 > 0] = 'B'<jupyter_output><empty_output><jupyter_text>a) (axis = 0) - ColunasObservação: Nos Data Frame podemos ter linhas iguais, deste que as colunas sejam diferente<jupyter_code>pd.concat([df1, df2], axis=0)<jupyter_output><empty_output><jupyter_text>b) (axis = 0) - ColunasObservação: Nos Data Frame podemos ter colunas iguais, deste que as linhas sejam diferente<jupyter_code>pd.concat([df1, df2], axis=1)<jupyter_output><empty_output><jupyter_text>14) isin Pesquisa na serie através de uma lista Ao passarmos a listagem de dados que desejamos, o método *isin* verificado dentro do *Serie* se os elementos da lista existem de fato, assinalando True ou False<jupyter_code>residencial = ['Quitinete', 
'Casa',
'Apartamento',
'Casa de Condomínio',
'Casa de Vila']
residencial
selecao = aluguel['Tipo'].isin(residencial)
selecao.head()
aluguel[selecao].head()<jupyter_output><empty_output><jupyter_text>15) apply  Permite que apliquemos uma função a cada registro do DataFrame ou Serie.<jupyter_code>casa = ['Casa', 'Casa de Condomínio', 'Casa de Vila']<jupyter_output><empty_output><jupyter_text>a) lambda<jupyter_code>aluguel['Tipo'].apply(lambda x: 'Casa' if x in casa else 'Apartamento')<jupyter_output><empty_output><jupyter_text>a) Função<jupyter_code>def tipoImovel(x):
    return 'Casa' if x in casa else 'Apartamento';
aluguel['Tipo'].apply(tipoImovel)<jupyter_output><empty_output><jupyter_text>5 Atributos  1) index Retorna os índice a serie<jupyter_code>notas['nota'].value_counts().index<jupyter_output><empty_output><jupyter_text>2) values Retona os valores da serie<jupyter_code>notas['nota'].value_counts().values<jupyter_output><empty_output><jupyter_text>3) dtypes Retorna os tipos de dados das colunas<jupyter_code>notas.dtypes<jupyter_output><empty_output><jupyter_text>4) shape Retorna o números de linhas e colunas do data frame<jupyter_code>notas.shape<jupyter_output><empty_output><jupyter_text>4 Gráfico  1) Histograma<jupyter_code>ax = notas['nota'].plot(kind='hist')<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12631877079940523, 'fraction_numerical': 0.03044678892586561, 'mean_word_length': 6.872909698996655, 'pattern_counts': {'":': 0, '<': 260, '<?xml version=': 0, '>': 262, 'https://': 1, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '65', 'dir': 'jupyter-structured-clean-dedup', 'id': '130767', 'license': 'MIT', 'n_tokens_mistral': 5851, 'n_tokens_neox': 5592, 'n_words': 1212, 'path': '01-pandas.ipynb', 'repo_name': '1-aquila-1/data-science', 'size': '14123'}