Estaba leyendo acerca de la documentación de las clases python, dice, en python "las clases en sí mismas son un objeto". ¿Cómo es eso diferente de las clases C# o Java? ¿Qué ventajas y desventajas tiene este tipo de clases en comparación con C# o Java?¿Qué se entiende por clases en sí mismas son objetos?
La principal diferencia es que significa que puede manipular fácilmente la clase como un objeto. La misma instalación está disponible en Java, donde puede usar los métodos de Class para obtener información sobre la clase de un objeto. En idiomas como Python, Ruby y Smalltalk, la naturaleza más dinámica del lenguaje le permite "abrir" la clase y cambiarla, lo que a veces se denomina "parche de monos".
Personalmente, no creo que las diferencias sean tan importantes, pero estoy seguro de que podemos iniciar una buena guerra religiosa al respecto.
En Python, las clases son objetos en el sentido de que puede asignarlos a variables, pasarlos a funciones, etc. al igual que cualquier otro objeto. Por ejemplo
>>> t = type(10)
>>> t
<type 'int'>
>>> len(t.__dict__)
55
>>> t() # construct an int
0
>>> t(10)
10
Java tiene Class objetos que proporcionan alguna información acerca de una clase, pero no se puede utilizar en lugar de los nombres de clase explícitos. No son realmente clases, solo estructuras de información de clase.
Class C = x.getClass();
new C(); // won't work
En C# y Java las clases no son objetos. Son tipos, en el sentido en que esos idiomas están tipados estáticamente. Es cierto que puede obtener un objeto que represente una clase específica, pero eso no es lo mismo que la clase misma.
En python, lo que parece una clase también es un objeto.
Se exlpained here mucho mejor de lo que puedo hacer :)
+1 para el gran enlace :) – zeekay
estáticamente tipado –
La declaración de una clase es simplemente declarando una variable:
class foo(object):
def bar(self): pass
print foo # <class '__main__.foo'>
son asignables y se almacena como una variable:
class foo(object):
pass
class bar(object):
pass
baz = bar # simple variable assignment
items = [foo, bar]
my_foo = items[0]() # creates a foo
for x in (foo, bar): # create one of each type
print x()
y pasado como una variable:
class foo(object):
def __init__(self):
print "created foo"
def func(f):
f()
func(foo)
Pueden ser creados por las funciones, incluida la lista de la clase base:
def func(base_class, var):
class cls(base_class):
def g(self):
print var
return cls
class my_base(object):
def f(self): print "hello"
new_class = func(my_base, 10)
obj = new_class()
obj.f() # hello
obj.g() # 10
Por el contrario, mientras que las clases en Java tienen objetos que los representan, por ejemplo. String.class, el nombre de la clase en sí, String, no es un objeto y no se puede manipular como uno solo. Eso es inherente a los lenguajes de tipo estático.
Las clases son objetos en el sentido de que son manipulables en código Python al igual que cualquier objeto. Otros han demostrado cómo puede pasarlos a las funciones, lo que les permite ser operados como cualquier objeto. Aquí es cómo se puede hacer esto:
class Foo(object):
pass
f = Foo()
f.a = "a" # assigns attribute on instance f
Foo.b = "b" # assigns attribute on class Foo, and thus on all instances including f
print f.a, f.b
En segundo lugar, al igual que todos los objetos, las clases se crean instancias en tiempo de ejecución. Es decir, una definición de clase es código que es ejecutado en lugar de una estructura que es compilada antes de ejecutar nada.Esto significa que una clase puede "incluir" cosas que solo se conocen cuando se ejecuta el programa, como las variables de entorno o la entrada del usuario. Estos se evalúan una vez cuando se declara la clase y luego se convierten en parte de la clase. Esto es diferente de los lenguajes compilados como C# que requieren este tipo de comportamiento para implementarse de manera diferente.
Finalmente, las clases, como cualquier objeto, se crean a partir de clases. Del mismo modo que un objeto se crea a partir de una clase, también lo es una clase creada a partir de un tipo especial de clase llamada metaclass . Puede escribir sus propias metaclases para cambiar cómo se definen las clases.
Otra ventaja de las clases ser objetos es que los objetos pueden cambiar su clase en tiempo de ejecución:
>>> class MyClass(object):
... def foo(self):
... print "Yo There! I'm a MyCLass-Object!"
...
>>> class YourClass(object):
... def foo(self):
... print "Guess what?! I'm a YourClass-Object!"
...
>>> o = MyClass()
>>> o.foo()
Yo There! I'm a MyCLass-Object!
>>> o.__class__ = YourClass
>>> o.foo()
Guess what?! I'm a YourClass-Object!
Los objetos tienen un atributo especial __class__ que apunta a la clase de la que son una instancia. Esto solo es posible porque las clases son objetos por sí mismas y, por lo tanto, pueden vincularse a un atributo como __class__.
Como esta pregunta tiene una etiqueta Smalltalk, esta respuesta es desde la perspectiva de Smalltalk. En la programación orientada a objetos, las cosas se hacen a través del envío de mensajes. Envía un mensaje a un objeto, si el objeto entiende ese mensaje, ejecuta el método correspondiente y devuelve un valor. Pero, ¿cómo se crea el objeto en primer lugar? Si se introduce una sintaxis especial para crear objetos, se romperá la sintaxis simple en función del envío de mensajes. Esto es lo que sucede en los lenguajes como Java:
p = new Point(10, 20); // Creates a new Point object with the help of a special keyword - new.
p.draw(); // Sends the message `draw` to the Point object.
Como es evidente a partir del código anterior, la lengua tiene dos maneras de hacer las cosas - un imperativo y la otra orientada a objetos. Por el contrario, Smalltalk tiene una sintaxis coherente basada sólo en los mensajes:
p := Point new: 10 y: 20.
p draw.
Aquí new es un mensaje enviado a un objeto único llamado Point que es una instancia de un Metaclass. Además de darle al lenguaje un modelo consistente de computación, las metaclases permiten la modificación dinámica de las clases. Por ejemplo, la siguiente declaración añadirá una nueva variable de instancia a la clase Point sin requerir una recompilación o reiniciar VM:
Point addInstVarName: 'z'.
La mejor lectura sobre este tema es The Art of the Metaobject Protocol.
En java, crea nuevas instancias de una clase de esta manera: Objeto o = C.newInstance(); – stacker