<jupyter_start><jupyter_text>1 Criando Séries<jupyter_code># Criando Series
s = pd.Series([1, 3, 4, np.nan, 6, 8])
s<jupyter_output><empty_output><jupyter_text>2 Criando DataFrame<jupyter_code># Criando uma lista de 6 datas a partir de 01/01/2018
dates = pd.date_range('20180101', periods=6)
dates

# Criando o DataFrame e indexando a lista de datas a nossa base de distribuição normal criada randomicamente
df = pd.DataFrame(np.random.randn(6, 4), index=dates, columns=list('ABCD')) 
df<jupyter_output><empty_output><jupyter_text>2.1 Criando DataFrame passando o dicionário de dados (dict)<jupyter_code>df2 = pd.DataFrame({'A': 1,
                    'B': pd.Timestamp('20180102'),
                    'C': pd.Series(1, index=list(range(4)), dtype='float32'),
                    'D': np.array([3] * 4, dtype='int32'),
                    'E': pd.Categorical(['test', 'train', 'test', 'train']),
                    'F': 'foo'})
df2
pd.Timestamp('20180102')
pd.Series(2, index=list(range(4)), dtype='float32')
np.array([3] * 2, dtype='int32')
# Verificando os tipos do DataFrame que criamos
df2.dtypes<jupyter_output><empty_output><jupyter_text>3 Visualizando Dados<jupyter_code>df.head() # Exibe os 5 primeiros registros
df.tail() # Exibe os 5 últimos registros
df.head(3) # dá para modificar a quantidade a ser exibida dos primeiros registros
df.tail(3)  # dá para modificar a quantidade a ser exibida dos últimos registros
# Exibindo os índices de uma base
df.index
# Exibindo as colunas de uma base
df.columns
# Exibindo os valores de uma base
df.values
# Exibindo um resumo estatístico da base
df.describe()
df.T # inverte as colunas pelas linhas
df.sort_index(axis=1, ascending=False) # muda a ordem das colunas para Descendente
df.sort_values(by='B') # Orderna uma base por uma coluna de forma ascendente
df.sort_values(by='B', ascending=False) # Orderna uma base por uma coluna de forma descendente<jupyter_output><empty_output><jupyter_text>4 Seleção de Dados Métodos .at, .iat, .loc, .iloc e .ix<jupyter_code>df['A'] # Selecionado dados pela coluna "A"
df.A # Esta é outra forma de utilizar, só que não é recomendado
df[0:2] # desta forma selecionas as 2 primeiras linhas
df['20180101':'20180103'] # Dá para selecionar em um intervalo de dados entre os valores<jupyter_output><empty_output><jupyter_text>4.1 Seleção utilizando label<jupyter_code>df.head()
df.loc[dates[0]] # Seleciona todos os valores da linha 1 (indice 0 "zero")<jupyter_output><empty_output><jupyter_text>4.2 Seleção Multima utilizando label<jupyter_code>df.loc[:, ['A', 'B']] #Seleciona  todas as linhas das colunas A e B
df.loc['20180101':'20180103', ['A', 'C']] # dá para combinar intevalos de valores com colunas
df.loc['20180102', ['A', 'D']]  # selecionar por um determinado valor e listar os valores correspondentes das colunas
df.loc[dates[0], 'A'] # selecionando um valor específico de uma coluna específica
df.at[dates[0], 'A'] # corresponde a chamada anterior<jupyter_output><empty_output><jupyter_text>4.3 Seleção por Posição<jupyter_code>df.head()
# Seleciona a linha de índice 3 ( Lembrando que o índice começa no zero 0,1,2,3...n)
# indice(3) -> 2018-01-04 	1.288924 	-2.344338 	0.456453 	-0.539733
df.iloc[3] 
df.iloc[3:5, 0:2] # Seleciona as linhas entre o indice 3 |- 5 e as colunas entre 0 |- 2
# Seleção com multiplas posições
df.iloc[[1,2,4], [0,2]]  # linhas 1,2,4 e colunas 0 e 2
# Seleção do curinmga ":" que seleciona tudo do 0 à N
df.iloc[1:3, :] # seleciona as linhas do intervalo 1 |- 3 e todas as colunas ":"
# O mesmo critério da In[62] também serve para as linhas
df.iloc[:, 1:3] # seleciona todas as linhas das colunas no intervalo 1 |- 3 (colunas B e C)
# utilizando valores explicitos
df.iloc[1,1]<jupyter_output><empty_output><jupyter_text>4.4 Seleção por indexação boleana (boolean)<jupyter_code>df.head()
# Note que constamm valores negativos na tabela origial
# para selecionarmos apenas os valores maiores que zero, podemos utilizar da seguinte forma:
df[df['A'] > 0] # é equivalore a df[df.A > 0]
# Dá para testar todas as celulas independente das colunas, com no exemplo anterior.
df[df > 0] # Note que onde a condição não é verdadeira, o valor foi trocado por NaN<jupyter_output><empty_output><jupyter_text>4.4.1 Utilizando o método isin()<jupyter_code>df2 = df.copy() # copia a tabela para a df2
df2.head()
# Aqui adicionamos mais uma coluna "E" e setamos valores no formato texto(object)
df2['E'] = ['one', 'one', 'two', 'three', 'four', 'three']
df2
df2[df2['E'].isin(['two', 'four'])] # busca dentro do dataframe da coluna especifica se existe aqueles valores<jupyter_output><empty_output><jupyter_text>5 Setando Dados (Setting)<jupyter_code># criando uma nova séria de dados para preencher uma nova coluna que será criada
s1 = pd.Series([1, 2, 3, 4, 5, 6], index=pd.date_range('20180102', periods=6))
s1
df['F'] = s1 # arqui estamos setando a série s1 na coluna F que estamos criando
df # note que a primeira linha, está com valor NaN
# Vamos setar o valor zero no primeiro registro da coluna A
df.at[dates[0],'A'] = 0
# de forma análoga utilizando o método iat(), vamos setar o valor zero na coluna de indice 1(B) da linha zero
df.iat[0,1] = 0
# Aqui vamos setar o valor 5 em todos os registros da coluna D
df.loc[:, 'D'] = np.array([5] * len(df))
df # todos os valores setados foram atribuidos ao DataFrame
df2 = df.copy() # copiando o DataFrame df
# Podemos setar valores com condições e trocando o sinal de operação
df2[df2 > 0] = -df2
df2 # Todos os valores > 0 agora estão negativos<jupyter_output><empty_output><jupyter_text>6 Tratando dados faltantes (Missing Data) Ps.:  NaN (acrónimo em inglês para Not a Number)<jupyter_code>df1 = df.reindex(index=dates[0:4], columns=list(df.columns) + ['E'])
df1
df1.loc[dates[0]:dates[1], 'E']
df1.loc[dates[0]:dates[1], 'E'] = 1 # Seta o valor 1 nas duas primeiras linhas da coluna E
df1
# vamos excluir as linhas que tenham valores faltantes
df1.dropna(how='any') # sobraria apenas a linha de índice 1
df1 # Note que as linhas não foram realmente excluídas, para isso teria que setar o atributo inplace=True
# Você pode preencher os valores faltantes com outro valor indifevente da linha ou coluna
df1.fillna(value=5) # Trovamos todos os NaN por 5
df1 # sem definir o inplace=True os valores continuam os mesmos
# Se você quizer saber quais celulas estão com valores faltantes (NaN), utilize assim:
pd.isna(df1)<jupyter_output><empty_output><jupyter_text>7 Operações  7.1 Operações Estatísticas Ps.: Operations in general exclude missing data<jupyter_code>df
df.mean() # Média aritimética
df.mean(1) # Mesma operação no outro eixo
# o shift define em qual índice das linhas começar a setar os valores
s = pd.Series([1, 3, 5, np.nan, 6, 8], index=dates).shift(2) 
s
df
s.reset_index()
type(s)
type(df)
s.index
# o método sub() subtrai do DataDrame "df" as linhas com valores faltantes em relação a série "s" pelo "index"
df.sub(s, axis='index')<jupyter_output><empty_output><jupyter_text>7.2 Método apply() Dá para utilizar funções e aplicar a uma massa de dados de nossos DataFrame<jupyter_code>df
df.apply(np.cumsum)  # Soma cumulativa, observe a coluna "D"<jupyter_output><empty_output><jupyter_text>Utilizando lambda. Retornando o valor intermediario entre o valor máximo e o valor mínimo do DataFrame df<jupyter_code>df.apply(lambda x: x.max() - x.min())<jupyter_output><empty_output><jupyter_text>7.3 Histogramação<jupyter_code># Gera uma série de dados de 10 registros aleatorios entre 0 e 7
s = pd.Series(np.random.randint(0, 7, size=10))
s
s.value_counts()<jupyter_output><empty_output><jupyter_text>7.4 String Methods Através do acesso a propriedade .str você pode aceesar vários métodos para manipular string<jupyter_code>s = pd.Series(['A', 'B', 'C', 'Aaba', 'Baca', np.nan, 'CABA', 'doc', 'cat'])
s
s.str.lower() # transforma os valores em minusculo
s.str.upper() # transforma os valores em maiúsculo
s.str.islower() # Verificar os registros minúsculos, etc...<jupyter_output><empty_output><jupyter_text>8 Merge  8.1 Concat<jupyter_code>df = pd.DataFrame(np.random.randn(10,4))
df
pieces = [df[:3], df[3:7], df[7:]] # separando o DataFrame em 3 partes
pieces
pd.concat(pieces) # Concatenando as 3 partes do DataFrame<jupyter_output><empty_output><jupyter_text>8.2 Join Este método é muito importante<jupyter_code>left = pd.DataFrame({'key': ['foo', 'foo'], 'lval': [1, 2]})
right = pd.DataFrame({'key': ['foo', 'foo'], 'rval': [4, 5]})
left
right
pd.merge(left, right, on='key') # Efetuando o Join através do método merge()<jupyter_output><empty_output><jupyter_text>Outro exemplo<jupyter_code>left2 = pd.DataFrame({'key':['foo', 'bar'], 'lval': [1, 2]})
right2 = pd.DataFrame({'key': ['foo', 'bar'], 'rval': [4, 5]})
left2
right2
pd.merge(left2, right2, on='key')<jupyter_output><empty_output><jupyter_text>9 Append<jupyter_code>df = pd.DataFrame(np.random.randn(8, 4), columns=['A', 'B', 'C', 'D'])
df
s = df.iloc[3]
s
df.append(s, ignore_index=True) # Adicionaod a linha armazenada em "s" ao DataFrame<jupyter_output><empty_output><jupyter_text>10 Grouping - groupby<jupyter_code>df = pd.DataFrame({'A': ['foo', 'bar', 'foo', 'bar',
                         'foo', 'bar', 'foo', 'bar'],
                   'B': ['one', 'one', 'two', 'three',
                         'two', 'two', 'one', 'three'],
                   'C': np.random.randn(8),
                   'D': np.random.randn(8)})
