String auf 8 Stellen kürzen und als Schlüssel verwenden

[mzueblin]

Zur statisitschen Auswertung von Messdaten (Dimensionen) werden diese über ein ASCII-File (.dfq qstat) von einem Messprogramm in ein Prüfplanungsprogramm übertragen. Leider halten sich beide Programme nicht perfekt an den Standard und so habe ich ein kleines Pythonskript dazwischenprogrammiert.

Die letzte Aufgabe die dabei noch nicht klappt, ist das kürzen der Punktbezeichnung auf 8 Stellen.

Ein Name von der Art:
'127_A_121-128_A_001', '1037_A_009-1040_A_001', '125_S_001'

soll auf 8 Stellen gekürzt werden wobei es sehr ähnliche Namen gibt, da einige einfach durchnummerierte Abandlungen sind (z.B. '127_A_121-128_A_001', '127_A_122-128_A_001' oder '125_S_001', '125_S_002')

Damit nachher eine sinnvolle Zuordnung gemacht werden kann und damit keine Probleme entstehen müssen die 8 Stelligen Strings Eindeutig und Rückführbar(möglichst auch noch von Menschen, wenn z.B. 128A noch erkennbar ist, ist das von Vorteil) sein.


Die Strings mit re zu zerlegen und z.B. die _ zu entfernen ist kein Problem, wie ich jedoch aus den übrigen Daten einen Wert mit weniger Stellen generieren kann, ist mir nicht klar.

Code: Alles auswählen

import re

bstr='K2002/2 1037_A_009-1040_A_001'

rep_partn=re.compile('(K2002/[0-9]{1,6}) (.*)' )

ree_partn=re.match(rep_partn,bstr)
str_partn=''.join(bstr[ree_partn.start(2):ree_partn.end(2)])

str_partn=str_partn.replace('_','')
str_partn_anfang=str_partn[0:5]
str_partn_ende=str_partn[5:]

Aus dem 'str_partn_ende' sollte jetzt einfach z.B. eine möglichst Sinnvolle 3-stelliger String werden, der die Abkürzung eindeutig rückführbar macht.


Bei Bedarf kann ich den Rest des Codes (mit dem Das File eingelesen wird etc.) auch posten.

[Hyperion]

Suchst Du einen Algorithmus, der das leistet oder kennst Du die Regeln und Dir ist nur unklar, wie man das umsetzen kann?

Für letzteres fehlt irgend wie die Beschreibung der Regeln, für ersteres machst Du da ja imho schon zu viele Vorgaben und nennst den Wertebereich nicht eindeutig genug.

Am einfachsten dürfte es sein, irgend wo das Mapping zu hinterlegen und komplett neue, eigenständige Indexe zu erstellen! Je nach Größe des Wertebereichs kann man sich dann die benötigten Zeichen überlegen.

[mutetella]

Am einfachsten dürfte es sein, irgend wo das Mapping zu hinterlegen und komplett neue, eigenständige Indexe zu erstellen!

Ich habe da mal was versucht:

Code: Alles auswählen

class KeyStore(object):
    def __init__(self, index_digit, key_digit, separator='.'):
        self.store = {}
        self.index = 0
        self.index_digit = index_digit
        self.key_digit = key_digit
        self.separator = separator if key_digit > 0 else ''
        self.template = '{index:0{index_digit}}{separator}{key:<{key_digit}}'

    def factory(self, key):
        generated_key = self.template.format(
            index=self.index,
            index_digit=self.index_digit,
            separator=self.separator,
            key=key[:self.key_digit],
            key_digit=self.key_digit)
        self.index += 1
        self.store[generated_key] = key
        return generated_key

Man müsste jetzt noch einen Mechanismus einbauen, der verhindert, dass die 'self.index' größer wird, als es 'self.index_digit' vorsieht. Aber das sollte kein Problem sein.
Somit könnte man für das Dictionary, in dem die Messdaten liegen, als key jeweils die factory-Methode aufrufen und hätte dann gleichzeitig ein Dictionary, in dem man das auch wieder zurückverfolgen kann.

