Hola de nuevo!

Os dejo el enlace de un libro en línea muy interesante. Agradecer a sus autores (Brad Miller y David Ranum) y al traductor del mismo (Mauricio Orozco-Alzate) esta grandiosa aportación. Lástima que no se pueda adquirir en PDF. Pero bueno, tampoco nos vamos a poner exigentes  


EDITO:

He visto que accediendo desde el enlace informa como página no segura. En todo caso, si ponéis en el buscador de Google esto:

Solución de problemas con algoritmos y estructuras de datos usando Python

Es la primera entrada que sale.

Hola de nuevo!  

Ya sé que es muy subjetiva la pregunta. Y quizás dependerá del tamaño del script. Pero después de ver algunos tutoriales (vídeos, webs, blogs...), los creadores de los mismos enseñan tkinter sin usar la POO. Aunque también es verdad, que en python, siempre estamos trabajando con objetos. Incluso con tkinter para hacer una simple ventana ya estamos instanciando de la clase:

ventana = Tk()

Por eso tengo la duda si es redundante crear clases sobre clases. Y si por otro lado se enreda mucho el código.

Quizás, como algunos programadores, tengo algunas dudas de cuando usar clases (o la POO) y cuando no.

Cuando empiezo a crear un código es como si otro programador invisible me estuviera diciendo ¡Ostras, usa la POO! Pero en tkinter no la veo tan imprenscindible.

Bueno, un saludo!

Hola de nuevo!  

Llevo un tiempo haciendo programas de Python en consola. Ahora me he decidido por usar una GUI. Y me he decantado por tkinter. He ido conociendo un poco los widgets y con el Checkbutton me han asaltado unas dudas:

En casi todos los ejemplos se crean unos pocos Checkbutton. Para cada uno de ellos se debe crear la variable de su estado y una función (normalmante llamada por command del widget Button). Pero claro, si queremos crear, por ejemplo, diez o veinte Checkbutton la cosa se desmadra y se crea un código redundante y repetitivo.

Ejemplo:

def imprime():
    global lista
    lista = []
    if _1.get() == 1:
        lista.append(1)
    if _2.get() == 1:
        lista.append(2)
    if _3.get() == 1:
        lista.append(3)
    if _4.get() == 1:
        lista.append(4)
    if _5.get() == 1:
        lista.append(5)
    if _6.get() == 1:
        lista.append(6)
    if _7.get() == 1:
        lista.append(7)
    if _8.get() == 1:
        lista.append(8)
    if _9.get() == 1:
        lista.append(9)
    if _10.get() == 1:
        lista.append(10)
_1 = IntVar()
_2 = IntVar()
_3 = IntVar()
_4 = IntVar()
_5 = IntVar()
_6 = IntVar()
_7 = IntVar()
_8 = IntVar()
_9 = IntVar()
_10 = IntVar()
chk1 = Checkbutton(ventana, text = '1', variable = _1, onvalue = 1, offvalue = 0).place(x = 10, y = 30)
chk2 = Checkbutton(ventana, text = '2', variable = _2, onvalue = 1, offvalue = 0).place(x = 10, y = 60) 
chk3 = Checkbutton(ventana, text = '3', variable = _3, onvalue = 1, offvalue = 0).place(x = 10, y = 90) 
chk4 = Checkbutton(ventana, text = '4', variable = _4, onvalue = 1, offvalue = 0).place(x = 10, y = 120)
chk5 = Checkbutton(ventana, text = '5', variable = _5, onvalue = 1, offvalue = 0).place(x = 10, y = 150) 
chk6 = Checkbutton(ventana, text = '6', variable = _6, onvalue = 1, offvalue = 0).place(x = 10, y = 180)
chk7 = Checkbutton(ventana, text = '7', variable = _7, onvalue = 1, offvalue = 0).place(x = 10, y = 210)
chk8 = Checkbutton(ventana, text = '8', variable = _8, onvalue = 1, offvalue = 0).place(x = 10, y = 240) 
chk9 = Checkbutton(ventana, text = '9', variable = _9, onvalue = 1, offvalue = 0).place(x = 10, y = 270)
chk10 = Checkbutton(ventana, text = '10', variable = _10, onvalue = 1, offvalue = 0).place(x = 60, y = 30)

