Usamos cookies para medir audiência e melhorar sua experiência. Você pode aceitar ou recusar a qualquer momento. Veja sobre o iMasters.
Esse tópico foi criado para postarmos scripts prontos na linguagem Python.
Para inaugurar a lista lá vai minha primeira contribuicao.
Trata-se de um trabalho da faculdade que fiz há algum tempo, acho que foi no 5 semestre.
Bom, para não tomar muito tempo esse script é a implementacao de um automato.
Se quiserem mais detalhes de como funciona é só perguntar.
print '********Automatos********'
alfabeto = raw_input('Digite um alfabeto: ')
alflen = len(alfabeto)
resposta = raw_input('Digite a quantidade de estados: ')
estados = int(resposta)
parte={}
vai={}
le={}
estadosf={}
i=0
for p in range(0, alflen):
for j in range(0, estados):
#print 'q%i' %j + ' le %c vai para: ' %alfabeto[p]
regra=raw_input ('q%i' %j + ' le %c vai para: q' %alfabeto[p])
parte[i] = j
vai[i] = int(regra)
le[i] = alfabeto[p]
i=i+1
estadoi = int (raw_input ('Qual e o estado inicial: q'))
qestadosf = int (raw_input ('Quantos estados finais: '))
print 'digite os %i estados finais' %qestadosf
for p in range(0, qestadosf):
estadosf[p] = int(raw_input ('q'))
palavra = raw_input('digite a palavra: ')
palavralen = len(palavra)
estadoa = estadoi
for p in range(0, palavralen):
mudou=0
j=0
for i in range(0, estados*alflen):
if (palavra[p] == le[i]) and (estadoa == parte[i]):
#if (palavra[p] == alfabeto[j]):
aux=vai[i]
mudou=1
break
if mudou == 1:
print 'de q%i ' %estadoa + 'leu %c ' %palavra[p] + 'foi para q%i ' %aux
estadoa=aux
else:
print 'nao tem regra para esse simbolo'
print 'o programa sera encerrado!!!'
break
teste = 0
for i in range(0, qestadosf):
if estadoa == estadosf[i]:
teste = 1
if teste == 1:
print 'A palavra eh valida'
else:
print 'A palavra nao eh valida'
Gerador de arquivos e diretórios aleatório. Fiz pra ajudar no teste do copiador em paralelo que é trabalho da faculdade.
#!/usr/bin/python
from random import randint,choice
from os import mkdir,chdir,pardir
from sys import argv
from string import letters,printable
MAX_DIR = 30 # Numero maximo de diretorios de primeiro nivel
MAX_DIR_NAME = 8 #Tamanho do nome do diretorio
MAX_SUB = 20 # Numero maximo de subdiretorios
MAX_SUB_DIRS = 10 # Numero maximo de diretorios de primeiro nivel que podem conter subdiretorios
MAX_ARQ = 30 # Numero maximo de arquivo em um diretorio
MAX_ARQ_DATA = 999999 # Numero maximo de dados no arquivo
MIN_ARQ_DATA = 50
for I in range(0,HAS_SUB):
INDICE = choice(HIERARQUIA.keys())
TMP_LISTA = []
SUBS = randint(0,MAX_SUB) # Quantos sudiretorios o diretorio em INDICE possui
print "Diretorio escolhido: %s \t Subdiretorios:%d\n"%(INDICE,SUBS)
for J in range(0,SUBS):
NOME = ''.join([choice(letters) for X in xrange(MAX_DIR_NAME)])
TMP_LISTA.append(NOME)
HIERARQUIA[INDICE] = TMP_LISTA
print " Gerador de arquivos aleatorio\n"
if len(argv) == 2 :
# Cria o diretorio
mkdir(argv[1])
chdir(argv[1])
DIC = {}
DIRS = define_chaves(DIC)
gera_subdiretorios(DIC,DIRS)
cria_hierarquia(DIC)
for I in DIC.keys():
cria_arquivos([I])
else:
print "USO:",argv[0]," DIRETORIO"
certo, agora vamos calcular a formula de baskara :)
#!/usr/bin/env python
#-- coding: utf-8 --
#Criado em Ter 2008-10-08 23:47 GMT -4
#Autor Renan Fernandes renan@kauamanga.com.br [url="[http://www.kauamanga.com.br"]http://www.kauamanga.com.br[/url]](http://www.kauamanga.com.br)
#Função: Calcular a formula de Baskara
#importa o modulo matematico do python
import math
print "A formula é essa:"
print "Ax² + Bx + C = 0";
print "Me diga, quanto vale A?"
#pega x²
valorA = input();
print "E o B?"
#pega x
valorB = input()
print "E o C?"
#pega valor sem x
valorC = input()
#calcula o delta,
#delta = b² - 4ac
delta = (valorB valorB) - (4 valorA * valorC)
#caso delta seja menor que 0 termina a conta
if delta < 0:
print "Delta é menor que 0(zero)"
print "Delta =", str(delta)
print "Saindo..."
exit()
#tira a raiz de delta e usa o int() para tirar o ponto flutuante
deltaRaiz = int(math.sqrt(delta))
#imprime as informações
print "Delta:", str(delta)
print "Raiz de Delta:", str(deltaRaiz)
print "X':", str(contaPositiva)
print "X\":", str(contaNegativa)
Essa é uma classe que ajuda no upload de qualquer arquivo o renomeando de forma númerica e sequencial no diretório escolhido, como se fossem chaves primárias de um banco de dados.
É importante lembrar que essa classe não faz o upload em si e nem qualquer validação de extensão, esse não é seu objetivo :)
import os
class SingleUploadFile(object):
'''
Classe que facilita o upload de arquivos renomeados em ordem númerica sem
o uso de um banco de dados.
Essa classe deve ser sempre estendida, onde destination será um diretório absoluto.
'''
destination = None
def __init__(self, file):
self.file = file
#Aqui ele cria os diretórios recursivamente caso não existam
if not os.path.exists(self.destination):
os.makedirs(self.destination)
self.file_path = os.path.join(self.destination, self.__rename_file(file))
def __rename_file(self, file):
'''
Método que renomeia o arquivo em ordem numérica, se o último arquivo for por exemplo 4.txt
o arquivo atual será 5.alguma_extensao.
*Arquivos com extensões diferentes recebem o mesmo tratamento númerico.
'''
file_slice = file.name.split('.')
#Pega a lista de todos os arquivos do diretório
dir_list = os.listdir(self.destination)
int_dir_list = []
#Loop que adiciona na lista apenas arquivos nomeados com números.
for file_it in dir_list:
no_ext_name = file_it.split('.')[0]
try:
no_ext_name = int(no_ext_name)
except ValueError:
continue
int_dir_list.append(no_ext_name)
#Pega o arquivo com maior número e adiciona 1 que será o nome do arquivo atual
#Se a lista estiver vazia, o nome do arquivo será 1
try:
file_name = max(int_dir_list) + 1
except ValueError:
file_name = 1
#retorna o nome do arquivo já com sua extensão.
return '%i.%s' %(file_name, file_slice[-1])
def make_upload(self):
''' Método responsável por gravar o arquivo no diretório selecionado '''
destination = open(self.file_path, 'wb+')
destination.write(self.file.read())
destination.close()Exemplo de uso:
class MyUploadFile(SingleUploadFile):
destination = '/home/my_user/public/uploads/'
file_upload = MyUploadFile(file_object)
file_upload.make_upload()
Você pode ainda estender a classe para devolver a url do arquivo ;)
Oi pessoal.
Meu primeiro script (que roda)!
Esse módulo faz conexão com um Banco de Dados do Firebird.
Disponível aqui: Interbase/Firebird para Python
E devolve uma variavel global para você operar com o cursor,
por exemplo, cursor.execute('comando sql').
Óbvio, devem ter um banco de dados FireBird (isso para os mais novatos :lol: )
Vejam:
def connect(IP, Caminho, Usuario, Senha):
try:
global con
con = kinterbasdb.connect(dsn=(IP+":"+Caminho),
user=Usuario,
password=Senha)
global cursor
cursor = con.cursor()
print"Conectado!"
command = cursor.execute
except:
connection = 0
print("Falha na conexão com o Banco de Dados.")
print("Verifique se digitou corretamente o caminho e/ou o IP.")
Diponível o código inteiro, porém não está rodando, justamente porque está com os módulos de executar e
cadastrar dados errados:
fbconnect.py
Eu tinha feito ele de forma que apenas se chamasse "connect()"
e ele conectava com o banco, porém, quis inserir a liberdade
de você mesmo escolher em qual banco conectar.
Eu estou tentando fazer um módulo para executar a sql, sem sucesso até agora.
Também estou tentando fazer um módulo de cadastro e de consulta.
Porém estou tentando ainda, se não conseguir, posto aqui para me ajudarem.
^_^
Abraço amigos.
Segue meu script que resolve a equação do 2° grau com numeros complexos e reais.
Está no github.
#from math import sqrt
def sqrt(x):
if x < 0:
x = complex(x * -1)
return x**0.5
def bhaskara(a, b, c):
""" Resolve a equação do 2° grau com numeros complexos e reais"""
if a != 0:
delta = (b**2) - (4ac)
if delta > 0:
# A equação tem duas raízes reias distintas
delta = sqrt(delta)
raiz1 = (-b + delta) / (2*a)
raiz2 = (-b - delta) / (2*a)
return [raiz1, raiz2]
elif delta == 0:
# A equação tem exatamente uma raiz.
raiz1 = -b / (2*a)
return [raiz1]
else:
# A equaçãoo não possui qualquer raiz real, mais possui raiz em números complexo.
delta = sqrt(delta)
raiz1 = (complex(-b,delta)) / (2*a)
raiz2 = (complex(-b,delta*-1)) / (2*a)
return [raiz1,raiz2]
else: return []#!/etc/bin/env python
import time
import os
import subprocess
class des():
palavra = "pepe"
palavra_completa = ""
value = 0
alfabeto2 = []
def __init__(self, alfabeto):
self.alfabeto = alfabeto
def run(self):
alfabeto2 = ['a', 'b' ,'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'z', 'k', 'y', 'w', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
for letra in self.alfabeto:
for seg_letra in alfabeto2:
self.palavra_completa = letra + seg_letra
#print " %s%s - %d " % (letra, seg_letra, self.value)
if self.palavra_completa == self.palavra:
print "Palavra procurada %s demorou %s segundos para ser encontrada" % (self.palavra_completa, time.clock())
validador = False
break
else:
validador = True
self.alfabeto.append(self.palavra_completa)
self.value += 1
if validador == False:
break
alfabeto = ['a', 'b' ,'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'x', 'z', 'k', 'y', 'w', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0']
procura = des(alfabeto)
procura.run()
import os
#cria uma string com comandos de cql para o CSV Comp
mycql=str('')
#insere comandos para criação de tabela e campos
mycql='''
{
Tabela_produtos;
@tabela;
0;0;0;0;
query=0;
destino=0
}{
Tabela_produtos;
@campos;(
CODIGO;
PRODUTO;
PRECO
);
0;0;0;
query=0;destino=0
}'''
#escreve string no driver e salva na entrada do interpretador do SGBD
driver=open('c://path/inpout_comp.exe','w')
driver.write(str(mycql))
driver.close
#executa Parser do SGBD
os.startfile('c://path/csv_parser.exe')
É um pouco grande, mas é um algoritmo que determina (com certeza) se um número é primo ou composto, sem apelar p/ fatoração. Precisa do numpy instalado porque mexe com polinômios. Se você rodar AKS(1), ele diz que 1 é primo,mas isso pode ser contornado fazendo um
while True :
Numero = raw_input("Numero:")
if Numero > 1:
break
print AKS(Numero)
Se vcs quiserem sobrecarregar a CPU, façam um range até 1024...
from math import ceil,floor,log10,sqrt
from numpy import poly1d,polydiv
def AKS(Numero):
# Calcula potencia exata
for base in range(2,Numero):
logaritmo = log10(Numero)/log10(base)
if ceil(logaritmo) == floor(logaritmo):
def mdc(Numero,r):
shift = 0
tmp1,tmp2 = Numero,r
while tmp1 > 0 and tmp2 > 0:
if tmp1%2 == 0 and tmp2%2 == 0:
tmp1,tmp2,shift = tmp1>>1,tmp2>>1,shift+1
elif tmp1%2 == 0:
tmp1 = tmp1>>1
elif tmp2%2 == 0:
tmp2 = tmp2>>1
elif tmp1 > tmp2:
tmp1 = tmp1-tmp2
else:
tmp2=tmp2-tmp1
return max(tmp1,tmp2)*(2**shift)
Calcula quantos numeros < r são relativamente primos a r.
def phi(r): contadorPhi = 0 for indexPhi in range(2,int(r)): if mdc(indexPhi,int(r)) == 1: contadorPhi+=1 return contadorPhiCalcula a ordem de Numero
def ordem(Numero,logaritmo): q = logaritmo+1 indexOrdem = 1 while indexOrdem <= logaritmo: if (Numero**indexOrdem)%q == 1: q+=1 indexOrdem=1 else: indexOrdem+=1 return q