Code: Alles auswählen

In [130]: k = KeyStore(4, 4)

In [131]: k.factory('127_A_121-128_A_001')
Out[131]: '0000.127_'

In [132]: k.factory('1037_A_009-1040_A_001')
Out[132]: '0001.1037'

In [133]: k.store
Out[133]: {'0000.127_': '127_A_121-128_A_001', '0001.1037': '1037_A_009-1040_A_001'}

mutetella

[mzueblin]

Suchst Du einen Algorithmus, der das leistet oder kennst Du die Regeln und Dir ist nur unklar, wie man das umsetzen kann?

Für letzteres fehlt irgend wie die Beschreibung der Regeln, für ersteres machst Du da ja imho schon zu viele Vorgaben und nennst den Wertebereich nicht eindeutig genug.

Am einfachsten dürfte es sein, irgend wo das Mapping zu hinterlegen und komplett neue, eigenständige Indexe zu erstellen! Je nach Größe des Wertebereichs kann man sich dann die benötigten Zeichen überlegen.

Ich suche einen Algorithmus der so etwas macht und die Umsetzung, die Umsetzung habe ich noch nicht probiert, da mir noch nicht klar ist wie das ganze zu machen ist.

Was ist am Datenformat noch unklar?
Die Strings, die ich beschrieben habe bezeichnen Punkte oder Merkmale am Bauteil, diese werden dann bei jedem Bauteil gemessen und anschliessend über dieses .dfq File in eine Auswertesoftware übertragen. Es gibt ca. 2700 Merkmale pro Bauteil.

Am einfachsten dürfte es sein, irgend wo das Mapping zu hinterlegen und komplett neue, eigenständige Indexe zu erstellen!

Ich habe da mal was versucht:

Code: Alles auswählen

class KeyStore(object):
    def __init__(self, index_digit, key_digit, separator='.'):
        self.store = {}
        self.index = 0
        self.index_digit = index_digit
        self.key_digit = key_digit
        self.separator = separator if key_digit > 0 else ''
        self.template = '{index:0{index_digit}}{separator}{key:<{key_digit}}'

    def factory(self, key):
        generated_key = self.template.format(
            index=self.index,
            index_digit=self.index_digit,
            separator=self.separator,
            key=key[:self.key_digit],
            key_digit=self.key_digit)
        self.index += 1
        self.store[generated_key] = key
        return generated_key

Man müsste jetzt noch einen Mechanismus einbauen, der verhindert, dass die 'self.index' größer wird, als es 'self.index_digit' vorsieht. Aber das sollte kein Problem sein.
Somit könnte man für das Dictionary, in dem die Messdaten liegen, als key jeweils die factory-Methode aufrufen und hätte dann gleichzeitig ein Dictionary, in dem man das auch wieder zurückverfolgen kann.

Code: Alles auswählen

In [130]: k = KeyStore(4, 4)

In [131]: k.factory('127_A_121-128_A_001')
Out[131]: '0000.127_'

In [132]: k.factory('1037_A_009-1040_A_001')
Out[132]: '0001.1037'

In [133]: k.store
Out[133]: {'0000.127_': '127_A_121-128_A_001', '0001.1037': '1037_A_009-1040_A_001'}

Vielen Dank für diesen Code, ich werde ihn noch genau betrachten aber er scheint schon recht nahe an einer Lösung zu sein. An sich müsste ich jetzt nur anstelle der Aufsteigenden Nummerierung ein anderes Stringformat generieren (9999 wird evtl. in der Zukunft knapp).

mutetella

[Hyperion]

Was ist am Datenformat noch unklar?

Es geht nicht um das Format, sondern welche möglichen Werte vorhanden sind. Ansonsten kann man ja keine bijektive Abbildung basteln... außer, man platziert eine Mapping-tabelle dazwischen, was Mutetella versucht hat.

[mutetella]

An sich müsste ich jetzt nur anstelle der Aufsteigenden Nummerierung ein anderes Stringformat generieren (9999 wird evtl. in der Zukunft knapp).

