5 |
6 |
7 | Deletar
8 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex050.py:
--------------------------------------------------------------------------------
1 | # leia seis numeros inteiros e mostre a soma apenas dos pares se for impar desconsiderar
2 | sm = 0
3 | for x in range(1,7):
4 | v = int(input('Digite um Numero Inteiro:'))
5 | if v % 2 == 0:
6 | sm += v
7 | print(sm)
8 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex055.py:
--------------------------------------------------------------------------------
1 | # leia o peso de 5 pessoa e mostre o maior e menor peso lido
2 | l = []
3 | for x in range(0,5):
4 | p = float(input('Digite Um Peso:'))
5 | l.append(p)
6 | l.sort()
7 | print(f'O Menor peso é: {l[0]}\nO Maior peso é: {l[len(l)-1]}')
8 |
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_1_introducao/aula_12/templates/response.html:
--------------------------------------------------------------------------------
1 | {% extends 'bootstrap/base.html' %}
2 |
3 |
4 | {% block content %}
5 |
6 |
7 |
8 |
teste
9 |
10 |
11 | {% endblock content %}
--------------------------------------------------------------------------------
/Selenium/Curso Selenium com python by Eduardo Mendes/aula_04/main.py:
--------------------------------------------------------------------------------
1 | from selenium.webdriver import Firefox
2 |
3 | browser = Firefox()
4 |
5 | url = 'https://selenium.dunossauro.live/aula_04_a.html'
6 |
7 | browser.get(url)
8 |
9 | lista_n_ordenada = browser.find_elements_by_tag_name('lu')
--------------------------------------------------------------------------------
/urionlinejudge-python/1050.py:
--------------------------------------------------------------------------------
1 | DDD = int(input())
2 |
3 | lista={61:'Brasilia',71:'Salvador',11:'Sao Paulo',21:'Rio de Janeiro',32:'Juiz de Fora',19:'Campinas',27:'Vitoria',31:'Belo Horizonte'}
4 |
5 | if DDD in lista :
6 | print(lista[DDD])
7 | else :
8 | print('DDD nao cadastrado')
--------------------------------------------------------------------------------
/HackerRank/13.py:
--------------------------------------------------------------------------------
1 | def mutate_string(string, position, character):
2 | var = string[:position] + character + string[position+1:]
3 | return var
4 |
5 | if __name__ == '__main__':
6 | s = input()
7 | i, c = input().split()
8 | s_new = mutate_string(s, int(i), c)
9 | print(s_new)
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/seek.py:
--------------------------------------------------------------------------------
1 | '''
2 | Seek e cursores
3 |
4 |
5 | seek() -> é utilizada para manipular o ponteiro de leitura/escrita
6 |
7 | '''
8 |
9 |
10 | value = open('./texto.txt', 'r')
11 |
12 |
13 | print(value.read())
14 | value.seek(0)
15 | print(value.read())
16 |
--------------------------------------------------------------------------------
/tkinter/hello_world.py:
--------------------------------------------------------------------------------
1 | from tkinter import *
2 | from tkinter import ttk
3 | root = Tk()
4 | frm = ttk.Frame(root, padding=10)
5 | frm.grid()
6 | ttk.Label(frm, text="Hello World!").grid(column=0, row=0)
7 | ttk.Button(frm, text="Quit", command=root.destroy).grid(column=1, row=0)
8 | root.mainloop()
--------------------------------------------------------------------------------
/SQLite/Pratica/ex002/criando.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | banco = sqlite3.connect('banco_dados.db')
4 |
5 | cursor = banco.cursor()
6 |
7 | cursor.execute("""CREATE TABLE conta (
8 | id integer PRIMARY KEY AUTOINCREMENT,
9 | login text,
10 | senha text)""")
11 | banco.commit()
12 |
13 |
--------------------------------------------------------------------------------
/web-scraping/requests/auto_sel.py:
--------------------------------------------------------------------------------
1 | from selenium.webdriver import Chrome
2 | from time import sleep
3 |
4 | driver = Chrome()
5 | # driver.get('https://pas.viavarejo.com.br/login')
6 | driver.get('https://www.kabum.com.br/')
7 |
8 | # https://www.webmotors.com.br/vans
9 |
10 | sleep(50)
11 |
12 |
--------------------------------------------------------------------------------
/SQLite/Pratica/ex001/criando.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | banco = sqlite3.connect('banco_dados.db')
4 |
5 | cursor = banco.cursor()
6 |
7 | cursor.execute("""CREATE TABLE conta (
8 | id integer PRIMARY KEY AUTOINCREMENT,
9 | login text,
10 | senha text)""")
11 |
12 | banco.commit()
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex046.py:
--------------------------------------------------------------------------------
1 | # Faça um programa que faça uma contagem regressiva de 10 até 0 com uma pausa de 1 segundo entre eles, mostrando Feliz ano novo
2 |
3 | from time import sleep
4 |
5 | for x in range(10,0,-1):
6 | print(x)
7 | sleep(1)
8 | print('Feliz Ano Novoooooo!!!!!!')
--------------------------------------------------------------------------------
/SQLite/Aulas/aula05.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | nome = 'Lucas'
4 | idade = '18'
5 | email = 'lucasgmail.com'
6 |
7 |
8 | banco = sqlite3.connect('primeiro_banco.db')
9 |
10 | cursor = banco.cursor()
11 |
12 | cursor.execute(f"UPDATE pessoas SET nome = 'Fabio' WHERE idade = 40")
13 |
14 | banco.commit()
--------------------------------------------------------------------------------
/web-scraping/Curso Web Scraping com python by walisson silva/Aula 02 - Requests/aula02.py:
--------------------------------------------------------------------------------
1 | import requests
2 |
3 | resposta = requests.get('https://lucasnunes.me/')
4 |
5 | print(f'Codigo de status: {resposta.status_code}')
6 |
7 | print(f'Cabeçalho: {resposta.headers}')
8 |
9 | print(f'Conteúdo: {resposta.content}')
--------------------------------------------------------------------------------
/Flask/Curso de Flask by Julia Rizza/aula03/app/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | from flask_sqlalchemy import SQLAlchemy
3 |
4 | app = Flask(__name__)
5 | app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///storage.db'
6 | db = SQLAlchemy(app)
7 |
8 | from app.controllers import default
9 |
10 | # a
11 |
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/general/aula_06/requirements.txt:
--------------------------------------------------------------------------------
1 | click==8.0.1
2 | colorama==0.4.4
3 | Flask==2.0.1
4 | Flask-Login==0.4.1
5 | Flask-SQLAlchemy==2.5.1
6 | greenlet==1.1.1
7 | itsdangerous==2.0.1
8 | Jinja2==3.0.1
9 | MarkupSafe==2.0.1
10 | SQLAlchemy==1.4.23
11 | Werkzeug==2.0.1
12 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex018.py:
--------------------------------------------------------------------------------
1 | # leia um angulo e mostre seno coseno tangente
2 | from math import cos,tan,sin,radians
3 | n1 = int(input('Digite um angulo:'))
4 | print(f'O valor do seno: é {sin(radians(n1)):.2f}\nO valor do coseno: {cos(radians(n1)):.2f}\nO valor da tangente: {tan(radians(n1)):.2f}')
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex031.py:
--------------------------------------------------------------------------------
1 | # receba distancia em km se for menor que 200km pague 0,5 por km rodado caso seja maior pague 0,45
2 | km = float(input('Digite uma distancia em KM:'))
3 | if km <= 200:
4 | custo = km*0.5
5 | else:
6 | custo = km*0.45
7 | print(f'Você precisa pagar {custo} R$')
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex034.py:
--------------------------------------------------------------------------------
1 | # receba um salario e caso for maior que 1250 aumento de 10% caso seja menor ou igual 15%
2 | sl = float(input('Digite seu salario:'))
3 | if sl <= 1250:
4 | slf = sl*1.15
5 | else:
6 | slf = sl*1.1
7 | print(f'O seu salario com reajuste ficou: {slf:.2f} R$ !')
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_5_templates/templates/users.html:
--------------------------------------------------------------------------------
1 | {% extends "base.html" %}
2 |
3 |
4 | {% from 'components/user.html' import user_component %}
5 |
6 | {% block content %}
7 |
8 |
9 | {% include 'components/notifications.html' %}
10 |
11 | {{ user_component(users) }}
12 |
13 |
14 | {% endblock %}
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/aula_06/templates/user.html:
--------------------------------------------------------------------------------
1 |
2 | {% for user in users %}
3 |
4 |
{{ user.id }}
5 |
{{ user.name }}
6 |
{{ user.email }}
7 |
8 | Deletar
9 | {% endfor %}
10 |
11 |
--------------------------------------------------------------------------------
/classes/bubble_sort e binary_search/readme.md:
--------------------------------------------------------------------------------
1 | # Exercícios sobre Bubble sort & Binary Search
2 |
3 | * [Binary Search](https://www.codingame.com/training/medium/shadows-of-the-knight-episode-1)
4 | * [Sorting](https://www.codingame.com/training/easy/the-descent)
5 | * [Binary Search - Guide](https://www.codingame.com/learn/binary-search)
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/general/aula_06/templates/login.html:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/funcoes_maior_grandeza.py:
--------------------------------------------------------------------------------
1 | '''
2 | Funções de maior grandeza -> Higher Order Functions - HOF
3 |
4 |
5 |
6 | o que é?
7 |
8 | Linguagens de programação que aceitam o conceito de HOF,
9 | ou seja aceitam funções e podem retornar funções dentro de uma outra função
10 | '''
11 |
12 |
13 |
14 |
15 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex004.py:
--------------------------------------------------------------------------------
1 | algo = input('Escreva algo:')
2 | print(type(algo))
3 | print('Algo é Numero? ', algo.isnumeric())
4 | print('Algo é Texto? ', algo.isalpha())
5 | print('Algo é Texto e Numerico? ', algo.isalnum())
6 | print('Algo é Todo em maiusculo? ', algo.isupper())
7 | print('Algo é Todo em minusculo? ', algo.islower())
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/primeira_classe/pessoa_fisica.py:
--------------------------------------------------------------------------------
1 | from pessoa import Pessoa
2 |
3 | class PessoaFisica(Pessoa):
4 | def __init__(self, CPF, nome, idade):
5 | super().__init__(nome,idade)
6 | self.CPF = CPF
7 |
8 | def getCPF(self):
9 | return self.CPF
10 |
11 | def setCPF(self, CPF):
12 | self.CPF = CPF
--------------------------------------------------------------------------------
/HackerRank/12.py:
--------------------------------------------------------------------------------
1 | def swap_case(string):
2 | string = str(string)
3 | var = ''
4 | for i in s:
5 | if i.isupper():
6 | var += i.lower()
7 | else:
8 | var += i.upper()
9 | return var
10 |
11 |
12 | if __name__ == '__main__':
13 | s = input()
14 | result = swap_case(s)
15 | print(result)
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_5_templates/templates/components/user.html:
--------------------------------------------------------------------------------
1 | {% macro user_component(users) %}
2 |
3 | {% for user in users %}
4 |
5 |
Nome: {{user['name']}}
6 |
Idade: {{user['age']}}
7 |
Email: {{user['email']}}
8 |
9 | {% endfor %}
10 |
11 | {% endmacro %}
--------------------------------------------------------------------------------
/HackerRank/5.py:
--------------------------------------------------------------------------------
1 | # ano bissexto
2 |
3 | def is_leap(year):
4 | leap = False
5 |
6 | if year % 4 == 0:
7 | if year % 100 == 0:
8 | if year % 400 == 0:
9 | leap = True
10 | else:
11 | leap = True
12 | return leap
13 |
14 |
15 | year = int(input())
16 | print(is_leap(year))
17 |
18 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex019.py:
--------------------------------------------------------------------------------
1 | # leia quatro nomes e escolha um
2 | from random import randint
3 | n1 = input('Digite um nome:')
4 | n2 = input('Digite um nome:')
5 | n3 = input('Digite um nome:')
6 | n4 = input('Digite um nome:')
7 |
8 | lista = [n1, n2, n3, n4]
9 | numerorand = randint(0,3)
10 | print(f'Aluno Sorteado: {lista[numerorand]}')
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/primeira_classe/pessoa_juridica.py:
--------------------------------------------------------------------------------
1 | from pessoa import Pessoa
2 |
3 | class PessoaJuridica(Pessoa):
4 | def __init__(self, CNPJ, nome, idade):
5 | super().__init__(nome, idade)
6 | self.CNPJ = CNPJ
7 |
8 | def getCNPJ(self):
9 | return self.CNPJ
10 |
11 | def setCNPJ(self, CNPJ):
12 | self.CNPJ = CNPJ
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex029.py:
--------------------------------------------------------------------------------
1 | # escreva um numero em km por hora, se for acima de 80 km/h tem multa de 7 RS por km
2 | n1 = float(input('Digite uma velocidade em Km/h:'))
3 | if n1 > 80:
4 | mt = (n1 - 80) * 7
5 | print(f'Você precisa pagar um multa de {mt:.2f} R$')
6 | else:
7 | print(f'Você é um bom motorista e não precisa pagar multa ;)')
8 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex011.py:
--------------------------------------------------------------------------------
1 | # leia largura e altura e verifique quanto de tinta precisa para pintar a parece considerando 1 litro de tinta pinta 2m2
2 |
3 | altura = float(input('Digite a altura da parede:'))
4 | largura = float(input('Digite a largura da parede:'))
5 |
6 | print('você ira precisar de {:.1f} litros de tinta'.format((altura*largura)/2))
7 |
8 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/097.py:
--------------------------------------------------------------------------------
1 | # uma função que receba um texo qualquer como parametro e mostre uma mensagem com tamanho dinamico
2 |
3 | def mensagem(texto):
4 | print('-'*len(texto))
5 | print(texto)
6 | print('-'*len(texto))
7 |
8 |
9 | mensagem(' curso de python by curso em video ')
10 | mensagem(' curso de python ')
11 | mensagem(' curso ')
12 |
13 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/114.py:
--------------------------------------------------------------------------------
1 | # crie um codigo em python que teste se o site pudim.com.br está acessivel pelo computador usado
2 |
3 | import urllib.request
4 | site = 'http://pudim.com.br/'
5 |
6 | try:
7 | teste = urllib.request.urlopen(site)
8 | except:
9 | print('Site Pudim Não está disponivel ;(')
10 | else:
11 | print('Site pudim Está disponivel ;)')
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_1_introducao/aula_06/app.py:
--------------------------------------------------------------------------------
1 | # Importando Flask
2 | from flask import Flask
3 |
4 | # definindo objeto da classe
5 | app = Flask(__name__)
6 |
7 | @app.route('/') # caminho da rota
8 | def index():
9 | return "Página Inicial" # Mostra o conteúdo na tela
10 |
11 | # so roda o app se for o arquivo principal
12 | if __name__ == "__main__":
13 | app.run()
--------------------------------------------------------------------------------
/Flask/REST API com Python e Flask/aula_01.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | from flask_restful import Resource, Api
3 |
4 | from resources.hotel import Hoteis, Hotel
5 |
6 | app = Flask(__name__)
7 | api = Api(app)
8 |
9 |
10 |
11 | api.add_resource(Hoteis, '/hoteis')
12 | api.add_resource(Hotel, '/hoteis/')
13 |
14 |
15 | if __name__ == '__main__':
16 | app.run(debug=True)
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/096.py:
--------------------------------------------------------------------------------
1 | # Faça uma função que receba as dimensoes de um terreno retangular(largura e altura) e mostre a area do terreno
2 | def area(largura,altura):
3 | area = largura * altura
4 | print(f'O terreno tem dimensões de {largura}x{altura} com Área: {area}')
5 |
6 |
7 | n1 = float(input('Digite a Largura:'))
8 | n2 = float(input('Digite a Altura:'))
9 | area(n1,n2)
--------------------------------------------------------------------------------
/classrom_py/templates/a.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 | Document
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex061.py:
--------------------------------------------------------------------------------
1 | # Leia o primeiro termo e a razão de uma PA, mostrando os 10 primeiros termos usando while
2 |
3 | pt = int(input('Digite um Valor Inteiro para o primeiro Termo:'))
4 | ra = int(input('Digite um Valor Inteiro para a Razão:'))
5 | nt = 1
6 | rt = pt
7 | while nt != 11:
8 | print(f' O {nt:2} Termo é: {rt:3} !!!')
9 | rt += ra
10 | nt += 1
11 |
--------------------------------------------------------------------------------
/Selenium/selenium_docker/app/main.py:
--------------------------------------------------------------------------------
1 | from time import sleep
2 | from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
3 | from selenium import webdriver
4 |
5 | sleep(10)
6 |
7 | driver = webdriver.Remote('http://selenium:4444/wd/hub', desired_capabilities=DesiredCapabilities.CHROME)
8 |
9 | driver.get('https://python.org')
10 | print(driver.page_source)
11 | print('teste')
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex026.py:
--------------------------------------------------------------------------------
1 | # leia uma frase, vezes aparece a letra A, a primeira posição ela apareçe pela primeira vez, e a posiçao ultima vez
2 | frase = str(input('Digite uma frase:')).strip()
3 | print(f' Quantas Vezes aparece a letra A: {frase.upper().count("A")}\n A primeira vez que aparece a letra A : {frase.upper().find("A")+1}\n A ultima vez que aparece : {frase.upper().rfind("A")+1}')
--------------------------------------------------------------------------------
/SQLite/Aulas/aula03.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | try:
4 | banco = sqlite3.connect('primeiro_banco.db')
5 |
6 | cursor = banco.cursor()
7 |
8 | cursor.execute("DELETE from pessoas WHERE idade = as")
9 |
10 | banco.commit()
11 | banco.close()
12 | print('Dados Removidos com Sucesso')
13 | except sqlite3.Error as erro:
14 | print(f'Erro ao Remover Dados, Nome : {erro}')
15 |
--------------------------------------------------------------------------------
/SQLite/Aulas/aula04.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | nome = 'Lucas'
4 | idade = '18'
5 | email = 'lucasgmail.com'
6 |
7 |
8 | banco = sqlite3.connect('primeiro_banco.db')
9 |
10 | cursor = banco.cursor()
11 |
12 | cursor.execute(f"INSERT INTO pessoas VALUES ('{nome}','{idade}','{email}')")
13 |
14 | banco.commit()
15 |
16 |
17 | cursor.execute("SELECT * FROM pessoas")
18 | print(cursor.fetchall())
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/string_io.py:
--------------------------------------------------------------------------------
1 | '''
2 | StringIO
3 |
4 |
5 | OBS: para ler ou escrever no os, precisa de permissão para tal
6 |
7 |
8 | StringIO -> Utilizado para ler e criar arquivos em memória
9 | '''
10 |
11 |
12 | from io import StringIO
13 |
14 | text = 'normal text'
15 |
16 |
17 | file = StringIO(text)
18 |
19 | print(file.read())
20 |
21 | file.write('teste')
22 |
23 |
24 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex008.py:
--------------------------------------------------------------------------------
1 | # leia um valor em metro e converta em centimetros e milimetros
2 |
3 | n1 = float(input('Digite um numero em metros:'))
4 | print('O numero em Kilometro : {}\nO numero em Hectomero: {}\nO Numero em Decametro: {}\nO numero em metros: {}\nO numero em Decimetro: {}\nO numero em Centimetros {}\nO numero em Milimetros {}\n'.format(n1/1000,n1/100,n1/10,n1,n1*10,n1*100,n1*1000))
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex052.py:
--------------------------------------------------------------------------------
1 | # Faça um programa que leia um numero inteiro inteiro e verifique se ele é um numero primo, sendo numero primo divido apenas por 1 e ele mesmo
2 |
3 | n1 = int(input('Digite um numero Inteiro:'))
4 | sm = 0
5 | for x in range(1,n1+1):
6 | if n1 % x == 0:
7 | sm += 1
8 | if sm == 2:
9 | print('Numero Primo')
10 | else:
11 | print('Numero Não Primo')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/ex112/utilidadesCev/dado/__init__.py:
--------------------------------------------------------------------------------
1 | def leiaDinheiro(texto='Digite um Valor:'):
2 | while True:
3 | r = input(texto).strip()
4 | if r.count(',') > 0:
5 | r = r.replace(',','.')
6 | if r.replace('.','',1).isdecimal():
7 | r = float(r)
8 | break
9 | print(f'O valor "{r}" não é um numero!!')
10 | return r
--------------------------------------------------------------------------------
/Selenium/selenium_docker/docker-compose.yml:
--------------------------------------------------------------------------------
1 | version: '3'
2 |
3 | services:
4 | selenium:
5 | image: selenium/standalone-chrome
6 | ports:
7 | - 4444:4444
8 | restart: always
9 |
10 | app:
11 | build:
12 | context: .
13 | volumes:
14 | - ./app:/app
15 | command: "python3 ./main.py"
16 | depends_on:
17 | - selenium
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/110.py:
--------------------------------------------------------------------------------
1 | # adicione ao modulo moeda.py criado nos desafios anteriores, uma função chamada resumo()
2 | # que mostre na tela algumas informações geradas pelas funções que ja temos no modulo criado ate aqui
3 |
4 | from ex110.moeda import *
5 |
6 | n1 = float(input('Digite um Valor:'))
7 | n2 = float(input('Digite o aumento:'))
8 | n3 = float(input('Digite a Redução:'))
9 | resumo(n1,n2,n3,True)
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/general/aula_06/templates/register.html:
--------------------------------------------------------------------------------
1 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 11/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 | def main(ui):
4 | pass
5 |
6 |
7 | if __name__ == "__main__":
8 | import sys
9 | app = QtWidgets.QApplication(sys.argv)
10 | MainWindow = QtWidgets.QMainWindow()
11 | ui = Ui_MainWindow()
12 | ui.setupUi(MainWindow)
13 | MainWindow.show()
14 | main(ui)
15 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 12/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 | def main(ui):
4 | pass
5 |
6 |
7 | if __name__ == "__main__":
8 | import sys
9 | app = QtWidgets.QApplication(sys.argv)
10 | MainWindow = QtWidgets.QMainWindow()
11 | ui = Ui_MainWindow()
12 | ui.setupUi(MainWindow)
13 | MainWindow.show()
14 | main(ui)
15 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 13/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 | def main(ui):
4 | pass
5 |
6 |
7 | if __name__ == "__main__":
8 | import sys
9 | app = QtWidgets.QApplication(sys.argv)
10 | MainWindow = QtWidgets.QMainWindow()
11 | ui = Ui_MainWindow()
12 | ui.setupUi(MainWindow)
13 | MainWindow.show()
14 | main(ui)
15 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 17/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 | def main(ui):
4 | pass
5 |
6 |
7 | if __name__ == "__main__":
8 | import sys
9 | app = QtWidgets.QApplication(sys.argv)
10 | MainWindow = QtWidgets.QMainWindow()
11 | ui = Ui_MainWindow()
12 | ui.setupUi(MainWindow)
13 | MainWindow.show()
14 | main(ui)
15 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 18/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 | def main(ui):
4 | pass
5 |
6 |
7 | if __name__ == "__main__":
8 | import sys
9 | app = QtWidgets.QApplication(sys.argv)
10 | MainWindow = QtWidgets.QMainWindow()
11 | ui = Ui_MainWindow()
12 | ui.setupUi(MainWindow)
13 | MainWindow.show()
14 | main(ui)
15 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex066.py:
--------------------------------------------------------------------------------
1 | # leia varios numeros inteiros e quando for digitado 999 parar, no final mostrar quantidade de numeros digitados e a soma deles, descosiderando o flag (999)
2 | sm = 0
3 | ct = 0
4 | while True:
5 | n = int(input('Digite um valor inteiro:'))
6 | if n == 999:
7 | break
8 | ct += 1
9 | sm += n
10 | print(f'Você Digitou {ct} Numeros, Com Valor {sm} Somados')
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/primeira_classe/main.py:
--------------------------------------------------------------------------------
1 | from pessoa_fisica import PessoaFisica
2 | from pessoa_juridica import PessoaJuridica
3 |
4 | a = PessoaFisica('111.222.333-44', nome='teste', idade=10)
5 |
6 | print(a.getCPF())
7 | print(a.getNome())
8 | print(a.getIdade())
9 |
10 | b = PessoaJuridica('11.222.3333/0001-99', nome='teste', idade=10)
11 |
12 | print(b.getCNPJ())
13 | print(b.getNome())
14 | print(b.getIdade())
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_5_templates/templates/components/notifications.html:
--------------------------------------------------------------------------------
1 |
2 | {% with messages = get_flashed_messages() %}
3 | {% if messages %}
4 |
5 | {% for message in messages %}
6 |
7 | {{ message }}
8 |
9 | {% endfor %}
10 |
11 | {% endif %}
12 | {% endwith %}
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/076.py:
--------------------------------------------------------------------------------
1 | # tenha um tupla unica com nomes de produtos e seus preços na sequencia, no final mostre uma listagem de preços organizando de forma tabular
2 |
3 | produtos = ('Caneta',5.9,'Caderno',12,'Lapis',1,'Apostila',20,'Lapiseira',9,'Quadro',25,'Porta Retrato',30)
4 | print(f'Produto{" "*16}Valor')
5 | for x in range(0,int(len(produtos)),2):
6 | print(f"{produtos[x]:.<20} R${produtos[x+1]:>6.2f}")
7 |
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/primeira_classe/pessoa.py:
--------------------------------------------------------------------------------
1 | class Pessoa:
2 | def __init__(self, nome, idade):
3 | self.nome = nome
4 | self.idade = idade
5 |
6 | def setNome(self, nome):
7 | self.nome = nome
8 |
9 | def setIdade(self, idade):
10 | self.idade = idade
11 |
12 | def getNome(self):
13 | return self.nome
14 |
15 | def getIdade(self):
16 | return self.idade
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 09/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 |
4 | def main(ui):
5 | pass
6 |
7 |
8 | if __name__ == "__main__":
9 | import sys
10 | app = QtWidgets.QApplication(sys.argv)
11 | MainWindow = QtWidgets.QMainWindow()
12 | ui = Ui_MainWindow()
13 | ui.setupUi(MainWindow)
14 | MainWindow.show()
15 | main(ui)
16 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex067.py:
--------------------------------------------------------------------------------
1 | # a tabuada de varios numeros, ume de cada vez para cada valor que o usuario digitar, o programa sera interrompido quando o flag for negativo.
2 | while True:
3 | print('= ='*20)
4 | n = int(input('Digite um Valor Inteiro:'))
5 | if n < 0:
6 | print(f'Valor negativo digitado: {n}, Parando...')
7 | break
8 | for x in range(1,11):
9 | print(f' {n} * {x} = {n*x}')
--------------------------------------------------------------------------------
/SQLite/Pratica/ex000/buscando.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | nome = 'Roberto'
4 | nascimento = '2001'
5 | email = 'roberto@gmail.com'
6 |
7 |
8 | banco = sqlite3.connect('primeiro_banco.db')
9 |
10 | cursor = banco.cursor()
11 |
12 | cursor.execute(f"INSERT INTO pessoas VALUES (NULL,'{nome}','{nascimento}','{email}')")
13 |
14 | banco.commit()
15 |
16 |
17 | cursor.execute("SELECT * FROM pessoas")
18 | print(cursor.fetchall())
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/aula_02/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | from flask_sqlalchemy import SQLAlchemy
3 |
4 | app = Flask(__name__)
5 | app.config['SQLALCHEMY_DATABASE+URI'] = 'sqlite:///app.db'
6 | app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
7 |
8 | db = SQLAlchemy(app)
9 |
10 | @app.route('/')
11 | def index():
12 | return 'Default'
13 |
14 | if __name__ == '__main__':
15 | app.run(debug=True)
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex064.py:
--------------------------------------------------------------------------------
1 | # Leia varios numeros inteiros so parar quando digitar 999, no final mostre quantos numeros foram digitados e qual foi a soma entre eles desconsiderando o flag
2 | cn = 0
3 | n = 0
4 | ct = 0
5 | while cn != 999:
6 | cn = int(input('Digite um numero Inteiro[para parar digite 999]:'))
7 | if cn != 999:
8 | n += cn
9 | ct +=1
10 | print(f' A soma resultou: {n} com {ct} numeros')
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex040.py:
--------------------------------------------------------------------------------
1 | # leia duas notas e faça media aritmetica media abaixo de 5 : reprovado, entre 5 e 6.9 recuperação, acima de 7 aprovado
2 |
3 | n1 = float(input('Digite sua nota do primeiro Semestre:'))
4 | n2 = float(input('Digite sua nota do segundo Semestre:'))
5 | m = (n1+n2) / 2
6 | if m < 5:
7 | print('Reprovado')
8 | elif 5 <= m <= 6.9:
9 | print('Recuperação')
10 | else:
11 | print('Aprovado')
12 |
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_5_templates/templates/base.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 | Document
7 |
8 |
9 |
10 |
11 | -- NAVBAR --
12 |
13 |
14 | {% block content %}
15 | {% endblock %}
16 |
17 |
18 |
--------------------------------------------------------------------------------
/pirex_help/src/matriz.py:
--------------------------------------------------------------------------------
1 | def gerar_diagonal_matriz():
2 | pass
3 |
4 | def gerar_matriz_triangular():
5 | pass
6 |
7 |
8 | '''
9 | 1 7 3 7 2
10 | 9 2 4 1 6
11 | 4 8 2 3 5
12 | 8 3 5 1 7
13 | 4 6 1 5 9
14 | '''
15 |
16 |
17 | lista_colunas = []
18 | lista_linhas = list(range(0,5))
19 |
20 | for x in lista_linhas:
21 | lista_colunas.append(lista_linhas)
22 |
23 | # 628
24 |
25 | for x in lista_colunas:
26 | print(x)
27 |
--------------------------------------------------------------------------------
/imagem/main.py:
--------------------------------------------------------------------------------
1 | # Instalando Bibliotecas
2 | # pip install pillow
3 |
4 | # Importando Bibliotecas
5 | from PIL import Image
6 | import os
7 |
8 |
9 |
10 | # Lendo Todos Os Arquivos Na Pasta
11 | origem = './jpg/'
12 | for raiz, diretorios, files in os.walk(origem):
13 | arquivos = files
14 |
15 | destino = './webp/'
16 | for arquivo in arquivos:
17 | image = Image.open(f'{origem}{arquivo}')
18 | image.save(f'{destino}{arquivo[:-4]}.webp')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/074.py:
--------------------------------------------------------------------------------
1 | # gerar cinco numeros aleatorio e colocar em uma tupla, apos mostrar os numeros sorteados e tambem o menor e o maior
2 |
3 |
4 | from random import randint
5 | numeros = tuple()
6 | for x in range(0,5):
7 | rand = randint(1,9)
8 | numeros += tuple(str(rand))
9 | print(f' Os numeros escolhidos Foram : {numeros}')
10 | print(f' O Maior Numero é : {max(numeros)}')
11 | print(f' O Menor Numero é : {min(numeros)}')
12 |
--------------------------------------------------------------------------------
/SQLite/Aulas/aula01.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | banco = sqlite3.connect('primeiro_banco.db')
4 |
5 | cursor = banco.cursor()
6 |
7 | #cursor.execute("CREATE TABLE pessoazinhas (ID integer PRIMARY KEY AUTOINCREMENT,nome text, idade integer, email text)")
8 |
9 | cursor.execute("INSERT INTO pessoazinhas VALUES (NULL,'Joao',20,'joao_123@gmail.com')")
10 |
11 | banco.commit()
12 |
13 |
14 | cursor.execute("SELECT * FROM pessoazinhas")
15 | print(cursor.fetchall())
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex051.py:
--------------------------------------------------------------------------------
1 | # leia o primeiro termo e a razão de uma progressão aritmetica, no final mostre os 10 primeiros termos
2 |
3 | pt = int(input('Digite o Primeiro termo da PA:'))
4 | ra = int(input('Digite a Razão da PA:'))
5 | c = 0
6 | ct = ((pt+1)*(ra+1)*100)
7 |
8 | if pt < 0 and ra > 0:
9 | ra = ra *-1
10 | if ct == 0:
11 | ct = 100*-1
12 | for x in range(pt,ct,ra):
13 | if c < 10:
14 | print(x)
15 | c += 1
16 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/111.py:
--------------------------------------------------------------------------------
1 | # crie um pacote chamado utilidadesCeV que tenha dois modulos internos chamados moeda e dado.
2 | # transfira todas as funções utilizadas nos desafios 107 ate o 110 para o primeiro
3 | # pacote e mantenha tudo funcionando
4 |
5 | from ex111.utilidadesCev.moeda import *
6 | from ex111.utilidadesCev.dado import *
7 |
8 | n1 = float(input('Digite um Valor:'))
9 | n2 = float(input('Digite as Porcentagens:'))
10 | resumo(n1,n2,True)
11 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/ex107/moeda.py:
--------------------------------------------------------------------------------
1 | # aumentar(),
2 | # diminuir()
3 | # dobro()
4 | # metade()
5 |
6 | def aumentar(numero,quanto):
7 | resultado = numero + numero * (quanto/100)
8 | return resultado
9 |
10 |
11 | def diminuir(numero,quanto):
12 | resultado = numero - numero * (quanto/100)
13 | return resultado
14 |
15 |
16 | def dobro(numero):
17 | return numero*2
18 |
19 |
20 | def metade(numero):
21 | return numero*0.5
22 |
--------------------------------------------------------------------------------
/SQLite/Pratica/ex001/inserindo.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | banco = sqlite3.connect('banco_dados.db')
4 |
5 | cursor = banco.cursor()
6 |
7 | login = input('Digite Um Nome de Login:')
8 | senha = input('Digite uma senha:')
9 |
10 | cursor.execute(f"INSERT INTO conta VALUES (NULL,'{login}','{senha}')")
11 |
12 | # cursor.execute(f'DELETE from pessoas where nome = "Roberto"')
13 |
14 | # cursor.execute(f'DELETE from pessoas where nome = "Carlos"')
15 |
16 |
17 | banco.commit()
--------------------------------------------------------------------------------
/HackerRank/14.py:
--------------------------------------------------------------------------------
1 | def count_substring(string, sub_string):
2 | string = str(string)
3 | sub_string = str(sub_string)
4 | count = 0
5 | for posi, i in enumerate(string):
6 | if string[posi:posi+len(sub_string)] == sub_string:
7 | count += 1
8 | return count
9 |
10 |
11 | if __name__ == '__main__':
12 | string = input().strip()
13 | sub_string = input().strip()
14 |
15 | count = count_substring(string, sub_string)
16 | print(count)
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Aulas/aula18.py:
--------------------------------------------------------------------------------
1 | pessoas = list()
2 | pessoa = list()
3 | nota = list()
4 | for x in range(0,2):
5 | pessoa.append(str(input('Digite seu nome:')).strip())
6 | nota.append(int(input('Digite Nota 1:')))
7 | nota.append(int(input('Digite Nota 2:')))
8 | pessoa.append(nota[:])
9 | pessoas.append(pessoa[:])
10 | nota.clear()
11 | pessoa.clear()
12 | print(pessoas)
13 | print(pessoas[0])
14 | print(pessoas[0][1])
15 | print(pessoas[0][1][1])
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/077.py:
--------------------------------------------------------------------------------
1 | # tupla com varias palavras, e mostrar quais verbos está dentro de cada um.
2 |
3 | palavras = ('palavras','mostrar','verbos','dentro','cada','melhores','nacional','codigo','escrever','jogar','divertir','python','ler','nascer')
4 | for c in range(0,len(palavras)):
5 | print(f' As vogais da palavra {palavras[c]: <10} São : ',end=' ')
6 | for x in palavras[c]:
7 | if x in 'aeiou':
8 | print(x, end=' ')
9 | print('')
10 |
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/product.py:
--------------------------------------------------------------------------------
1 | # from itertools import product
2 |
3 | # anos = range(2020,2025)
4 | # meses = range(1,13)
5 | # for ano in anos:
6 | # for mes in meses:
7 | # print(f'{ano}-{str(mes).zfill(2)}')
8 |
9 | from itertools import product
10 |
11 | anos = range(2020,2025)
12 | meses = range(1,13)
13 | dias = range(1,31)
14 | for ano, mes, dia in product(anos, meses, dias):
15 | print(f'{ano}-{str(mes).zfill(2)}-{str(dia).zfill(2)}')
16 |
17 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex009.py:
--------------------------------------------------------------------------------
1 | # leia um numero inteira e mostre sua tabuada
2 |
3 | # print('{:=^20}'.format('Teste'))
4 | n1 = int(input('Digite um numero:'))
5 | print('{:=^30}\n {} x 1 = {}\n {} x 2 = {}\n {} x 3 = {}\n {} x 4 = {}\n {} x 5 = {}\n {} x 6 = {}\n {} x 7 = {}\n {} x 8 = {}\n {} x 9 = {}\n {} x 10 = {}\n {:=^30}'.format(f' Tabuada do numero {n1} ',n1,n1*1,n1,n1*2,n1,n1*3,n1,n1*4,n1,n1*5,n1,n1*6,n1,n1*7,n1,n1*8,n1,n1*9,n1,n1*10,f' Tabuada do numero {n1} '))
6 |
7 |
8 |
9 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex023.py:
--------------------------------------------------------------------------------
1 | # leia um numero de 0 a 9999 e mostre na tela cada digito separado, por unidade dezena centena milhar
2 | n1 = int(input('Digite um numero de 0 a 9999:'))
3 | u = n1 // 1 % 10
4 | d = n1 // 10 % 10
5 | c = n1 // 100 % 10
6 | m = n1 // 1000 % 10
7 |
8 | print(f' O numero digitado tem {m} Milhare(s)')
9 | print(f' O numero digitado tem {c} Centena(s)')
10 | print(f' O numero digitado tem {d} Dezena(s)')
11 | print(f' O numero digitado tem {u} Unidade(s)')
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex036.py:
--------------------------------------------------------------------------------
1 | # Receba o valor da casa, salario e em quantos anos e verifique se a prestação mensal excede 30%, caso sim o emprestimo sera negado
2 |
3 | vcasa = float(input('Digite o valor da casa:'))
4 | salario = float(input('Digite o seu salario:'))
5 | anos = int(input('Digite em quantos anos deseja pagar:'))
6 |
7 | prestacao = (vcasa / anos)
8 |
9 | if ((salario * 0.3)*12) >= prestacao:
10 | print('Emprestimo Aceito')
11 | else:
12 | print('Emprestimo Negado')
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex054.py:
--------------------------------------------------------------------------------
1 | # leia o ano de nascimento de sete pessoas mostre quantas são maiores de idade e quantos nao atingiram, maioridade = 21 anos
2 |
3 | from datetime import datetime
4 | anoa = int(datetime.today().year)
5 | sm = 0
6 |
7 | for x in range(0,7):
8 | anod = int(input('Digite o ano de nascimento:'))
9 | idade = anoa - anod
10 | if idade >= 21:
11 | sm += 1
12 | print(f'Dos 7, {sm} São Maiores de idade, e {7-sm} Ainda são menor(es)')
13 |
14 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex063.py:
--------------------------------------------------------------------------------
1 | # receba uma quantidade n de numeros inteiros e mostre na tela os n primeiros elementos de uma sequencia de fibonaci
2 |
3 | nf = int(input('Digite a quantidade de numeros da Sequencia Fibonnaci desejado:'))
4 | cf = 0
5 | n1 = 0
6 | n2 = 1
7 | n3 = n1+n2
8 | while cf != nf:
9 | if cf+1 != nf:
10 | print(n1,end=' -> ')
11 | else:
12 | print(n1,end='')
13 | n1 = n2
14 | n2 = n3
15 | n3 = n1+n2
16 | cf += 1
17 |
18 |
--------------------------------------------------------------------------------
/SQLite/Pratica/ex002/login.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 | banco = sqlite3.connect('banco_dados.db')
3 | cursor = banco.cursor()
4 |
5 | try:
6 | cursor.execute(f"SELECT * from conta WHERE login = '{login}' AND senha = '{senha}'")
7 | except sqlite3.Error as erro:
8 | print(f'Digite a senha ou login Corretamente {erro}')
9 | banco.commit()
10 | resultado = cursor.fetchall()
11 | if len(resultado) != 0:
12 | print(f'Olá {login}, Bem Vindo')
13 | else:
14 | print('Digite a senha ou login corretamente')
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Curso python 3/projeto.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | a = 10 + 10
4 | a = 10 - 10
5 | a = 10 * 10
6 | a = 10 / 10
7 | a = 10 // 10
8 | a = 10 ** 10
9 | a = 10 % 10
10 | a = 10 ** (1/2)
11 |
12 |
13 |
14 | a = 10 // 3
15 | b = 10 % 3
16 | print(a,b)
17 |
18 | '''
19 |
20 | a = input('teste:')
21 | b = input('teste:')
22 | c = input('teste:')
23 | d = input('teste:')
24 | print('valor a : {} valor b : {} valor c: {}, valor d: {}'.format(a,b,c,d))
25 |
26 |
27 |
28 |
29 |
30 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex053.py:
--------------------------------------------------------------------------------
1 | # leia uma frase e verifique se ela é um palindromo, descosiderando os espaços
2 |
3 | f = str(input('Digite uma frase:')).strip()
4 | f = f.split()
5 | f = ''.join(f)
6 | f = f.upper()
7 | sm = 0
8 | for x in range(1,len(f)+1):
9 | xx = (len(f)+1) - x
10 | # print(f[x-1],f[xx-1])
11 | if f[x-1] == f[xx-1]:
12 | sm += 1
13 | if sm == len(f):
14 | print('Está frase é um Palindromo')
15 | else:
16 | print('Está frase não é um Palindromo')
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 07/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 |
3 | def main(ui):
4 |
5 | def teste():
6 | print(ui.texto.text())
7 |
8 | ui.botao.clicked.connect(teste)
9 |
10 | if __name__ == "__main__":
11 | import sys
12 | app = QtWidgets.QApplication(sys.argv)
13 | MainWindow = QtWidgets.QMainWindow()
14 | ui = Ui_MainWindow()
15 | ui.setupUi(MainWindow)
16 | MainWindow.show()
17 | main(ui)
18 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex022.py:
--------------------------------------------------------------------------------
1 | # leia um nome completo e mostre : letra maiusculas, letras miusculas, quantas letras sem espaços, letras tem o primero nome.
2 | nome = input('Digite seu nome completo:')
3 | print(f' O seu nome completo em maiusculo é : {nome.upper()}')
4 | print(f' O seu nome completo em minusculo é : {nome.lower()}')
5 | print(f' O seu nome tem {len(nome.replace(" ",""))} letras sem espaços')
6 | linha = nome.split()
7 | print(f' O seu nome tem {len(linha[0])} Letras no primeiro nome')
8 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Curso python 3/aula07a.py:
--------------------------------------------------------------------------------
1 | # nome = input('Escreva seu nome:')
2 | # print('Prazer en te conhecer {:20}!'.format(nome))
3 | # print(f'Prazer em te conhecer {nome:=^20}!')
4 |
5 | n1 = int(input('Digite um valor:'))
6 | n2 = int(input('Digite outro valor:'))
7 | sm = n1 + n2
8 | sb = n1 - n2
9 | m = n1 * n2
10 | d = n1 / n2
11 | di = n1 // n2
12 | e = n1 ** n2
13 | print(f' A Soma é: {sm}\n A subtração é: {sb}\n a divisão é {d:.3f}\n o produto é {m}\n a Divisão inteira é: {di}\n a portencia é {e}')
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex038.py:
--------------------------------------------------------------------------------
1 | # leia dois numeros inteiros e compare os, mostrando na tela qual é maior ou por ordem digitada o primeiro(segundo) valor é maior ou se sao iguais.
2 | n1 = int(input('Digite um Numero inteiro:'))
3 | n2 = int(input('Digite outro Numero Inteiro:'))
4 |
5 | if n1 > n2:
6 | print(f'O primeiro valor {n1} é maior que o segundo {n2}')
7 | elif n2 > n1:
8 | print(f'O Segundo valor {n2} é maior que o primeiro {n1}')
9 | else:
10 | print(f'Os Numeros {n1} e {n2} são Iguais')
--------------------------------------------------------------------------------
/Flask/Curso de Flask by Julia Rizza/aula04/app/__init__.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | from flask_sqlalchemy import SQLAlchemy
3 | from flask_script import Manager
4 | from flask_migrate import Migrate, MigrateCommand
5 |
6 | app = Flask(__name__)
7 | app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///storage.db'
8 | db = SQLAlchemy(app)
9 |
10 | migrate = Migrate(app, db)
11 |
12 | manager = Manager(app)
13 | manager.add_command('db', MigrateCommand)
14 |
15 |
16 | from app.controllers import default
17 |
18 | # a
19 |
--------------------------------------------------------------------------------
/test/python-tdd-explorando-testes-unitarios by Alura/aula 01/main.py:
--------------------------------------------------------------------------------
1 | from codigo.bytebank import Funcionario
2 |
3 | def teste_idade():
4 | funcionario_teste = Funcionario('Teste', '13/03/2000', 1111)
5 | print(f'Teste = {funcionario_teste.idade()}')
6 |
7 | funcionario_teste1 = Funcionario('Teste', '13/03/1999', 1111)
8 | print(f'Teste = {funcionario_teste1.idade()}')
9 |
10 | funcionario_teste2 = Funcionario('Teste', '01/12/1999', 1111)
11 | print(f'Teste = {funcionario_teste2.idade()}')
12 |
13 | teste_idade()
--------------------------------------------------------------------------------
/web-scraping/Curso Web Scraping com python by walisson silva/exercicios/script_correcao.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 |
4 | banco = sqlite3.connect('banco_dados.db')
5 | cursor = banco.cursor()
6 |
7 |
8 | for x in range(11,20):
9 |
10 | cursor.execute(f'SELECT data FROM transferecias WHERE id = {x}')
11 | resultado = cursor.fetchall()[0][0][:-5]
12 | banco.commit()
13 |
14 | cursor.execute(f"UPDATE transferecias SET data = '{resultado}' WHERE id = '{x}'")
15 | banco.commit()
16 | banco.close()
17 |
18 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex041.py:
--------------------------------------------------------------------------------
1 | # leia o ano de nascimento até 9, Mirim até 14 infantil, até 19 junior, até 20: senior acima master
2 | from datetime import date
3 | anoh = date.today().year
4 | anon = int(input('Digite seu ano de nascimento:'))
5 | idade = anoh - anon
6 | print(f'Idade : {idade}')
7 | if idade <= 9:
8 | print('Mirim')
9 | elif idade <= 14:
10 | print('Infantil')
11 | elif idade <= 19:
12 | print('Junior')
13 | elif idade <= 25:
14 | print('Senior')
15 | else:
16 | print('Master')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/112.py:
--------------------------------------------------------------------------------
1 | # dentro do pacote UtilidadesCeV que criamos no desafio 111 temos um modulo chamado dado, crie uma função chamada
2 | # leiaDinhiro()e que seja capaz de funcionar como a função input(), mas com uma validação de dados para aceitar apenas valores que sejam monetarios
3 | # realizando calculo com ,
4 | #
5 |
6 | from ex112.utilidadesCev.moeda import *
7 | from ex112.utilidadesCev.dado import *
8 |
9 | n1 = leiaDinheiro()
10 | n2 = float(input('Digite as Porcentagens:'))
11 | resumo(n1,n2,True)
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/counter.py:
--------------------------------------------------------------------------------
1 | """
2 | Modulo Collections (Modulo conhecido por alta performance) - Counter
3 |
4 | Counter tem objetivo de receber um conjunto(iteravel) e conta a quantidade de vezes que ocorre o mesmo elemento
5 |
6 | lista = [1,1,1,2,3,3,3,4,5,5,5,1,1,6,6,6,7,7,7,7,8,8,8,9,9,9,1,1,1,1,1]
7 |
8 | contador = Counter(lista)
9 |
10 | print(contador)
11 |
12 | objeto_counte.most_common(qtd) - retorna qtd iterado mais comum
13 | """
14 |
15 | from collections import Counter
16 |
17 |
18 |
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula01/aula01/asgi.py:
--------------------------------------------------------------------------------
1 | """
2 | ASGI config for aula01 project.
3 |
4 | It exposes the ASGI callable as a module-level variable named ``application``.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
8 | """
9 |
10 | import os
11 |
12 | from django.core.asgi import get_asgi_application
13 |
14 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'aula01.settings')
15 |
16 | application = get_asgi_application()
17 |
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula01/aula01/wsgi.py:
--------------------------------------------------------------------------------
1 | """
2 | WSGI config for aula01 project.
3 |
4 | It exposes the WSGI callable as a module-level variable named ``application``.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
8 | """
9 |
10 | import os
11 |
12 | from django.core.wsgi import get_wsgi_application
13 |
14 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'aula01.settings')
15 |
16 | application = get_wsgi_application()
17 |
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula03/todo/todo/asgi.py:
--------------------------------------------------------------------------------
1 | """
2 | ASGI config for todo project.
3 |
4 | It exposes the ASGI callable as a module-level variable named ``application``.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/3.1/howto/deployment/asgi/
8 | """
9 |
10 | import os
11 |
12 | from django.core.asgi import get_asgi_application
13 |
14 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'todo.settings')
15 |
16 | application = get_asgi_application()
17 |
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula03/todo/todo/wsgi.py:
--------------------------------------------------------------------------------
1 | """
2 | WSGI config for todo project.
3 |
4 | It exposes the WSGI callable as a module-level variable named ``application``.
5 |
6 | For more information on this file, see
7 | https://docs.djangoproject.com/en/3.1/howto/deployment/wsgi/
8 | """
9 |
10 | import os
11 |
12 | from django.core.wsgi import get_wsgi_application
13 |
14 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'todo.settings')
15 |
16 | application = get_wsgi_application()
17 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex060.py:
--------------------------------------------------------------------------------
1 | # Leia um numero qualquer e mostre seu fatorial
2 |
3 |
4 | ''' Resolução Utilizando While
5 | final = 0
6 | n = int(input('Digite um Numero Inteiro:'))
7 | sm = 0
8 | rn = n
9 | ni = n
10 | while n != 1:
11 | rn *= (n-1)
12 | n -= 1
13 | sm += 1
14 | print(f' {ni}! = {rn}')
15 |
16 | '''
17 |
18 | # Resolução utilizando for
19 | n = int(input('Digite um Numero Inteiro:'))
20 | sm = 1
21 | for x in range(n,1,-1):
22 | sm *= x
23 | print(f' {n}! = {sm}')
24 |
25 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex028.py:
--------------------------------------------------------------------------------
1 | # gerar numero random entre 0 e 5, pedir um numero ao usuario e verificar se está correto, caso sim venceu senão perdeu.
2 | from random import randint
3 | pc = randint(0,5)
4 | print(f'''
5 | {'_--_'*12}
6 | Vou pensar em um numero entre o e 5... advinhe-o
7 | {'_--_'*12}
8 | ''')
9 |
10 | usuario = int(input('Tentea advinhar o numero que pensei:'))
11 | if usuario == pc:
12 | print('Você acertou')
13 | else:
14 | print(f'Você errou colocando {usuario}, o computador escolheu: {pc}')
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 22/janela.py:
--------------------------------------------------------------------------------
1 | # File: main.py
2 |
3 | import sys
4 | from PySide2.QtUiTools import QUiLoader
5 | from PySide2.QtWidgets import QApplication
6 | from PySide2.QtCore import QFile
7 |
8 | if __name__ == "__main__":
9 | app = QApplication(sys.argv)
10 |
11 | ui_file = QFile("nome_arquivo.ui")
12 | ui_file.open(QFile.ReadOnly)
13 |
14 | loader = QUiLoader()
15 | window = loader.load(ui_file)
16 | ui_file.close()
17 | window.show()
18 |
19 | sys.exit(app.exec_())
20 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex039.py:
--------------------------------------------------------------------------------
1 | # informe o ano de nascimento se ele ainda vai se alistar, se é hora, passou do tempo. e mostar quanto tempo falta ou tempo que passou
2 | from datetime import date
3 | anoa = int(date.today().year)
4 | anon = int(input('Digite seu ano de nascimeto:'))
5 |
6 | if (anoa - anon) == 18:
7 | print('Ano de se alistar')
8 | elif (anoa - anon) < 18:
9 | print(f'Você ainda ira se alistar em {((anoa-anon)-18)*-1} Ano(s)')
10 | else:
11 | print(f'Voce já passou do ano de alistamento em {(anoa-anon)-18} Ano(s)')
12 |
13 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/104.py:
--------------------------------------------------------------------------------
1 | # crie um programa que tenha a função leiaint() que vai funcionar de
2 | # forma semelhante a funcao input do python, so que fazendo a validacao para aceitar apenas um valor numerico inteiro.
3 | def leianint():
4 | while True:
5 | n1 = input('Digite um numero Inteiro:')
6 | if n1.isnumeric():
7 | n1 = int(n1)
8 | break
9 | else:
10 | print('Erro, Por favor Digite um numero Inteiro')
11 | return n1
12 |
13 |
14 | # Programa Principal
15 | leianint()
16 |
--------------------------------------------------------------------------------
/SQLite/Projetos/Cadastrar_Produtos/Readme.md:
--------------------------------------------------------------------------------
1 | # Interface Cadastramento de produtos
2 |
3 |
4 | ## Descrição
5 |
6 | Sistema para cadastrar produtos utilizando PySide2 + Qt5 e banco de dados SQLite.
7 |
8 | ## Funcionalidades
9 |
10 | * Cadastrar Produtos
11 | * Verificar Produtos cadastrados
12 |
13 | ## Instalando Pre Requisitos
14 |
15 | ```
16 | pip install -r requisitos.txt
17 | ```
18 |
19 | ## Executando
20 |
21 | ```
22 | python janela.py
23 | ```
24 |
25 | ## Prints
26 |
27 | 
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/090.py:
--------------------------------------------------------------------------------
1 | # leia o nome e media de um aluno, guardando tambem a situação em um dicionario, no final mostrar o conteudo da estrutura na tela.
2 | aluno = {}
3 | aluno['Nome'] = str(input('Digite seu Nome:'))
4 | aluno['Media'] = float(input('Digite A Media:'))
5 | if aluno['Media'] < 5:
6 | aluno['situacao'] = 'Reprovado'
7 | elif 5 <= aluno['Media'] < 7:
8 | aluno['situacao'] = 'Recuperação'
9 | elif 7 < aluno['Media']:
10 | aluno['situacao'] = 'Aprovado'
11 | print(f'Aluno: {aluno["Nome"]}\nSituação: {aluno["situacao"]}')
12 |
--------------------------------------------------------------------------------
/classrom_py/consumindo_api.py:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 | var_python = '''
5 | https://olinda.bcb.gov.br/olinda/servico/PTAX/versao/v1/odata/CotacaoMoedaPeriodo(moeda=@moeda,dataInicial=@dataInicial,dataFinalCotacao=@dataFinalCotacao)?@moeda={moeda}&@dataInicial={data_inicial}&@dataFinalCotacao={data_final}
6 | '''.format(moeda='USD', data_inicial='01/01/2019', data_final='01/01/2020')
7 |
8 | print(var_python)
9 |
10 | #
11 |
12 | '''
13 | Metodos HTTP:
14 |
15 | GET: Buscar informacoes
16 | POST: Criar informacoes
17 | PUT: Alterar informacoes
18 | DELETE: Deletar informacoes
19 |
20 | '''
--------------------------------------------------------------------------------
/graphql/example_docs/schema.py:
--------------------------------------------------------------------------------
1 | import typing
2 | import strawberry
3 |
4 |
5 | @strawberry.type
6 | class Book:
7 | title: str
8 | author: str
9 |
10 |
11 | @strawberry.type
12 | class Query:
13 | books: typing.List[Book]
14 |
15 | def get_books():
16 | return [
17 | Book(
18 | title="The Great Gatsby",
19 | author="F. Scott Fitzgerald",
20 | ),
21 | ]
22 |
23 | @strawberry.type
24 | class Query:
25 | books: typing.List[Book] = strawberry.field(resolver=get_books)
26 |
27 |
28 | schema = strawberry.Schema(query=Query)
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/default_dict.py:
--------------------------------------------------------------------------------
1 | """
2 | Modulo Collections (Modulo conhecido por alta performance) - Default Dict
3 |
4 |
5 | > Ao utilizar o Default dict se passa um valor padrão, que quando não for atribuído valor, ele puxara automaticamente o padrão, e quando ele for
6 | referenciado antes de criado ele cria e passa o valor como default
7 | """
8 |
9 | from collections import defaultdict
10 |
11 | dicionario = defaultdict(lambda: 0)
12 |
13 | dicionario['teste'] = 'algum'
14 | print(dicionario)
15 | print(dicionario['ola'])
16 | print(dicionario)
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/raise.py:
--------------------------------------------------------------------------------
1 | '''
2 | Levantando Erros com Raise
3 |
4 | raise -> Lança um erro
5 |
6 | Utilizado em geral para gerar mensagens de erro personalizadas
7 |
8 | ex:
9 |
10 | raise TipoDoErro('Mensagem de erro')
11 |
12 | '''
13 |
14 |
15 | def colore(texto : str, cor : str):
16 | if type(texto) is not str:
17 | raise TypeError('O texto precisa ser uma string')
18 | if type(cor) is not str:
19 | raise TypeError('A Cor precisa ser uma string')
20 | print(f'o texto {texto} está com a cor {cor}')
21 |
22 | colore('kiler', 7)
23 |
--------------------------------------------------------------------------------
/graphql/example_docs/test_request.py:
--------------------------------------------------------------------------------
1 | # we have imported the requests module
2 | import requests
3 | import json
4 | # defined a URL variable that we will be
5 | # using to send GET or POST requests to the API
6 | url = "http://0.0.0.0:8000/graphql"
7 |
8 | body = """
9 | {
10 | books(title: "The Great Gatsby") {
11 | title
12 | author
13 | }
14 | }
15 | """
16 |
17 | response = requests.post(url=url, json={"query": body})
18 | print("response status code: ", response.status_code)
19 | if response.status_code == 200:
20 | print("response : ", json.loads(response.content))
--------------------------------------------------------------------------------
/urionlinejudge-python/1044.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Leia 2 valores inteiros (A e B). Após, o programa deve mostrar uma mensagem "Sao Multiplos" ou "Nao sao Multiplos", indicando se os valores lidos são múltiplos entre si.
4 | Entrada
5 |
6 | A entrada contém valores inteiros.
7 | Saída
8 |
9 | A saída deve conter uma das mensagens conforme descrito acima.
10 |
11 | '''
12 |
13 | linha = input().split(' ')
14 | linha = list(map(float,linha))
15 | A,B = linha
16 |
17 | if (A % B) == 0 or (B % A) == 0 :
18 | print('Sao Multiplos')
19 | else:
20 | print('Nao sao Multiplos')
--------------------------------------------------------------------------------
/web-scraping/requests/user_agent.py:
--------------------------------------------------------------------------------
1 | # do webscraping with requests at websites that are user-side rendering
2 | import requests
3 | from requests_html import HTMLSession
4 |
5 |
6 | url = 'https://www.kabum.com.br/'
7 | headers = {'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_10_1) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.95 Safari/537.36'}
8 |
9 | # response = requests.get(url, headers=headers)
10 |
11 | with HTMLSession() as session:
12 | response = session.get(url, headers=headers, timeout=10)
13 | response.html.render()
14 | print(response.html.html)
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex035.py:
--------------------------------------------------------------------------------
1 | # leia o comprimento de 3 retas e verifique se podem formar um triangulo ou não
2 | r1 = float(input('Digite uma reta do triangulo:'))
3 | r2 = float(input('Digite uma reta do triangulo:'))
4 | r3 = float(input('Digite uma reta do triangulo:'))
5 | lista = [r1,r2,r3]
6 | lista.sort()
7 | n1,n2,n3 = lista
8 | if (((n2-n3) < n1 < (n2 + n3)) and ((n1-n3) < n2 < (n1+n3)) and ((n1-n2) < n3 < (n1+n2))):
9 | print('Pode se formar um triangulo com essas medidas')
10 | else:
11 | print('Não é possivel formar um triangulo com essas medidas')
--------------------------------------------------------------------------------
/sistema/testes.py:
--------------------------------------------------------------------------------
1 | import os
2 |
3 | steam = '66054934'
4 | link = f'https://steamidfinder.com/lookup/[U%3A1%3A{steam}]/'
5 | path = "C:/Program Files (x86)/Steam/userdata"
6 | cfg = f'{path}/{steam}/730/local/cfg/config.cfg'
7 | pastas = []
8 |
9 | for raiz, diretorios, arquivos in os.walk(path):
10 | if len(diretorios) != 0:
11 | pastas.append(diretorios)
12 |
13 | pastas = pastas[0]
14 |
15 | for pospasta, pasta in enumerate(pastas):
16 | if pasta.isnumeric():
17 | pass
18 | else:
19 | pastas.pop(pospasta)
20 |
21 |
22 |
23 | print(pastas)
24 | print(link)
25 | print(cfg)
--------------------------------------------------------------------------------
/tkinter/tk_poo.py:
--------------------------------------------------------------------------------
1 | import tkinter as tk
2 |
3 | class Application(tk.Tk):
4 | def __init__(self):
5 | tk.Tk.__init__(self)
6 | self.geometry('500x500')
7 | self.title('Your first App')
8 | first_label = tk.Label(self, text = "I'm a cool App!!", font=10)
9 | first_label.pack(pady= 2, padx = 2)
10 |
11 | button_explore = tk.Button(self,
12 | text = "Browse Files",
13 | command = self.destroy)
14 |
15 | button_explore.pack(pady= 2, padx = 2)
16 | app = Application()
17 | app.mainloop()
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 10/interface.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | MainWindow
4 |
5 |
6 |
7 | 0
8 | 0
9 | 320
10 | 240
11 |
12 |
13 |
14 | MainWindow
15 |
16 |
17 |
18 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 10/untitled.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | MainWindow
4 |
5 |
6 |
7 | 0
8 | 0
9 | 320
10 | 240
11 |
12 |
13 |
14 | MainWindow
15 |
16 |
17 |
18 |
19 |
20 |
21 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex065.py:
--------------------------------------------------------------------------------
1 | # Leia varios numeros inteiros pelo teclado, no final da execução, mostre a media e qual foi o maior e o menor. o programa deve perguntar ao usuario se ele quer continuar ou não a digitar valores
2 | flag = 'a'
3 | sm = 0
4 | ct = 0
5 | ls = []
6 | while flag not in 'Ss':
7 | print('= ='*15)
8 | n = int(input('Digite um numero:'))
9 | flag = str(input('Deseja parar? [S/N]:'))
10 | sm += n
11 | ct += 1
12 | ls.append(n)
13 | print(f'A media dos Numeros Digitados é: {sm/ct}\nO maior numero digitado é: {max(ls)}\nO menor Numero Digitado: {min(ls)}')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/107.py:
--------------------------------------------------------------------------------
1 | # crie um modulo chamado moeda.py que tenha as funções incorporadas
2 | # aumentar(),
3 | # diminuir()
4 | # dobro()
5 | # metade()
6 | # faça tambem um programa que importe esse modulo e use algumas dessas funções
7 | #
8 |
9 | from ex107.moeda import *
10 |
11 |
12 | n1 = int(input('Digite um numero:'))
13 | print(f'O dobro de R${n1} é R${dobro(n1)}')
14 | print(f'A metade de R${n1} é R${metade(n1)}')
15 | print(f'O numero R${n1} com {10}% de aumento fica: R${aumentar(n1,10)}')
16 | print(f'O numero R${n1} com {10}% de redução fica: R${diminuir(n1,10)}')
17 |
18 |
--------------------------------------------------------------------------------
/Selenium/Curso Selenium com python by Eduardo Mendes/aula_01/README.md:
--------------------------------------------------------------------------------
1 | # Anotações Selenium Com Python
2 | ## Configuração de Ambiente Windows
3 | * Python
4 | 3.8.2
5 | * Editor
6 | Atom
7 | Vscode
8 | * Navegadores
9 | Firefox
10 | Google Chrome
11 | * Webdrive
12 | GeckDriver
13 | ChromeDriver
14 | ## Instalação Chocolatey (gerenciador Pacotes Windows)
15 | * Link: https://chocolatey.org/
16 | * Pacotes: https://community.chocolatey.org/packages
17 | * Como usar : https://chocolatey.org/install
18 | ## Comandos
19 | ```choco install nome_pacote```
20 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex021.py:
--------------------------------------------------------------------------------
1 | # abre e reproduza um arquivo mp3
2 | # import playsound
3 | # arquivo = '/home/lucas/Poemas/Audio-poemas/Sentido_da_vida/sentidodavida.mp3'
4 | # playsound.playsound(arquivo)
5 |
6 | # import subprocess
7 |
8 | # import vlc
9 | # p = vlc.MediaPlayer("/home/lucas/Poemas/Audio-poemas/Sentido_da_vida/sentidodavida.mp3")
10 | # p.play()
11 |
12 |
13 | import playsound
14 | arquivo = '/home/lucas/Poemas/Audio-poemas/Sentido_da_vida/sentidodavida.mp3'
15 | playsound.playsound('/home/lucas/Poemas/Audio-poemas/Sentido_da_vida/sentidodavida_completo.mp3',True)
16 |
17 |
--------------------------------------------------------------------------------
/SQLite/Pratica/ex001/login.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | banco = sqlite3.connect('banco_dados.db')
4 |
5 | cursor = banco.cursor()
6 |
7 |
8 | login = input('Digite Um Nome de Login:')
9 | senha = input('Digite uma senha:')
10 |
11 | try:
12 | cursor.execute(f"SELECT * from conta WHERE login = '{login}' AND senha = '{senha}'")
13 | except sqlite3.Error as erro:
14 | print(f'Digite a senha ou login Corretamente {erro}')
15 |
16 | banco.commit()
17 | resultado = cursor.fetchall()
18 | if len(resultado) != 0:
19 | print(f'Olá {login}, Bem Vindo')
20 | else:
21 | print('Digite a senha ou login corretamente')
--------------------------------------------------------------------------------
/urionlinejudge-python/1007.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 | Leia quatro valores inteiros A, B, C e D. A seguir, calcule e mostre a diferença do produto de A e B pelo produto de C e D segundo a fórmula: DIFERENCA = (A * B - C * D).
4 | Entrada
5 |
6 | O arquivo de entrada contém 4 valores inteiros.
7 | Saída
8 |
9 | Imprima a mensagem DIFERENCA com todas as letras maiúsculas, conforme exemplo abaixo, com um espaço em branco antes e depois da igualdade.
10 |
11 | '''
12 |
13 | A = int(input())
14 | B = int(input())
15 | C = int(input())
16 | D = int(input())
17 |
18 | DIFERENCA = (A * B - C * D)
19 |
20 | print('DIFERENCA =',DIFERENCA)
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/general/aula_06/templates/users.html:
--------------------------------------------------------------------------------
1 |
2 |
10 | {% for user in users %}
11 |
16 | {% endfor %}
17 |
18 |
19 |
20 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex062.py:
--------------------------------------------------------------------------------
1 | # Melhore o desafio 61 pedindo para o usuario quantos termos a mais ele quer mostrar
2 |
3 | pt = int(input('Digite o valor do primeiro Termo:'))
4 | ra = int(input('Digite o valor da Razão:'))
5 | nt = 1
6 | rt = pt
7 | pa = 10
8 | ntt = nt
9 | while pa != 0:
10 | nt = 0
11 | print('= =' * 30)
12 | while nt != pa:
13 | print(f' O termo N-{ntt:2} é igual á {rt:3}')
14 | rt += ra
15 | nt += 1
16 | ntt += 1
17 | pa = int(input('Você gostaria de continuar? Se sim Digite a quantidade de Termos para continuarmos, caso não digite [0]:'))
18 | print('Fim')
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Curso python 3/aula09a.py:
--------------------------------------------------------------------------------
1 | frase = 'curso em video python'
2 | print(len(frase))
3 | print(frase.count('o'))
4 | print(frase.find('py'))
5 | print('em' in frase)
6 | print(frase.replace('o','u'))
7 | print(frase.upper())
8 | print(frase.lower())
9 | print(frase.capitalize())
10 | print(frase.title())
11 | print(frase.strip())
12 | print(frase.rstrip())
13 | print(frase.lstrip())
14 | print(frase.split())
15 | linha = frase.split()
16 | linha2 = ''.join(linha)
17 | linha3 = frase.replace(' ','')
18 | print(len(linha))
19 | print(linha[len(linha)-1])
20 | print(linha2)
21 | print(linha3)
22 |
23 |
24 |
25 |
26 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/108.py:
--------------------------------------------------------------------------------
1 | # adapte o codigo do desafio 107, criando uma função adicional chamada moeda(), que consiga mostrar os valores como um valor monetario formatado
2 | #
3 |
4 | from ex108.moeda import *
5 |
6 | n1 = float(input('Digite um Valor:'))
7 | n2 = float(input('Digite as Porcentagens:'))
8 | print('-*'*30)
9 | print(f'O dobro de {moeda(n1)} é {moeda(dobro(n1))}')
10 | print(f'A metade de {moeda(n1)} é {moeda(metade(n1))}')
11 | print(f'O numero {moeda(n1)} com {n2}% de aumento fica: {moeda(aumentar(n1,n2))}')
12 | print(f'O numero {moeda(n1)} com {n2}% de redução fica: {moeda(diminuir(n1,n2))}')
13 | print('-*'*30)
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex043.py:
--------------------------------------------------------------------------------
1 | # Leia o Peso e altura e calcule o IMC e mostre seu status abaixo de 18.5: abaixo do peso, entre 18.5 e 25:peso ideal. 30 até 40: obesidade, acima de 40: obesidade morbida
2 | peso = float(input('Digite seu Peso(Em kilos):'))
3 | altura = float(input('Digite sua Altura(Em Metros):'))
4 | imc = peso / (altura ** 2)
5 | if imc < 18.5:
6 | print('Abaixo do peso')
7 | elif 18.5 <= imc <= 25:
8 | print('Peso Ideal')
9 | elif 25 < imc <= 29.9:
10 | print('Sobrepeso')
11 | elif 30 <= imc <= 40:
12 | print('Obesidade')
13 | else:
14 | print('Obesidade Morbida')
15 | print(f'Com o imc: {imc:.2f}')
16 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1004.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 |
4 | Leia dois valores inteiros. A seguir, calcule o produto entre estes dois valores e atribua esta operação à variável PROD. A seguir mostre a variável PROD com mensagem correspondente.
5 | Entrada
6 |
7 | O arquivo de entrada contém 2 valores inteiros.
8 | Saída
9 |
10 | Imprima a variável PROD conforme exemplo abaixo, com um espaço em branco antes e depois da igualdade. Não esqueça de imprimir o fim de linha após o produto, caso contrário seu programa apresentará a mensagem: “Presentation Error”.
11 |
12 | '''
13 | num1 = int(input())
14 | num2 = int(input())
15 | prod = (num1 * num2)
16 | print('PROD = ',prod)
--------------------------------------------------------------------------------
/urionlinejudge-python/1065.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Faça um programa que leia 5 valores inteiros. Conte quantos destes valores digitados são pares e mostre esta informação.
4 | Entrada
5 |
6 | O arquivo de entrada contém 5 valores inteiros quaisquer.
7 | Saída
8 |
9 | Imprima a mensagem conforme o exemplo fornecido, indicando a quantidade de valores pares lidos.
10 |
11 | '''
12 |
13 | pares = 0
14 | n1 = input()
15 | n2 = input()
16 | n3 = input()
17 | n4 = input()
18 | n5 = input()
19 |
20 | lista = [n1,n2,n3,n4,n5]
21 | lista1 = list(map(int,lista))
22 | for x in lista1:
23 | if x % 2 == 0:
24 | pares += 1
25 | print('%.0f valores pares' %pares)
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/ordered_dict.py:
--------------------------------------------------------------------------------
1 | """
2 | Modulo Collections (Modulo conhecido por alta performance) - Ordered Dict
3 |
4 |
5 | > Um dicionario que tem a ordem de inserção garantida
6 |
7 | # Demonstrando Diferença entre Dict e Ordered Dict
8 |
9 | from collections import OrderedDict
10 |
11 | dict1 = {'a':1,'b':2}
12 | dict2 = {'b':2,'a':1}
13 | print(dict1 == dict2)
14 | # True
15 |
16 | odict1 = OrderedDict({'a':1,'b':2})
17 | odict2 = OrderedDict({'b':2,'a':1})
18 |
19 | print(odict1 == odict2)
20 | # False
21 |
22 |
23 | # Ordered dict retornou falso pois os elementos não são iguais pela ordem
24 | """
25 |
26 |
27 |
28 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1046.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Leia a hora inicial e a hora final de um jogo. A seguir calcule a duração do jogo,
5 | sabendo que o mesmo pode começar em um dia e terminar em outro, tendo uma duração mínima de 1 hora e máxima de 24 horas.
6 | Entrada
7 |
8 | A entrada contém dois valores inteiros representando a hora de início e a hora de fim do jogo.
9 | Saída
10 |
11 | Apresente a duração do jogo conforme exemplo abaixo.
12 |
13 | '''
14 |
15 | linha = input().split(' ')
16 | linha = list(map(int,linha))
17 | HI,HF = linha
18 |
19 | if HF <= HI :
20 | HF = HF + 24
21 | duracao = HF - HI
22 | print('O JOGO DUROU %.0f HORA(S)' %duracao)
--------------------------------------------------------------------------------
/SQLite/Projetos/Tela_Login/Readme.md:
--------------------------------------------------------------------------------
1 | # Interface Login Simples
2 |
3 |
4 | ## Descrição
5 |
6 | Sistema simples de login com PySide2 + Qt5 e banco de dados SQLite.
7 |
8 | ## Funcionalidades
9 |
10 | * Login
11 | * Cadastrar Usuario
12 | * Redefinir Senha
13 | * Deletar Usuario
14 |
15 | ## Instalando Pre Requisitos
16 |
17 | ```
18 | pip install -r requisitos.txt
19 | ```
20 |
21 | ## Executando
22 |
23 | ```
24 | python janela.py
25 | ```
26 |
27 | ## Prints
28 |
29 | 
30 | 
31 | 
32 | 
--------------------------------------------------------------------------------
/pirex_help/src/email_academico.py:
--------------------------------------------------------------------------------
1 | def criar_emails_acadamicos(alunos):
2 | lista_email_alunos = []
3 | alunos_clean = list(map(str.strip, alunos.lower().split(',')))
4 | for aluno in alunos_clean:
5 | nome_aluno_separado = aluno.split()
6 | lista_nome_limpo = []
7 | for nome in nome_aluno_separado:
8 | if not nome in ['de', 'da', 'das', 'do', 'dos']:
9 | lista_nome_limpo.append(nome)
10 | email = f"{'.'.join(lista_nome_limpo)}@academico.ufgd.edu.br"
11 | tupla_nome_email = (nome_aluno_separado[0], email)
12 | lista_email_alunos.append(tupla_nome_email)
13 | return lista_email_alunos
14 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1014.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Calcule o consumo médio de um automóvel sendo fornecidos a distância total percorrida (em Km) e o total de combustível gasto (em litros).
5 | Entrada
6 |
7 | O arquivo de entrada contém dois valores: um valor inteiro X representando a distância total percorrida (em Km),
8 | e um valor real Y representando o total de combustível gasto, com um dígito após o ponto decimal.
9 | Saída
10 |
11 | Apresente o valor que representa o consumo médio do automóvel com 3 casas após a vírgula, seguido da mensagem "km/l".
12 |
13 | '''
14 |
15 | km = int(input())
16 | lt = float(input())
17 | kml = (km/lt)
18 | print('%.3f km/l'%kml)
19 |
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/erros_mais_comuns.py:
--------------------------------------------------------------------------------
1 | '''
2 | -> Erros mais comuns em Python
3 |
4 | Importante saber o que significa cada erro e como resolvelos:
5 |
6 | Erros Mais Comuns:
7 |
8 | 1. SyntaxeError -> Ocorre quando o python não reconhece um trecho do código
9 |
10 | # Exmplos SyntaxError
11 |
12 | 1.1)
13 |
14 | def funcao:
15 | print('teste')
16 |
17 | 1.2)
18 |
19 | def = 1
20 |
21 | 1.3)
22 |
23 | return
24 |
25 | 2. NameError -> Ocorre quando nome de variavel ou função não definida é chamada
26 |
27 | Exemplos NameError
28 |
29 | 2.1)
30 | print(teste)
31 |
32 | 2.2)
33 | teste()
34 | '''
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
--------------------------------------------------------------------------------
/imagem/README.md:
--------------------------------------------------------------------------------
1 | # Pasta Para Estudo de Manipulação de imagens com Python
2 |
3 | ## Biblioteca pillow
4 |
5 | ### Importando
6 |
7 | ```from PIL import Image```
8 |
9 | ### Usabilidade
10 |
11 | #### Abrindo
12 |
13 | ```imagem = Image.open('caminho_arquivo.extensão')```
14 |
15 | #### Salvando
16 |
17 | ```imagem.save('caminho_arquivo.extensão') ```
18 |
19 | ## Bibliografia
20 |
21 | > * [Documentação Pillow](https://python-pillow.org/)
22 | > * [Tipos de Imagens Suportadas](https://pillow.readthedocs.io/en/stable/handbook/image-file-formats.html)
23 | > * [Mini Tutorial EN](https://www.developer.com/languages/displaying-and-converting-images-with-python/)
24 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1003.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 | Leia dois valores inteiros, no caso para variáveis A e B. A seguir, calcule a soma entre elas e atribua à variável SOMA. A seguir escrever o valor desta variável.
4 | Entrada
5 |
6 | O arquivo de entrada contém 2 valores inteiros.
7 | Saída
8 |
9 | Imprima a variável SOMA com todas as letras maiúsculas, com um espaço em branco antes e depois da igualdade seguido pelo valor correspondente à soma de A e B.
10 | Como todos os problemas, não esqueça de imprimir o fim de linha após o resultado, caso contrário, você receberá "Presentation Error".
11 |
12 | '''
13 |
14 | A=int(input())
15 | B=int(input())
16 | SOMA=A+B
17 | print('SOMA = ',SOMA)
18 |
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex033.py:
--------------------------------------------------------------------------------
1 | # leia 3 numeros e verifique o maior e o menor
2 | n1 = float(input('Digite um numero:'))
3 | n2 = float(input('Digite um numero:'))
4 | n3 = float(input('Digite um numero:'))
5 | p1, p2, p3 = 0, 0, 0
6 |
7 | if n1 > (n3 and n2):
8 | p1 = n1
9 | if n2 < n3:
10 | p2 = n2
11 | else:
12 | p2 = n3
13 | elif n2 > (n1 and n3):
14 | p1 = n2
15 | if n1 < n3:
16 | p2 = n1
17 | else:
18 | p2 = n3
19 | else:
20 | p1 = n3
21 | if n1 < n2:
22 | p2 = n1
23 | else:
24 | p2 = n2
25 | print(f'O Maior Valor digitado foi : {p1}\nO Menor valor digitado foi: {p2}')
26 |
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/aula02/computador.py:
--------------------------------------------------------------------------------
1 | class Computador:
2 | def __init__(self, marca, memoria_ram, placa_de_video):
3 | self.marca = marca
4 | self.memoria_ram = memoria_ram
5 | self.placa_de_video = placa_de_video
6 |
7 |
8 | def Ligar(self):
9 | print('Estou Ligando')
10 |
11 |
12 | def Desligar(self):
13 | print('Estou Desligando')
14 |
15 | def ExibirInformacoesDesteComputador(self):
16 | print(self.marca, self.memoria_ram, self.placa_de_video)
17 |
18 |
19 | computador1 = Computador('Intel','4gb','Intel')
20 | computador1.Ligar()
21 | computador1.Desligar()
22 | computador1.ExibirInformacoesDesteComputador()
23 |
--------------------------------------------------------------------------------
/fast_api/Background/app.py:
--------------------------------------------------------------------------------
1 | from time import sleep
2 | import logging
3 |
4 | from fastapi import FastAPI, BackgroundTasks
5 |
6 | logging.basicConfig(level=logging.DEBUG)
7 |
8 | app = FastAPI()
9 |
10 | def send_email(message):
11 | sleep(5)
12 | print(message)
13 |
14 | @app.get("/async")
15 | async def index(background_tasks: BackgroundTasks):
16 | # send_email()
17 | background_tasks.add_task(send_email, 'Test')
18 | background_tasks.add_task(send_email, 'Test1')
19 | return {'result': 'success'}, 200
20 |
21 | @app.get("/sync")
22 | async def index():
23 | send_email('test')
24 | # background_tasks.add_task(send_email, 'Test')
25 | return {'result': 'success'}, 200
26 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 06/janela.py:
--------------------------------------------------------------------------------
1 | from interface import Ui_MainWindow
2 | from PyQt5 import QtCore, QtGui, QtWidgets
3 |
4 |
5 | def saudacao():
6 | print('Olá, Mundo')
7 |
8 |
9 | class MainWindow(QtWidgets.QMainWindow, Ui_MainWindow):
10 | def __init__(self):
11 | super(MainWindow, self).__init__()
12 | self.setupUi(self)
13 |
14 | # def saudacao():
15 | # print('Olá, Mundo')
16 |
17 | self.botao.clicked.connect(saudacao)
18 |
19 |
20 | if __name__ == "__main__":
21 | import sys
22 | app = QtWidgets.QApplication(sys.argv)
23 | ui = MainWindow()
24 | ui.show()
25 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/urionlinejudge-python/1060.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Faça um programa que leia 6 valores. Estes valores serão somente negativos ou positivos (desconsidere os valores nulos).
4 | A seguir, mostre a quantidade de valores positivos digitados.
5 | Entrada
6 |
7 | Seis valores, negativos e/ou positivos.
8 | Saída
9 |
10 | Imprima uma mensagem dizendo quantos valores positivos foram lidos.
11 |
12 | '''
13 |
14 | postivos = 0
15 | n1 = input()
16 | n2 = input()
17 | n3 = input()
18 | n4 = input()
19 | n5 = input()
20 | n6 = input()
21 |
22 | lista = [n1,n2,n3,n4,n5,n6]
23 | lista1 = list(map(float,lista))
24 | for x in lista1:
25 | if x > 0 :
26 | postivos += 1
27 | print('%.0f valores positivos' %postivos)
--------------------------------------------------------------------------------
/urionlinejudge-python/1016.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Dois carros (X e Y) partem em uma mesma direção. O carro X sai com velocidade constante de 60 Km/h e o carro Y sai com velocidade constante de 90 Km/h.
5 |
6 | Em uma hora (60 minutos) o carro Y consegue se distanciar 30 quilômetros do carro X, ou seja, consegue se afastar um quilômetro a cada 2 minutos.
7 |
8 | Leia a distância (em Km) e calcule quanto tempo leva (em minutos) para o carro Y tomar essa distância do outro carro.
9 | Entrada
10 |
11 | O arquivo de entrada contém um número inteiro.
12 | Saída
13 |
14 | Imprima o tempo necessário seguido da mensagem "minutos".
15 |
16 | '''
17 |
18 | dist = int(input())
19 | tempo = dist * 2
20 | print('%.0f minutos'%tempo)
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/109.py:
--------------------------------------------------------------------------------
1 | # modifique as funcoes que foram criadas no desafio 107, para que elas aceitem um parametro a mais, informando se o valor retornado por elas vai ser
2 | # ou nao formatado pela função moeda(), desenvolvida no desafio 108
3 | #
4 |
5 | from ex109.moeda import *
6 |
7 |
8 | n1 = float(input('Digite um Valor:'))
9 | n2 = float(input('Digite as Porcentagens:'))
10 | print('-*'*30)
11 | print(f'O dobro de {moeda(n1)} é {dobro(n1,True)}')
12 | print(f'A metade de {moeda(n1)} é {metade(n1,True)}')
13 | print(f'O numero {moeda(n1)} com {n2}% de aumento fica: {aumentar(n1,n2,True)}')
14 | print(f'O numero {moeda(n1)} com {n2}% de redução fica: {diminuir(n1,n2,True)}')
15 | print('-*'*30)
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/085.py:
--------------------------------------------------------------------------------
1 | # digitar 7 valores numericos e cadastra-los em uma lista unica que mantenha separado os numeros pares e os numeros impares, no final mostre os valores pares e impares de forma crescente
2 | """
3 |
4 | Alternativa
5 |
6 | cria = list()
7 | lista = list()
8 | lista.append(cria[:])
9 | lista.append(cria[:])
10 | """
11 |
12 | lista = [[],[]]
13 |
14 | for x in range(0,7):
15 | valor = int(input(f'Digite um valor {x+1}: '))
16 | if valor % 2 == 0:
17 | lista[0].append(valor)
18 | else:
19 | lista[1].append(valor)
20 | lista[0].sort()
21 | lista[1].sort()
22 | print(f'Os Valores pares São: {lista[0]}')
23 | print(f'Os Valores Impares São: {lista[1]}')
24 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 14/interface.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | MainWindow
4 |
5 |
6 |
7 | 0
8 | 0
9 | 320
10 | 240
11 |
12 |
13 |
14 | MainWindow
15 |
16 |
17 | background-color: rgb(226, 254, 255);
18 |
19 |
20 |
21 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 28/interface.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | MainWindow
4 |
5 |
6 |
7 | 0
8 | 0
9 | 320
10 | 240
11 |
12 |
13 |
14 | MainWindow
15 |
16 |
17 | background-color: rgb(0, 255, 255);
18 |
19 |
20 |
21 |
22 |
23 |
24 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex042.py:
--------------------------------------------------------------------------------
1 | # leia 3 angulos e mostre se pode mostrar um triangulo e qual tipo do triangulo sendo: Equilátero: todos os lados iguais, Isósceles: dois lados igauis, Escaleno: todos os lados diferentes
2 |
3 | n1 = float(input('Digite um Lado do Triangulo:'))
4 | n2 = float(input('Digite um Lado do Triangulo:'))
5 | n3 = float(input('Digite um Lado do Triangulo:'))
6 |
7 | if n1 < n2 + n3 and n2 < n1 + n3 and n3 < n1 + n2:
8 | print('Pode se formar Um Triangulo:',end = ' ' )
9 | if n1 == n2 == n3:
10 | print('Equilatero')
11 | elif n1 == n2 or n1 == n3 or n2 == n3:
12 | print('Isósceles')
13 | else:
14 | print('Escaleno')
15 | print('Não pode se Formar um triangulo')
16 |
--------------------------------------------------------------------------------
/basic_python/aulas_by_geek_university/iterador_customizado.py:
--------------------------------------------------------------------------------
1 | '''
2 | Escrevendo um iterador customizado
3 | '''
4 |
5 |
6 |
7 |
8 | class contador:
9 | def __init__(self, start, end):
10 | self.start = start
11 | self.end = end
12 |
13 | def __iter__(self):
14 | return self
15 |
16 | def __next__(self):
17 | if self.start < self.end:
18 | x = self.start
19 | self.start += 1
20 | return x
21 | raise StopIteration
22 |
23 |
24 | objeto_contador = contador(1, 10)
25 | # it = iter(objeto_contador)
26 | # print(next(it))
27 | # print(next(it))
28 | # print(next(it))
29 | # print(next(it))
30 | # print(next(it))
31 |
32 | for x in contador(1, 10):
33 | print(x)
--------------------------------------------------------------------------------
/web-scraping/Curso Web Scraping com python by walisson silva/Aula 03 - BeatifulSoup/aula03.py:
--------------------------------------------------------------------------------
1 | import requests
2 | from bs4 import BeautifulSoup
3 |
4 | resposta = requests.get('https://g1.globo.com/')
5 |
6 | conteudo = resposta.content
7 |
8 | site = BeautifulSoup(conteudo, 'html.parser')
9 |
10 |
11 | # Html da noticia
12 | noticia = site.find('div',attrs={'class':'feed-post-body'})
13 |
14 |
15 | # Titulo da noticia : a class="feed-post-link
16 | titulo = noticia.find('a',attrs={'class':'feed-post-link'})
17 |
18 | print(titulo.text)
19 |
20 |
21 | # Subtitulo : div class="feed-post-body-resumo">
22 |
23 | subtitulo = noticia.find('div',attrs={'class':'feed-post-body-resumo'})
24 | print(subtitulo.text)
25 |
26 |
27 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1013.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Faça um programa que leia três valores e apresente o maior dos três valores lidos seguido da mensagem “eh o maior”. Utilize a fórmula:
4 |
5 | Obs.: a fórmula apenas calcula o maior entre os dois primeiros (a e b). Um segundo passo, portanto é necessário para chegar no resultado esperado.
6 | Entrada
7 |
8 | O arquivo de entrada contém três valores inteiros.
9 | Saída
10 |
11 | Imprima o maior dos três valores seguido por um espaço e a mensagem "eh o maior".
12 |
13 | '''
14 |
15 | linha = input().split(" ")
16 | a,b,c = linha
17 | maior = (int(a) + int(b) + abs(int(a) - int(b))) / 2
18 | resultado = (int(maior) + int(c) + abs(int(maior) - int(c)))/2
19 | print('%.0f eh o maior'%resultado)
20 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex058.py:
--------------------------------------------------------------------------------
1 | # Computador pensar em um numero entre 0 e 10, porem o jogador vai tentando advinhar até acertar, e no final mostrar quantos palpiter foram necessarios
2 |
3 | from random import randint
4 | vpc = int(randint(0,10))
5 | vus = -1
6 | sm = 0
7 | while not vpc == vus:
8 | print('= ='*10)
9 | vus = int(input('Tente Advinhar o Numero Que o computador está pensando:'))
10 | if vpc != vus:
11 | if vpc > vus:
12 | print(f'{vus} não é o numero que pensei, Tente um Maior ;)!!')
13 | else:
14 | print(f'{vus} não é o numero que pensei, Tente um Menor!!')
15 |
16 | sm += 1
17 | print(f'Parabens {vus} é o Numero que pensei, Você precisou apenas de {sm} Tentativas')
18 |
19 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/099.py:
--------------------------------------------------------------------------------
1 | # uma funcao que receba varios parametros com valores inteiros, seu programa tem que analisar todos os valores e dizer qual deles é o maior
2 | from time import sleep
3 | def maior(*numeros):
4 | print('*-'*25)
5 | print('Analizando os valores......')
6 | print('Os Numero do grupo são: ', end='')
7 | for x in numeros:
8 | sleep(.5)
9 | print(f'{x} ',end='')
10 | print(f' Ao todo foram informados {len(numeros)} Numeros')
11 | if len(numeros) != 0:
12 | print(f'O maior valor do grupo é: {max(numeros)}')
13 | else:
14 | print('O maior valor do grupo é: 0')
15 |
16 |
17 | maior(2, 9, 4, 5, 7, 1)
18 | maior(4, 7, 0)
19 | maior(1, 2)
20 | maior(6)
21 | maior()
22 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1019.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Leia um valor inteiro, que é o tempo de duração em segundos de um determinado evento em uma fábrica, e informe-o expresso no formato horas:minutos:segundos.
4 | Entrada
5 |
6 | O arquivo de entrada contém um valor inteiro N.
7 | Saída
8 |
9 | Imprima o tempo lido no arquivo de entrada (segundos), convertido para horas:minutos:segundos, conforme exemplo fornecido.
10 |
11 | '''
12 |
13 | segundos = (int(input()))
14 | minutos = 0
15 | hora = 0
16 | while (segundos > 59) :
17 | segundos = segundos - 60
18 | minutos = minutos + 1
19 |
20 | while (minutos > 59) :
21 | minutos = minutos - 60
22 | hora = hora + 1
23 |
24 |
25 |
26 | print('%s:%s:%s' % (hora,minutos,segundos))
27 |
28 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 14/janela.py:
--------------------------------------------------------------------------------
1 | from interface import *
2 | import time
3 | import SysTrayIcon
4 |
5 |
6 | def trayWaiting():
7 |
8 | while SysTrayIcon.SysTrayIcon.WINDOW == True:
9 | time.sleep(3)
10 | else:
11 | SysTrayIcon.SysTrayIcon.WINDOW == True
12 | MainWindow.show()
13 | sys.exit(app.exec_())
14 |
15 |
16 |
17 | def main(ui):
18 | pass
19 |
20 |
21 | if __name__ == "__main__":
22 | import sys
23 | app = QtWidgets.QApplication(sys.argv)
24 | app.aboutToQuit.connect(trayWaiting)
25 | MainWindow = QtWidgets.QMainWindow()
26 | ui = Ui_MainWindow()
27 | ui.setupUi(MainWindow)
28 | MainWindow.show()
29 | main(ui)
30 | sys.exit(app.exec_())
--------------------------------------------------------------------------------
/Mundo 1 by Curso em Video/Exercicios Python 3/ex020.py:
--------------------------------------------------------------------------------
1 | # leia quatro nomes e mostre em uma ordem
2 |
3 | from random import shuffle
4 |
5 |
6 | n1 = input('Digite um nome:')
7 | n2 = input('Digite um nome:')
8 | n3 = input('Digite um nome:')
9 | n4 = input('Digite um nome:')
10 | lista = [n1,n2,n3,n4]
11 | shuffle(lista)
12 | number = 0
13 | for x in lista:
14 | number += 1
15 | print(f' O Nome do aluno {number}: {x}')
16 |
17 | '''
18 | resultado = list()
19 | number = 0
20 |
21 | for x in range(0,4):
22 | random = randint(0,len(lista))
23 | resultado.append(lista[random-1])
24 | del lista[random-1]
25 |
26 |
27 | for x in resultado:
28 | number += 1
29 | print(f' O Nome do aluno {number}: {x}')
30 | '''
31 |
32 |
33 |
34 |
35 |
36 |
37 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex037.py:
--------------------------------------------------------------------------------
1 | # Leia um numero inteiro qualquer e peça para o usuario qual base de conversão sendo 1 para binario - 2 octal - 3 para hexadecimal
2 |
3 | numero = int(input('Digite um numero:'))
4 | choice = int(input('''
5 | Digite A base de conversão que gostaria sendo:
6 | 1 - Binario
7 | 2 - Octal
8 | 3 - Hexadecimal
9 | Digite:'''))
10 |
11 | dic = {1:'Binario',2:'Octal',3:'Hexadecimal'}
12 | if choice == 1:
13 | base = 1
14 | resultado = bin(numero)[2:]
15 | elif choice == 2:
16 | base = 2
17 | resultado = oct(numero)[2:]
18 | elif choice == 3:
19 | base = 3
20 | resultado = hex(numero)[2:]
21 | else:
22 | print('Digite um numero valido')
23 | exit()
24 | print(f'O seu numero {numero} na base {dic[base]} é: {resultado}')
--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 |
2 | *.iml
3 | *.xml
4 | *.pyc
5 | *.bat
6 | *.qrc
7 | SQLite/Projetos/Tela_Login/banco_dados.db
8 | SQLite/Projetos/Tela_Login/banco_dados.db
9 | GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 02/raiz.txt
10 | GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 20/nomes.txt
11 | GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 20/nomes_1.txt
12 | Scripts-Python/texto_base.txt
13 | Scripts-Python/texto_bruto.txt
14 | Scripts-Python/texto_formatado.txt
15 | GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 20/.txt
16 | SQLite/Projetos/Caixa_Supermercado/banco_dados.db
17 | SQLite/Projetos/Caixa_Supermercado/esquema.txt
18 | SQLite/Projetos/Caixa_Supermercado/banco_dados.db
19 | *.db
20 | *.json
21 | *.db
22 | *.csv
23 | *.log
24 |
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/aula_03/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask
2 | from flask_sqlalchemy import SQLAlchemy
3 |
4 | app = Flask(__name__)
5 | app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///app.db"
6 | app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
7 |
8 | db = SQLAlchemy(app)
9 |
10 | class User(db.Model):
11 | id = db.Column(db.Integer, primary_key=True)
12 | name = db.Column(db.String(84), nullable=False)
13 | email = db.Column(db.String(84), nullable=False, unique=True, index=True)
14 | password = db.Column(db.String(255), nullable=False)
15 |
16 | def __str__(self):
17 | return self.name
18 |
19 |
20 | @app.route('/')
21 | def index():
22 | return 'Default'
23 |
24 | if __name__ == '__main__':
25 | app.run(debug=True)
--------------------------------------------------------------------------------
/HackerRank/11.py:
--------------------------------------------------------------------------------
1 | #
2 | if __name__ == '__main__':
3 | pessoas = []
4 | pessoa = []
5 | scores = []
6 | penultimo = []
7 | for x in range(int(input().strip())):
8 | name = input().strip()
9 | score = float(input().strip())
10 | pessoa.append(name)
11 | pessoa.append(score)
12 | scores.append(score)
13 | pessoas.append(pessoa[:])
14 | pessoa.clear()
15 | for x in range(scores.count(min(scores))):
16 | scores.remove(min(scores))
17 | scores.sort()
18 | for x in range(scores.count(min(scores))):
19 | penultimo.append(scores[x])
20 | if pessoas[0][0] != 'Test1':
21 | pessoas.reverse()
22 | for x in pessoas:
23 | if x[1] == penultimo[0]:
24 | print(x[0])
25 |
--------------------------------------------------------------------------------
/Mundo 2 by Curso em Video/Exercicios/ex056.py:
--------------------------------------------------------------------------------
1 | # desenvolva que leia nome idade e sexo de 4 pessoas no final mostre a media de idade destas pessoas, o nome do homem mais velho, quantas mulheres tem menos de 20 anos
2 |
3 | si = 0
4 | sf = 0
5 | dc = {}
6 | ls = []
7 | for x in range(0,4):
8 | print('-'*10)
9 | nome = str(input('Digite o Nome:')).strip().capitalize()
10 | idade = int(input('Digite a idade:'))
11 | s = str(input('Digite o Sexo M/F:')).strip().upper()
12 | si += idade
13 | if s == 'M':
14 | ls.append(idade)
15 | dc[idade] = nome
16 | elif idade < 20:
17 | sf += 1
18 | ls.sort()
19 | if ls == []:
20 | ls = [0]
21 | print(f'\nMedia Idades : {si/4}\nNome homem mais velho: {dc[ls[len(ls)-1]]}\nMulheres com menos de 20 anos: {sf}')
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/aula02/carro.py:
--------------------------------------------------------------------------------
1 | '''
2 | Criar a classe carro e definir no minimo 3 propiedades e 3 metodos
3 | '''
4 |
5 |
6 | class Carro:
7 | def __init__(self, marca, modelo, ano, cor):
8 | self.marca = marca
9 | self.modelo = modelo
10 | self.ano = ano
11 | self.cor = cor
12 |
13 | def Ligar_motor(self):
14 | print(f'O {self.modelo} está ligando o motor')
15 |
16 | def Desligar_motor(self):
17 | print(f'O {self.modelo} está desligando o motor')
18 |
19 | def Fechar_vidro(self):
20 | print('Fechando o vidro...')
21 |
22 | def Exibir_info(self):
23 | print(self.marca, self.modelo, self.ano, self.cor)
24 |
25 | carro1 = Carro('Toyota','Corolla','2006','Bege')
26 |
27 | carro1.Exibir_info()
28 |
--------------------------------------------------------------------------------
/statistic/basic_statistics_by_hackerank/ex_02.py:
--------------------------------------------------------------------------------
1 | #!/bin/python3
2 |
3 | import math
4 | import os
5 | import random
6 | import re
7 | import sys
8 |
9 | #
10 | # Complete the 'weightedMean' function below.
11 | #
12 | # The function accepts following parameters:
13 | # 1. INTEGER_ARRAY X
14 | # 2. INTEGER_ARRAY W
15 | #
16 |
17 | def weightedMean(X, W):
18 | total_w = sum(W)
19 | list_values = []
20 | for item in zip(X, W):
21 | list_values.append(item[0] * item[1])
22 | total_x = sum(list_values) / total_w
23 | print(round(total_x, 1))
24 |
25 | if __name__ == '__main__':
26 | n = int(input().strip())
27 |
28 | vals = list(map(int, input().rstrip().split()))
29 |
30 | weights = list(map(int, input().rstrip().split()))
31 |
32 | weightedMean(vals, weights)
33 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1035.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Leia 4 valores inteiros A, B, C e D. A seguir, se B for maior do que C e se D for maior do que A,
4 | e a soma de C com D for maior que a soma de A e B e se C e D, ambos, forem positivos e se a variável A for par escrever a mensagem "Valores aceitos",
5 | senão escrever "Valores nao aceitos".
6 | Entrada
7 |
8 | Quatro números inteiros A, B, C e D.
9 | Saída
10 |
11 | Mostre a respectiva mensagem após a validação dos valores.
12 |
13 | '''
14 |
15 |
16 |
17 | linha = input().split(' ')
18 |
19 | A,B,C,D = linha
20 |
21 | A = int(A)
22 | B = int(B)
23 | C = int(C)
24 | D = int(D)
25 |
26 | if (B>C and D>A and (C+D)>(A+B) and C > 0 and D > 0 and (A % 2) == 0 ) :
27 | print('Valores aceitos')
28 | else:
29 | print('Valores nao aceitos')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/100.py:
--------------------------------------------------------------------------------
1 | # um programa que tenha uma lista e duas foncoes que sorteia e uma que some par,
2 | # a primeira vai gerar 5 numeros aleatorios e colocalos dentro de uma lista
3 | # a segunda vai somar os valores pares gerador anteriormente
4 | from random import randint
5 |
6 |
7 | def sortear(lista):
8 | for x in range(0, 5):
9 | numeros.append(randint(1, 10))
10 | # return numeros
11 |
12 |
13 | def somapar(numeros):
14 | s = 0
15 | for x in numeros:
16 | if (x % 2) == 0:
17 | s += x
18 |
19 |
20 |
21 |
22 | print(f'A soma dos pares é {s}')
23 |
24 | numeros = []
25 | sortear(numeros)
26 |
27 | # numeros = sortear()
28 | print(f'Os numeros sorteados Foram: {numeros}')
29 | somapar(numeros)
30 |
31 |
32 |
33 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1002.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 | A fórmula para calcular a área de uma circunferência é: area = π . raio2. Considerando para este problema que π = 3.14159:
4 |
5 | - Efetue o cálculo da área, elevando o valor de raio ao quadrado e multiplicando por π.
6 | Entrada
7 |
8 | A entrada contém um valor de ponto flutuante (dupla precisão), no caso, a variável raio.
9 | Saída
10 |
11 | Apresentar a mensagem "A=" seguido pelo valor da variável area, conforme exemplo abaixo, com 4 casas após o ponto decimal. Utilize variáveis de dupla precisão (double).
12 | Como todos os problemas, não esqueça de imprimir o fim de linha após o resultado, caso contrário, você receberá "Presentation Error".
13 | '''
14 |
15 | raio = float(input())
16 | n = 3.14159
17 | raio2 = raio ** 2
18 | area = n * raio2
19 | print('A=%.4f'%area)
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula01/manage.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """Django's command-line utility for administrative tasks."""
3 | import os
4 | import sys
5 |
6 |
7 | def main():
8 | """Run administrative tasks."""
9 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'aula01.settings')
10 | try:
11 | from django.core.management import execute_from_command_line
12 | except ImportError as exc:
13 | raise ImportError(
14 | "Couldn't import Django. Are you sure it's installed and "
15 | "available on your PYTHONPATH environment variable? Did you "
16 | "forget to activate a virtual environment?"
17 | ) from exc
18 | execute_from_command_line(sys.argv)
19 |
20 |
21 | if __name__ == '__main__':
22 | main()
23 |
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula03/todo/manage.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 | """Django's command-line utility for administrative tasks."""
3 | import os
4 | import sys
5 |
6 |
7 | def main():
8 | """Run administrative tasks."""
9 | os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'todo.settings')
10 | try:
11 | from django.core.management import execute_from_command_line
12 | except ImportError as exc:
13 | raise ImportError(
14 | "Couldn't import Django. Are you sure it's installed and "
15 | "available on your PYTHONPATH environment variable? Did you "
16 | "forget to activate a virtual environment?"
17 | ) from exc
18 | execute_from_command_line(sys.argv)
19 |
20 |
21 | if __name__ == '__main__':
22 | main()
23 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/086.py:
--------------------------------------------------------------------------------
1 | # crie uma matriz de dimensao 3x3 e preencha com valores lidos pelo teclado
2 | """
3 |
4 | Alternativa
5 |
6 | lista = list()
7 | lista0 = list()
8 | lista1 = list()
9 | lista2 = list()
10 | lista.append(lista0)
11 | lista.append(lista1)
12 | lista.append(lista2)
13 | """
14 |
15 | lista = [[],[],[]]
16 |
17 | ct = 0
18 | for x in range(0,3):
19 | for c in range(0,3):
20 | valor = int(input(f'Digite o valor [{x}]:[{c}] :'))
21 | lista[x].append(valor)
22 | print(f'''
23 | {'+-+'*15}
24 | {' '*5}[{lista[0][0]: ^5}]{' '*5}[{lista[0][1]: ^5}]{' '*5}[{lista[0][2]: ^5}]
25 | {' '*5}[{lista[1][0]: ^5}]{' '*5}[{lista[1][1]: ^5}]{' '*5}[{lista[1][2]: ^5}]
26 | {' '*5}[{lista[2][0]: ^5}]{' '*5}[{lista[2][1]: ^5}]{' '*5}[{lista[2][2]: ^5}]
27 | {'+-+'*15}
28 | ''')
29 |
--------------------------------------------------------------------------------
/data_science/curso_cientista_dados_by_rafael/pandas/aulas/merge_concat.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "metadata": {
3 | "language_info": {
4 | "codemirror_mode": {
5 | "name": "ipython",
6 | "version": 3
7 | },
8 | "file_extension": ".py",
9 | "mimetype": "text/x-python",
10 | "name": "python",
11 | "nbconvert_exporter": "python",
12 | "pygments_lexer": "ipython3",
13 | "version": 3
14 | },
15 | "orig_nbformat": 4
16 | },
17 | "nbformat": 4,
18 | "nbformat_minor": 2,
19 | "cells": [
20 | {
21 | "cell_type": "code",
22 | "execution_count": null,
23 | "metadata": {},
24 | "outputs": [],
25 | "source": [
26 | "import pandas as pd\n",
27 | "import numpy as np\n",
28 | "\n",
29 | "path = \"Players.csv\"\n",
30 | "\n",
31 | "df = pd.read_csv(path)"
32 | ]
33 | }
34 | ]
35 | }
--------------------------------------------------------------------------------
/urionlinejudge-python/1064.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 | Faça um programa que leia 6 valores. Estes valores serão somente negativos ou positivos (desconsidere os valores nulos).
4 | A seguir, mostre a quantidade de valores positivos digitados.
5 | Entrada
6 |
7 | Seis valores, negativos e/ou positivos.
8 | Saída
9 |
10 | Imprima uma mensagem dizendo quantos valores positivos foram lidos.
11 |
12 | '''
13 |
14 | postivos = 0
15 | total = 0
16 | n1 = input()
17 | n2 = input()
18 | n3 = input()
19 | n4 = input()
20 | n5 = input()
21 | n6 = input()
22 |
23 | lista = [n1,n2,n3,n4,n5,n6]
24 | lista1 = list(map(float,lista))
25 | listapos = []
26 | for x in lista1:
27 | if x > 0 :
28 | postivos += 1
29 | listapos.append(x)
30 | media = sum(listapos) / postivos
31 | print('%.0f valores positivos' %postivos)
32 | print('%.1f'%media)
33 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/073.py:
--------------------------------------------------------------------------------
1 | # uma tupla com os 20 primeiros times da tabela do campeonato brasileiro de futebol, na ordem colocação. por fim mostrar,
2 | # apenas os 5 primeiros colocados, os ultimos 4 colocados,
3 | # um lista com os times em ordem alfabetica,
4 | # em que posição na tabela esta o time do Grêmio
5 |
6 | times = ('Atlético-MG','Internacional','São Paulo','Palmeiras','Vasco','Flamengo','Santos','Fortaleza','Fluminense','Sport','Ceará','Grêmio','Corinthians','Atlético-GO','Athletico','Coritiba','Bragantino','Botafogo','Bahia','Goiás')
7 | print(f'Os times Participando são: {times}')
8 | print(f'Os Primeiros 5 colocados Foram: {times[:5]}')
9 | print(f'Os Ultimos 4 colocados foram: {times[-4:]}')
10 | print(f'Os Times em ordem alfabetica fica: {sorted(times)}')
11 | print(f'O Time do Grêmio esta na posição {times.index("Grêmio")+1}')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/088.py:
--------------------------------------------------------------------------------
1 | # Cria grupo com 6 numeros aleatorios sem repetir entre 1 e 60. o usuario ira digitar a quantidade de grupos
2 | from time import sleep
3 | from random import randint
4 | qtd = int(input('Digite a quantidade de Jogos: '))
5 | lista = list()
6 | jogo = list()
7 | for x in range(0,qtd):
8 | for x in range(0,6):
9 | valor = randint(1,60)
10 | if x == 0:
11 | jogo.append(valor)
12 | else:
13 | while True:
14 | valor = randint(1,60)
15 | if valor not in jogo:
16 | break
17 | jogo.append(valor)
18 | lista.append(jogo[:])
19 | jogo.clear()
20 | print(f'{"Gerador Jogos":-^30}')
21 | for num,x in enumerate(lista):
22 | sleep(1)
23 | x.sort()
24 | print(f'Jogo {num+1}: {x}')
25 |
26 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/ex108/moeda.py:
--------------------------------------------------------------------------------
1 | # aumentar(),
2 | # diminuir()
3 | # dobro()
4 | # metade()
5 |
6 | def aumentar(numero,quanto):
7 | resultado = numero + numero * (quanto/100)
8 | return resultado
9 |
10 |
11 | def diminuir(numero,quanto):
12 | resultado = numero - numero * (quanto/100)
13 | return resultado
14 |
15 |
16 | def dobro(numero):
17 | return numero*2
18 |
19 |
20 | def metade(numero):
21 | return numero*0.5
22 |
23 |
24 | def moeda(numero,moeda='R$'):
25 | numero = str(numero)
26 | if numero.count(',') > 0:
27 | numero = numero.replace(',','.')
28 | numero = float(numero)
29 | numero = float(numero)
30 | numero = f'{moeda}{numero:.2f}'
31 | numero = str(numero)
32 | numero = numero.replace('.',',')
33 | return numero
34 |
35 |
36 |
37 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/103.py:
--------------------------------------------------------------------------------
1 | # uma função chamada ficha que receba dois parametros opcionais, o nome de um jogador e quantos gols ele marcou
2 | # o programa devera ser capaz de mostrar a ficha do jogador, mesmo que algum dado não
3 | # tenha sido informado corretamente
4 |
5 | def ficha(nome='',gols=0):
6 | if str(nome).isnumeric():
7 | gols = nome
8 | nome = ''
9 | if len(nome) == 0:
10 | nome = ''
11 | if len(gols) == 0:
12 | gols = 0
13 | if gols.isnumeric():
14 | pass
15 | else:
16 | gols = 0
17 |
18 | print(f'O jogador {nome} marcou {gols} Gols!!')
19 |
20 |
21 | # Programa Principal
22 | nome = str(input('Digite o nome do jogador:')).strip().capitalize()
23 | gols = input('Digite a quantidade de gols:')
24 | ficha(nome,gols)
25 |
--------------------------------------------------------------------------------
/SQLite/Pratica/ex000/criando.py:
--------------------------------------------------------------------------------
1 | import sqlite3
2 |
3 | nome = 'Felipe'
4 | nascimento = '2010'
5 | email = f'{nome}@gmail.com'
6 |
7 |
8 | banco = sqlite3.connect('primeiro_banco.db')
9 |
10 | cursor = banco.cursor()
11 |
12 | # cursor.execute("""CREATE TABLE pessoas (
13 | # id integer PRIMARY KEY AUTOINCREMENT,
14 | # nome text,
15 | # ano_nascimento integer,
16 | # email text)""")
17 |
18 | #cursor.execute(f"INSERT INTO pessoas VALUES (NULL,'{nome}','{nascimento}','{email}')")
19 |
20 | # cursor.execute(f'DELETE from pessoas where nome = "Roberto"')
21 |
22 | # cursor.execute(f'DELETE from pessoas where nome = "Carlos"')
23 |
24 |
25 | banco.commit()
26 |
27 | pesquisa_nome = 'Roberta'
28 | cursor.execute(f"SELECT ano_nascimento FROM pessoas WHERE nome = '{pesquisa_nome}'")
29 | variavel = cursor.fetchall()
30 | print(variavel[0][0])
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_5_templates/main.py:
--------------------------------------------------------------------------------
1 | from flask import flash, Flask, render_template, request, redirect, url_for
2 |
3 |
4 | app = Flask(__name__, template_folder='templates')
5 | app.config['SECRET_KEY'] = 'secret'
6 |
7 |
8 | @app.route('/templates')
9 | def templates():
10 |
11 |
12 | flash('This is a flash message')
13 |
14 | return render_template('templates.html')
15 |
16 | @app.route('/users')
17 | def users():
18 |
19 | flash('Users flash message')
20 | users = [{
21 | 'name': 'lucas',
22 | 'age': '22',
23 | 'email': 'lucas@gmail.com'
24 | },
25 | {
26 | 'name': 'KILERHG',
27 | 'age': '19',
28 | 'email': 'kilerhg@gmail.com'
29 | }
30 | ]
31 |
32 | return render_template('users.html', users=users)
33 |
34 |
35 | if __name__ == '__main__':
36 | app.run(debug=True)
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_1_introducao/aula_08/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask, request
2 |
3 |
4 | app = Flask(__name__)
5 |
6 | @app.route('/')
7 | def index():
8 | data = dict(
9 | path=request.path,
10 | referrer = request.referrer,
11 | content_type=request.content_type,
12 | method=request.method
13 | )
14 | return "Posts"
15 |
16 | @app.route('/posts')
17 | @app.route('/posts/')
18 | def posts(id):
19 | titulo = request.args.get("titulo")
20 | data = dict(
21 | path=request.path,
22 | referrer=request.referrer,
23 | content_type=request.content_type,
24 | method=request.method,
25 | titulo=titulo,
26 | id=id if id else 0
27 | )
28 | return data
29 |
30 |
31 |
32 |
33 | if __name__ == '__main__':
34 | app.run()
--------------------------------------------------------------------------------
/regex/curso_regex_by_luiz/aula01.py:
--------------------------------------------------------------------------------
1 | import re
2 |
3 | # Sempre utilizar regex em string com r''. assim evitando repetir caracteres de escape
4 |
5 | ## Metódos de utilização
6 |
7 | ### findall() -> Encontra todas as ocorrências e retorna uma lista
8 | ### search() -> Encontra o Primeiro e Retorna um objeto Match
9 | ### sub() -> Substitui as ocorrências encontradas. podendo limitar a um ou todos.
10 | ### compile() -> Cria um objeto compilado que pode ser utilizado varias vezes sem reprocessamento em memoria
11 |
12 |
13 | regex_script = r'[0-9]{3}.[0-9]{3}.[0-9]{3}-[0-9]{2}'
14 | text = 'asdsadasdasdas 123.123.123-12 asadasdsads'
15 |
16 | print(re.search(regex_script, text)) # Retorna um Objeto Match com posição e conteudo
17 | print(re.findall(regex_script, text)) # Retorna lista de todas ocorrencias
18 | print(re.sub(regex_script, 'au', text)) # Retorna o script original com substituição
19 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/115.py:
--------------------------------------------------------------------------------
1 | # crie um pequeno sistema modularizado que
2 | # permita cadastrar pessoas pelo seu nome e idade em um arquivo de txt simples
3 | # o sistema so vai ter 2 opções: cadastrar uma nova pessoa e listar todas as pessoas cadastradas
4 |
5 | from ex115 import *
6 | from time import sleep
7 |
8 | '''
9 | 1 - Ver pessoas Que estão cadastradas
10 | 2 - Cadastrar novas Pessoas
11 | 3 - Sair do Programa
12 | '''
13 |
14 |
15 | while True:
16 | escolha = menu()
17 | if escolha == 1:
18 | lerDados()
19 | sleep(3)
20 | elif escolha == 2:
21 | nome = lerNome()
22 | idade = lerIdade()
23 | salvarDados(formatarTexto(nome,idade))
24 | print(f'O registro da pessoa {nome} foi salvo!!!')
25 | sleep(3)
26 | else:
27 | titulo('Obrigado, Volte Sempre!!!')
28 | break
29 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1009.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 |
4 | Faça um programa que leia o nome de um vendedor, o seu salário fixo e o total de vendas efetuadas por ele no mês (em dinheiro). Sabendo que este vendedor ganha 15%
5 | de comissão sobre suas vendas efetuadas, informar o total a receber no final do mês, com duas casas decimais.
6 | Entrada
7 |
8 | O arquivo de entrada contém um texto (primeiro nome do vendedor) e 2 valores de dupla precisão (double) com duas casas decimais,
9 | representando o salário fixo do vendedor e montante total das vendas efetuadas por este vendedor, respectivamente.
10 | Saída
11 |
12 | Imprima o total que o funcionário deverá receber, conforme exemplo fornecido.
13 |
14 | '''
15 |
16 |
17 | nome = str(input())
18 | salariobase = float(input())
19 | vendas = float(input())
20 | salario = float((salariobase + (vendas * 0.15)))
21 | print('TOTAL = R$ %.2f'%salario)
--------------------------------------------------------------------------------
/urionlinejudge-python/1020.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Leia um valor inteiro correspondente à idade de uma pessoa em dias e informe-a em anos, meses e dias
5 |
6 | Obs.: apenas para facilitar o cálculo, considere todo ano com 365 dias e todo mês com 30 dias.
7 | Nos casos de teste nunca haverá uma situação que permite 12 meses e alguns dias, como 360, 363 ou 364.
8 | Este é apenas um exercício com objetivo de testar raciocínio matemático simples.
9 | Entrada
10 |
11 | O arquivo de entrada contém um valor inteiro.
12 | Saída
13 |
14 | Imprima a saída conforme exemplo fornecido.
15 |
16 | '''
17 |
18 | dias = (int(input()))
19 | meses = 0
20 | anos = 0
21 |
22 | while (dias>364) :
23 | anos = anos + 1
24 | dias = dias - 365
25 |
26 | while (dias>29) :
27 | meses = meses + 1
28 | dias = dias - 30
29 |
30 | print('%s ano(s)\n%s mes(es)\n%s dia(s)' % (anos,meses,dias))
--------------------------------------------------------------------------------
/pirex_help/src/figuras.py:
--------------------------------------------------------------------------------
1 | class retangulo():
2 |
3 | def __init__(self, centro, largura, comprimento):
4 | self.largura = largura
5 | self.comprimento = comprimento
6 | self.centro = centro
7 |
8 | def __str__(self):
9 | pass
10 |
11 | def calcular_perimetro(self):
12 | resultado = (self.largura * 2) + (self.comprimento * 2)
13 | return resultado
14 |
15 | def calcular_area(self):
16 | resultado = self.largura * self.comprimento
17 | return resultado
18 |
19 | class circulo:
20 | def __init__(self, raio, centro):
21 | self.centro = centro
22 | self.raio = raio
23 |
24 | def __str__(self):
25 | pass
26 |
27 | def calcular_perimetro(self):
28 | return self.raio * (2 * 3.14)
29 |
30 | def calcular_area(self):
31 | return 3.14 * ( self.raio ** 2 )
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/aula_05/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask, render_template
2 | from flask_sqlalchemy import SQLAlchemy
3 |
4 | app = Flask(__name__)
5 | app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///app.db"
6 | app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
7 |
8 | db = SQLAlchemy(app)
9 |
10 | class User(db.Model):
11 | id = db.Column(db.Integer, primary_key=True)
12 | name = db.Column(db.String(84), nullable=False)
13 | email = db.Column(db.String(84), nullable=False, unique=True, index=True)
14 | password = db.Column(db.String(255), nullable=False)
15 |
16 | def __str__(self):
17 | return self.name
18 |
19 |
20 | @app.route('/')
21 | def index():
22 | users = User.query.all() # Select * from users.
23 | return render_template('user.html', users=users)
24 |
25 | if __name__ == '__main__':
26 | app.run(debug=True)
--------------------------------------------------------------------------------
/Flask/Masterclass/aulas/capitulo_2_sqlalchemy/aula_06/app.py:
--------------------------------------------------------------------------------
1 | from flask import Flask, render_template
2 | from flask_sqlalchemy import SQLAlchemy
3 |
4 | app = Flask(__name__)
5 | app.config['SQLALCHEMY_DATABASE_URI'] = "sqlite:///app.db"
6 | app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
7 |
8 | db = SQLAlchemy(app)
9 |
10 | class User(db.Model):
11 | id = db.Column(db.Integer, primary_key=True)
12 | name = db.Column(db.String(84), nullable=False)
13 | email = db.Column(db.String(84), nullable=False, unique=True, index=True)
14 | password = db.Column(db.String(255), nullable=False)
15 |
16 | def __str__(self):
17 | return self.name
18 |
19 |
20 | @app.route('/')
21 | def index():
22 | users = User.query.all() # Select * from users.
23 | return render_template('user.html', users=users)
24 |
25 | if __name__ == '__main__':
26 | app.run(debug=True)
--------------------------------------------------------------------------------
/urionlinejudge-python/1006.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 |
4 | Leia 3 valores, no caso, variáveis A, B e C, que são as três notas de um aluno. A seguir, calcule a média do aluno, sabendo que a nota A tem peso 2,
5 | a nota B tem peso 3 e a nota C tem peso 5. Considere que cada nota pode ir de 0 até 10.0, sempre com uma casa decimal.
6 | Entrada
7 |
8 | O arquivo de entrada contém 3 valores com uma casa decimal, de dupla precisão (double).
9 | Saída
10 |
11 | Imprima a variável MEDIA conforme exemplo abaixo, com 1 dígito após o ponto decimal e com um espaço em branco antes e depois da igualdade. Assim como todos os problemas, não esqueça de imprimir o fim de linha após o resultado, caso contrário, você receberá "Presentation Error".
12 |
13 | '''
14 |
15 |
16 | A = float(input())
17 | B = float(input())
18 | C = float(input())
19 | MEDIA = float(((((A * 2) + (B * 3)) + (C * 5) )/ 10))
20 | print('MEDIA = %.1f'%MEDIA)
--------------------------------------------------------------------------------
/urionlinejudge-python/1038.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Com base na tabela abaixo, escreva um programa que leia o código de um item e a quantidade deste item. A seguir, calcule e mostre o valor da conta a pagar.
5 |
6 | Entrada
7 |
8 | O arquivo de entrada contém dois valores inteiros correspondentes ao código e à quantidade de um item conforme tabela acima.
9 | Saída
10 |
11 | O arquivo de saída deve conter a mensagem "Total: R$ " seguido pelo valor a ser pago, com 2 casas após o ponto decimal.
12 |
13 | '''
14 |
15 | linha = input().split(' ')
16 | codigo,qtd = linha
17 | codigo = int(codigo)
18 | qtd = int(qtd)
19 |
20 | if codigo == 1:
21 | preco = 4
22 | if codigo == 2:
23 | preco = 4.5
24 | if codigo == 3:
25 | preco = 5
26 | if codigo == 4:
27 | preco = 2
28 | if codigo == 5:
29 | preco = 1.5
30 |
31 | conta = qtd * preco
32 |
33 | print('Total: R$ %.2f'%conta)
34 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1008.py:
--------------------------------------------------------------------------------
1 | '''/
2 | Escreva um programa que leia o número de um funcionário, seu número de horas trabalhadas, o valor que recebe por hora e calcula o salário desse funcionário. A seguir, mostre o número e o salário do funcionário, com duas casas decimais.
3 | Entrada
4 |
5 | O arquivo de entrada contém 2 números inteiros e 1 número com duas casas decimais, representando o número, quantidade de horas trabalhadas e o valor que o funcionário recebe por hora trabalhada, respectivamente.
6 | Saída
7 |
8 | Imprima o número e o salário do funcionário, conforme exemplo fornecido, com um espaço em branco antes e depois da igualdade. No caso do salário, também deve haver um espaço em branco após o $.
9 | '''
10 | numero = int(input())
11 | horas = int(input())
12 | salariohora = float(input())
13 | salario = float(salariohora * horas)
14 | print("NUMBER = %d" %numero)
15 | print("SALARY = U$ %.2f" %salario)
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula01/aula01/urls.py:
--------------------------------------------------------------------------------
1 | """aula01 URL Configuration
2 |
3 | The `urlpatterns` list routes URLs to views. For more information please see:
4 | https://docs.djangoproject.com/en/3.1/topics/http/urls/
5 | Examples:
6 | Function views
7 | 1. Add an import: from my_app import views
8 | 2. Add a URL to urlpatterns: path('', views.home, name='home')
9 | Class-based views
10 | 1. Add an import: from other_app.views import Home
11 | 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
12 | Including another URLconf
13 | 1. Import the include() function: from django.urls import include, path
14 | 2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
15 | """
16 | from django.contrib import admin
17 | from django.urls import path
18 |
19 | urlpatterns = [
20 | path('admin/', admin.site.urls),
21 | ]
22 |
--------------------------------------------------------------------------------
/GUI qt5 pyside2/Curso de Qt5 PySide2 GUI by The Grapevine/Aula 02/interface.ui:
--------------------------------------------------------------------------------
1 |
2 |
3 | MainWindow
4 |
5 |
6 |
7 | 0
8 | 0
9 | 320
10 | 240
11 |
12 |
13 |
14 | MainWindow
15 |
16 |
17 |
18 |
19 |
20 | 0
21 | 0
22 | 320
23 | 21
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/081.py:
--------------------------------------------------------------------------------
1 | # ler varios numeros e colocar em uma lista depois disso, mostrar:
2 | # A- Quantos numeros foram digitados
3 | # B- A lista de valores ordenada de forma decrescente
4 | # C- Se o valor 5 foi digitado e está ou não na lista
5 | lista = []
6 | while True:
7 | lista.append(int(input('Digite um valor:')))
8 | flag = str(input('Você deseja continuar? [S/N]:')).strip().upper()[0]
9 | if flag not in 'SN':
10 | while True:
11 | flag = str(input('Você deseja continuar? [S/N]:')).strip().upper()[0]
12 | if flag in 'SN':
13 | break
14 | if flag == 'N':
15 | break
16 | print(f'{len(lista)} Numeros foram Digitados')
17 | lista.sort()
18 | print(f'A lista de forma decrescente: {lista[::-1]}')
19 | if lista.count(5) > 0:
20 | print(f'O valor 5 está na lista')
21 | else:
22 | print('O valor 5 Não está na lista')
--------------------------------------------------------------------------------
/urionlinejudge-python/1005.py:
--------------------------------------------------------------------------------
1 | '''/
2 |
3 |
4 | Leia 2 valores de ponto flutuante de dupla precisão A e B, que correspondem a 2 notas de um aluno. A seguir, calcule a média do aluno, sabendo que a nota A tem peso 3.5 e a nota B tem peso 7.5 (A soma dos pesos portanto é 11). Assuma que cada nota pode ir de 0 até 10.0, sempre com uma casa decimal.
5 | Entrada
6 |
7 | O arquivo de entrada contém 2 valores com uma casa decimal cada um.
8 | Saída
9 |
10 | Calcule e imprima a variável MEDIA conforme exemplo abaixo, com 5 dígitos após o ponto decimal e com um espaço em branco antes e depois da igualdade. Utilize variáveis de dupla precisão (double) e como todos os problemas, não esqueça de imprimir o fim de linha após o resultado, caso contrário, você receberá "Presentation Error".
11 |
12 | '''
13 |
14 | A = float(input())
15 | B = float(input())
16 | MEDIA = float((((A * 3.5) + (B * 7.5)) / 11))
17 | print('MEDIA = %.5f'%MEDIA)
--------------------------------------------------------------------------------
/classrom_py/app.py:
--------------------------------------------------------------------------------
1 | import logging
2 | from flask import Flask, jsonify, request, render_template
3 |
4 | app = Flask(__name__)
5 |
6 | @app.route("/", methods=['GET'])
7 | def index():
8 | return render_template("a.html")
9 |
10 | @app.route("/get", methods=['GET', 'POST'])
11 | def get():
12 | if request.method == 'GET':
13 | return jsonify({'value': "I'M GET"})
14 | return jsonify({'value': "I'M GET"})
15 |
16 |
17 | @app.route("/get//", methods=['GET'])
18 | def get_id(id_user, id_post):
19 | return jsonify({'value': f"I'M USER ID {id_user}, POST ID {id_post}"})
20 |
21 |
22 | @app.route("/post", methods=['POST'])
23 | def post():
24 | var = request.get_json()
25 | print(var)
26 | print(var['algum_valor'])
27 | return jsonify('Sucesso'), 200 # nicolas é gato
28 |
29 |
30 | if __name__ == '__main__':
31 | app.run(debug=True)
32 |
33 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1015.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Leia os quatro valores correspondentes aos eixos x e y de dois pontos quaisquer no plano, p1(x1,y1) e p2(x2,y2)
5 | e calcule a distância entre eles, mostrando 4 casas decimais após a vírgula, segundo a fórmula:
6 |
7 | Distancia =
8 | Entrada
9 |
10 | O arquivo de entrada contém duas linhas de dados. A primeira linha contém dois valores de ponto flutuante: x1 y1 e a segunda linha contém dois valores de ponto flutuante x2 y2.
11 | Saída
12 |
13 | Calcule e imprima o valor da distância segundo a fórmula fornecida, com 4 casas após o ponto decimal.
14 |
15 | '''
16 |
17 | import math
18 | line1 = input().split(' ')
19 | line2 = input().split(' ')
20 | x1,y1 = line1
21 | x2,y2 = line2
22 | x1 = float(x1)
23 | y1 = float(y1)
24 | x2 = float(x2)
25 | y2 = float(y2)
26 | Distancia = math.sqrt(((x2-x1) ** 2) + ((y2-y1) ** 2))
27 | print('%.4f'%Distancia)
28 |
29 |
30 |
31 |
--------------------------------------------------------------------------------
/Estudos Avulsos/Classes/aula02/steam.py:
--------------------------------------------------------------------------------
1 | # Criar uma classe que receba o nome do jogo, preço, Data lançamento, Analises steam recentes, Genero
2 |
3 | class Jogo:
4 | def __init__(self, nome, preco, lancamento, analises, genero):
5 | self.nome = nome
6 | self.preco = preco
7 | self.lancamento = lancamento
8 | self.analises = analises
9 | self.genero = genero
10 |
11 | def Executar(self):
12 | print(f'Abrindo o Jogo {self.nome}')
13 |
14 | def Fechar(self):
15 | print(f'Fechando o Jogo {self.nome}')
16 |
17 | def Avaliar(self):
18 | avalir_jogo = str(input('Avalie o Jogo:')).strip
19 |
20 | def ExibirInformacoesJogo(self):
21 | print(self.nome, self.preco, self.lancamento, self.analises, self.genero)
22 |
23 | game = Jogo('Europa Universalis IV','17,49','13/ago/2013','Muito Positivas', 'Simulação')
24 |
25 | game.ExibirInformacoesJogo()
26 |
--------------------------------------------------------------------------------
/campo_minado/functions.py:
--------------------------------------------------------------------------------
1 | # B - Bomba
2 | # V - Vazio
3 |
4 |
5 | def gera_matriz(colunas : int, linhas : int):
6 | lista_matriz = []
7 | for coluna in range(0, colunas):
8 | lista_matriz.append(list('V'* linhas))
9 | return lista_matriz
10 |
11 |
12 | def gera_pos_bomba(max_colunas, max_linhas):
13 | from random import randint
14 | x, y = randint(0, max_linhas-1), randint(0, max_colunas-1)
15 | return x, y
16 |
17 |
18 | colunas, linhas = 3, 3
19 | lista_matriz = gera_matriz(colunas=colunas, linhas=linhas)
20 |
21 | x, y = gera_pos_bomba(max_colunas=colunas, max_linhas=linhas)
22 | lista_matriz[x][y] = 'B'
23 | print(lista_matriz)
24 | print(x+1, y+1)
25 |
26 | # Varrendo
27 |
28 |
29 | # m : minus 1
30 | # p : plus 1
31 | # n : not change
32 |
33 | for c in range(0, colunas):
34 | for l in range(0, linhas):
35 | atual = lista_matriz[c][l]
36 | atual_x_n_y_n = ''
37 | atual_x_n_y_n = ''
38 |
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/079.py:
--------------------------------------------------------------------------------
1 | # digitar varios valores numericos, caso o numero ja esteja na lista ele não adicionara, ao fim mostrar todos os numeros escritos de forma crescente
2 | lista = []
3 | flag = ''
4 | while True:
5 | valor = int(input('Digite um valor:'))
6 | if len(lista) > 0:
7 | if valor not in lista:
8 | lista.append(valor)
9 | print(f'O valor {valor} foi adicionado com sucesso!!')
10 | else:
11 | print(f'O valor {valor} Não foi adicionado, Valor Repetido!!!')
12 | else:
13 | lista.append(valor)
14 | print(f'O valor {valor} foi adicionado com sucesso!!')
15 | if flag in 'SN':
16 | while True:
17 | flag = str(input('Deseja Continuar [S/N]:')).strip().upper()[0]
18 | if flag in 'SN':
19 | break
20 | if flag in 'N':
21 | break
22 | lista.sort()
23 | print(f'O valor da lista: {lista}')
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/082.py:
--------------------------------------------------------------------------------
1 | # ler varios numeros e colocar em uma lista, criar duas listas extras que vão conter apenas os valores pares e os valores impares, ao final mostre o conteudo das tres lista
2 | lista = []
3 | flag = 'B'
4 | listapar = []
5 | listaimpar = []
6 | while True:
7 | lista.append(int(input('Digite um valor:')))
8 | flag = str(input('Você deseja continuar [S/N]:')).strip().upper()[0]
9 | if flag not in 'SN':
10 | while True:
11 | flag = str(input('Você deseja continuar [S/N]:')).strip().upper()[0]
12 | if flag in 'SN':
13 | break
14 | if flag == 'N':
15 | break
16 | for x in lista:
17 | if x % 2 == 0:
18 | listapar.append(x)
19 | else:
20 | listaimpar.append(x)
21 | print(f'Os valores Digitados Foram: {lista}')
22 | print(f'Os valores Pares Digitados Foram: {listapar}')
23 | print(f'Os valores Impares Digitados Foram: {listaimpar}')
--------------------------------------------------------------------------------
/Django/Curso_de_Django_2 by Matheus Battisti - Hora de Codar/aula03/todo/todo/urls.py:
--------------------------------------------------------------------------------
1 | """todo URL Configuration
2 |
3 | The `urlpatterns` list routes URLs to views. For more information please see:
4 | https://docs.djangoproject.com/en/3.1/topics/http/urls/
5 | Examples:
6 | Function views
7 | 1. Add an import: from my_app import views
8 | 2. Add a URL to urlpatterns: path('', views.home, name='home')
9 | Class-based views
10 | 1. Add an import: from other_app.views import Home
11 | 2. Add a URL to urlpatterns: path('', Home.as_view(), name='home')
12 | Including another URLconf
13 | 1. Import the include() function: from django.urls import include, path
14 | 2. Add a URL to urlpatterns: path('blog/', include('blog.urls'))
15 | """
16 | from django.contrib import admin
17 | from django.urls import path, include
18 |
19 | urlpatterns = [
20 | path('admin/', admin.site.urls),
21 | path('', include('tasks.urls'))
22 | ]
23 |
--------------------------------------------------------------------------------
/urionlinejudge-python/1017.py:
--------------------------------------------------------------------------------
1 | '''
2 |
3 |
4 | Joaozinho quer calcular e mostrar a quantidade de litros de combustível gastos em uma viagem, ao utilizar um automóvel que faz 12 KM/L.
5 | Para isso, ele gostaria que você o auxiliasse através de um simples programa. Para efetuar o cálculo,
6 | deve-se fornecer o tempo gasto na viagem (em horas) e a velocidade média durante a mesma (em km/h). Assim,
7 | pode-se obter distância percorrida e, em seguida, calcular quantos litros seriam necessários. Mostre o valor com 3 casas decimais após o ponto.
8 | Entrada
9 |
10 | O arquivo de entrada contém dois inteiros. O primeiro é o tempo gasto na viagem (em horas) e o segundo é a velocidade média durante a mesma (em km/h).
11 | Saída
12 |
13 | Imprima a quantidade de litros necessária para realizar a viagem, com três dígitos após o ponto decimal
14 |
15 | '''
16 |
17 | tempo = int(input())
18 | velmedia = int(input())
19 | calculo = ((velmedia / 12)*tempo)
20 | print('%.3f'%calculo)
--------------------------------------------------------------------------------
/Mundo 3 by Curso em Video/Exercicios/102.py:
--------------------------------------------------------------------------------
1 | # uma funcao fatorial que receba dois parametros, o primeiro que indique o numero a calcular
2 | # e o segundo chamado show, que sera um valor logico(opcional) indicando se sera mostrado
3 | # ou nao na tela o processo de calculo do fatorial
4 |
5 | def fatorial(num=1,show=False):
6 | """
7 | -> Função para calculo de Fatorial
8 | :param num: Numero a ser calculado / numero inteiro
9 | :param show: Parametro opcional, se deseja ou não mostrar a conta na tela. True/False
10 | :return: O resultado do calculo Fatorial
11 | """
12 | fac = 1
13 | if show:
14 | for x in range(num,0,-1):
15 | fac *= x
16 | if x != 1:
17 | print(f'{x} ',end='x ')
18 | print(f'{x} = ',end='')
19 | else:
20 | for x in range(num,0,-1):
21 | fac *= x
22 | return fac
23 |
24 |
25 | # Programa Principal
26 | print(fatorial(5,True))
27 |
--------------------------------------------------------------------------------
/test/python-tdd-explorando-testes-unitarios by Alura/aula 01/codigo/bytebank.py:
--------------------------------------------------------------------------------
1 | from datetime import date
2 |
3 | class Funcionario:
4 | def __init__(self, nome, data_nascimento, salario):
5 | self._nome = nome
6 | self._data_nascimento = data_nascimento
7 | self._salario = salario
8 |
9 | @property
10 | def nome(self):
11 | return self._nome
12 |
13 | @property
14 | def salario(self):
15 | return self._salario
16 |
17 | def idade(self):
18 | data_nasciemnto_quebrada = self._data_nascimento.split('/')
19 | ano_nascimento = data_nasciemnto_quebrada[-1]
20 | ano_atual = date.today().year
21 | return ano_atual - int(ano_nascimento)
22 |
23 | def calcular_bonus(self):
24 | valor = self._salario * 0.1
25 | if valor > 1000:
26 | valor = 0
27 | return valor
28 |
29 | def __str__(self):
30 | return f'Funcionario({self._nome}, {self._data_nascimento}, {self._salario})'
--------------------------------------------------------------------------------