Archivo

Archive for the ‘Python’ Category

Downloader en Python

Simple downloader de archivos hecho en Python:

#!usr/bin/python

import sys,urllib,os,urlparse

def head():
 print "\n -- == Downloader == --\n"

def copyright():
 print "\n(C) Doddy Hackman 2011\n"
 sys.exit(1)

def uso():
 print "\n[+] downloader.py  \n"

def proxar(a,b,c):
 sys.stdout.write("\r[+] Status : %s / %s" % (a * b,c))

def down(file,filesave):
 print "\n[+] File to download : "+filesave+"\n"
 try:
  urllib.urlretrieve(file,filesave,reporthook=proxar)
 except:
  print "\n[-] Error\n"
  copyright()
 print "\n\n[+] File Download in "+os.curdir+"/"+filesave

head()

if len(sys.argv) == 3 :
 down(sys.argv[1],sys.argv[2])
else :
 uso()

copyright()

# The End

Fuente: foro.code-makers.net

Categorías:Programación, Python

Simple cliente FTP en Python

Aca traigo un simple cliente FTP:

#!usr/bin/python
#FTP Manager 0.2 (C) Doddy Hackman 20111

from ftplib import FTP
import sys

def head():
 print "\n -- == FTP Manger == --\n\n"

def copyright():
 print "\n\n(C) Doddy Hackman 2011\n"
 sys.exit(1)

def show():
 print "\nSintax : "+sys.argv[0]+"   \n"

def menu():
 print "\n"
 print "1 : dir"
 print "2 : cwd"
 print "3 : chdir"
 print "4 : delete dir"
 print "5 : delete file"
 print "6 : rename file"
 print "7 : make directory"
 print "8 : size"
 print "9 : abort\n\n"
 op = input("[Option] : ")
 return op

def enter(host,user,password):
 print "[+] Connecting to ",host,"\n"
 enter = FTP(host,user,password)
 print "\n[+] Enter in the system\n"

 def menu2():
  op = menu()
  if op == 1:
   try:
    lista = enter.dir()
    for a in lista:
     print a
    menu2()
   except:
    menu2()
  elif op == 2:
   try:
    print "\n\n[+] Path : "+enter.pwd()+"\n\n"
    menu2()
   except:
    menu2()
  elif op == 3:
   try:
    dir = raw_input("\n\n[Directory] : ")
    enter.cwd(dir)
    print "\n\n[+] Directory Changed\n\n"
    menu2()
   except:
    menu2()
  elif op == 4:
   try:
    dir = raw_input("\n\n[Directory] : ")
    enter.rmd(dir)
    print "\n\n[+] Directory Deleted\n\n"
    menu2()
   except:
    menu2()
  elif op == 5:
   try:
    file = raw_input("\n\n[File] : ")
    enter.delete(file)
    print "\n\n[+] File Deleted\n\n"
    menu2()
   except:
    menu2()
  elif op == 6:
   try:
    oldfile = raw_input("\n\n[Name] : ")
    newfile = raw_input("\n[New Name] : ")
    enter.rename(oldfile,newfile)
    print "\n\n[+] Name Changed\n\n"
    menu2()
   except:
    menu2()
  elif op == 7:
   try:
    dir = raw_input("\n\n[New Directory] : ")
    enter.mkd(dir)
    print "\n\n[+] Directory Created\n\n"
    menu2()
   except:
    menu2()
  elif op == 8:
   try:
    file = raw_input("\n\n[File] : ")
    peso = enter.size(file)
    print "\n\n[+] ",peso," KB \n\n"
    menu2()
   except:
    menu2()
  elif op == 9:
   enter.quit()
   copyright()

  else:
   menu2()
 menu2()

head()

if len(sys.argv) != 4:
 show()
else:
 enter(sys.argv[1],sys.argv[2],sys.argv[3])

copyright()
Categorías:Programación, Python

Tutorial: compilar *.py a *.exe

Bueno en este pequeño tutorial les voy a explicar como compilar un archivo *.py de python a *.exe, primero que nada veremos la pagina oficial del programa http://www.py2exe.org/ , luego lo descargamos d la siguiente dirección: http://sourceforge.net/project/showfiles.php?group_id=15583

Empezamos con el procedimientos

Paso 1

Primero que nada instalamos el py2exe en la maquina en el directorio donde quedo instalado el python; Una vez ya creado nuestro archivo que queremos compilar, creamos otro archivo *.py que contenga estas lineas :

from distutils.core import setup
import py2exe
setup(console=["nombre_de_archivo.py"])

Donde dice nombre_de_archivo lo cambiamos por el nombre del archivo a pasar a *.exe.

Paso 2

Ahora guardamos los dos archivo setup.py y nombre_de_archivo.py, en el directorio de instalación de python que va a depender de la versión…  entonces nos dirigimos a la consola de comandos Inicio > Ejecutar > “CMD”

