Python bekommt jedes Mal eine neue Instanz erstellen

Question

ich eine Klasse, um Daten zu erzeugen:

class dataGen(): 

     #class to generate data. 

     def firstName(): 
       firstName = 'Storm' + str(timeGen.timeGen()) 
       return firstName 

     def lastName(): 
       lastName = 'Trooper' + str(timeGen.timeGen()) 
       return lastName 

     def randString(): 
       rint = random.randint(1,20) 
       r4ndString = ''.join(random.choice(string.ascii_uppercase + string.ascii_lowercase + string.digits) for _ in range(rint)) 
       return r4ndString 

     def email(): 
       EmailA = dataGen.randString() 
       EmailB = dataGen.randString() 
       items = ['.com','.net','.org'] 
       tld = random.choice(items) 
       return str(EmailA) + '@' + str(EmailB) + str(tld) 

     def empid(size=20, chars=string.ascii_uppercase + string.ascii_lowercase + string.digits): 
       return ''.join(random.choice(chars) for _ in range(size)) 

     def ssnGen(): 
       ssnGenD = random.randint(100000000,999999999) 
       return ssnGenD 

Klasse macht SQL-Aufruf:

class sqlConn(): 

     #Class to handle all SQL connections 

     def realEmail(cEmail): 
       cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=Dev1SQL1;DATABASE=TimeCurrent;Trusted_Connection=yes') 
       cursor = cnxn.cursor() 
       sql = 'exec tbl.usp_Lookup_Email "%s"' % cEmail 
       cursor.execute(sql) 
       data = cursor.fetchall() 
       return(data) 

     def realEmpID(cEmpID): 
       cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=Dev1SQL1;DATABASE=TimeCurrent;Trusted_Connection=yes') 
       cursor = cnxn.cursor() 
       sql = 'exec tbl.usp_Lookup_EmplID "%s"' % cEmpID 
       cursor.execute(sql) 
       data = cursor.fetchall() 
       return(data)     

     def realEmpName(cFName, cLName): 
       cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=Dev1SQL1;DATABASE=TimeCurrent;Trusted_Connection=yes') 
       cursor = cnxn.cursor() 
       value = (cFName, cLName) 
       sql = 'exec tbl.usp_Lookup_Name "%s", "%s"' % value     
       cursor.execute(sql) 
       data = cursor.fetchall() 
       return(data) 

     def realSSN(cSSN): 
       cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=Dev1SQL1;DATABASE=TimeCurrent;Trusted_Connection=yes') 
       cursor = cnxn.cursor() 
       sql = ' exec tbl.usp_Lookup_SSN "%s"' % cSSN 
       cursor.execute(sql) 
       data = cursor.fetchall() 
       return(data) 

... und ich eine Klasse, die anruft, basierend auf den Ergebnissen meiner SQL-Abfrage.

def deID(HOLDERLIST): 
     #Takes in the holderList from holderClass, checks aganst the database to see if the fakeFeild for each of the values has data, 
     #If the feild does not return none, it uses that data. If it is none, then it generates new data. 
     for item in HOLDERLIST: 
       for idx, lis in enumerate(item):       
         if idx == 0: 
           fName = item[0] 
           lName = item[1] 
           name = sqlConn.realEmpName(fName, lName) 
           if name == None: 
             item[0] = dataGen.firstName() 
             item[1] = dataGen.lastName() 

           else: 
             item[0] = name[0][0] 
             item[1] = name[0][1] 

         elif idx == 2: 
           SSN = sqlConn.realSSN(item[idx]) 
           if SSN == None: 
             item[idx] = dataGen.ssnGen()           
           else: 
             item[idx] = SSN           

         elif idx == 3: 
           email = sqlConn.realEmail(item[idx]) 
           if email == None: 
             item[idx] = dataGen.email() 
           else: 
             item[idx] = email          


     print('Holderlist deID')   
     return(HOLDERLIST) 

Meine Hauptschleife

