Python definieren Klassenfunktionen in separaten py-Datei

Question

Ich arbeite an einem Projekt, das sich mit Datenanalyse befasst. Um den Prozess des Findens und Änderns von Funktionen zu vereinfachen, habe ich mich entschieden, Funktionen mit ähnlichen Zwecken in verschiedenen py-Dateien zu speichern. Das Problem tritt auf, wenn Funktionen in einer Py-Datei Funktionen erfordern, die von einer anderen funktionieren. Ich denke, ich kann das Problem lösen, indem ich mit einer Klasse arbeite. Um die Lösung zu demonstrieren ich umzusetzen versuche, ich habe drei Dateien:

a.py

def a1(self): 
    self.var=3 

def a2(self): 
    self.b1(4) 

b.py

def b1(self, x): 
    self.var=x 

def b2(self): 
    self.a1() 

testClass.py

class test(object): 
    def __init__(self): 
     self.var=0 

    from b import * 
    from a import * 

a=test() 
print a.var 
a.a1() 
print a.var 

a.a2() 
print a.var 

a.b2() 
print a.var 

Diese tut, was ich will, aber Python ist unglücklich mit mir für den Import dieser 2 Py-Dateien auf diese Weise. In C++ konnte ich nur meine Funktionen prototypieren, die Deklaration weiterleiten und dann ihre Definitionen in eine andere Datei schreiben und keine Probleme haben. Was ist der richtige Weg, um Funktionen für eine Klasse in einer Py-Datei zu definieren, in der sich die Klassendefinition nicht befindet?

Answer 1

Verwenden Mix-in-Klassen:

# In a.py 
class A(object): 
    def a1(self): 
     self.var=3 

    def a2(self): 
     self.b1(4) 

# In b.py 
class B(object): 
    def b1(self, x): 
     self.var=x 

    def b2(self): 
     self.a1() 


# In testclass.py 
class Test(A, B): 
    def __init__(self): 
     self.var=0 

Answer 2

Sie brauchen keine Klassen, Sie müssen einfach die Verantwortung Ihrer Funktionen überdenken. Im Allgemeinen hängt jeder Fall, in dem Sie A von B und B haben, von A ab, Sie sind verwirrt.

Was Sie wollen, normalerweise haben, ist:

• C hängt von A und B
• A auf B abhängig ist, oder umgekehrt

Ein Beispiel, vielleicht haben Sie ein Modul für Abrufen und Parsen Ihrer Daten und eine weitere für die Verarbeitung. Sie könnten also data und processing haben. Man könnte so etwas wie dieses:

A -> B Stil

processing.py

import data 


def process_something(): 
    something = data.get_something() 
    for thing in something: 
     print('This is a thing: {}'.format(thing)) 


def process_something_else(): 
    something_else = data.get_something_else() 
    for thing in something_else: 
     print('This is something else: {}'.format(thing)) 

** ** data.py

def get_something(): 
    with open('file.txt') as f: 
     return f.readlines() 


def get_something_else(): 
    with open('another.txt') as f: 
     return f.readlines() 

Sie werden bemerken, dass die Funktionen in processing nur von den Funktionen in data abhängen und nicht umgekehrt. Sie möchten das nicht neu arrangieren, also hatten Sie process_something und get_something in einer Datei und process_something_else und get_something_else in einer anderen Datei.

Alternativ könnten Sie processing Agnostiker machen.

C -> A und C -> B Stil

your_program.py

import data 
import processing 


processing.process_something(data.get_something()) 
processing.process_something_else(data.get_something_else()) 

processing.py

def process_something(something): 
    for thing in something: 
     print('This is a thing: {}'.format(thing)) 

def process_something_else(something): 
    for thing in something: 
     print('This is something else: {}'.format(thing)) 

Und data.py die gleiche

Answer 3

1. Um Verwirrung zu vermeiden aussehen würde, in a.py und b.py, benennen Sie Ihre Implementierung Funktionen a1_impl, a2_impl, ... (oder eine andere konsistente Namenskonvention).

2. Aktualisieren Sie den Code:

   from b import * 
   from a import * 
   
   class test(object): 
       a1 = a1_impl # and however many others you need 
       b1 = b1_impl 
   
       def __init__(self): 
        self.var=0 
   

auf Python Getestet 2.7.10.

Die Zuweisungsanweisungen in class erstellen Klassenattribute, die in jede Instanz kopiert werden. Bei den Attributen handelt es sich um Funktionen mit der richtigen Signatur, so dass sie als Member-Funktionen Ihrer Klasseninstanzen aufgerufen werden können.