python - resueltos - Pasar variables, crear instancias, uno mismo, la mecánica y el uso de clases: necesita explicación

programacion orientada a objetos python pdf

Question

He estado sentado sobre esto todo el día y ya estoy un poco cansado, así que discúlpeme por ser breve.

Soy nuevo en Python.

Acabo de reescribir un programa de trabajo, en un montón de funciones en una clase y todo desordenado. No sé si soy yo, pero estoy muy sorprendido de no poder encontrar un tutorial para principiantes sobre cómo manejar las clases en la web, así que tengo algunas preguntas.

En primer lugar, en la sección __init__ de la clase he declarado un montón de variables con self.variable=something .

¿Es correcto que pueda acceder / modificar estas variables en todas las funciones de la clase usando self.variable en esa función? En otras palabras, al declarar self.variable he hecho estas variables, variables globales en el alcance de la clase, ¿no?

Si no, ¿cómo me manejo?

En segundo lugar , ¿cómo paso correctamente los argumentos a la clase? Algún código de ejemplo sería genial.

En tercer lugar , ¿cómo llamo a una función de la clase fuera del ámbito de la clase? Algún código de ejemplo sería genial.

En pocas palabras , ¿cómo creo una instancia de la class INITIALCLASS en otra class OTHERCLASS , pasando las variables de OTHERCLASS a INITIALCLASS ? Algún código de ejemplo sería genial.

Quiero llamar a una función de OTHERCLASS con argumentos de INITIALCLASS . Lo que he hecho hasta ahora es.

class OTHERCLASS():
def __init__(self,variable1,variable2,variable3):
self.variable1=variable1
self.variable2=variable2
self.variable3=variable3
def someotherfunction(self):
something=somecode(using self.variable3)
self.variable2.append(something)
print self.variable2
def somemorefunctions(self):
self.variable2.append(variable1)
class INITIALCLASS():
def __init__(self):
self.variable1=value1
self.variable2=[]
self.variable3=''''
self.DoIt=OTHERCLASS(variable1,variable2,variable3)
def somefunction(self):
variable3=Somecode
#tried this
self.DoIt.someotherfunctions()
#and this
DoIt.someotherfunctions()

Claramente no entendía cómo pasar variables a clases o cómo manejarme, cuándo usarlas y cuándo no. Probablemente tampoco entendí cómo crear correctamente una instancia de una clase. En general, no entendía la mecánica de las clases, así que por favor, ayúdame y explícamelo como si no tuviera idea (lo que no entiendo, parece). O indíqueme un video completo o un tutorial legible.

Todo lo que encuentro en la web son ejemplos muy simples, que no me ayudaron mucho. O simplemente definiciones muy cortas de clases e instancias de métodos de clase, etc.

Puedo enviarles mi código original si quieren, pero es bastante largo.

Answer 1

Así que aquí hay un ejemplo simple de cómo usar las clases: Supongamos que eres un instituto de finanzas. Desea que las cuentas de sus clientes sean administradas por una computadora. Así que necesitas modelar esas cuentas. Ahí es donde entran las clases. Trabajar con clases se llama programación orientada a objetos. Con las clases modelas objetos del mundo real en tu computadora. Entonces, ¿qué necesitamos para modelar una cuenta bancaria simple? Necesitamos una variable que guarde el saldo y una que guarde el nombre de los clientes. Además, algunos métodos para aumentar y disminuir el equilibrio. Eso podría parecer:

class bankaccount():
def __init__(self, name, money):
self.name = name
self.money = money
def earn_money(self, amount):
self.money += amount
def withdraw_money(self, amount):
self.money -= amount
def show_balance(self):
print self.money

Ahora tienes un modelo abstracto de una cuenta simple y su mecanismo. El def __init__(self, name, money) es el constructor de las clases. Se acumula el objeto en la memoria. Si ahora desea abrir una nueva cuenta, debe crear una instancia de su clase. Para hacer eso, debes llamar al constructor y pasar los parámetros necesarios. En Python un constructor es llamado por el nombre de las clases:

spidermans_account = bankaccount("SpiderMan", 1000)

Si Spiderman quiere comprarle a MJ un nuevo anillo, tiene que retirar algo de dinero. Llamaría al método de withdraw por su cuenta:

spidermans_account.withdraw_money(100)

Si quiere ver el saldo lo llama:

spidermans_account.show_balance()

Todo sobre las clases es modelar objetos, sus atributos y mecanismos. Para crear un objeto, ejemplícelo como en el ejemplo. Los valores se pasan a clases con métodos de obtención y establecimiento como `earn_money () ´. Esos métodos acceden a las variables de tus objetos. Si desea que su clase almacene otro objeto, debe definir una variable para ese objeto en el constructor.

Answer 2

El punto central de una clase es que creas una instancia , y esa instancia encapsula un conjunto de datos. Por lo tanto, es incorrecto decir que sus variables son globales dentro del alcance de la clase: digamos que una instancia tiene atributos, y esa instancia puede referirse a sus propios atributos en cualquiera de sus códigos (a través de self.whatever ). De manera similar, cualquier otro código dado a una instancia puede usar esa instancia para acceder a los atributos de la instancia, es decir, instance.whatever .

Answer 3

class Foo (object):
# ^class name #^ inherits from object
bar = "Bar" #Class attribute.
def __init__(self):
# #^ The first variable is the class instance in methods.
# # This is called "self" by convention, but could be any name you want.
#^ double underscore (dunder) methods are usually special. This one
# gets called immediately after a new instance is created.
self.variable = "Foo" #instance attribute.
print self.variable, self.bar #<---self.bar references class attribute
self.bar = " Bar is now Baz" #<---self.bar is now an instance attribute
print self.variable, self.bar
def method(self, arg1, arg2):
#This method has arguments. You would call it like this: instance.method(1, 2)
print "in method (args):", arg1, arg2
print "in method (attributes):", self.variable, self.bar
a = Foo() # this calls __init__ (indirectly), output:
# Foo bar
# Foo Bar is now Baz
print a.variable # Foo
a.variable = "bar"
a.method(1, 2) # output:
# in method (args): 1 2
# in method (attributes): bar Bar is now Baz
Foo.method(a, 1, 2) #<--- Same as a.method(1, 2). This makes it a little more explicit what the argument "self" actually is.
class Bar(object):
def __init__(self, arg):
self.arg = arg
self.Foo = Foo()
b = Bar(a)
b.arg.variable = "something"
print a.variable # something
print b.Foo.variable # Foo