PYTHON

Prévia do material em texto

PYTHON 
PYCHARM, VS CODE, JUPYTER 
main.py 
OBS: Precisa do arquivo python instalado na máquina e um editor de código. 
 
Ctrl + s - Para salvar o arquivo VS Code 
# → Comentário em python. ‘/n’ → Quebra de linha print(‘’) →Imprime na tela. 
input(‘’) - Espaço para digitar 
 
print('ola mundo') - Imprimir na tela 
 
, end=’’ nn tem a quebra de linha 
 
VARIÁVEIS BÁSICAS 
- Armazenamento de dados temporários utilizados pelo programa. 
- Atribuir um nome e um valor. 
- Bool , int, str e float. 
 
Classes: 
- String: - Booleano: - Floats: - Integers: 
nome= ‘Aly’ True ou false peso = 70.5 idade = 24 , peso=7 
- Complex: Número complexo. OBS: Float : n° com casa decimal. 
print(type(1+2j)) 
 
Type → Mostrar qual a classe. 
Ex: print(type(idade)) 
 
Input → Armazena a entrada de dados do usuário. Instruir o usu oq ele deve fazer. 
 Ex: nome = input(“digite seu nome”) 
OBS: Vai aparecer a frase e o espaço para escrever. O input retorna os valores como uma string. Às 
vezes vai precisar fazer a conversão. 
 
 
 
Conversão de string para classe: Colocar int, float, antes da frase 
Ex: nome = int( input(“digite sua idade:”)) 
 peso = float( input(“digite seu peso”)) 
 
 
Função isinstance() - Retorna verdadeiro se a classe for correta, se for retorna true, se não 
retorna false. - Validação de dados do usuário. 
 
 
 
 
OPERADORES 
+ ⇢ Soma - ⇢ Subtração * ⇢ Multipli / ⇢ Divisão real 
// ⇢ Divi int %⇢ Módulo ** ⇢ Potenciação 
 
OPERADORES DE COMPARAÇÃO 
== ⇢ Igual a != ⇢ Diferente de > ⇢ Maior q = ⇢ Maior ou igual a = 18): if (condição): 
 print('pode entrar') ação 
else: else: 
 print('não pode entrar') ação 
 
 
 
 
 
 
 
LAÇOS DE REPETIÇÕES 
- Executar um bloco de instruções repetidamente por determinados números ou não. 
- For e while(enquanto). 
While - Um teste lógico é realizado no início do loop e sempre q esse teste for verdadeiro os 
comandos dentro desse bloco é executado infinitamente e para quando o teste der falso. 
num = 1 
while (num = 20 ): 
 print('valido') 
 break #Finaliza a repetição ao digitar um número válido 
 else: 
 print('invalido') 
 # vai aparecendo para digitar o número até ser maior ou igual a 20 
 
for tentativa in range(5): # Repete no máximo 5 vezes 
 num = int(input('Digite um número: ')) 
 if (num >= 20): 
 print('Válido') 
 break # Sai do loop se o número for válido 
 else: 
 print('Inválido') 
print("Fim do programa!") # Exibido após 5 tentativas ou um número válido 
# Só pode digitar errado 5 vezes. 
 
Continue - Encerra a interação atual do laço/atual. 
lista = ('1','3','5', '9', '2') 
for num in lista: #Repetição - coloca a var lista dentro da var num 
 if num == '9': 
 continue 
 print(num) 
# O número 9 vai ser excluído da exibição da lista 
 
 
ENCADEAMENTO DE LAÇOS DE REPETIÇÃO 
- Um laço de repetição dentro de outro laço de repetição. 
 
 
 
FUNÇÕES 
- Blocos reutilizáveis de código que fazem tarefas específicas , como por exemplo replicação 
de código. 
- Modularização, reuso do código, legibilidade. 
- A função é criada e ela fica armazenada até o momento correto de ser utilizada. 
- def 
 
def nome_função (argumentos): # Criar a função 
instruções 
mensagem() # Chamar a função 
 
def soma(a, b): 
 print(a+b) 
soma(12, 7) 
 
Return - A função retorna o valor e para de fazer outros testes. 
def fun(a, b): 
 return a - b 
z = 10 
p = 7 
c = fun(z, p) 
print(c) 
 
parâmetros: 
# escrever na tela um número x vezes 
def contar(num = 11, caractere = None): #parâmetro 
 for i in range(0, num): #repetir o número 11 vezes 
 print(caractere) 
digite = input('digite algo:') #O que escrito em dentro da var digite vai se impresso 11 vz 
if __name__ == "__main__": 
 contar(caractere = digite) 
def soma_mult(a, b, c ): 
 if c == 0: 
 return a * b 
 else: 
 return a + b + c 
x = int(input('digite: ')) 
y = int(input('digite: ')) 
z = int(input('digite: ')) 
if __name__ == '__main__' : 
 res = soma_mult(x, y, z) 
 print(res) 
