Post seus scripts aqui!

[Kandrade 7]

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'

[_Isis_ 202]

É 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):
	 return "COMPOSTO"

  logaritmo = floor((log10(Numero)/log10(2))**2)

  #o_r(n)
  r = ordem(Numero,logaritmo)

  a = 1
  while a <= r :
  k = mdc(a,Numero)
  if 1 < k and k < Numero:
	 return "COMPOSTO"
  a+=1

  if Numero <= r:
  return "PRIMO"
  else:
  limite = int(floor(sqrt(phi(r))*(log10(Numero)/log10(2))))
  zeroPoly = lambda lista,termos: termos > 1 and zeroPoly(lista,termos-1) or lista.append(0)
  redutor = []
  zeroPoly(redutor,r+1)
  redutor[0],redutor[-1] = 1,-1
  redutor = poly1d(redutor)

  for a in range(1,limite+1):
	 LS = []
	 zeroPoly(LS,2)
	 LS[0],LS[-1] = 1,a
	 LS = poly1d(LS)**Numero

	 RS = []
	 zeroPoly(RS,Numero+1)
	 RS[0],RS[-1] = 1,a
	 RS = poly1d(RS)

	 resto1 = polydiv(LS,redutor)[1]
	 resto1 = polydiv(resto1,poly1d([Numero]))[1]
	 resto2 = polydiv(RS,redutor)[1]
	 resto2 = polydiv(resto2,poly1d([Numero]))[1]

	 if resto1 != resto2:
		return "COMPOSTO"

  return "PRIMO"


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 contadorPhi


# Calcula 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

[_Isis_ 202]

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


# Inicializa o dicionario da hierarquia de diretorios
def define_chaves(HIERARQUIA):
  DIR_QTDE = randint(1,MAX_DIR)
  print "Numero de diretorios:%d\n"%(DIR_QTDE)
  for I in range(0,DIR_QTDE+1):
  # Gera o nome do diretorio aleatoriamente
  NOME = ''.join([choice(letters) for X in xrange(MAX_DIR_NAME)])
  HIERARQUIA.setdefault(NOME,[])
  return DIR_QTDE


# Gera os subdiretorios de cada chave no dicionario
def gera_subdiretorios(HIERARQUIA,DIR_QTDE):
  # Quantos diretorios possuem subdiretorios
  while True:
  HAS_SUB = randint(0,MAX_SUB_DIRS)
  if (HAS_SUB<=DIR_QTDE):
	 break
  print "Quantidade de diretorios que possuem subdiretorios:%d\n"%(HAS_SUB)

  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


# Dado um dicionario, cria a hierarquia de diretorios
def cria_hierarquia(HIERARQUIA):
  for I in HIERARQUIA.keys():
  mkdir(str(I))
  chdir(str(I))
  for J in HIERARQUIA[I]:
	 mkdir(str(J))
  chdir(pardir)


# Dado um dicionario, cria os arquivos aleatoriamente
def cria_arquivos(HIERARQUIA):
  for I in HIERARQUIA:
  print "Arquivos em %s\n"%(I)
  chdir(str(I))
  ARQ_QTD = randint(0,MAX_ARQ)
  print "Quantidade de arquivos:%d\n"%(ARQ_QTD)
  for J in range(0,ARQ_QTD):
	 DATA_QTD = randint(MIN_ARQ_DATA,MAX_ARQ_DATA)
	 NOME = ''.join([choice(letters) for X in xrange(MAX_DIR_NAME)])
	 DATA = ''.join([choice(printable) for Y in xrange(DATA_QTD)])
	 FILE = open(NOME,"w")
	 FILE.writelines(DATA)
	 FILE.close()
  chdir(pardir) 


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"

[Renan T. Fernandes 0]

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]
#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² - 4*a*c
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))

# x = -b +/- RaizDeDelta
#	 ----------------
#		   2 * a
contaPositiva = (-valorB + deltaRaiz) / (2 * valorA)
contaNegativa = (-valorB - deltaRaiz) / (2 * valorA)

#imprime as informações
print "Delta:", str(delta)
print "Raiz de Delta:", str(deltaRaiz)
print "X':", str(contaPositiva)
print "X\":", str(contaNegativa)

[Heigler 0]

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 ;)

[Heur 0]

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:

 

# -*- coding: cp1252 -*-
try:
    import kinterbasdb
except:
    pass

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.

[NEI.ESC 0]

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) - (4*a*c)

       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 []

# Calculador Equação do 2° Grau http://www.profcardy.com/calculadoras/aplicativos.php?calc=2
print(bhaskara(6,2,-20))
print(bhaskara(6,2,20))
print(bhaskara(2,6,-20))
print(bhaskara(2,6,20))
#print bhaskara(3,-7,2)
#print bhaskara(-1,4,-4)
#print bhaskara(1,8,16) # http://www.brasilescola.com/matematica/equacao-2-grau.htm
#print bhaskara(5,-6,5)
#print bhaskara(2,-16,50) # exercicio tirado do site: http://www.brasilescola.com/matematica/numeros-complexos1.htm
#print bhaskara(2,-10,12)

[Mayron Ceccon 5]

#!/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()

[Almir Bispo 2]

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')