def main(): 

     datagenInstance = dataGen() 
     SQLConnInstance = sqlConn() 
     CLIENT, filename, FILESTRUCT = selectFile() 
     PARSED = parse(filename) 
     HOLDERLIST = holderClass(PARSED, FILESTRUCT) 
     deIDedData = deID(HOLDERLIST) 
     deIDedFile = merge(PARSED, deIDedData, FILESTRUCT) 
     fileExport(filename, deIDedFile) 

if __name__ == '__main__': 

    main() 

HOLDERLIST ist nur eine CSV-Datei, die in eine Liste von 4 Strings analysiert wird. Das Problem, das ich habe, ist, dass die SQL-Verbindungsklasse und die DataGen-Klasse nicht jedes Mal neue Aufrufe vornehmen. Jedes Mal, wenn die Schleife ausgeführt wird, sollte eine neue Instanz der beiden oben genannten Klassen erstellt werden. Ich weiß, dass ich in Sprachen wie C# und C++ neue an der Vorderseite des Aufrufs anbringen kann, um die Sprache zu zwingen, bei jedem Aufruf eine neue Instanz zu erstellen. Ich habe die Literatur über die Verwendung von Dingen wie neue in Python gelesen, aber das scheint in der Klassendeklaration platziert werden, und ich verstehe nicht wirklich Python-Klasse Dekorationen so gut.

Answer 1

Es scheint, als ob Sie mit Klassen in Python nicht so vertraut sind. Sie haben zwei Klassen erstellt, die nur Klassenmethoden und keine Instanzattribute enthalten. Um Ihre dataGen Klasse zu aktualisieren Instanz basiert sein, könnten Sie so etwas wie verwenden:

class DataGen(object): 
    def __init__(self): 
     self.first_name = 'Storm' + str(timeGen.timeGen()) 
     self.last_name = 'Trooper' + str(timeGen.timeGen()) 
     self.email = DataGen.rand_email() 
     self.empid = DataGen.rand_empid() 
     self.ssn = DataGen.rand_ssn() 

    @staticmethod 
    def rand_string(): 
     r_int = random.randint(1,20) 
     r_string = ''.join(random.choice(string.ascii_uppercase + 
         string.ascii_lowercase + string.digits) 
        for _ in range(r_int)) 
     return r_string 

    @staticmethod 
    def rand_email(): 
     email_a = DataGen.rand_string() 
     email_b = DataGen.rand_string() 
     items = ['.com','.net','.org'] 
     tld = random.choice(items) 
     return str(email_a) + '@' + str(email_b) + str(tld) 

    @staticmethod 
    def rand_empid(size=20, chars=string.ascii_uppercase + 
           string.ascii_lowercase + string.digits): 
     return ''.join(random.choice(chars) for _ in range(size)) 

    @staticmethod 
    def rand_ssn(): 
     ssn = random.randint(100000000,999999999) 
     return ssn 

Wenn eine Instanz einer Klasse erstellt wird, die __init__ Funktion aufgerufen wird und verwendet wird, um die Klasse zu instanziieren (was in der Regel bedeutet, Einstellung Instanzattribute). Allen Instanzmethoden wird implizit der Parameter self übergeben, der die Instanz der Klasse ist. Der Decorator staticmethod überschreibt dieses Verhalten und wenn diese Methoden aufgerufen werden, werden keine Parameter implizit übergeben. Das Erstellen einer Instanz und der Zugriff auf ihre Attribute ist unkompliziert.

instance = DataGen() 

print(instance.first_name) # Storm8 
print(instance.last_name) # Trooper6 
print(instance.email) # xOy37zF@bR68DdLr36mq.net 
print(instance.empid) # JhPGpnwUQlm9tCaWbW3F 
print(instance.ssn) # 370469583 

Wenn Sie jedoch datagenInstance in der Hauptschleife erstellen, ist es nicht überall eingesetzt werden. Sie müssen es an die relevanten Funktionen übergeben. Es ist schwierig, viel mehr Anleitung als das zu bieten, da Sie wahrscheinlich viel Code neu strukturieren müssen. kann Ihnen helfen, Klassen besser zu erklären.