A estrutura if __name__ == "__main__": em Python é usada para garantir que um bloco de código 
seja executado somente quando o script for executado diretamente, e não quando ele for importado 
como um módulo em outro script. 
 
 
MÓDULOS 
 
Random - Gera números automaticamente/aleatórios. 
- import random 
- Tem vários para usar Ex: random.random() 
import random 
valor = random.randint(1,20) #vai gerar um número inteiro entre 1 e 20 
print(valor) 
 #Vai gerar um número inteiro entre 1 e 20 
import random 
for i in range(5): 
 valor = random.randint(1,50) 
 print(valor) 
# Vai gerar um número aleatório por 5 vz 
 
Re - Biblioteca para expressões regulares. 
- import re 
Expressões regulares - São padrões usados para buscar, substituir e validar textos. Elas ajudam a 
encontrar palavras específicas, padrões de caracteres, números, formatos de e-mail, etc.. 
 
Counter - Ele é usado para contar elementos em listas, strings ou qualquer estrutura iterável. 
- from collections import Counter 
from collections import Counter 
frutas = ["maçã", "banana", "laranja", "banana", "maçã", "maçã"] 
contagem = Counter(frutas) 
print(contagem) 
 
 
Manipulação de erros exceções 
 
- Exceção - Erro que ocorreu ao executar o problema. 
- Blocos try e except. 
- Pode ou não especificar a exceção. 
 
Try - Dentro dele o código que provavelmente ocasionou o erro. 
Except - Dentro dele vai colocar o tratamento ou mensagem. - pode ou não escrever a exceção. 
 
round(x, x) - arredondar , 2 quant de casas decimais 
 
n1 = int(input('digite um número')) 
n2 = int( input('digite um número')) 
try: 
 r = round(n1/n2, 2) #arredondar 
except: 
 print('Não é possivel dividir por 0') 
else: 
 print('resultado:', r) 
#Caso no n2 digite zero aparecerá essa mensagem ao invés de travar, se não irá executar o 
else normalmente. 
 
def div(k , j): 
 return round(k/j,2) 
 
while True: 
 try: # para identificar o erro 
 n1 = int( input('digite um número: ')) 
 n2 = int( input('digite um número: ')) 
 r = div(n1,n2) 
 except ValueError: # Tratamento para entrada inválida 
 print('Erro: Digite apenas números inteiros.') 
 except ZeroDivisionError: #Tratamento n2 0 
 print('não é possivel ter a base 0') 
 except: #Erro nn previsto 
 print('Ocorreu um erro desconhecido') 
 else: 
 print('resultado:', r) 
 break 
#Vai ficar em loop até digitar um número válido 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
concatenando 
 
def - para definir funções. Uma função é um bloco de código reutilizável que executa uma tarefa 
específica 
 
 
pypi.org 
APPEND -??? 
pop ??? 
 
 
 
 
Manipulação de strings 
nome = 'Fábio' 
letra = nome[2] 
print(letra) 
 
 
Sets - Conjuntos - Coleções não ordenadas de 
ex: eastro_set 
 
for tentativa in range(5):# Só pode errar no max 5 vezes 
 def rest(f, g): #Função 
 return f - g 
 a = tentativa 
 b = -1 
 c = rest(a, b) # Chamar a função 
 num = int(input('Digite um número: ')) 
 if (num >= 20): 
 print('Válido') 
 break # Sai do loop se o número for válido 
 else: 
 print('Inválido') 
 print('Tentativa:', c)#Vai mostrar o n da tentativa 
 if (c >= 5): 
 print('tentativas esgotadas')# terminando as 5 