y nos dirigimos al directorio de instalación de Python c:\python25 ( usando el comando cd.. para subir de carpeta y cd python25 para entrar o acceder a la carpeta, comandos basicos batch)

Una vez dentro del directorio en el cmd tecleamos la siguiente linea de comandos

c:\python25> setup.py py2exe

Lo que hará será ejecutar nuestro archivo setup.py y arrancar el py2exe para compilar

Despues al compilar nos aparecerá algo como esto:

running py2exe
*** searching for required modules ***
*** parsing results ***
creating python loader for extension 'zlib'
creating python loader for extension 'unicodedata'
creating python loader for extension 'bz2'
*** finding dlls needed ***
*** create binaries ***
*** byte compile python files ***
byte-compiling C:Tutorialbuildbdist.win32winexetempbz2.py to bz2.pyc
byte-compiling C:Tutorialbuildbdist.win32winexetempunicodedata.py to unicodedata.pyc
byte-compiling C:Tutorialbuildbdist.win32winexetempzlib.py to zlib.pyc
skipping byte-compilation of c:Python24libStringIO.py to StringIO.pyc
[skipping many lines for brevity]
skipping byte-compilation of c:Python24libwarnings.py to warnings.pyc
*** copy extensions ***
*** copy dlls ***
copying c:Python24libsite-packagespy2exerun.exe -> C:Tutorialdisthello.exe
*** binary dependencies ***
Your executable(s) also depend on these dlls which are not included,
you may or may not need to distribute them.
Make sure you have the license if you distribute any of them, and
make sure you don't distribute files belonging to the operating system.
ADVAPI32.dll - C:WINDOWSsystem32ADVAPI32.dll
USER32.dll - C:WINDOWSsystem32USER32.dll
SHELL32.dll - C:WINDOWSsystem32SHELL32.dll
KERNEL32.dll - C:WINDOWSsystem32KERNEL32.dll

Por último el programa creará una carpeta en c:\python25\dist\ que es dodne se ha guardado nuestro *.exe compilado con todas librerias necesarias para ejecutarlo, ( queda bastante pesado o.o)

Fuente: foro.code-makers.net

Python: lista de 50 módulos con diferentes propósitos

Python es un lenguaje muy simple y fácil de aprender con una gran potencia. Yo lo uso principalmente para realizar tareas automatizadas que no requieran mucho código ni una interfaz gráfica. Lo que más me gusta de este lenguaje es la gran cantidad de módulos disponibles que tiene, para las diferentes necesidades del programador: interfaz gráfica, interacción Web y FTP, programación de videojuegos, bioquímica, robótica, cheats para videojuegos, brute forcing, cracking, étc.

Aquí les dejo la URL de un sitio que contiene una lista de 50 módulos de Python para todas las necesidades: Python: 50 modules for all needs

Categorías:Programación, Python

Python: módulos y paquetes

Módulos

Para facilitar el mantenimiento y la lectura los programas demasiado largos pueden dividirse en módulos, agrupando elementos relacionados. Los módulos son entidades que permiten una organización y división lógica de nuestro código. Los ficheros son su contrapartida física: cada archivo Python almacenado en disco equivale a un módulo.

Vamos a crear nuestro primer módulo. Entonces, creando un pequeño archivo modulo.py con el siguiente contenido:

def mi_funcion():
  print "una funcion"

class MiClase:
  def __init__(self):
    print "una clase"

print "un modulo"

Si quisiéramos utilizar la funcionalidad definida en este módulo en nuestro programa tendríamos que importarlo. Para importar un módulo se utiliza la palabra clave import seguida del nombre del módulo, que consiste en el nombre del archivo menos la extensión. Como ejemplo, creemos un archivo programa.py en el mismo directorio en el que guardamos el archivo del módulo, con el siguiente contenido:

import modulo

modulo.mi_funcion()

El import no solo hace que tengamos disponible todo lo definido dentro del módulo, sino que también ejecuta el código del módulo. Por esta razón nuestro programa, además de imprimir el texto “una funcion” al llamar a mi_funcion, también imprimiría el texto “un modulo”, debido al print del módulo importado. No se imprimiría, no obstante, el texto “una clase”, ya que lo que se hizo en el módulo fue tan solo definir de la clase, no instanciarla.

La clausula import también permite importar varios módulos en la misma línea. En el siguiente ejemplo podemos ver cómo se importa con una sola clausula import los módulos de la distribución por defecto de Python os, que engloba funcionalidad relativa al sistema operativo; sys, con funcionalidad relacionada con el propio intérprete de Python y time, en el que se almacenan funciones para manipular fechas y horas.

import os, sys, time

print time.asctime()

Sin duda os habréis fijado en este y el anterior ejemplo en un detalle importante, y es que, como vemos, es necesario preceder el nombre de los objetos que importamos de un módulo con el nombre del módulo al que pertenecen, o lo que es lo mismo, el espacio de nombres en el que se encuentran. Esto permite que no sobreescribamos accidentalmente algún otro objeto que tuviera el mismo nombre al importar otro módulo.

