<jupyter_start><jupyter_text>Aula 1<jupyter_code>import pandas as pd
dados_portugues = pd.read_csv("data_set/stackoverflow_portugues.csv")
dados_portugues.head()
questao_portugues = dados_portugues.Questão[5]
print(questao_portugues)<jupyter_output><p>Desenvolvi uma página em PHP para uso interno da empresa que trabalho e apenas pouquíssimas pessoas a utilizam. Através dessa página é possível fazer algumas consultas, inserções, alterações e remoções de dados de uma tabela em um banco de dados MySQL, porém eu acredito que meu código em PHP não está protegido contra injeção de código SQL, por exemplo:</p>

<pre><code>//----CONSULTA SQL----//
$busca = mysql_query ('insert into Produtos (coluna) values(' . $valor . ')');
</code></pre>

<p>Logo, digamos que o usuário usar a sentença: <code>1); DROP TABLE Produtos;</code> para ao campo <code>valor</code> o comando ficaria: </p>

<pre><code>insert into Produtos (coluna) values(1); DROP TABLE Produtos;
</code></pre>

<p>Ele vai inserir um novo registro cujo o campo <code>coluna</code> será <code>1</code> e logo em seguida ele vai deletar a tabela Produtos.</p>

<p>Como posso melhorar meu código para prevenir essa situação?</p><jupyter_text>Aula 2<jupyter_code>dados_ingles = pd.read_csv("data_set/stackoverflow_ingles.csv")
dados_ingles.head()
questao_ingles = dados_ingles.Questão[0]
print(questao_ingles)
dados_espanhol = pd.read_csv("data_set/stackoverflow_espanhol.csv")
dados_espanhol.head()
questao_espanhol = dados_espanhol.Questão[0]
print(questao_espanhol)
import re
re.findall(r"<.*?>",questao_portugues)
print(questao_portugues)
texto_teste = re.sub(r"<.*?>","  T----E----S----T----E  ",questao_portugues)
print(texto_teste)















re.search(r"70","18728736187263817628631872638716283670")
regex = re.compile(r"70")
regex.search("18728736187263817628631872638716283670")
from timeit import timeit
setup = """import re"""
timeit("""re.search(r"70","18728736187263817628631872638716283670")""",
      setup)














setup = """import re
regex = re.compile(r"70")"""

timeit("""regex.search("18728736187263817628631872638716283670")""",
      setup)<jupyter_output><empty_output><jupyter_text>Aula 3<jupyter_code>def remover(textos, regex):
    if type(textos) == str:
        return regex.sub("", textos)
    else:
        return [regex.sub("", texto) for texto in textos]
regex_html = re.compile(r"<.*?>")
questao_sem_tag = remover(questao_ingles, regex_html)
print(questao_sem_tag)
print(questao_ingles)
def substituir_codigo(textos, regex):
    if type(textos) == str:
        return regex.sub("CODE", textos)
    else:
        return [regex.sub("CODE", texto) for texto in textos]
questao_ingles
regex_codigo = re.compile(r"<code>(.|(\n))*?</code>")
questao_sem_code = substituir_codigo(questao_espanhol,regex_codigo)
print(questao_sem_code)














dados_portugues.head()
questoes_port_sem_code = substituir_codigo(dados_portugues.Questão,
                                           regex_codigo)
questoes_port_sem_code_tag = remover(questoes_port_sem_code, regex_html)


dados_portugues["sem_code_tag"] = questoes_port_sem_code_tag







dados_portugues.head()
questoes_ing_sem_code = substituir_codigo(dados_ingles.Questão,
                                           regex_codigo)
questoes_ing_sem_code_tag = remover(questoes_ing_sem_code, regex_html)


dados_ingles["sem_code_tag"] = questoes_ing_sem_code_tag
dados_ingles.head()
questoes_esp_sem_code = substituir_codigo(dados_espanhol.Questão,
                                           regex_codigo)
questoes_esp_sem_code_tag = remover(questoes_esp_sem_code, regex_html)


