<jupyter_start><jupyter_text>Fundamentos da linguagem Python  MÓDULO 1  1.1. Operadores matemáticos<jupyter_code># adição 

5 + 7
# subtração 

21 - 9
# multiplicação 

3 * 9
# divisão

59 / 3<jupyter_output><empty_output><jupyter_text>1.1.1. Operação com variáveis<jupyter_code>a = 39
b = a + 1
b
b * 2<jupyter_output><empty_output><jupyter_text>**Aquecimento operadores matemáticos**<jupyter_code># compras 


arroz = 10
leite = 11.50
carne = 30.80
sabonete = 9.56
alvejante = 19.58
resultado = arroz + leite + carne + sabonete + alvejante 
resultado
print('O valor total das compras é: R$', resultado)
# potenciação 

2 ** 2
# módulo ou resto da divisão 

10 % 7<jupyter_output><empty_output><jupyter_text>1.2. Operadores relacionais<jupyter_code># igualdade

700 == 90
100 == 100
80.0 == 80
# desigualdade 

3 != 7
3 != 3
# maior que 

500 > 90
90 > 500
# menor que 

500 < 90
90 < 500
# maior ou igual 

8 >= 8
5 >= 10<jupyter_output><empty_output><jupyter_text>1.3. Operadores lógicos **and** = e**or** = ou **not** = não **and** = se todas as alternativas forem verdadeiras**or** = se pelo menos uma das alternativas forem verdadeiras**not** = se for verdadeira será falso **1.Para estudar em uma universidade, o aluno deve:**Ter passado no vestibulareEstar com toda documentação necessáriae Estar matriculado<jupyter_code>50 > 40 and 50 > 49<jupyter_output><empty_output><jupyter_text>**2. Para obter flexibilidade no período de provas, o aluno deve:**Ser militar e estar de serviçoou Estar de licença maternidadeou Estar de atestado médico<jupyter_code>80 > 3 or 15 > 20<jupyter_output><empty_output><jupyter_text>1.4. Laços de repetiçoes for<jupyter_code>for i in range (0, 20, 3):
    print(i)<jupyter_output>0
3
6
9
12
15
18<jupyter_text>Essa função cria um loop de um range(sequencia numerica) for é função (i) é a variável in conecta ao range ( inicio da sequncia, fim da sequencia, intervalos)<jupyter_code>lista = [3, 8, 44, 100]
for x in lista:
    print(x)
lista2 = [3, 8, 44, 100]
for i in lista2:
    
    if i % 2 == 0:
     print(i)
lista3 = [ [1,2,3], [2,3,5], [7,8,5,4,3,2] ]
for ii in lista3:
    print(ii)
di = {'d1': 10,'d2': 20,'d3': 30,'d4': 40,'d5': 50, };

d2 = {'d2': 10,'d2': 20,'d2': 30,'d2': 40,'d2': 50};    
di
for i in di:
    print(i)
di.items()
for c, v, in di.items():
    print( c, v)<jupyter_output>d1 10
d2 20
d3 30
d4 40
d5 50<jupyter_text>1.5. Laços de repetiçoes whille(enquanto)<jupyter_code>k = 8

while k <= 10:
    print(k)
    
    k += 1<jupyter_output>8
9
10<jupyter_text>**pass, break e continue**<jupyter_code>for letra in 'programador':
    if letra == 'a':
        pass
    print(letra)
for letra in 'programador':
    if letra == 'a':
        continue
    print(letra)
for letra in 'programador':
    if letra == 'a':
        break
    print(letra)<jupyter_output>p
r
o
g
r<jupyter_text>1.6. Funções<jupyter_code>def print_text():
    print('Aqui é um texto qaulquer')
print_text()
def print_isto(x):
    print(x)
print_isto(7958)
def potencia(x):
    p = x ** 2
    return p
potencia(4)
def sub(x):
    r = x + 4
    return r
sub (1000)
def potencia_n(x, n = 2 ):
    p = x ** n
    return p
potencia_n(5)
potencia_n(5, 3)<jupyter_output><empty_output><jupyter_text>MÓDULO 2  IMPORTS<jupyter_code>import pandas as pd
import numpy as np<jupyter_output><empty_output><jupyter_text>2.1. Dataframes<jupyter_code>series = pd.Series([7, 4, 2, np.nan, 6, 9 ])
series
type(series)
datas = pd.date_range('20220101', periods = 6 )
datas
type(datas)
df = pd.DataFrame(np.random.randn(6,4), index= datas, columns = list('ABCD'))
df
df2 = pd.DataFrame({'A': 7,
                    'B': pd.Timestamp('20220101'),
                    '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': 'Python'})