df<jupyter_output><empty_output><jupyter_text>10.1  Combinando o agrupamentos com funções<jupyter_code>df.groupby('A').sum()
# mais de uma coluna no agrupamento
df.groupby(['A', 'B']).sum()<jupyter_output><empty_output><jupyter_text>11 Reshaping - Remodelando  11.1 Stack A função zip() retorna uma lista de tuplas, onde a i-ésima tupla contém o i-ésimo elemento de cada um dos argumentos.<jupyter_code>x = [1,2,3]
y = [4,5,6]
for t in zip(x, y):
    print(t)
# o mesmo que:
list(zip(x, y))
# Voltando para o estudo de Stack
tuples = list(zip(*[['bar', 'bar', 'baz', 'baz',
                    'foo', 'foo', 'qux', 'qux'],
                   ['one', 'two', 'one', 'two',
                    'one', 'two', 'one', 'two']]))
tuples
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
index
df = pd.DataFrame(np.random.randn(8, 2), index = index, columns=['A', 'B'])
df
# Este métido é muito importante. Transforma as colunas A e B em um Stack, ou seja, "empilha" seus valores na mesma coluna
stacked = df.stack() 
stacked
# Para reverter o stack(), você utiliza o unstack()
stacked.unstack()<jupyter_output><empty_output><jupyter_text>12 Pivot Table Pivot table você consegue mudar o eixo de uma tabela, onde você pode inverter as colulas pelas linhas e vise-vesa<jupyter_code># Criando o DataFrame dom 5 colunas e 12 linhas 
df = pd.DataFrame({'A': ['one', 'one', 'two', 'three'] * 3,
                   'B': ['A', 'B', 'C'] * 4,
                   'C': ['foo', 'foo', 'foo', 'bar', 'bar', 'bar'] * 2,
                   'D': np.random.randn(12),
                   'E': np.random.randn(12)
                  })