dados_espanhol["sem_code_tag"] = questoes_esp_sem_code_tag
dados_espanhol.head()







print(dados_espanhol.sem_code_tag[0])<jupyter_output>Las sentencias dinámicas son sentencias SQL que se crean como cadenas de texto (strings) y en las que se insertan/concatenan valores obtenidos de alguna fuente (normalmente proveniente del usuario), lo que puede hacer que sean vulnerables a inyección SQL si no se sanean las entradas, como por ejemplo:

CODE

Eso es un ejemplo de una vulnerabilidad grave en la seguridad de una aplicación (web o no) porque si el usuario introdujese un valor como CODE nos encontraríamos con que la sentencia ejecutada sería:

CODE

Y se eliminaría la tabla Usuarios con todos los datos contenidos en ella. 

¿Cómo puedo evitar que la inyección SQL ocurra en PHP?<jupyter_text>Aula4<jupyter_code>regex_pontuacao = re.compile(r"[^\w\s]")
print(remover(questoes_esp_sem_code_tag[0], regex_pontuacao))
def minusculo(textos):
    if type(textos) == str:
        return textos.lower()
    else:
        return [texto.lower() for texto in textos]
print(minusculo(questoes_esp_sem_code_tag[0]))
regex_digitos = re.compile(r"\d+")
print(remover("Alura \n 1234 Caelum 1234", regex_digitos))
regex_espaco = re.compile(r" +")
regex_quebra_linha = re.compile(r"(\n)")
def substituir_por_espaco(textos, regex):
    if type(textos) == str:
        return regex.sub(" ", textos)
    else:
        return [regex.sub(" ", texto) for texto in textos]
    
print(substituir_por_espaco("Alura \n \n     Caleum", regex_quebra_linha))
questoes_port_sem_pont = remover(dados_portugues.sem_code_tag, 
                                 regex_pontuacao)
questoes_port_sem_pont_minus = minusculo(questoes_port_sem_pont)
questoes_port_sem_pont_minus_dig = remover(questoes_port_sem_pont_minus,
                                          regex_digitos)


questoes_port_sem_quebra_linha = substituir_por_espaco(questoes_port_sem_pont_minus_dig,
                                                       regex_quebra_linha)
questoes_port_sem_espaco_duplicado = substituir_por_espaco(questoes_port_sem_quebra_linha,
                                                          regex_espaco)

dados_portugues["questoes_tratadas"] = questoes_port_sem_espaco_duplicado




















dados_portugues.head()
dados_portugues.questoes_tratadas[0]
questoes_ing_sem_pont = remover(dados_ingles.sem_code_tag, 
                                 regex_pontuacao)
questoes_ing_sem_pont_minus = minusculo(questoes_ing_sem_pont)
questoes_ing_sem_pont_minus_dig = remover(questoes_ing_sem_pont_minus,
                                          regex_digitos)


questoes_ing_sem_quebra_linha = substituir_por_espaco(questoes_ing_sem_pont_minus_dig,
                                                       regex_quebra_linha)
questoes_ing_sem_espaco_duplicado = substituir_por_espaco(questoes_ing_sem_quebra_linha,
                                                          regex_espaco)

dados_ingles["questoes_tratadas"] = questoes_ing_sem_espaco_duplicado
dados_ingles.head()
print(dados_ingles.questoes_tratadas[0])
questoes_esp_sem_pont = remover(dados_espanhol.sem_code_tag, 
                                 regex_pontuacao)
questoes_esp_sem_pont_minus = minusculo(questoes_esp_sem_pont)
questoes_esp_sem_pont_minus_dig = remover(questoes_esp_sem_pont_minus,
                                          regex_digitos)
questoes_esp_sem_quebra_linha = substituir_por_espaco(questoes_esp_sem_pont_minus_dig,
                                                       regex_quebra_linha)
questoes_esp_sem_espaco_duplicado = substituir_por_espaco(questoes_esp_sem_quebra_linha,
                                                          regex_espaco)