df2
df2.dtypes<jupyter_output><empty_output><jupyter_text>2.2. Merge<jupyter_code># Cadastro da loja a
cadastro_a = {'Id': ['AA2930','BB4563','CC2139','DE2521','GT3462','HH1158'],
            'Nome':  ['Victor', 'Amanda', 'Bruna', 'Carlos', 'Ricardo', 'Maria'],
            'Idade': [20,35,40,54,30,27],
            'CEP': ['00092-029','11111-111','22222-888','00000-999','88888-111','77777-666']
           }

cadastro_a = pd.DataFrame(cadastro_a, columns = ['Id','Nome','Idade','CEP'])
cadastro_a
# Cadastro da loja b
cadastro_b = {'Id': ['CC9999','EF4488','DD9999','GT3462','HH1158'],
            'Nome':  ['Marcos', 'Patricia', 'Ericka', 'Ricardo', 'Maria'],
            'Idade': [19,30,22,30,27],
            'CEP': ['00092-029','11111-111','11111-888','88888-111','77777-666']
           }
 
cadastro_b = pd.DataFrame(cadastro_b, columns = ['Id','Nome','Idade','CEP'])
cadastro_b
# Registro de compras de todas unidades
compras = {'Id': ['AA2930','EF4488','CC2139','EF4488','CC9999','AA2930','HH1158','HH1158'],
            'Data':  ['2019-01-01','2019-01-30','2019-01-30','2019-02-01','2019-02-20','2019-03-15','2019-04-01','2019-04-10'],
            'Valor': [200,100,40,150,300,25,50,500]
           }
 
compras = pd.DataFrame(compras, columns = ['Id','Data','Valor'])

compras<jupyter_output><empty_output><jupyter_text>* Merge **inner join** junta a interceção entre as tabelas<jupyter_code>pd.merge(cadastro_a, cadastro_b[['Id', 'Idade', 'CEP']], on= ['Id'], how='inner', suffixes= ('_A', '_B'))<jupyter_output><empty_output><jupyter_text>* Merge **full join** junta a todas as informações das tabelas<jupyter_code>lojas = pd.concat([cadastro_a, cadastro_b], ignore_index= True)
clientes_unicos = lojas.drop_duplicates(subset=['Id'])
clientes_unicos<jupyter_output><empty_output><jupyter_text>* Merge **left join** junta informações do lado esquerdo da tabela<jupyter_code>esquerda = pd.merge(cadastro_a, compras, how='left', on=['Id'])
compras
cadastro_a
esquerda
esquerda.groupby(['Id', 'Nome'])['Valor'].sum()<jupyter_output><empty_output><jupyter_text>2.3. Groupby<jupyter_code>dfg = pd.DataFrame({'A': ['verdadeiro', 'falso', 'verdadeiro', 'falso', 'verdadeiro', 'falso', 'verdadeiro', 'falso'],
                    
                    'B': ['um', 'um', 'dois', 'tres', 'dois', ' dois', 'um ', 'tres'],
                    
                    'C': np.random.randn(8),
                    
                    'D': np.random.randn(8)})
dfg<jupyter_output><empty_output><jupyter_text>Soma dos valores das colunas baseada na coluna A<jupyter_code>dfg.groupby(['A']).sum()<jupyter_output><empty_output><jupyter_text>Média dos valores das colunas baseada na coluna A<jupyter_code>dfg.groupby(['A']).mean()<jupyter_output><empty_output><jupyter_text>Soma dos valores das colunas baseada na coluna B<jupyter_code>dfg.groupby(['B']).sum()<jupyter_output><empty_output><jupyter_text>Média dos valores das colunas baseada na coluna B<jupyter_code>dfg.groupby(['B']).mean()<jupyter_output><empty_output><jupyter_text>Soma dos valores das colunas baseada nas colunas A e B<jupyter_code>dfg.groupby(['A','B']).sum()<jupyter_output><empty_output><jupyter_text>2.4. Indexação   Todo índice em pyhon inicia em 0.Sempre que quisermos selecionar algum objeto em uma lista, devemos considerar esse requisito.<jupyter_code>lista = [ 32, 96, 11, 27]
lista[0]<jupyter_output><empty_output><jupyter_text>Sempre que quisermos selecionar os números de trás pra frente, basta adicionar o sinal de subtração e ordenar a casa<jupyter_code>lista [-1]<jupyter_output><empty_output><jupyter_text>Indexação múltlipla<jupyter_code>arrays = [[1, 2, 5, 4], ['red', 'blue', 'green', 'blue']]
pd.MultiIndex.from_arrays(arrays, names=('number', 'color'))
numbers = [0, 1, 2]
colors = ['green', 'purple']<jupyter_output><empty_output><jupyter_text>**MultiIndex com produto cartesiano**<jupyter_code>pd.MultiIndex.from_product([numbers, colors], names = ['number', 'color'])<jupyter_output><empty_output><jupyter_text>2.5. Reshping dados<jupyter_code>datas = pd.date_range('20220101', periods= 6 )