Esto es un extracto del código. El que hace referencia a la duda que me surge. Es decir, se puede dar el caso que un programa tenga 100 casillas a seleccionar ¿Cómo se puede evitar este código tan repetitivo?

Saludos!

Hola de nuevo!

Quizás recomendaríais otro tipo de modulo para este tipo de impresiones. Bueno, me refiero a mostrar gráficas y salida de datos. Pygame se suele utilizar para el tema de videojuegos y multimedia. Algo tan simple como mostrar la salida de un ciclo FOR (u otras salidas de datos) no  me llegaba a aclarar. En todo caso, me gustaría saber vuestra opinión, si es la forma correcta de hacer esta implementación.

Creo un ciclo para mostrar 40 números. Pero como llega un momento que la ventana definida en pygame se queda pequeña, hemos de crear otra columna para que se muestre el resto de números. Lo ideal seria que se creasen tantas columnas como números del ciclo. Claro esta que llegaría un momento que también se llegaría al limite de esa misma ventana ¿Se debería crear una nueva ventana y perderíamos la anterior? ¿Pygame no tiene la barra de desplazamiento como las ventanas de windows?

Os dejo el código que he creado:
(Es un esquema básico o plantilla para mostrar el ejemplo)

import pygame
import sys
pygame.init()
 
pantalla = pygame.display.set_mode((800, 600))
fuente = pygame.font.SysFont('Comic Sans MS', 20, True, False)
 
while True:
 
    for evento in pygame.event.get():
        if evento.type == pygame.QUIT:
            pygame.quit()
            sys.exit()            
 
    pantalla.fill((255, 255, 255))
 
    # Coordenadas iniciales impresion de columnas
    y = 0
    x = 0
    for numero in range(1, 41):        
        imprime_numero = fuente.render(str(numero), True, (0, 0, 0))
        pantalla.blit(imprime_numero, (x, y))
        y += 20
        # Si la coordenada 'y' llega a 400 se crea una nueva columna
        if y == 400:
            x = 40
            y = 0                   
 
    pygame.display.flip()

Si lo ejecutáis se crea una columna del 1 al 20 y otra del 21 al 40.
¿Es la forma correcta de imprimir un ciclo FOR en pygame?

Saludos!

EDITO:

Con esta modificación en la linea 26 se crean mas columnas en base a mas números en el ciclo:

x += 40

Hola de nuevo...

Estudiando el tema de los nodos y sus recorridos me surgio una duda con el bucle while. Para entrar en un bucle while la condicion debe ser verdadera. Hasta ahi nada nuevo. Osea, solo que pongamos:

while 1:
    pass

Entramos en el bucle. Y esto es por que 1 es True.

1 == True
True

Pero...

2 == True
False
 

No devuelve False ¿Entonces como es que se entra en el bucle while?

x = 0
while 2:
    print('hola')
    x += 1
    if x == 5:
        break
 

Con este codigo se ejecuta el bucle. Seguro que la duda es muy tonta y alguna explicacion tiene que se me ha pasado por alto.

El codigo del nodo es el tipico:

class Nodo:
    def __init__(self, carga = None, prox = None):
        self.carga = carga
        self.prox = prox
 
    def __str__(self):
        return str(self.carga)
 
 
n4 = Nodo(4)
n3 = Nodo(3, n4)
n2 = Nodo(2, n3)
n1 = Nodo(1, n2)
 
 
 
def recorrer(nodo):
    print(nodo)
    while nodo:
        print(nodo)
        nodo = nodo.prox
 