df
# Vamos inverte a coluna "C" ["bar" e "foo"] pela "D"
pd.pivot_table(df, values='D', index=['A', 'B'], columns=['C'])
# melhor compreenção da Pivo table
pd.pivot_table(df, values=['D', 'E'], index=['C'], columns=['A'])
pd.pivot_table(df, values=['D', 'E'], index=['C'], columns=['A']).reset_index() # melhorando a visualização<jupyter_output><empty_output><jupyter_text>13 Time Series - Séries temporais O que define o tipo de dados do date_range é o parâmetro freq. Mais informações:     http://pandas.pydata.org/pandas-docs/stable/timeseries.htmloffset-aliases<jupyter_code>rng = pd.date_range('01/01/2018', periods=100, freq='S')
ts = pd.Series(np.random.randint(0, 500, len(rng)), index=rng)
ts.resample('5min').sum()
# Time zone
rng = pd.date_range('3/1/2018 00:00', periods=5, freq='D')
ts = pd.Series(np.random.randn(len(rng)), rng)
ts
ts_utc = ts.tz_localize('UTC')
ts_utc
# Conversão em intervalo de tempo
rng = pd.date_range('1/1/2018', periods=5, freq='M')
ts = pd.Series(np.random.randn(len(rng)), index=rng)
ts
ps = ts.to_period() # este método é muito útil para construção de indices para agrupamentos de datas
ps
ps.to_timestamp() # pegando novamtne o valor de timestamp
# Convertendo em períodos de tempos
prng = pd.period_range('1999Q1', '2000Q4', freq='Q-NOV')
ts = pd.Series(np.random.randn(len(prng)), prng)
ts.index = (prng.asfreq('M', 'e') +1).asfreq('H', 's') + 9
ts<jupyter_output><empty_output><jupyter_text>14 Categoricals Categorical em Pandas, é similar ao conceito de Variáveis Categóricas da matemática<jupyter_code>df = pd.DataFrame({"id": [1,2,3,4,5,6],
                   "raw_grade": ['a', 'b', 'b', 'a', 'a', 'e']})
