2010-10-04 3 views
-2

quel est le moyen le plus simple de décompresser un nom de données?décompresser le nom

Par exemple, changer de forme compressée:

abc[3:0] 

en forme décompressé:

abc[3] 
abc[2] 
abc[1] 
abc[0] 

préférable 1 doublure :)

+0

Par "nom de données" voulez-vous dire "variable" ou est-ce que "abc [3: 0]" est une chaîne que vous voulez diviser en quatre chaînes séparées? – CanSpice

+0

Sauf si vous essayez de faire une question de comparaison de langue, les balises python, perk et awk ne sont presque certainement pas appropriées. Étant donné la syntaxe que vous utilisez, 'python' semble plutôt approprié. – jkerian

+0

@jkerian: sauf bien sûr qu'en Python, abc [3: 0] obtiendrait, err, 0 items commençant au troisième, pas les items 3,2,1,0. – geoffspear

Répondre

1

Ceci est un petit exercice de pyparsing que je l'ai fait dans le passé, adapté à votre exemple (prend également en charge plusieurs plages et index non appariés, tous séparés par des virgules - voir le dernier cas de test):

from pyparsing import (Suppress, Word, alphas, alphanums, nums, delimitedList, 
    Combine, Optional, Group) 

LBRACK,RBRACK,COLON = map(Suppress,"[]:") 

ident = Word(alphas+"_", alphanums+"_") 
integer = Combine(Optional('-') + Word(nums)) 
integer.setParseAction(lambda t : int(t[0])) 
intrange = Group(integer + COLON + integer) 

rangedIdent = ident("name") + LBRACK + delimitedList(intrange|integer)("indexes") + RBRACK 

def expandIndexes(t): 
    ret = [] 
    for ind in t.indexes: 
     if isinstance(ind,int): 
      ret.append("%s[%d]" % (t.name, ind)) 
     else: 
      offset = (-1,1)[ind[0] < ind[1]] 
      ret.extend(
       "%s[%d]" % (t.name, i) for i in range(ind[0],ind[1]+offset,offset) 
       ) 
    return ret 
rangedIdent.setParseAction(expandIndexes) 

print rangedIdent.parseString("abc[0:3]") 
print rangedIdent.parseString("abc[3:0]") 
print rangedIdent.parseString("abc[0:3,7,14:16,24:20]") 

Prints:

['abc[0]', 'abc[1]', 'abc[2]', 'abc[3]'] 
['abc[3]', 'abc[2]', 'abc[1]', 'abc[0]'] 
['abc[0]', 'abc[1]', 'abc[2]', 'abc[3]', 'abc[7]', 'abc[14]', 'abc[15]', 'abc[16]', 'abc[24]', 'abc[23]', 'abc[22]', 'abc[21]', 'abc[20]'] 
+0

cool !, êtes-vous capable de revenir de décompresser à compresser? – user466130

+2

Je pense que cela peut être laissé comme un exercice pour l'OP. – PaulMcG

2

En Perl:

#!perl -w 

use strict; 
use 5.010; 

my @abc = qw/ a b c d /; 
say join(" ", reverse @abc[0..3]); 

Ou si vous les vouliez en variables distinctes:

my($abc3, $abc2, $abc1, $abc0) = reverse @abc[0..3]; 

Edit: par votre clarification:

my $str = "abc[3:0]"; 
$str =~ /(abc)\[(\d+):(\d+)\]/; 
my $base = $1; 
my $from = ($2 < $3 ? $2 : $3); 
my $to = ($2 > $3 ? $2 : $3); 
my @strs; 
foreach my $num ($from .. $to) { 
    push @strs, $base . '[' . $num . ']'; 
} 
+1

Il en est de même pour toutes les valeurs de $ de à $ inclusivement, ou seulement jusqu'à $ to-1. Comment cela fonctionne avec les index négatifs? – PaulMcG

+0

inclusivement. Bien que le foreach ne soit pas la magie, c'est le –

+0

Enregistrer trois lignes de code et utiliser trois variables de correspondance nugatoire en affectant directement les résultats de l'expression de correspondance aux trois variables scalaires nommées et en effectuant une seule comparaison dans le foreach. expression: '$ from <$ à: $ from .. $ à: reverse $ from .. $ to' (non testé) – daxim

Questions connexes