Sin embargo es posible utilizar la construcción from-import para ahorrarnos el tener que indicar el nombre del módulo antes del objeto que nos interesa. De esta forma se importa el objeto o los objetos que indiquemos al espacio de nombres actual.

from time import asctime

print asctime()

Aunque se considera una mala práctica, también es posible importar todos los nombres del módulo al espacio de nombres actual usando el caracter ‘*’:

from time import *

Ahora bien, recordareis que a la hora de crear nuestro primer módulo insistí en que lo guardarais en el mismo directorio en el que se encontraba el programa que lo importaba. Entonces, ¿cómo podemos importar los módulos os, sys o time si no se encuentran los archivos os.py, sys.py y time.py en el mismo directorio?

A la hora de importar un módulo Python recorre todos los directorios indicados en la variable de entorno PYTHONPATH en busca de un archivo con el nombre adecuado. El valor de la variable PYTHONPATH se puede consultar desde Python mediante sys.path

import sys

sys.path

De esta forma para que nuestro módulo estuviera disponible para todos los programas del sistema bastaría con que lo copiáramos a uno de los directorios indicados en PYTHONPATH.

En el caso de que Python no encontrara ningún módulo con el nombre especificado, se lanzaría una excepción de tipo ImportError.

Por último es interesante comentar que en Python los módulos también son objetos; de tipo module en concreto. Por supuesto esto significa que pueden tener atributos y métodos. Uno de sus atributos, __name__, se utiliza a menudo para incluir código ejecutable en un módulo pero que este sólo se ejecute si se llama al módulo como programa, y no al importarlo. Para lograr esto basta saber que cuando se ejecuta el módulo directamente __name__ tiene como valor __main__, mientras que cuando se importa, el valor de __name__ es el nombre del módulo:

print "Se muestra siempre"

if __name__ == "__main__":

print "Se muestra si no es importacion"

Otro atributo interesante es __doc__, que, como en el caso de funciones y clases, sirve a modo de documentación del objeto (docstring o cadena de documentación). Su valor es el de la primera línea del cuerpo del módulo, en el caso de que esta sea una cadena de texto; en caso contrario valdrá None.

Paquetes

Si los módulos sirven para organizar el código, los paquetes sirven para organizar los módulos. Los paquetes son tipos especiales de módulos (ambos son de tipo module) que permiten agrupar módulos relacionados. Mientras los módulos se corresponden a nivel físico con los archivos, los paquetes se representan mediante directorios.

En una aplicación cualquiera podríamos tener, por ejemplo, un paquete iu para la interfaz o un paquete bbdd para la persistencia a base de datos.

Para hacer que Python trate a un directorio como un paquete es necesario crear un archivo __init__.py en dicha carpeta. En este archivo se pueden definir elementos que pertenezcan a dicho paquete, como una constante DRIVER para el paquete bbdd, aunque habitualmente se tratará de un archivo vacío. Para hacer que un cierto módulo se encuentre dentro de un paquete, basta con copiar el archivo que define el módulo al directorio del paquete.

Como los modulos, para importar paquetes también se utiliza import y from-import y el caracter ‘.’ para separar paquetes, subpaquetes y módulos.

import paq.subpaq.modulo

paq.subpaq.modulo.func()
Categorías:Programación, Python

"Hola Mundo" en Python

Python es un lenguaje en el que no es necesario declarar un “main()” para indicarle cuál es la función principal y desde dónde debe comenzar a correr a la hora de ejecutar una aplicación Python.

Las aplicaciones Python son scripts lineales. El intérprete de Python lee el script de principio a fin, sin buscar una función “main()”, por eso un “Hola Mundo” en este lenguaje sería:

print "Hola Mundo"

Sólo eso. No es necesario tampoco importar ninguna biblioteca o librería externa, ya que la función print Pyhon la implementa por default.

Categorías:Programación, Python

Python: código para reemplazar carácteres de un archivo

Código que permite reemplazar carácteres de un archivo.
Por ejemplo, tenemos un archivo que tiene muchos ‘8’(ocho), y queremos reemplazar todos esos ‘8’ por ‘9’(nueve). Entonces utilizamos este código que permitirá reemplazar todos los ochos por nueves.

filename = "archivo.txt"
char1 = '8'
char2 = '9'

filer = open(filename, "r")
filew = open(filename+'.mod', "w")

buff = filer.read()
rbuff = buff.replace(char1, char2)

filew.write(rbuff)

filer.close()
filew.close()

Lo que hace esto es reemplazar un carácter por otro detro del fichero archivo.txt y luego guarda el archivo ya modificado en otro archivo llamado igual que el archivo original pero con la extension .mod al final: archivo.txt.mod

Categorías:Programación, Python