df['raw_grade']
df['grade'] = df['raw_grade'].astype('category')
df['grade']
df['grade'].cat.categories = ["very good", "good", "very bad"]
df['grade']
# A ordenação das categorias são em relação a sua ordem e não em relação a sua escrita
df.sort_values(by='grade') # tome cuidado com essa particularidade
# agrupando por categoria
df.groupby('grade').size()
# adicionando novas categorias. Note que mudou a ordem das categorias além das novas criadas. veja a seguir a ordenação
df['grade'] = df['grade'].cat.set_categories(['very bad', 'bad', 'medium', 'good', 'very good'])
df['grade']
df.sort_values(by='grade') # como a ordem das categorais mudou após a atribuição, muda o comportamento do sort_values
# Ao agrupar também, você notará que aparecerá essas novas categorias criadas que não contém valores
df.groupby('grade').size()<jupyter_output><empty_output><jupyter_text>15  Plotting - Plotando gráficos<jupyter_code>ts = pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2018', periods=1000))
ts = ts.cumsum()
ts.plot()
df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=['A', 'B', 'C', 'D'])
df = df.cumsum()
plt.figure();df.plot();plt.legend(loc='best')<jupyter_output><empty_output><jupyter_text>16 Obtendo dados In/Out  16.1 Arquivos CSV  Para criar um arquivo, por exemplo csv, basta utilizar o método to_csv()<jupyter_code>df.to_csv('foo.csv')<jupyter_output><empty_output><jupyter_text>para fazermos a leitura basta utilizar o método read_csv()<jupyter_code>file_csv = pd.read_csv('foo.csv')
file_csv.head()<jupyter_output><empty_output><jupyter_text>16.2 Arquivos HDF5<jupyter_code># criação
df.to_hdf('foo.h5', 'df')
# Leitura
file_hdf = pd.read_hdf('foo.h5', 'df')
file_hdf.head()<jupyter_output><empty_output><jupyter_text>16.3 Arquivos Excel<jupyter_code># Criação
df.to_excel('foo.xlsx', sheet_name='Sheet1')
# Leitura
file_excel = pd.read_excel('foo.xlsx', 'Sheet1', index_col=None, na_values=['NA'])
file_excel.head()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14420255237835256, 'fraction_numerical': 0.030915170954753293, 'mean_word_length': 5.030452674897119, 'pattern_counts': {'":': 4, '<': 129, '<?xml version=': 0, '>': 135, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, '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': '32', 'dir': 'jupyter-structured-clean-dedup', 'id': '279057', 'license': 'MIT', 'n_tokens_mistral': 5924, 'n_tokens_neox': 5664, 'n_words': 1570, 'path': 'notebooks/pandas/pydata/10 minutes to pandas.ipynb', 'repo_name': 'walmirsilva/python-data-science-study', 'size': '14653'}