# Aqui podemos ver como n2 vale 2 y si es false ¿Por que se entra en while?     
recorrer(n2)
 

Ya sé que esta pregunta abre un debate que igual no lleva a ningún lado. Pero veo que hay muchos partidarios de la recursividad y otros que no tanto. Es como cuando se aplica la POO en todos los códigos, cuando igual, no hace falta. Pero claro, a veces es difícil distinguir cuando usar la POO o la recursividad. Leo a programadores (calificados de expertos) que argumentan que todo lo que se puede hacer con recursividad se puede aplicar con iteración. Y en caso de duda ¿Por dónde decantarse?

Donde veo que utilizan mucho el tema de la recursividad es con la IA o el tema de árboles y grafos.  Ósea, con estructuras de datos no lineales. La cuestión, es, si con iteración se podrían conseguir los mismos resultados o sería más complicado.

Quizás soy la única persona en la tierra que lee más fácil la iteración que la recursividad. Porque se suele argumentar que el código recursivo es más legible y elegante (aquí me refiero a Python) . No sé, a mí siempre se me ha hecho más enrevesado. Pero claro, eso ya es algo subjetivo.

Supongo, que a fuerza de programar, esas dudas se disipan. Y casi instintivamente sabe uno cuando aplicar la recursividad y cuando no.

Pues eso…¿Utilizáis mucho la recursividad? A mi es uno de los conceptos que más pereza me ha dado siempre por estudiar. O quizás, desde mi ignorancia, lo he dajado en segundo plano.

Hola de nuevo!

Estoy haciendo alguna prueba con cx_freeze. Osea, para convertir archivos py a exe.

Con scripts sencillos me funciona. Por ejemplo (prueba_2.py):

for i in range(1, 100):
    print(i)
input()

Luego creo el script de cx_freeze (setup.py):

from cx_Freeze import setup, Executable
 
 
setup(name = "Plantilla", 
      version = "0.1", 
      description = "Crear ejecutable",  
      executables = [Executable("prueba_2.py")])

Esto me crea la carpeta build dentro del directorio de python. Y dentro de la carpeta build tengo el ejecutable prueba_2.exe y alguna carpeta mas.

El problema viene, cuando en algun script que creo, importo algun modulo. Por ejemplo, pickle. Creia que con esto bastaba:

from cx_Freeze import setup, Executable
 
build_exe_options = {"packages": ["pickle"]}
 
setup(name = "Plantilla", 
      version = "0.1", 
      description = "Crear ejecutable",  
      options = {"build_exe": build_exe_options},
      executables = [Executable("ejemplo.py")])

Pero no funciona. He leido algunos tutoriales pero sigue sin funcionar. Para construir el exe hago la tipica llamada:

C:\Python34>py setup.py build

Hay alguna plantilla de cx_freeze para poder utilizar los modulos standard de Python? En mi caso, la version 3.4

Hola!

Profundizando mas en el tema de las clases, intento conocer un poco mas los operadores y metodos que seran utiles usando la sobrecarga.

La sobrecarga de operadores esta mas o menos clara:

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad
        self.inventario = '1,2,3,4,5,6,7'.split(',')
 
    # metodos aritmeticos
 
    def __add__(self, other):
        # suma
        return self.edad + other.edad     
 
    def __sub__(self, other):
        # resta
        return self.edad - other.edad
 

Para sobrecargar la funcion standard de python pow(a, b):

def __pow__(self, valor):
        # potenciacion
        return self.edad ** valor

Luego instanciariamos:

p1 = Persona('Juan', 30)
p2 = Persona('Ivan', 20)

Y probariamos las sobrecargas:

print(p1 + p2) # 50 (__add__)
print(p1 - p2) # 10 (__sub__)
print(p1 ** 2) # 900 (__pow__)

¿Pero como se sobrecargaria, por ejemplo, la funcion standard len()? Seria para comprobar el numero de elementos del atributo self.inventario. Creo que asi seria erroneo:

def __len__(self):
        return len(self.inventario)

Aunque funcionar, funciona...

print(len(p1)) # 7

La duda es si sobrecargar funciones standard de Python consiste en meter la misma funcion dentro del metodo sobrecargado. Es que visto asi, suena a redundancia ¿No?

Por que cuando queremos utilizar la salida de print mediante la sobrecarga hacemos:

def __str__(self):
        # se ejecuta mediante print()
        return 'Nombre: {}'.format(self.nombre)

No esto:

def __print__(self):
        # se ejecuta mediante print()
        return 'Nombre: {}'.format(self.nombre)

Resumiendo, ¿Es mejor crear nuestros propios metodos y meter dentro de ellos las funciones standard?

Saludos!  

Hola de nuevo...

Igual la pregunta es una herejia. Si es asi, pido disculpas. Pero creo, que ha dia de hoy, aun no le encuentro un uso sustancial con las clases (me refiero al uso de las propiedades).

Supongo que como todo el mundo al estudiar la POO, uno se enfoca con los atributos, metodos, herencia, sobrecarga de metodos, polimorfismo y un poco menos encapsulacion. Digo un poco menos "encapsulacion" por que Python tampoco trata los metodos y atributos de forma privada al cien por cien.

Por lo que entiendo, una propiedad o property dentro de una clase, significa usar un metodo como si fuera un atributo. Pero cuando pasamos a llamar a ese metodo usando la propiedad solo obviamos los parentesis. Es por eso que tampoco veo tanto ahorro.

Pongo los ejemplos clasicos de una clase Circulo. Los dos primeros ejemplos son semejantes. Osea, en el primer ejemplo usamos el decorador @property. En el segundo, la funcion interna property()

1er EJEMPLO:

class Circulo_1:
 
    def __init__(self, radio):
        self.radio = radio
 
    @property
    def dameArea(self):
        return 3.14159 * (self.radio ** 2)

2do. EJEMPLO:

class Circulo_2:
 
    def __init__(self, radio):
        self.radio = radio        
 
    def dameArea(self):
        return 3.14159 * (self.radio ** 2)
 
    area = property(dameArea)

Y por ultimo sin usar las propiedades:

class Circulo_3:
 
    def __init__(self, radio):
        self.radio = radio        
 
    def dameArea(self):
        return 3.14159 * (self.radio ** 2)

Instanciamos y pasamos a correr el codigo en cada ejemplo:

# instanciamos:
c1 = Circulo_1(20)
c2 = Circulo_2(20)
c3 = Circulo_3(20)
 

c1.dameArea
1256.636
c2.area
1256.636
c3.dameArea()
1256.636
 

En el tercer caso, sin usar property, solo hemos de poner dos parentesis y punto. Tampoco lo veo nada del otro mundo. En el segundo ejemplo, podemos crear un variable asignandole los valores de metodo usando la funcion property(). Y en el primer caso, usando un decorador.

Supongo que muchos programadores avanzados le daran uso a las propiedades. Y mas aun con los getters y setters. Pero si no usamos atributos o metodos semi-privados ¿Es necesario usar las propiedades en python?

Hola!

Bueno, esta claro que para gustos los colores. Yo suelo programar en Python, pero como un hobby y tal. Seguramente, que si uno se dedica a esto (programacion) de forma profesional, necesitara usar GUIs y ventanas. Osea, interfaces mas majos. La cosa es, de si uno puede hacer buenos programas en consola. Tampoco me refiero que sea solo linea de comandos. Si no, hacer menus y cambios de pantalla utilizando solo codigo. Sin utilizar ventanas, botones, lineas de desplazamiento, etc...

Es que, a veces veo,  que para poner un simple 'Hola Mundo' se debe picar relativamente bastante codigo para que solo se muestre una ventana. Supongo que porque se utilza la POO.

Resumiendo ¿Se es un raro por disfrutar la programacion espartana?