Nun ja, wie Du in meinem Beispiel ja siehst, kannst Du über das Attribut 'index_digit' angeben, wie viele Stellen der Index haben soll.
Letztlich muss man sich halt entscheiden: Ein größerer Index ('index_digit') oder mehr Raum für den Originalstring ('key_digit'). 1 Stelle kannst Du noch gewinnen, wenn Du den Separator ('separator') streichst.
Ein anderes Stringformat (was meinst Du damit eigentlich?) an Stelle des Index wird da auch nichts daran ändern können.

mutetella

[mzueblin]

Was ist am Datenformat noch unklar?

Es geht nicht um das Format, sondern welche möglichen Werte vorhanden sind. Ansonsten kann man ja keine bijektive Abbildung basteln... außer, man platziert eine Mapping-tabelle dazwischen, was Mutetella versucht hat.

Eine Festlegung welche Werte vorliegen ist leider recht schwierig, da aufgrund von Zeichnungsänderungen z.B. anderer Werte notwendig würden.

An sich müsste ich jetzt nur anstelle der Aufsteigenden Nummerierung ein anderes Stringformat generieren (9999 wird evtl. in der Zukunft knapp).

Nun ja, wie Du in meinem Beispiel ja siehst, kannst Du über das Attribut 'index_digit' angeben, wie viele Stellen der Index haben soll.
Letztlich muss man sich halt entscheiden: Ein größerer Index ('index_digit') oder mehr Raum für den Originalstring ('key_digit'). 1 Stelle kannst Du noch gewinnen, wenn Du den Separator ('separator') streichst.
Ein anderes Stringformat (was meinst Du damit eigentlich?) an Stelle des Index wird da auch nichts daran ändern können.

mutetella

Ja, den Separator hätte ich schon geopfert, auch wenn die resultierenden Nummern dann immer kryptischer werden.

Mit "anderes Stringformat" meine ich, das man ansatt von 0000 - 9999 z.B. 0000 - ZZZZ benutzt, evtl. auch den ganzen ASCII-Raum.

[mzueblin]

Um klarer zu machen was ich will habe ich einmal die Nutzung des 'Textraumes' von 0 bis 255 für die Indexe erstellt, id_str wuerde dann ins Textfile geschrieben, so müsste ich nur 2 Stellen für bis zu 65536 Werte benützen. Ich bin aber noch am abklären welches Datenformat das 8-Stellige Feld genau akzeptiert.

Code: Alles auswählen

## Integer Index von 0 bis 65k in zweistelligen String konvertieren
int_eins=35000
strstelle1=int(int_eins/255)
strstelle2=int_eins-strstelle1*255
str1=chr(strstelle1)
str2=chr(strstelle2)
id_str=''.join([str1,str2])

## Rueckkonvertierung
int_ausg=ord(id_str[0])*255+ord(id_str[1])
print(int_ausg)

[BlackJack]

@mzueblin: Das wird wahrscheinlich so nicht funktionieren, weil nicht alle Bytewerte in Dateinamen auftauchen dürfen. Welche erlaubt sind unterscheidet sich auch noch von Dateisystem zu Dateisystem. Und bei vielen Zeichen ausserhalb vom ASCII-Wertebereich kann es natürlich Probleme beim Transfer auf andere Systeme oder beim Archivieren geben, da alle beteiligten Systeme und Programme keine Änderungen an der Kodierung vornehmen dürfen.

Ansonsten ist das Umwandeln von einer Zahl in einen ”gepackten” Bytestring mit dem `struct`-Modul machbar.

[mutetella]

Ich habe zum Testen mal folgende Funktion geschrieben, die letztlich das macht, was Du in Deinem Beispiel gezeigt hast:

Code: Alles auswählen

def str_id(int_):
    return ''.join((
        chr(int_/255),
        chr(int_-(int_/255)*255)
        ))

