Insérer un caractère de saut de ligne à chaque 64 caractères à l'aide de Python

À l'aide de Python j'ai besoin d'insérer un caractère de saut de ligne dans une chaîne de tous les 64 caractères. En Perl, c'est facile:

s/(.{64})/$1\n/

Comment cela pourrait-il être fait en utilisant des expressions régulières en Python?
Est-il plus pythonic façon de le faire?

InformationsquelleAutor bignum | 2010-04-17

python regex

30

Même comme en Perl, mais avec une barre oblique inverse à la place du dollar pour l'accès aux groupes:
```
s = "0123456789"*100 # test string
import re
print re.sub("(.{64})", "\\n", s, 0, re.DOTALL)
```
re.DOTALL est l'équivalent en Perl s/ option.
- REQUÊTE: Si la chaîne source est s2="0123456789"*200 , ta solution me semble être brisé, qui uniquement insère exactement 16 '\n' (sur Python 2.7.1). Un correctif?
- Jolie trouvaille. Le problème est qu'il y est un autre paramètre "nombre" entre la chaîne de recherche et les drapeaux (re.DOTALL). Depuis j'ai oublié ce paramètre, re.DOTALL (valeur 16) a été utilisé comme nombre maximum de remplacements.
- est-il possible d'utiliser une variable à la place de 64?
- Eh bien, il suffit d'insérer votre numéro au lieu de 64 ?!
- comment voulez-vous atteindre ce pour une entrée multiligne et les convertir pour par exemple. une ligne thisisafile à thi,sisafi,l,e (le nombre de caractères après pour entrer un caractère codé en dur)comme ici par exemple, il aurait été 3 6 1 1
- Je pense que @Forethinker signifie "utiliser une variable", pas "utiliser une autre constante". "(.{%d})"%varname semble un peu hackish; il doit y avoir une meilleure façon.
InformationsquelleAutor AndiDog

sans regexp:

def insert_newlines(string, every=64):
    lines = []
    for i in xrange(0, len(string), every):
        lines.append(string[i:i+every])
    return '\n'.join(lines)

plus court mais moins lisible (omi):

def insert_newlines(string, every=64):
    return '\n'.join(string[i:i+every] for i in xrange(0, len(string), every))

Le code ci-dessus est pour Python 2.x. Pour Python 3.x, vous souhaitez utiliser range et pas xrange:

def insert_newlines(string, every=64):
    lines = []
    for i in range(0, len(string), every):
        lines.append(string[i:i+every])
    return '\n'.join(lines)

def insert_newlines(string, every=64):
    return '\n'.join(string[i:i+every] for i in range(0, len(string), every))

Cette solution est d'un ordre de grandeur plus rapide. timeit.timeit dit 100000 exécutions de l'expression de la solution de prendre de 27,8 secondes, tandis que 100000 exécutions de vos plus courte de la solution de prendre 4.45 secondes).
Je voudrais aussi dire que la version la plus courte est la "plus pythonic": un one-liner, assez élégant, à l'aide de générateurs et de la join méthode.

InformationsquelleAutor gurney alex

14

J'irais avec:
```
import textwrap
s = "0123456789"*100
print '\n'.join(textwrap.wrap(s, 64))
```
- textwrap est l'espace conscient, donc ce ne sera pas la poignée "12345 "*100 correctement.
InformationsquelleAutor jfs
9

prenant @J. F. Sebastian solution un pas de plus, et c'est près de pénale 🙂
```
import textwrap
s = "0123456789"*100
print textwrap.fill(s, 64)
```
regarder ma... pas de regexes! car comme vous le savez... http://regex.info/blog/2006-09-15/247

merci pour nous introduire à d'habillage de texte module... même si elle a été en Python depuis 2.3, je n'ai jamais été au courant de ça jusqu'à maintenant (oui, j'avoue que public)!!
- textwrap est l'espace conscient, donc ce ne sera pas la poignée "12345 "*100 correctement.
- transformer (en toute sécurité) et à l'arrière? thx tho!
InformationsquelleAutor wescpy

Minuscule, pas sympa:

"".join(s[i:i+64] + "\n" for i in xrange(0,len(s),64))

InformationsquelleAutor Michael

Je vous suggérons la méthode suivante:

"\n".join(re.findall("(?s).{,64}", s))[:-1]

C'est, plus ou moins, la non-RE méthode profitant de la RE moteur pour la boucle.

Sur un pc lent, j'ai comme un serveur à la maison, cela donne:

$ python -m timeit -s 's="0123456789"*100; import re' '"\n".join(re.findall("(?s).{,64}", s))[:-1]'
10000 loops, best of 3: 130 usec per loop

AndiDog de la méthode:

$ python -m timeit -s "s='0123456789'*100; import re" 're.sub("(?s)(.{64})", r"\n", s)'
1000 loops, best of 3: 800 usec per loop

alex gurney 2e/Michael méthode:

$ python -m timeit -s "s='0123456789'*100" '"\n".join(s[i:i+64] for i in xrange(0, len(s), 64))'
10000 loops, best of 3: 148 usec per loop

Je ne considère pas le textwrap méthode correcte pour la spécification de la question, donc je ne vais pas le temps que cela.

MODIFIER

Changé répondre parce que c'était incorrect (honte sur moi!)

EDIT 2

Juste pour le plaisir, la RE-méthode à l'aide de itertools. C'taux tiers de la vitesse, et il n'est pas Pythonic (trop lispy):

"\n".join(
   it.imap(
     s.__getitem__,
     it.imap(
       slice,
       xrange(0, len(s), 64),
       xrange(64, len(s)+1, 64)
     )
   )
 )

$ python -m timeit -s 's="0123456789"*100; import itertools as it' '"\n".join(it.imap(s.__getitem__, it.imap(slice, xrange(0, len(s), 64), xrange(64, len(s)+1, 64))))'
10000 loops, best of 3: 182 usec per loop

Cela ne semble pas fonctionner correctement. Si vous mettez plus de 64 caractères qu'il génère un saut de ligne après chaque personnage plutôt que d'après tous les 64 caractères.
Spot sur, biffabacon. Il fixe.
Votre réponse est très utile TZΩΤΖΙΟΥ. Merci beaucoup.

InformationsquelleAutor tzot

itertools a une jolie recette pour une fonction grouper qui est bon pour ça, surtout si votre dernière tranche est inférieure à 64 caractères et vous ne voulez pas une tranche d'erreur:

def grouper(iterable, n, fillvalue=None):
    "Collect data into fixed-length chunks or blocks"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx
    args = [iter(iterable)] * n
    return izip_longest(fillvalue=fillvalue, *args)

Utiliser comme ceci:

big_string = <YOUR BIG STRING>
output = '\n'.join(''.join(chunk) for chunk in grouper(big_string, 64))

InformationsquelleAutor isosceleswheel

Vous devez vous connecter pour publier un commentaire.