df = pd.DataFrame(np.random.randn(6, 4), index = datas, columns = ['var_A', 'var_B', 'var_C', 'var_D'])
df
dft = df.T
dft
df.shape<jupyter_output><empty_output><jupyter_text>2.5.1. Função pivot<jupyter_code>data = pd.date_range('20220101', periods= 12 )

pessoa = ['George', 'Victor', 'Lucas']
data
nome = []

gasto = []

for i in range(12):
    nome.append(np.random.choice(pessoa))
    gasto.append(np.round(np.random.randn()*100,2 ))
    
    nome
df = pd.DataFrame({'Data': data, 'Nome': nome, 'Gasto': gasto})
df
pd.pivot(df, index= 'Data', columns= 'Nome', values= 'Gasto')<jupyter_output><empty_output><jupyter_text>2.5.2. Função pivot table<jupyter_code>carros = [7, 4, 3, 2, 8]

data = pd.date_range('20220101','20220101', periods= 5 )

vendedor = ['George', 'Vagner', 'Pedro', 'Vagner', 'George']
df = pd.DataFrame({'Vendas': carros, 'Data': data, 'Vendedor': vendedor})
df<jupyter_output><empty_output><jupyter_text>A função **pivot table** não entrega valores de index duplicados<jupyter_code>pd.pivot_table(df, index= 'Data', columns= 'Vendedor', values= 'Vendas', aggfunc='sum')<jupyter_output><empty_output><jupyter_text>2.5.3. Stack e unstack de dados coleta de dados da internet<jupyter_code>df = pd.read_csv('https://cdncontribute.geeksforgeeks.org/wp-content/uploads/nba.csv')
df.head(4)
df.shape
#Essa função empilha os dados em uma coluna

empilhamento = df.stack()
empilhamento.head(20)
# Essa função reverte o processo de empilhamento

empilhamento.unstack()<jupyter_output><empty_output><jupyter_text>2.5.4. Função melt<jupyter_code>df = pd.DataFrame({ 'A': {0: 'a', 1: 'b', 2: 'c'},
                    'B': {0: 1, 1: 3, 2: 5,},
                    'C': {0: 2, 1: 4, 2: 6}})
df
pd.melt(df, id_vars=['A'], value_vars=['B'])
pd.melt(df, id_vars=['A'], value_vars=['B', 'C'])
pd.melt(df, id_vars=['A'], value_vars=['B', 'C'], var_name='nome da var', value_name='valor da var')
data = {
    'Localização' : ['cidadeA', 'cidadeB'], 
    'Temperatura' : ['prevista', 'atual'],
    'Set-2021':     [30, 32],
    'Out-2021':     [45, 43],
    'Nov-2021':     [24, 22]
}

print(data)
df = pd.DataFrame(data, columns = ['Localização', 'Temperatura', 'Set-2021', 'Out-2021', 'Nov-2021'])
df
df2 = pd.melt(df, id_vars=['Localização', 'Temperatura'], var_name='Data', value_name='Valor')

df2<jupyter_output><empty_output><jupyter_text>2.6. Seleção de linhas e colunas<jupyter_code>datas = pd.date_range('20210101', periods = 600)

df = pd.DataFrame(np.random.rand(600, 5), index = datas, columns = list('ABCDE'))
df.head(4)
df['D'].tail(5)
df[1 : 5]
df.loc[:, ['B', 'C', 'D']]<jupyter_output><empty_output><jupyter_text>**Filtragem do intervalo entre as datas especificadas e das colunas A e C**<jupyter_code>df.loc['20220101' : '20220323', ['A', 'C']].head(5)<jupyter_output><empty_output><jupyter_text>**Filtragem de todas as colunas da linha 1**<jupyter_code>df.iloc[1]<jupyter_output><empty_output><jupyter_text>**Filtragem de um intervalo específico entre linhas e colunas (1º intervalo linhas, 2º colunas)**<jupyter_code>df.iloc[1:4, 1: 6]<jupyter_output><empty_output><jupyter_text>**Filtragem de linhas e colunas escolhidas**<jupyter_code>df.iloc[[7, 4, 8], [0, 3]]<jupyter_output><empty_output><jupyter_text>**Filtros booleanos**<jupyter_code>df[df.A>0]
df[df > 0]<jupyter_output><empty_output><jupyter_text>2.7. Limpeza dos dados  2.7.1 Sumarização dos dados<jupyter_code>datas = pd.date_range('20180101', periods = 6)