Damit kannst Du mal verschiedene Zahlen durchprobieren. Du wirst sehen, dass in den meisten Fällen nicht der von Dir gewünschte 2stellige string herauskommt.
So wie BlackJack geschrieben hat, wären für das, was Du vorhast, nur folgende ASCII-Werte wirklich brauchbar:

Code: Alles auswählen

In [19]: for i in xrange(33,127):
    print chr(i),
   ....:     
   ....:  

mutetella

[mzueblin]

Mit 33 bis 127 wäre ich immernoch gut bedient, dabei käme ich immernoch mit 2-3 Stellen im 8-Stelligen String aus.

@Blackjack: Es geht nicht um Dateinamen, sondern um Namen für Punktmerkmale, die als String via Textfile an eine Datenbank übergeben werden. Die Datenbank akzeptiert aber nur 8-Stellen.

Ich erhalte aber erst übermorgen vom Softwareanbieter bescheid, was für ein Datenformat ich der Datenbank übergeben kann.

[BlackJack]

@mzueblin: Auch in dem Fall würde ich damit rechnen, dass nicht alle Bytewerte erlaubt sind. Textdatei? Sind da Zeilenumbrüche wichtig? Und sehr viele Werkzeuge, die mit Textdateien umgehen, mögen keine Nullbytes in den Daten.

Wenn die doppelte Zeichenanzahl für die 2¹⁶ Möglichkeiten auch okay wäre, dann könntest Du die Zahlen als 4-Zeichen-Hexadezimalzahlen angeben. Oder einen Drei-Byte-Wert mit Base64 in vier Zeichen kodieren. Damit liessen sich dann 2²⁴≈16 Millionen Werte in vier Zeichen ausdrücken.

[mzueblin]

wäre die Lösung über base64 so gemeint? :
#Hinkonvertierung
import base64
byteindex=(99999).to_bytes(3,byteorder='big')
base64index=base64.b64encode(byteindex)
stringindex=base64index.decode(encoding='utf-8',errors='strict')

#Rueckkonvertierung
base64index2=bytes(stringindex,'UTF-8')
byteindex2=base64.b64decode(base64index2)
intindex2=int.from_bytes(byteindex2, byteorder='big')

[mzueblin]

So, auch dank der Hilfe hier habe ich nun erreicht was ich wollte.
Kritik am Programm ist oder an den Python-Stilfehrfehlungen sind herzlich willkommen, nun sollten auch ein paar der Fragen etwas klarer sein/werden:

Code: Alles auswählen

###Nachbearbeitung von DFQ Files
##Einschränkungen: Auf dem auführenden Computer muss Python 3.2 installiert sein.
##                 Es können nur maximal 262143 verschiedene über 8-stellige Merkmalsnamen verarbeitet werden

##Zusatzmodule laden
import re
import pickle

##Funktionen definieren
def shortindex(index_in):
    ##Kuerzt eine Zahl von 0 bis 262143 auf einen 3 stelligen String
    import base64
    byteindex=(index_in).to_bytes(3,byteorder='big')
    base64index=base64.b64encode(byteindex)
    index_out=base64index.decode(encoding='utf-8',errors='strict')
    index_out=index_out[1:4]
    return index_out
    
def longindex(index_in):
    ##Gibt fuer eine mit 'shortindex' gekuerzte Zahl den ursprünglichen Index aus den 3 Buchstaben
    import base64
    index_verl=''.join(['A',index_in])
    base64index2=bytes(index_verl,'UTF-8')
    byteindex2=base64.b64decode(base64index2)
    index_out=int.from_bytes(byteindex2, byteorder='big')
    return index_out

## Files zum lesen öffnen, muss später mit Funktion mit übergabe der Pfade etc. werden
inputfile='D:\\rqmread\\RQM_Testin_bnz.DFQ'
outputfile='D:\\rqmread\\RQM_Testout_bnz.DFQ'
StorageFile='D:\\rqmread\\RQM_Short_Names_pickled'

instr=1 #instr initialisieren damit While loop startet

