operadores - if else python ejemplos

¿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 marco de Moose OO de Perl Moose y el marco de 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 a mitad de mi implementación de que un atributo debería ser de solo lectura).

Answer 1

De haber usado ambos, la gran fortaleza de Moose es su brevedad. Comparar el perl OO clásico:

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 bastante vendido, pero Moose recién está comenzando. 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 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 del primer ejemplo de "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 getters y setters 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 potencia, 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.