df = pd.DataFrame(np.random.randn(6,4), index = datas, columns = ['var_A', 'var_B', 'var_C', 'var_D'])
df2 = pd.DataFrame({'A': pd.Timestamp('20130102'),
                    'B': pd.Series(1, index = list(range(4)), dtype= 'float32'),
                    'C': np.array([3] * 4, dtype = 'int32'),
                    'D': pd.Categorical(['test', 'train', 'test', 'train']),
                    'F': 'Python'
    
})
df
df.shape
df.dtypes
df.describe()
df2
df.shape
df2.dtypes
df2.describe()
df
df1 = df.reindex(index = datas [ 0: 4 ], columns = list(df.columns) + ['var_E'])
df1
df1.loc[datas[0]: datas [1], 'var_E'] = 77
df1
df1.describe()<jupyter_output><empty_output><jupyter_text>2.7.2. Dados faltantes NaN<jupyter_code>datas = pd.date_range('20180101', periods = 60, freq="D")

df = pd.DataFrame(np.random.randn(60,5), index = datas, columns = list("ABCDE")) 
df.head(3)
df['F'] = df.A[df.A > 0]
df.head(3)
df1 = df.copy()
df2 = df.copy()<jupyter_output><empty_output><jupyter_text>**Extração dos valores NaN. Sempre que ultilizamos este comando, também perdemos os demais dados da linha.**<jupyter_code>df1.dropna().shape 
df.shape
df2.head()<jupyter_output><empty_output><jupyter_text>**Substituição dos valores NaN pela média da coluna F**<jupyter_code>df2.F.fillna(np.mean(df2.F))
df3 = df.copy()<jupyter_output><empty_output><jupyter_text>**Substituição de TODOS os valores NaN da tabela por 777**<jupyter_code>df3.fillna(value = 777)<jupyter_output><empty_output><jupyter_text>2.7.3. Dados únicos<jupyter_code>df2 = pd.DataFrame({'A': 1.,
                    'B': pd.Timestamp('20130102'),
                    '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': 'Python',
                    'G': [2, 2, 4, 4],
                    'H': [np.nan, 2, 4, np.nan]
    
})
df2<jupyter_output><empty_output><jupyter_text>Sempre que usar a função nunique ela aponta os dados ÚNICOS ( axis=0 está relacionado a linha e axis= 1 à coluna)<jupyter_code>df2.nunique(axis = 1, dropna = True)<jupyter_output><empty_output><jupyter_text>2.7.4. Dados duplicados **Essa função mostra valores duplicados em todas as linhas**<jupyter_code>df2.drop_duplicates()<jupyter_output><empty_output><jupyter_text>**Essa função mantém o 1° valor e exclui os valores duplicados na coluna especificada**<jupyter_code>df2.drop_duplicates(subset= 'G')<jupyter_output><empty_output><jupyter_text>2.7.5. Ordenação dos dados<jupyter_code>df = pd.DataFrame({
                    'col1' : [ 'A', 'A', 'B', np.nan, 'D', 'C' ],  
                    'col2' : [ 2, 1, 9, 8, 7, 4 ],
                    'col3' : [ 0, 1, 9, 4, 2, 3 ],
                })
df<jupyter_output><empty_output><jupyter_text>**Ordenação de valores pela coluna 1**<jupyter_code>df.sort_values(by='col1')<jupyter_output><empty_output><jupyter_text>**Ordenação de valores pelas colunas 1 e 2**<jupyter_code>df.sort_values(by=['col1', 'col2'])<jupyter_output><empty_output><jupyter_text>**Ordenação de valores pelas colunas 1 e 2 de forma decrescente**<jupyter_code>df.sort_values(by=['col1', 'col2'], ascending= False)
df.sort_values('col1', ascending= True)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.17253784022262947, 'fraction_numerical': 0.060001357496775945, 'mean_word_length': 4.636572302983932, 'pattern_counts': {'":': 0, '<': 208, '<?xml version=': 0, '>': 216, 'https://': 1, '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': '52', 'dir': 'jupyter-structured-clean-dedup', 'id': '342385', 'license': 'MIT', 'n_tokens_mistral': 6626, 'n_tokens_neox': 5994, 'n_words': 1224, 'path': 'notebooks/fundamentos_da_linguagem_python.ipynb', 'repo_name': 'Emanoelgenez/Analise_de_dados', 'size': '14733'}