merkm=re.compile('K[0-9]{4}/[0-9]{1,6} ') #Ueberpruefungs Pattern um nummerierte Ks zu finden 
group_spl=re.compile('(K[0-9]{4}/)([0-9]{1,6}) (.*)')#Match Pattern um den String nachher in Bearbeitbare Gruppen zerlegen
muellre=re.compile('K2002/[0-9]{1,6} _DMAJ') #Pattern um Muelldatensätze zu finden

datenre=re.compile('[-.0-9]{1,12}\\x14[-.0-9]{1,12}\\x14[0-9]{2}\.[0-9]{2}\.[0-9]{4}/[0-9]{2}:[0-9]{2}:[0-9]{2}\\x0f')
datensplitre=re.compile('\\x0f') #Pattern um Datengruppen zu splitten

linecounter=0 
leseblock=0 #Schalter damit durch readline() nicht eine Zeile zu Beginn eines Merkmalsblocks verworfen wird
muellcondition=0 #Bedinung durch die ein Merkmalsblcok verworfen wird 
reindex=0 #um wieviel der DFQ-Interne Merkmalsindex zurückgestellt werden muss wegen verworfenen Merkmalsblöcken
muellfinder=[] #Liste um nach "Muell" zu suchen
muellindexliste=[]

fileR=open(inputfile, 'r')
fileW=open(outputfile, 'w')