dados_espanhol["questoes_tratadas"] = questoes_esp_sem_espaco_duplicado
dados_espanhol.head()
print(dados_espanhol.questoes_tratadas[0])<jupyter_output>las sentencias dinámicas son sentencias sql que se crean como cadenas de texto strings y en las que se insertanconcatenan valores obtenidos de alguna fuente normalmente proveniente del usuario lo que puede hacer que sean vulnerables a inyección sql si no se sanean las entradas como por ejemplo code eso es un ejemplo de una vulnerabilidad grave en la seguridad de una aplicación web o no porque si el usuario introdujese un valor como code nos encontraríamos con que la sentencia ejecutada sería code y se eliminaría la tabla usuarios con todos los datos contenidos en ella cómo puedo evitar que la inyección sql ocurra en php<jupyter_text>Aula 5<jupyter_code>from nltk.util import bigrams
texto_teste = "alura"
print(list(bigrams(texto_teste)))













from nltk.lm.preprocessing import pad_both_ends

print(list(bigrams(pad_both_ends(texto_teste, n = 2))))<jupyter_output>[('<s>', 'a'), ('a', 'l'), ('l', 'u'), ('u', 'r'), ('r', 'a'), ('a', '</s>')]<jupyter_text>Aula 6<jupyter_code>dados_portugues["idioma"] = "port"
dados_espanhol["idioma"] = "esp"
dados_ingles["idioma"] = "ing"

dados_portugues.head()












len(dados_espanhol)
from sklearn.model_selection import train_test_split

port_treino, port_teste = train_test_split(dados_portugues.questoes_tratadas,
                                          test_size = 0.2,
                                          random_state = 123)














from sklearn.model_selection import train_test_split

esp_treino, esp_teste = train_test_split(dados_espanhol.questoes_tratadas,
                                          test_size = 0.2,
                                          random_state = 123)

from sklearn.model_selection import train_test_split

ing_treino, ing_teste = train_test_split(dados_ingles.questoes_tratadas,
                                          test_size = 0.2,
                                          random_state = 123)











todas_questoes_port = ' '.join(port_treino)

from nltk.tokenize import WhitespaceTokenizer

todas_palavras_port = WhitespaceTokenizer().tokenize(todas_questoes_port)
print(todas_palavras_port)




from nltk.lm.preprocessing import padded_everygram_pipeline


port_treino_bigram, vocab_port = padded_everygram_pipeline(2,
                                                           todas_palavras_port)




















from nltk.lm.preprocessing import padded_everygram_pipeline


port_treino_bigram, vocab_port = padded_everygram_pipeline(2,
                                                           todas_palavras_port)













from nltk.lm import MLE

modelo_port = MLE(2)
modelo_port.fit(port_treino_bigram, vocab_port)


















modelo_port.generate(num_words=6)


















from nltk.lm import NgramCounter

modelo_port.counts[['m']].items()



















texto = "good morning"
palavras = WhitespaceTokenizer().tokenize(texto)
palavras_fakechar = [list(pad_both_ends(palavra, n = 2)) for palavra in palavras]
palavras_bigramns = [list(bigrams(palavra)) for palavra in palavras_fakechar]
print(palavras_bigramns)








print(palavras_bigramns[0])

print(modelo_port.perplexity(palavras_bigramns[0]))
print(modelo_port.perplexity(palavras_bigramns[1]))<jupyter_output>47.67024857599163
21.544936606913122
{'fraction_non_alphanumeric': 0.08537152422579745, 'fraction_numerical': 0.022598344648005208, 'mean_word_length': 3.5146935348446684, 'pattern_counts': {'":': 0, '<': 51, '<?xml version=': 0, '>': 51, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 43, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '6', 'dir': 'jupyter-structured-clean-dedup', 'id': '23249', 'license': 'MIT', 'n_tokens_mistral': 3885, 'n_tokens_neox': 3693, 'n_words': 704, 'path': '2 - Regex com Python/nlp-modelos-linguagem-master/Aula_06.ipynb', 'repo_name': 'DaviSegundo/MachineLearning_Study', 'size': '10753'}