Comment analyser efficacement des fichiers à largeur fixe en Python : module Struct vs découpage de chaîne optimisé ?

Analyser efficacement les fichiers à largeur fixe

Les fichiers à largeur fixe présentent un défi d'analyse unique en raison de leurs longueurs de colonnes prédéterminées. Trouver des moyens efficaces d'extraire les données de ces fichiers est crucial pour le traitement des données.

Énoncé du problème

Étant donné un fichier avec des lignes de largeur fixe, où chaque colonne représente une valeur spécifique , développez une méthode efficace pour analyser ces lignes en composants distincts. Actuellement, le découpage de chaînes est utilisé, mais des problèmes de lisibilité et d'adéquation aux fichiers volumineux se posent.

Solution

Deux méthodes d'analyse efficaces sont présentées :

Méthode 1 : Utilisation du module struct

Le module struct de la bibliothèque standard Python fournit un moyen pratique de décompresser les données des flux de données binaires. Il peut être utilisé avec des fichiers de largeur fixe en définissant une chaîne de format qui spécifie la largeur et le type de chaque champ. Cette méthode offre à la fois rapidité et simplicité.

Exemple :

<code class="python">import struct

fieldwidths = (2, -10, 24)
fmtstring = ' '.join('{}{}'.format(abs(fw), 'x' if fw < 0 else 's') for fw in fieldwidths)

# Convert Unicode input to bytes and the result back to Unicode string.
unpack = struct.Struct(fmtstring).unpack_from  # Alias.
parse = lambda line: tuple(s.decode() for s in unpack(line.encode()))

print('fmtstring: {!r}, record size: {} chars'.format(fmtstring, struct.calcsize(fmtstring)))

line = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789\n'
fields = parse(line)
print('fields: {}'.format(fields))</code>

Méthode 2 : Utilisation du découpage de chaînes avec compilation

Bien que le découpage de chaînes puisse sembler simple, sa vitesse peut être améliorée en compilant une version plus efficace à l'aide de eval(). Cette méthode génère une liste de limites de tranches constantes et donc plus rapides à exécuter.

Exemple (optimisé) :

<code class="python">def make_parser(fieldwidths):
    cuts = tuple(cut for cut in accumulate(abs(fw) for fw in fieldwidths))
    pads = tuple(fw < 0 for fw in fieldwidths) # bool flags for padding fields
    flds = tuple(zip_longest(pads, (0,)+cuts, cuts))[:-1]  # ignore final one
    slcs = ', '.join('line[{}:{}]'.format(i, j) for pad, i, j in flds if not pad)
    parse = eval('lambda line: ({})\n'.format(slcs))  # Create and compile source code.
    # Optional informational function attributes.
    parse.size = sum(abs(fw) for fw in fieldwidths)
    parse.fmtstring = ' '.join('{}{}'.format(abs(fw), 'x' if fw < 0 else 's')
                                                for fw in fieldwidths)
    return parse</code>

Les deux méthodes fournissent des moyens efficaces d'analyser fichiers de largeur fixe. La méthode 1 utilisant le module struct est facile à utiliser tandis que la méthode 2 utilisant le découpage de chaînes optimisé offre des performances légèrement meilleures lorsqu'elle est optimisée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!