while instr != '':
    if leseblock ==1:
        leseblock=0
    else:
        instr=fileR.readline()
    linecounter=linecounter+1
    ismerkm=re.match(merkm, instr)
    isdata=re.match(datenre, instr)
    isk100=re.match('K0100 ', instr)
    merkmgruppe=[]

    if ismerkm == None and isdata == None and isk100 == None: ##Direktes weiterschreiben von nicht-merkmalsbezogenen  
        fileW.write(instr)                                    ##Linien und nicht-K0100 Linien und nicht-Daten Linien  
    elif ismerkm != None: ##Nachberarbeitung von merkmalsbezogenen Daten
        vor_index=re.search('/', instr)
        nach_index=re.search(' ', instr)
        ursprungsindex=instr[vor_index.end():nach_index.start()]
        weitererindex=ursprungsindex
        
        while ismerkm != None and weitererindex == ursprungsindex: ##Gruppe von merkmalsbezogenen Daten einlesen 
            merkmgruppe.append(instr)
            instr=fileR.readline()
            linecounter=linecounter+1
            vor_index=re.search('/', instr)
            nach_index=re.search(' ', instr)
            ismerkm=re.match(merkm, instr)
            if vor_index != None and nach_index != None:
                weitererindex=instr[vor_index.end():nach_index.start()]
                
        for j in range(len(merkmgruppe)): ##Ueberpruefen ob schlechte Daten vorhanden sind
            muellfinder_match=re.match(muellre, merkmgruppe[j])
            if muellfinder_match != None:
                memerkm=re.search(group_spl,merkmgruppe[0])
                muellindex=int(merkmgruppe[0][memerkm.start(2):memerkm.end(2):1])-1
                muellindexliste.append(muellindex)
                muellcondition=1
                break
                       
        if muellcondition == 0: ##Bearbeiten von guten Daten
            for i in range(len(merkmgruppe)):
                
                merkmgruppe[i]=merkmgruppe[i].replace('K2001', 'KXYXX', 1) ##K2001 und K2002 vertauschen
                merkmgruppe[i]=merkmgruppe[i].replace('K2002', 'K2001', 1)
                merkmgruppe[i]=merkmgruppe[i].replace('KXYXX', 'K2002', 1)

                remerkm=re.search(group_spl,merkmgruppe[i])
                merkmgruppe[i]=''.join([merkmgruppe[i][remerkm.start(1):remerkm.end(1):1],
                                        str(int(merkmgruppe[i][remerkm.start(2):remerkm.end(2):1])-reindex),
                                        ' ',
                                        merkmgruppe[i][remerkm.start(3)::]]) ##Index frisch nummerieren
                if merkmgruppe[i].find('K2001') != -1: ##Herausfinden an welcher Position K2001 ist umd später die Korrekte Reihenfolge K2001, K2002, K2003 zu haben
                    K2001pos=i
                    K2001str=merkmgruppe[i]
                if merkmgruppe[i].find('K2002') != -1: ##K2002 (Merkmalsname) allenfalls auf 8 Stellen kürzen (RQM unterstützt nur 8)
                    K2002pos=i
                    K2002index=merkmgruppe[i][remerkm.start(3)::]
                    K2002index=K2002index[:-1]#\n abschneiden
                    if len(K2002index) > 8:
                        with open(StorageFile,'rb') as f:
                            try:
                                verkuerzteindexe=pickle.load(f) ##Schon auf 8 Stellen gekürzte Namen aus Datei laden als dict (langer Index als Schlüssel
                            except EOFError:
                                verkuerzteindexe={}
                            try:
                                kurzindex=verkuerzteindexe[K2002index] ##Verkuerzung für bestehenden Index suchen
                            except KeyError:    ##Name noch nicht gebraucht --> grössten Index suchen
                                values=verkuerzteindexe.values()
                                stringindexliste=[]
                                ct=0
                                for val in values:
                                    stringindexliste.insert(ct,val)
                                    stringindexliste[ct]=longindex(stringindexliste[ct][-3:])
                                    ct=ct+1
                                try:    
                                    maxindex=max(stringindexliste)
                                except  ValueError:
                                    maxindex=-1
                                kurzindex=''.join([K2002index[:5],shortindex(maxindex+1)]) ##Kurzindex aus 5+3 Stellen zusammensetzen
                                verkuerzteindexe.update([[K2002index,kurzindex]]) ##Ins dict zurückschreiben
                                with open(StorageFile, 'wb') as f:
                                    pickle.dump(verkuerzteindexe,f,pickle.HIGHEST_PROTOCOL) ##Ins File pickeln
                                        
                            merkmgruppe[i]=''.join([merkmgruppe[i][remerkm.start(1):remerkm.end(1):1],
                                                    str(int(merkmgruppe[i][remerkm.start(2):remerkm.end(2):1])),
                                                    ' ',
                                                    kurzindex,
                                                    '\n']) ##gekürzten Index in die Gruppe schreiben
                            
                            K2003write=1    #Vorbereitung um langen, alten Index unter K2003 ins File zu schreiben
                            K2003str=''.join(['K2003/',
                                              str(int(merkmgruppe[i][remerkm.start(2):remerkm.end(2):1])),
                                              ' ',
                                              K2002index,
                                              '\n'])
                    K2002str=merkmgruppe[i]        
                            
            if K2002pos < K2001pos:     #K2001-K2003 richtig sortieren
                merkmgruppe.pop(K2002pos)
                merkmgruppe.pop(K2001pos-1)
            else:
                merkmgruppe.pop(K2001pos)
                merkmgruppe.pop(K2002pos-1)
            if K2003write == 1:  
                merkmgruppe.insert(0,K2003str)
            merkmgruppe.insert(0,K2002str)
            merkmgruppe.insert(0,K2001str)
            for line in merkmgruppe:
                fileW.write(line)
        else:
            reindex=reindex+1
            muellcondition=0
                    
        leseblock=1 #einmal einlesen blockieren damit keine Linien übersprungen werden
        K2003write=0
        muellfinder=[]
    elif isdata != None: #Daten einlesen und Datensätze die als Müll identifiziert wurden auch in den Daten löschen
        datenliste=re.split(datensplitre,instr)
        l=0
        for k in muellindexliste:
            del datenliste[k-l]
            l=l+1
        
        outstr='\x0f'.join(datenliste)
        anzahlstr=''.join(['K0100 ',str(len(datenliste)-1),'\n']) #richtige Anzahl Einträge zurürckschreiben (als K0100)
        fileW.write(anzahlstr)
        fileW.write(outstr) #Daten schreiben
        #print('Daten geschrieben (sollte nur ein mal auftauchen)')
   
fileW.close()
fileR.close()