[Python]Gestor de pago de cuentas

Hola, buen día a todos !

Hace un rato que no subo nada de nada al blog :P , últimamente ando programando cosas, pero nada subo al blog :’( , así que programé un “Gestor de pagos de cuentas”.

Tiene sencillas opciones:

  • 1.- Ver cuentas.
  • 2.- Agregar/Editar una cuenta.
  • 3.- Informar pago de cuenta.
  • 4.- Ver cuentas pagadas.
  • 5.- Calcular cuanto he pagado en cuentas.
  • 6.- Eliminar una cuenta pagada.
  • 7.- Salir.

Pasaré a explicar algunas:

La primera opción nos permitirá visualizar las cuentas que hayamos ingresado anteriormente con la opción 2.

La segunda opción nos permitirá agregar alguna cuenta que tengamos pendientes en pagar. Nos pedirá el nombre de la cuenta, cuanto es el monto a cancelar y la fecha en la que debemos pagar la cuenta. El programa cuando se inicia verifica todas las cuentas y nos avisa que cuenta vence el día en que se ejecute.

La tercera opción nos dará la posibilidad de informar que ya hemos pagado una cuenta pendiente. Al entrar en esta opción nos mostrará las cuentas que no se han pagado, nos pedirá el nombre de la cuenta que vamos a señalar que está pagada, luego preguntará ¿Pagada?(s/n) , luego nos dirá si queremos conservar el registro de que esa cuenta fue pagada, en caso de ser “s” luego tendremos acceso a esos datos desde el menú, de lo contrario se perderán.

La opción cuatro solo nos mostrará en pantalla las cuentas que hemos pagado.

Opción 5 hará un calculo total de cuanto dinero hemos utilizado en el pago de nuestras cuentas, recuerda que si en la opción 3 no señalaste guardar un registro aquí no se sumará dicho gasto.

Mientras que la opción 6 nos mostrará por pantalla las cuentas que ya hemos pagado, dándonos la posibilidad de eliminar uno de los registros.

Sin más preámbulos , el código:

#-*- coding: utf-8 -*-
import datetime, re, os, sys

def clear_screen():
	os.system("cls") if(os.name=='nt') else os.system("clear")

if not os.path.isdir("cuentas"):
	respuesta = raw_input("""
No están las carpetas necesarias para el correcto
	Funcionamiento del programa
           ¿Desea crerlas? (s/n): """).lower()
	if respuesta=="s":
		try:
			os.mkdir("cuentas")
			os.mkdir("cuentas_pagadas")
			raw_input("Se crearon los archivos necesarios, presiona una enter para ir al programa.")
		except:
			print "Error al crear los archivos necesarios."
			sys.exit(1)
	else:
		print "No se instalará el programa."
		sys.exit(1)
else:
	pass
separar_fecha = str(datetime.datetime.now()).split(" ")[0]
parsear_fecha = separar_fecha.split("-")
fecha_normal = " %s/%s/%s"%(parsear_fecha[2], parsear_fecha[1], parsear_fecha[0])
clear_screen()
class cuentas:
	def extraer_cuentas(self):
		return os.listdir("cuentas/")

	def verificar_fechas(self):
		try:
			for cuenta in self.extraer_cuentas():
				ver_pagos = open("cuentas/%s"%cuenta,"r")
				for dato, valor in re.findall("(.*):(.*)",ver_pagos.read()):
					if "Vence" in dato:
						if valor==fecha_normal:
							print """
			¡ALERTA!
		 La cuenta de %s vence hoy!
		 """%cuenta.capitalize()
				ver_pagos.close()
		except:
			print "No se encontraron cuentas"

	def __init__(self):
		self.verificar_fechas()

	def ver_cuentas(self):
		global todos_lospagos
		todos_lospagos = []
		try:
			for ver_cuenta in self.extraer_cuentas():
				ver_pagos = open("cuentas/%s"%ver_cuenta,"r")
				todos_lospagos.append(ver_pagos.read()+"\n----")
				ver_pagos.close()
			return True
		except:
			return False

	def agregar_pago(self, tipo, valor, fecha):
		clear_screen()
		try:
			escribir_nuevo = open("cuentas/%s"%tipo,"w")
			escribir_nuevo.write("""Tipo de cuenta  : %s
Monto a cancelar: %s
Vence el día    : %s
Estado          : No pagada"""%(tipo, valor, fecha))
			escribir_nuevo.close()
			return True
		except:
			return False

	def cuenta_pagada(self, cuenta, estado, conservar):
		if estado == "s":
			if conservar == "s":
				try:
					cuenta_r = open("cuentas/%s"%cuenta,"r")
					cuenta_w = open("cuentas_pagadas/%s"%cuenta,"w")
					cuenta_w.write(cuenta_r.read().replace("No pagada", "Pagada"))
					cuenta_w.close()
					cuenta_r.close()
					os.remove("cuentas/%s"%cuenta)
					return True
				except:
					return False
			else:
				try:
					os.remove("cuentas/%s"%cuenta)
					return True
				except:
					return False
		else:
			return False

	def dinero_encuentas(self):
		try:
			global suma
			suma = 0
			for h in os.listdir("cuentas_pagadas"):
				for valor in re.findall("Monto a cancelar: (.*)",open("cuentas_pagadas/%s"%h,"r").read()):
					suma+=int(valor)
			return True
		except:
			return False

pago = cuentas()

while True:
	print """
 	¡ Bienvenido al gestor de pago de cuentas !
		La fecha de hoy es%s"""%fecha_normal
	try:
		opcion_principal = input("""
1.- Ver cuentas.
	2.- Agregar/Editar una cuenta.
		3.- Informar pago de cuenta.
			4.- Ver cuentas pagadas.
				5.- Calcular cuanto he pagado en cuentas.
					6.- Eliminar una cuenta pagada.
						7.- Salir.

Ingresa una opción: """)
		if opcion_principal == 7:
			break
		elif opcion_principal == 1:
			clear_screen()
			if len(os.listdir("cuentas"))>0:
				if pago.ver_cuentas():
					pago.verificar_fechas()
					print "Cuentas registradas:"
					for out in todos_lospagos:
						print out
				else:
					print "Error inesperado."
			else:
				print "No hay cuentas registradas."
		elif opcion_principal == 2:
			clear_screen()
			print "Si la cuenta ya existe, será reescrita con nuevos datos."
			try:
				print "Rellene los siguientes campos por favor. Si desea volver al menú presione \"q\" y ENTER."
				tipo_c = raw_input("Nombre de la cuenta: ").capitalize()
				if tipo_c != "Q":
					valor_c = raw_input("¿Cuanto debe pagar?: ")
					fecha_pago = raw_input("Fecha de pago(dd/mm/aa):")
					v_d = fecha_pago.split("/")
					v_f = fecha_normal.split("/")
					if len(v_d[0])==2 and len(v_d[1])==2 and len(v_d[2])==4:
						if v_d[2]>v_f[2] or v_d[2]==v_f[2] and not v_d[1]<=v_f[1]:
							if v_d[1] and v_f[1]:
								if pago.agregar_pago(tipo_c, valor_c, fecha_pago):
									print "Se agregó la cuenta correctamente."
								else:
									print "No se pudo agregar la cuenta, intentalo de nuevo."
							elif v_d[1]==v_f[1] and v_d[0]>=v_f[0]:
								if pago.agregar_pago(tipo_c, valor_c, fecha_pago):
									print "Se agregó la cuenta correctamente."
								else:
									print "No se pudo agregar la cuenta, intentalo de nuevo."
							else:
								print "La fecha no es válida o ya pasó..."

						else:
							print "Fecha mal ingresada."
					else:
						clear_screen()
						pass
			except:
				print "Ingrese datos válidos."

		elif opcion_principal == 3:
			clear_screen()
			if len(os.listdir("cuentas"))>0:
				print "Si usted decide no conservar registro de la cuenta, esta\nno será considerada en la opción 5"
				print "\nCuentas aún no pagadas:\n------"
				print "\n".join(os.listdir("cuentas"))
				cuenta = raw_input("------\nCuenta:").capitalize()
				estado = raw_input("¿Pagada?(s/n): ").lower()
				conservar = raw_input("¿Conservar registro?(s/n): ").lower()
				if pago.cuenta_pagada(cuenta, estado, conservar):
					print "Realizado con éxito"
				else:
					print "Ocurrió un problema."
			else:
				print "No hay cuentas registradas."
		elif opcion_principal == 4:
			clear_screen()
			if len(os.listdir("cuentas_pagadas"))>0:
				try:
					for h in os.listdir("cuentas_pagadas"):
						print open("cuentas_pagadas/%s"%h,"r").read()
						print "----"
				except:
					print "No se pueden ver las cuentas pagadas."
			else:
				print "No has pagado ni una cuenta aún."
		elif opcion_principal == 5:
			clear_screen()
			if len(os.listdir("cuentas_pagadas"))>0:
				if pago.dinero_encuentas():
					print "El dinero que has pagado en cuentas es de:",suma
			else:
				print "No has pagado ni una cuenta aún."
		elif opcion_principal == 6:
			clear_screen()
			cuentas_totales = os.listdir("cuentas_pagadas")
			if len(cuentas_totales)>0:
				print "Lista de las cuentas ya canceladas:"
				for listar_cuentas in cuentas_totales:
					print "* "+listar_cuentas
				eliminar_cuenta = raw_input("¿Que cuenta ya cancelada desea eliminar?: ").capitalize()
				if eliminar_cuenta in cuentas_totales:
					try:
						clear_screen()
						os.remove("cuentas_pagadas/%s"%eliminar_cuenta)
						print "Cuenta eliminada Correctamente"
					except:
						clear_screen()
						print "No se pudo eliminar la cuenta."
				else:
					clear_screen()
					print "No existe la cuenta solicitada."
			else:
				print "No hay cuentas pagadas."
	except:
		print "La opción ingresada no es un número."

Saludos, Javier.

Posted in Inicio

¡ Foro en Root Codes !

Hola a todos !

En esta oportunidad no vengo a presentar ni un código ni idea. Vengo a presentar el foro oficial de la web, alojado AQUÍ .

La idea es que ahí todos planteen sus dudas, aportes, quejas, ideas, etc. Espero veros registrados eh ! , quienes deseen aportar con algún rango en alguna sección hacedme saber por favor !

Junto con esta noticia, informo que re-activé el servicio de RootCodes | Paste una opción al ya conocido Pastebin, pero oriundo de RootCodes !

¡ Los espero por ahí. Saludos, Javier !

Posted in Inicio

[Python]Cliente FTP – RootCodes.Com

cliente_ftp

¡ Hola, buen día !

Hoy me tomé un par de minutos para programar un cliente FTP oficial del sitio web. Es por consola, pero vamos que ya estoy en planes de pasarlo a PyQT4. El código consta de 133 humildes líneas, intenté utilizar el máximo control de errores en el programa, para evitar que el programa salga de su curso normal… Si alguien ve que falla en algo por favor avisad aquí mismo ! , el cliente FTP por consola nos permitirá un par de acciones una vez conectado, estas son las básicas:

1.- Listar directorios / Archivos.
2.- Ingresar a un directorio.
3.- Eliminar un archivo ó directorio.
4.- Crear un directorio.
5.- Descargar un archivo remoto.
6.- Enviar un archivo local.
7.- Ver peso de un archivo remoto.
8.- Desconectar.

No creo que sea necesario describir cada una, así que los invito a leer el código :

# -*- coding: utf-8 -*-
from ftplib import FTP
while True:
	estado_conexion = 0
	try:
		print """
	¡ Hola, bienvenido al cliente FTP - RootCodes.Com !

¿ Qué deseas hacer ?

1.- Conectar a servidor FTP.
2.- Creditos/Autor.
3.- Salir.
"""
		opc = input("Opcion:")
		if opc == 1:
			try:
				servidor = raw_input("Servidor: ")
				usuario = raw_input("Usuario: ")
				clave = raw_input("Clave: ")
				sesion = FTP(servidor)
				print sesion.getwelcome()
				try:
					estado_conexion = 1
					sesion.login(usuario,clave)
					pasive_mode = raw_input("¿ Desea activar el modo pasivo ? (s/n) > ").lower()
					if pasive_mode == "s":
						print "¡ Activando modo pasivo !"
						try:
							sesion.set_pasv(True)
							print "¡ Modo pasivo activado !"
						except:
							print "¡ No se pudo activar modo pasivo !"
						while estado_conexion!=0:
							print "\n\nActualmente te encuentras en:", sesion.pwd()
							print """
1.- Listar directorios / Archivos.
2.- Ingresar a un directorio.
3.- Eliminar un archivo ó directorio.
4.- Crear un directorio.
5.- Descargar un archivo remoto.
6.- Enviar un archivo local.
7.- Ver peso de un archivo remoto.
8.- Desconectar.
"""
							try:
								in_server = input("Opción: ")
							except:
								print "¡ Ingresa un número porfavor !"
							if in_server == 1:
								try:
									print "Lista de archivos / directorios:"
									sesion.dir()
								except:
									print "¡ Error al listar archivos / directorios !"
							elif in_server == 2:
								try:
									join_dir = raw_input("Directorio: ")
									sesion.cwd(join_dir)
								except:
									print "¡ Error al intentar ingresar al directorio !"
							elif in_server == 3:
								print "1.- Eliminar archivo.\n2.- Eliminar Directorio."
								try:
									que_eliminar = input("Opción: ")
								except:
									print "¡ Por favor ingresa un número válido !"
								if que_eliminar == 1:
									try:
										archivo_del = raw_input("Archivo a eliminar: ")
										sesion.delete(archivo_del)
										print "¡ Archivo eliminado correctamente !"
									except:
										print "¡ Error al intentar eliminar el archivo !"
								elif que_eliminar == 2:
									try:
										carpeta_del = raw_input("Directorio a eliminar: ")
										sesion.rmd(carpeta_del)
										print "¡ Directorio Eliminado correctamente !"
									except:
										print "¡ Error al intentar eliminar el directorio !"
								else:
									print "¡ Opción ingresada no existe !"
							elif in_server == 4:
								try:
									crear_carpeta = raw_input("Nombre del nuevo directorio: ")
									sesion.mkd(crear_carpeta)
									print "¡ Nuevo directorio creado con éxito !"
								except:
									print "¡ Error al intentar crear el directorio !"
							elif in_server == 5:
								try:
									archivo_download = raw_input("Archivo a descargar: ")
									sesion.retrbinary("RETR %s"%archivo_download, open(archivo_download,"wb").write)
									print "¡ Archivo descargado con éxito !"
								except:
									print "¡ No se pudo descargar el archivo !"
							elif in_server == 6:
								try:
									archivo_local = raw_input("Archivo local: ")
									file_local = open(archivo_local,'rb')
									sesion.storbinary("STOR "+archivo_local, file_local)
									file_local.close()
									print " ¡Archivo enviado con éxito !"
								except:
									print "¡ No se pudo enviar el archivo !"
							elif in_server == 7:
								try:
									archivo_peso = raw_input("Archivo local: ")
									print "El peso del archivo %s, es: %s"%(archivo_peso,sesion.size(archivo_peso))
								except:
									print "¡ No se pudo obtener el peso !"
							elif in_server == 8:
								sesion.quit()
								estado_conexion=0
								print "¡ Desconectado con éxito !"
				except:
					print "¡ No se pudo lograr la conexión !"
			except:
				print "¡ Error en los datos de conexión !"

		elif opc == 2:
			print """
		Créditos -> Autor : JaAViEr || 0x5d
			  Twitter : @0x5d
			  WebSite : http://www.rootcodes.com
			"""

		elif opc == 3:
			print "¡ Gracias por utilizar Cliente FTP - RootCodes.Com !"
			break
	except:
		print "¡ Opción incorrecta !"

¡ Espero les haya gustado !

Saludos, Javier.

Posted in Inicio

[Python]Enviando y recibiendo cookies – JaAViEr|0x5d

cookies

 

Hola, buen día !

Hoy, estuve leyendo acerca de las preciadas cookies, antes de continuar, por si alguien no sabe que son las cookies, consultemos a la ya famosa Wikipedia:

Los cookies en informática sirven para:

  • Llevar el control de usuarios: cuando un usuario introduce su nombre de usuario y contraseña, se almacena una cookie para que no tenga que estar introduciéndolas para cada página del servidor. Sin embargo, una cookie no identifica a una persona, sino a una combinación de computador-navegador-usuario.
  • Conseguir información sobre los hábitos de navegación del usuario, e intentos de spyware, por parte de agencias de publicidad y otros. Esto puede causar problemas de privacidad y es una de las razones por la que las cookies tienen sus detractores.

Para la info completa aquí !

Bien, con este tema rápidamente me vinieron a la mente varias ideas para programar con respecto al caso. Me puse manos a la obra y pues por ahora conseguí un humilde programa de 68 líneas (sin reducir nada).

El código lo que hace es enseñarnos 3 opciones:

  1. Ver cookies.
  2. Enviar cookies.
  3. Salir.

Con la primera opción, nos pedirá una URL y nos devolverá las cookies contenidas en dicho sitio, posteriormente nos da la opción de poder almacenarla en un archivo.

Mientras que la segunda opción nos permitirá enviar una o más cookies a algún sitio web(NO ME HAGO RESPONSABLE DEL MAL USO QUE LE PUEDAN DAR), dándonos la opción de guardar la salida del HTML en un archivo local o simplemente mostrarlo en consola.

Si piensan en: Y para que guardarlo ? , podría ser para ver si algún logueo se realiza de forma correcta, si algunos datos varían con cada cookie, etc. A su imaginación lo dejo !

La tercera opción no tiene mucha ciencia, no creo que haya que explicarla jajaja. Bien, sin más preámbulos, el código:

# -*- coding: utf-8 -*-
#Autor: JaAViEr|0x5d
#Web: http://www.rootcodes.com
#Twitter: @0x5d

import urllib2, re, sys

while True:
	print"""
		¡ Obtén o envía cookies desde Python !

	1.- Ver cookies.
		2.- Enviar cookies.
			3.- Salir.
	"""
	try:
		opc = input("Opción ::> ")
		if opc in range(1,4):
			if opc == 3:
				break
			elif opc==1:
				try:
					url = raw_input("URL :: > http://")
					headers = urllib2.urlopen("http://%s"%url).info()
					cookie = re.findall("Set-Cookie:(.*)",str(headers))[0]
					if cookie:
						print "Cookie obtenida:\n", cookie
						save_q = raw_input("Guardar la cookie en un archivo?(TXT) (s/n) ::>").lower()
						if save_q=="s":
							try:
								archivo = open("%s.txt"%raw_input("Archivo : "),"w")
								archivo.write(str(cookie))
								archivo.close()
								print "Archivo guardado con éxito!"
							except:
								print "No se pudo guardar el archivo..."
					else:
						print "No se obtuvo cookies..."
				except:
					print "No se pudo conectar"
			elif opc==2:
				print "Recuerda separar cada cookie con un punto y coma (;) !"
				try:
					url = raw_input("URL :: > http://")
					cookie_tosend = raw_input("Cookies: ")
					save_cookies = urllib2.build_opener()
					save_cookies.addheaders.append(('Cookie', cookie_tosend))
					abrir_web = save_cookies.open("http://%s"%url)
					try:
						q_show = raw_input("Desea volcar el html en un archivo?(HTML) (s/n) ::> ")
						if q_show=="s":
							try:
								save_output = open("%s.html"%raw_input("Archivo de salida(sin .html):"),"w")
								save_output.write(abrir_web.read())
								save_output.close()
								print "Archivo guardado con éxito !"
							except:
								print "No se pudo guardar el archivo..."
						else:
							print abrir_web.read()
					except:
						print "Ocurrió un problema inesperado..."
				except:
					print "Error inesperado..."
			else:
				print "No existe dicha opcion"
	except:
		print "Por favor ingresa un número"

Hice el código lo más ordenado posible, manejando controles de error para todo, evitando un código desastroso (:

Pueden hacer la prueba del programa con esta url : Prueba Cookies

Envíen desde el programa, la cookie “name=Javier” y vean el resultado :D

Y como siempre… Espero sea de su agrado el código !

Saludos, Javier.

Posted in Inicio

[Python]Código Ofuscado JaAViEr|0x5d

Hola, buen día a todos nuevamente !

Estuve pensando en la gente que dice que Python es un lenguaje poco menos inofuscable(no sé si exista la palabra :P) y me pensé hacer un código ofuscado, pero sin depender de librerías :O , Python puro, ya que en la vez pasada lo hice vía base64 más algunas cositas -> http://www.rootcodes.com/pythoncalculadora-ofuscada

Ahora me propuse hacer otro código ofuscado, pero sin librerías ni nada. Es algo difícil de hacer(relativamente), ya que Python es un lenguaje estructurado, lo que facilita la lectura del código, así que ahí me las anduve ingeniando para que sea algo más engorroso :P, el código es el siguiente, espero sea de su ‘agrado’:

def ____(a_a_a):
	_____, ______, ________ = ([],[a_a_a],"")
	while ______[+False-True]!=False:     (_____
	, ______)=(_____+[______[False-True-True+True]%(True-False+True)],______+[______[-True+False+False**3]/(False+False+True*2)])
	for _ in _____[::-1]: ________+="%s"%_
	return (
	________
				)
(other_s
,t,
_x_) = ([
],raw_input,
[" "]
)
h =		(
	[__
		for
			__
in
str(
"""abcdefghijkl
	mnopqrs
			tuvwxyz"""
	)
			])
([(h.pop(),
other_s.append("%s"%(
___)))for ___
				in
			"""abcdefghijkl
	mnopqrs
tuvwxyz"""
	  ]);
(		[
_x_.append(_i_.replace("\n",""))
for _i_
	in
			other_s
		]	)
for s_s in t(">"):	 print ____(_x_.index(s_s)),

Bien, y que hace ?
Te pedirá un texto y te devolverá la posición de cada letra, pero en Binario :P , espero que alguien más se anime a ofuscar código Python y lo suba :D

Saludos, Javier

Posted in Inicio

[Python]Técnicas para reducir código

Hola, buen día !
En esta oportunidad pretendo seguir fomentando la reducción de código, aunque sea por unos cuantos caracteres, las formas que explicaré quizás no sean tan útiles para reducir mucho el source, pero si podrían usarlo para ofuscar códigos :P.

Bien, al grano ! . Como bien sabemos, hay varias funciones internas en nuestro amado Python, tales
como : int(), str(), raw_input(), input(), etc…

Entre esa lista podemos incluir nuestras funciones creadas vía “def”. Bien, pero eso que tiene de
especial ? , ahora vamos a eso …

Pondré un caso bien sencillo con el uso de def():

def funcion(parametro):
	print parametro

func = funcion
print func

Veremos que la salida es:

<function funcion at 0xb74a2454>

Bueno y eso qué dirán ustedes :P , aquí viene lo entretenido. Podemos insertar nuestra función dentro de una variable cualquiera y a partir de ese momento podemos llamar a dicha función por
el nombre de la variable… No se entiende ? , un ejemplo:

def funcion_sumar(primero, segundo):
	return primero+segundo

sumando = funcion_sumar
print "Resultado:",sumando(1,2)

Salida:

Resultado: 3

Lo mismo podemos aplicar con las anteriores funciones mencionadas. Yo sinceramente la utilidad que le veo es más que nada para la ofuscación de códigos o para utilizar menos carácteres en
nuestro código, cuando llamamos muchas veces a la función.

Bien, otra forma singular de llamar funciones podría ser insertar nuestras funciones en un diccionario, para quienes no saben a que me refiero con un diccionario:

diccionario = {"variable":valor}

Un sencillo ejemplo para que vean a que me refiero:

funciones = {"alfa":raw_input,"nums":input}
print funciones['alfa']("Texto ::>")
print funciones['nums']("Numero ::>")

Bien, es una manera diferente, pero no es la mejor para optimizar nuestros códigos…
Una forma similar, pero más corta sería:

alfa, nums = (raw_input, input)
print alfa("Texto ::>")
print nums("Numero ::>")

Eso quiere decir que alfa = raw_input() y nums = input()

Lo bueno de esto es que no nos limita a solo usarlo con Python en Consola, podemos aplicarlo por
ejemplo al hermoso PyQT4, por ejemplo, para no tener que escribir QtGui.QPushButton(“Valor”,self)
cada vez que creamos un botón, o para no tener que escribir QtGui.QLabel(“Valor”,self) por cada
label, tampoco tener que escribir QtGui.QLineEdit(“Valor”,self) por cada LineEdit en el formulario.

Podemos usar las siguientes líneas:

label, inpt, boton =(QtGui.QLabel,QtGui.QLineEdit,QtGui.QPushButton)

Por lo que luego de eso para crear un QtGui.QLabel(); solo debemos llamarlo así:

label("New Label", self)

De igual forma es aplicable para cada elemento, también podríamos utilizarlo para ofuscar códigos en PyQT4, pero a eso si que no le veo más utilidad que proteger nuestro source QT4, un ejemplo
de lo que digo en PyQT4:

# -*- coding: utf-8 -*-
# Autor : 0x5d ~> JaAViEr
# Sitio Web ~> www.rootcodes.com
# Twitter ~> @0x5d

from PyQt4 import QtGui, QtCore
import sys

class testeo(QtGui.QWidget):
  def __init__(self, parent=None):
    QtGui.QWidget.__init__(self, parent)
    self.setWindowTitle("Bin to Dec | 0x5d")
    label, inpt, boton =(QtGui.QLabel,QtGui.QLineEdit,QtGui.QPushButton)
    self.label_binario = label("Binario :", self).setGeometry(2,15,59,17)
    self.input_binario = inpt(self)
    self.input_binario.setGeometry(60,10,230,27)
    self.label_resultado = label("Resultado :", self).setGeometry(2,50,80,17)
    self.input_salida = inpt(self)
    self.input_salida.setGeometry(80,43,210,27)
    self.input_salida.setReadOnly(True)
    self.boton_limpiar = boton("Limpiar campos", self)
    self.boton_limpiar.setGeometry(1,75,140,27)
    self.boton_convertir = boton("Convertir", self)
    self.boton_convertir.setGeometry(145,75,140,27)
    self.connect(self.boton_limpiar, QtCore.SIGNAL("clicked()"), self.clear_inputs)
    self.connect(self.boton_convertir, QtCore.SIGNAL("clicked()"), self.conversor)

  def clear_inputs(self):
    self.input_binario.setText("")
    self.input_salida.setText("")

  def conversor(self):
    numero = str(self.input_binario.text())
    t = 0
    for i,h in zip(numero[::-1],range(0,len(numero))): t+=int(i)*2**int(h)
    self.input_salida.setText(str(t))

app = QtGui.QApplication(sys.argv)
form = testeo()
form.show()
app.exec_()

Espero sea de su agrado el artículo :) !

Saludos, Javier !

Posted in Inicio

[Python]Formas de saber si una palabra es palindromo

Hola, buen día a todos !

En esta oportunidad no vengo a dejar un graaaaaaaaaan material :P , pero siempre me gusta intentar hacer una misma cosa de varias maneras. Es por eso que decidí ver de cuantas formas podríamos hacer para verificar si una palabra es palíndromo. Bien, veamos el primero:

n = raw_input(">")
if n.isdigit():
	d = [h for h in n]
	if d == d[::-1]:  print "El numero es capicua: %s"%(n)
	else: print "El numero no es capicua : %s"%(n)
else:
	d = [h for h in n]
	if d == d[::-1]:  print "El texto es palindromo: %s"%(n)
	else: print "El texto no es palindromo : %s"%(n)

Como podemos apreciar el código es bastante sencillo , pedimos entrada por teclado. Verificamos si es la variables un dígito o no(if n.isdigit()). Luego la típica salida invirtiendo la cadena con variable[::-1].

Veamos otro código más sencillo aún:

variable = raw_input("Texto ::> ")
print "Resultado:",[h for h in variable[::-1]] == [s for s in variable]

Apenas dos líneas :D , un ejemplo de salida sería:

jaavier@Debian:~/codigos$ python palindromo.py
Texto ::> reconocer
Resultado: True
jaavier@Debian:~/codigos$ 

Otro ejemplo muy similar sería:

var = raw_input("Texto ::> ")
print "Respuesta:",var == var[::-1]

Con la misma salida que el anterior:

jaavier@Debian:~/codigos$ python palindromo.py
Texto ::> reconocer
Resultado: True
jaavier@Debian:~/codigos$ 

Y pues la manera más típica:

var = raw_input("Texto ::> ")
if var==var[::-1]:
	print "Es Palindromo"
else:
	print "No es palindromo"

También tenemos la famosa función lambda():

palindromo = lambda parametro: parametro==parametro[::-1]
print palindromo(raw_input("Texto ::> "))

Nos devolverá True o False.
Y Pues si son unos amantes de la reducción de código como yo, pueden aplicar:

print (lambda d: d==d[::-1])(raw_input("Texto ::> "))

Y a ti , que forma se te ocurre ?

Saludos, Javier.

Posted in Códigos