¿Cómo se compara Moose con el sistema OO de Python?

Question

Mi pregunta original era demasiado vaga y fue "cerrada como no constructiva". Como tal, revisaré la pregunta para que atienda las respuestas que ya se han publicado. :-)

Estoy interesado en las diferencias entre el framework Moose OO de Perl Moose y el framework OO de Python. Como primer punto de comparación, ¿qué tan fácil es crear una clase simple con un par de atributos y un puñado de métodos?

Ahora, si esta pregunta se vuelve a abrir, también me gustaría saber: ¿Qué tan fácil es refactorizar el código en el futuro si decido hacer un atributo de "solo lectura"? En otras palabras, ¿qué pasos debo tomar para que un atributo deje de ser legible y escribible para que sea de solo lectura? (Lo sé, es malo cambiar una API, pero supongamos que estoy trabajando en algo internamente y me doy cuenta en el medio de mi implementación de que un atributo debería ser de solo lectura.)

Answer 1

De haber usado ambos, Moose's gran fortaleza es su brevedad. Comparar clásico OO Perl:

package Person; 
use strict; 
use warnings; 

sub new { 
    my $self = {}; 
    my $class = ref($proto) || $proto; 
    $self->{FIRST_NAME} = undef; 
    $self->{LAST_NAME} = undef; 
    bless ($self, $class); 
    return $self; 
} 

sub first_name { 
    my $self = shift; 
    if (@_) { $self->{FIRST_NAME} = shift } 
    return $self->{FIRST_NAME}; 
} 

sub last_name { 
    my $self = shift; 
    if (@_) { $self->{LAST_NAME} = shift } 
    return $self->{LAST_NAME}; 
} 

1; 

con Moose:

package Person; 
use Moose; 
use namespace::autoclean; 

has 'first_name' => (is => 'rw', isa => 'Str',); 
has 'last_name' => (is => 'rw', isa => 'Str',); 

__PACKAGE__->meta->make_immutable; 
1; 

Y estoy más o menos vendido, pero Moose es sólo conseguir comienzo. Creo que mi siguiente característica favorita fue Types, que realmente podría simplificar un programa en una gran base de código y detener toda una serie de errores desagradables. Por ejemplo, habría sido muy bien manejado uno me picaron el otro día (mientras codificaba Python, en realidad) donde cierta propiedad de un objeto era una Fecha en algunos casos, pero una cadena que representa una fecha en otros.

No he oído hablar de ningún sistema OO alternativo para python.

Answer 2

La fuerza de OO de Python es probablemente en su omnipresencia. Es decir, el sistema integrado OO es tan simple y la sintaxis es tan accesible que es, por lejos, el paradigma de programación dominante de Python. Por ejemplo, el equivalente aproximado de primer ejemplo "Persona" de Todd Gardner podría funcionar como:

class Person: 
    def __init__(self): 
     self.firstname = None 
     self.lastname = None 

me = Person() 
me.firstname = 'Kirk' # These two lines update instance attributes 
me.lastname = 'Strauser' 

Esta versión define captadores y definidores para acceder a los valores:

class AnotherPerson: 
    def __init__(self): 
     self._firstname = None 
     self._lastname = None 

    @property 
    def firstname(self): 
     return self._firstname 

    @firstname.setter 
    def firstname(self, newname): 
     self._firstname = newname 

    @property 
    def lastname(self): 
     return self._lastname 

    @lastname.setter 
    def lastname(self, newname): 
     self._lastname = newname 

you = AnotherPerson() 
you.firstname = 'David' # These two lines call instance methods 
you.lastname = 'Mertens' 

Python y Perl son aproximadamente equivalentes en poder, flexibilidad y expresividad. Si puedes hacer algo en uno, probablemente puedas hacerlo de manera similar en el otro. Sin embargo, creo que Python tiene una clara ventaja en el diseño de OO simple, hasta el punto de que no existe una razón para que los modelos de objetos alternativos ganen una tracción significativa.