print("Fim do programa!") # Exibido após 5 tentativas ou um número válido 
( 
#Precisa digitar um número maior ou igual a 20, só pode digitar errado 5 vezes, e a cada errada vai 
mostrar o número da tentativa, após chegar a 5 o programa é encerrado e aparece a mensagem 
'tentativas esgotadas'. 
 
 
 
 
 
 
while True: #Para garantir que a senha armazenada seja válida 
 try: 
 escolha_uma_senha = int( input('escolha uma senha: ')) 
 print('senha armazenada✅') 
 break #Sai do loop caso seja válida 
 except ValueError:#Tratamento para caso digite algum caractere inválido. 
 print('digite apenas números inteiros❌') #Continua o loop caso não seja 
for tentativa in range(5):# Só pode errar no max 5 vezes 
 try:#caso o usuário digite algum caractere sem ser um int 
 c = tentativa + 1 
 senha = int(input('Digite a senha correta: ')) 
 if (senha == escolha_uma_senha): 
 print('senha correta ✅') 
 print('Bem vindo!') 
 break # Sai do loop se a senha for correta 
 else: 
 print('Senha incorreta❌') 
 print('⚠Tentativa:', c , 'de 5')#Vai mostrar o n° da tentativa 
 if (c == 5): 
 print('tentativas esgotadas') #terminando as 5 tentativas vai aparecer essa mensagem 
 except ValueError: #Tratamento para caso digite algum caractere inválido. 
 print('digite apenas números inteiros❌') 
print("Fim do programa!") #Mensagem final após todas as tentativas . 
 
#Precisa digitar a senha correta, só pode digitar errado 5 vezes, e a cada errada vai mostrar o 
número da tentativa, após chegar a 5 o programa é encerrado e aparece a mensagem 'Tentativas 
esgotadas', caso digite a correta o programa finaliza e aparece a mensagem ‘Bem vindo’. 
 
 
 
escolha_uma_senha = int( input('escolha uma senha: ')) 
print('senha armazenada') 
for tentativa in range(5):# Só pode errar no max 5 vezes 
 def rest(f, g): #Função 
 return f + g 
 a = tentativa 
 b = 1 
 c = rest(a, b) # Chamar a função 
 
 senha = int(input('Digite a senha correta: ')) 
 if (senha == escolha_uma_senha): 
 print('Válido') 
 print('Bem vindo!') 
 break # Sai do loop se o número for válido 
 else: 
 print('Inválido') 
 print('Tentativa:', c)#Vai mostrar o n da tentativa 
 if (c >= 5): 
 print('tentativas esgotadas')# terminando as 5 
print("Fim do programa!") # Exibido após 5 tentativas ou um número válido 
 
 
 
 
if __name__ == ‘__mains__’: 
 
TensorFlow, PyTorch → Redes neurais e deep learning 
Scikit-learn → Aprendizado de máquina 
Pandas, NumPy → Manipulação de dados 
OpenCV → Visão computacional 
NLTK, spaCy → Processamento de linguagem natural 
 
 
 
https://www.programiz.com/online-compiler/4apBnCT9UebBr 
 
 
 
https://www.programiz.com/online-compiler/6gfjqfExpuDEJ 
 
 
 
 
 
 
 
Reescritor de texto 
import random 
 
def synonym_replacement(text): 
 """ 
 Substitui palavras por sinônimos para reescrever o texto de forma mais variada. 
 Mantém a capitalização das palavras substituídas. 
 """ 
 synonyms = { 
 "rápido": ["veloz", "ligeiro", "ágil"], 
 "feliz": ["contente", "alegre", "satisfeito"], 
 "falar": ["dizer", "expressar", "afirmar"], 
 "bom": ["ótimo", "excelente", "maravilhoso"], 
 "inteligente": ["esperto", "astuto", "perspicaz"], 
 "trabalho": ["atividade", "ocupação", "função"], 
 "criança": ["menino", "garoto", "pequeno"], 
 "grande": ["enorme", "vasto", "amplo"], 
 "carro": ["automóvel", "veículo", "máquina"], 
 "amigo": ["companheiro", "colega", "camarada"], 
 "cidade": ["município", "metrópole", "urbe"], 
 "importante": ["relevante", "significativo", "crucial"] 
 } 
 
 words = text.split() 
 rewritten_words = [] 
 
 for word in words: 
 lower_word = word.lower() 
 if lower_word in synonyms and random.random() > 0.5: 
 synonym = random.choice(synonyms[lower_word]) 
 synonym = synonym.capitalize() if word[0].isupper() else synonym # Mantém a capitalização 
 rewritten_words.append(synonym) 
 else: 
 rewritten_words.append(word) 
 
 return " ".join(rewritten_words) 
 
def sentence_restructuring(text): 
 """ 
 Faz pequenas mudanças estruturais na frase para reescrevê-la sem perder coerência. 
 Em vez de trocar palavras aleatórias, inverte partes da sentença. 
 """ 
 words = text.split() 
https://www.programiz.com/online-compiler/4apBnCT9UebBr
https://www.programiz.com/online-compiler/6gfjqfExpuDEJ
 
 if len(words) > 5: 
 half = len(words) // 2 
 words = words[half:] + words[:half] # Inverte a ordem de duas metades da frase 
 
 return " ".join(words) 
 
def rewrite_text(text): 
 """ 
 Reescreve o texto utilizando substituição de sinônimos e reestruturação de frases. 
 """ 
 text = synonym_replacement(text) 
 text = sentence_restructuring(text) 
 return text 
 
if __name__ == "__main__": 
 text = input("Digite o texto a ser reescrito: ") 
 rewritten = rewrite_text(text) 
 print("Texto reescrito:", rewritten) 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
	PYTHON 
	VARIÁVEIS BÁSICAS 
	OPERADORES 
	OPERADORES DE COMPARAÇÃO 
	Operadores lógicos: 
	DICIONÁRIOS 
	LISTAS 
	CONDICIONAIS 
	LAÇOS DE REPETIÇÕES 
	ENCADEAMENTO DE LAÇOS DE REPETIÇÃO 
	FUNÇÕES 
	MÓDULOS