define class over 2 files

[naveen]

Is it possible to split up a class definition over multiple files?

 

[Steven D'Aprano]

Is it possible to split up a class definition over multiple files?

Not exactly, but you can do variations of this:


In file A.py, create:

class Parent:
def method(self):
return "Method"


In file B.py, do this:

import A
class Child(B.parent):
def another_method(self):
return "Another Method"


Now your class Child has two methods, method() and another_method().


Similarly, you can do this:

# File A.py

def function(x, y):
return x+y # or something more complicated


# File B.py

import A

def MyClass(object):
def func(self, x, y):
return A.function(x, y)

 

[naveen]

Is it possible to split up a class definition over multiple files?

Not exactly, but you can do variations of this: .... [subclass a class]
Steven

Thanks Steven.
I guess I will just preprocess the script:
<class.sh>
cat partA.py > class.py
cat partB >> class.py
python class.py
</class.sh>

 

[naveen]

indicator of bad practice. What is the problem you're trying to solve?

Ben Finney

No major problem.
I was just trying to make some experimental changes to autokey. My
repo: http://github.com/tinku99/autokey.git/

Didn't want to subclass or reorganize a class just yet.

 

[Simon Forman]

Not exactly, but you can do variations of this:


In file A.py, create:

class Parent:
   def method(self):
       return "Method"


In file B.py, do this:

import A
class Child(B.parent):

class Child(A.Parent):

 

[Jan Kaliszewski]

Answer in short, I don't think so.

Why not?

---------
File a.py:

class MyClass:
def foo(self, x):
return x * 6

---------
File b.py:

import a
def bar(self):
print 'bar'
def baz(self, a):
print self.foooo(a)

# adding methods by hand:
a.MyClass.bar = bar
a.MyClass.baz = baz

---------
File c.py

import a
def foooo(self, a):
return a * self.foo(4)
def baaar(self):
print self.baz('tralala')
def bazzz(self):
print 'bzzzzzzzzzz'

# adding methods more automaticly:
for name, obj in globals().values():
setattr(a.MyClass, name, obj)

Now why would you want to do that?

It's a good question. As others said it's very probable that some other
solution would be better (e.g. inheritance).

Cheers,
*j

 

[greg]

Not exactly, but you can do variations of this:

... [subclass a class]

Multiple inheritance can also be useful:

# A_Part1.py

class A_Part1:
...

# A_Part2.py

class A_Part2:
...

# A.py

from A_Part1 import A_Part1
from A_Part2 import A_Part2

class A(A_Part1, A_Part2):
...