Facile d'ignorer les lignes vides lors de la lecture d'un fichier en Python

J'ai un code qui lit un fichier de noms et crée une liste:

names_list = open("names", "r").read().splitlines()

Chaque nom est séparé par un saut de ligne, comme ceci:

Allman
Atkinson

Behlendorf

Je veux ignorer toutes les lignes qui ne contiennent que des espaces. Je sais que je peux le faire par la création d'une boucle et de vérifier chaque ligne j'ai lu et puis l'ajouter à une liste si elle n'est pas vide.

Je me demandais juste si il y avait une plus Pythonic moyen de le faire?

Il n'y est une réponse ici: stackoverflow.com/questions/4791080/...

InformationsquelleAutor Ambrosio | 2011-01-30

python

56

Je pile générateur d'expressions:
```
with open(filename) as f_in:
    lines = (line.rstrip() for line in f_in) # All lines including the blank ones
    lines = (line for line in lines if line) # Non-blank lines
```
Maintenant, lines est tous les non-lignes vides. Cela vous évitera d'avoir à appeler la bande sur la ligne deux fois. Si vous voulez une liste de lignes, vous pouvez le faire:
```
with open(filename) as f_in:
    lines = (line.rstrip() for line in f_in) 
    lines = list(line for line in lines if line) # Non-blank lines in a list
```
Vous pouvez aussi le faire dans un one-liner (sauf with déclaration), mais ce n'est pas plus efficace et plus difficile à lire:
```
with open(filename) as f_in:
    lines = list(line for line in (l.strip() for l in f_in) if line)
```
Mise à jour:

Je suis d'accord que c'est laid en raison de la répétition de jetons. Vous pouvez simplement écrire un générateur si vous préférez:
```
def nonblank_lines(f):
    for l in f:
        line = l.rstrip()
        if line:
            yield line
```
Puis l'appeler comme:
```
with open(filename) as f_in:
    for line in nonblank_lines(f_in):
        # Stuff
```
mise à jour 2:
```
with open(filename) as f_in:
    lines = filter(None, (line.rstrip() for line in f_in))
```
et sur Disponible (avec déterministe de comptage de référence)
```
lines = filter(None, (line.rstrip() for line in open(filename)))
```
En Python 2 utilisez itertools.ifilter si vous voulez un générateur et en Python 3, il suffit de passer le tout à list si vous voulez une liste.
- Je pense que le troisième ligne dans votre premier code devrait lire for line in lines.
- Kling. La droite. Merci pour le tuyau.
- "Cela vous évitera d'avoir à appeler la bande sur la ligne deux fois." - oui; et c'est certainement plus net à cet égard; mais vous avez encore finissent par se répéter, et je me demande si c'est vraiment fait en terme de performance passe par la surcharge de chaînage des générateurs comme ça. Quelqu'un veut-il faire des tests?
- Il utilise deux générateur d'expressions, mais ce n'est pas répétition, ils sont entièrement différentes expressions.
- Je veux dire que les jetons comme "line" se répète un tas.
- Knechtel, Vérifier ma mise à jour. Pensez-vous que le générateur approche est la meilleure?
- Sans doute. Je ne pense pas que tout est parfait ici. 🙂
- Merci, vos réponses ont été très intéressantes et utiles.
- Bon, Que pensez-vous de filter?
- La même chose. Je veux dire, vous pourriez me montrer 100 subtilement différentes variations, et je ne pense pas que je pourrais choisir un gagnant clair. 🙂 Un de ces est très bien mais vraiment.
- Votre première oneliner est si difficile à lire, que ni vous ni la joyeuse bande des électeurs et les commentateurs ont remarqué qu'il a besoin de () après l.strip 🙂
- Machin. Bon oeil.
- +1 pour nonblank_lines fonction. Ce devrait être la première. Le reste est soit le code de golf ou un dévoreur de mémoire, car il se lit l'intégralité des fichiers dans une seule des listes (parfois) l'ensemble du fichier n'est pas nécessaire.
- Qu'entendez-vous par "code de golf" et "dévoreur de mémoire", s'il vous plaît ? Je ne suis pas anglophone et parfois je ne comprends pas les subtilités de la langue anglaise. D'ailleurs, je ne comprends pas également la partie "il lit l'intégralité des fichiers dans une seule des listes (parfois) l'ensemble du fichier n'est pas nécessaire" : oui, si le problème était plus complexe, la solution doit être plus complexe...mais que faisons-nous maintenant, après cette remarque ?
- Code de Golf peut être trouvé dans Google. Essayez d'utiliser une recherche pour voir ce que vous pouvez trouver. Comme le golf, c'est un jeu de minimiser la quantité de code pour obtenir un morceau de la programmation. Simplement en minimisant le code est rarement utile. Personne ne gagne à Code de Golf.
- Hog" signifie que le premier exemple utilise plus de mémoire que nécessaire. C'est un "cochon" et mange trop de mémoire. Il y a rarement un besoin de lire tout le fichier en mémoire à la fois dans le but d'appliquer un filtre simple. Le nonblank_lines générateur de fonction accomplit le filtre requis sans lire tout le fichier en mémoire.
- Oh merci. Mon googler réflexe n'était pas activé, car je croyais que ces expressions sont de votre propre créativité, basée sur la langue anglaise souplesse. 🙁 Concernant votre remarque, je ne comprends toujours pas: que j'ai compris le mécanisme, "pour la ligne ..." lit progressivement un fichier, sans avance de la charge de la totalité du fichier en mémoire vive. Et dans le aaronasterling trois solutions, il est "pour ligne à f_in' instruction. Et alors ?!
- est le fichier entier comme une seule liste. N'est-ce pas clair? Il lit le fichier en entier dans une seule liste. Tous les fichiers. Dans la mémoire. Dans le même temps. Le générateur de fonction ne pas lire le fichier en entier tous en mémoire en même temps; il ne crée un seul de la liste avec le contenu du fichier.
- nonblank_lines() dans la solution 2 est une fonction qui lit le fichier, comme le font les autres (générateur de ligne.rstrip() à la ligne dans f_in) dans les solutions 1 et 3 de aaronasterling; et tous les trois dans le même progressive, sur demande, de la manière. Ils ne sont pas responsables de la façon dont ils sont utilisés, par une fonction list() ou une itération ou un filtre de fonction de() pour obtenir un stockage des données de l'objet. De sorte que la taille de la liste, qui pèse sur la RAM, si le fichier est énorme, ne peut pas être un critère pour décider que l'un de ces trois équivalent des générateurs est mieux que l'autre.
- lit le fichier entier comme une seule liste. Il n'y a pas d'alternative but derrière cette ligne de code. D'accord? La fonction peut être utilisée pour traiter le fichier ligne par ligne, sans enregistrer l'intégralité du fichier en mémoire. Oui, il peut également être utilisé pour lire le fichier en entier, mais la fonction peut être utilisée de diverses façons. D'accord? Et la fonction peut être utilisée pour traiter une ligne à la fois. D'accord? Le lines =... instruction d'affectation ne peut pas être utilisé pour traiter les lignes une à une, car il doit lire l'intégralité du fichier dans un unique liste.
- lignes= ... assignement s'il vous plaît ? Il ya beaucoup de lignes= quelque chose dans le post de aaronasterling
- lignes= ... assignement s'il vous plaît ?" Ils font tous la même chose de différentes façons. Ils lisent la totalité du fichier en mémoire. Contrairement à la fonction, qui peut être utilisé pour traiter une ligne à la fois sans avoir à charger toutes les lignes dans la mémoire.
- J'ai posté une réponse dans une simple image parce que c'est trop étroit ici. Mais oui, "Ils font tous la même chose de différentes façons.", nonblank_lines (), composé, ils sont tous équivalents générateurs, nonblank_lines() n'a rien de spécial. En passant, avez-vous parler des moyens de LECTURE d'UN FICHIER ou de l'différents ALGORITHMES à l'aide de différents outils à partir d'un fichier au stockage de l'objet ?
- lire l'intégralité du fichier en mémoire. ". Je répète ma réponse: "Ils ne sont pas responsables de la façon dont ils sont utilisés" et de la taille de l'objet qui stocke les données extraites. Ils font leur travail de lecture à la demande d'un fichier - , ils n'ont pas à décider de la destination de lire les données. Par conséquent, vous ne pouvez pas accuser le résultat de la taille et de la volonté du développeur d'enregistrer le résultat en mémoire.
- Vous point m'échappe totalement. Le lines=... états -- tous -- doivent lire l'intégralité du fichier. Pas de choix. Pas de solutions de rechange. La définition de la fonction est complètement différent. Il peut être utilisé dans un contexte dans lequel chaque ligne est traitée séparé. Il a le choix. Il a des alternatives.
- Merci!!!! Maintenant, je vois @eyquem point. Et il y a seulement trois lines = avec pas de liste ou de filtre. Je comprends le point que lines = (...) sera un générateur. Et je vois enfin la subtilité que j'ai eu tort. Je pense toujours que vous devez changer l'ordre de vos réponse.
- Pour moi (la ligne.rstrip() à la ligne dans f_in) et nonblank_lines() COMME ÉCRIT dans le aaronsterling de la poste sont tenus de lire entièrement le fichier. Si, vous avez raison dans le sens qu'une instruction 'if test: break" peut être inséré dans le présent nonblank_lines() pour le faire devenir un stopable_nonblank_lines() qui ne lisent pas l'intégralité du fichier. Il permet également de mettre les quantités de traitements entre l'appel et le rendement. Ce sont les différences qui font (de la ligne.rstrip() à la ligne dans f_in) un générateur d'expression et nonblank_lines() un générateur de fonction. Peut-être que je comprends des mots trop strictement
- Je suis d'accord avec vous que la fonction est la plus belle façon de faire cela. "Et je me demande encore pourquoi.....
- Le nonblank_lines() de la fonction et de la (line.rstrip() for line in f_in) sont DEUX générateur de fonctions. Je me suis trompé sur certains lines= exemples. Certains des lines= exemples sont générateur de fonctions qui ne sont pas de créer des listes de mémoire. Certains des lines= exemples ne créer géant listes. Le nonblank_lines() de la fonction et de la (line.rstrip() for line in f_in) sont DEUX générateur de fonctions.
- elle s'est méprise sur certaines lignes= exemples. Certaines des lignes= exemples sont générateur de fonctions qui ne sont pas de créer des listes de mémoire. Certaines des lignes= exemples ne créer géant des listes." Oui, c'est mal écrit, avec le même nom pour les différents objets similaires. Que c'est également mauvais pour appeler des "lignes" qu'est ce qu'une liste de noms.
- Mais non, le nonblank_lines() et la fonction du (de la ligne.rstrip() à la ligne dans f_in) ne sont PAS à la fois générateur de FONCTIONS. Ce dernier est un générateur d'EXPRESSION. Comparer les docs.python.org/reference/datamodel.html#index-862 et docs.python.org/reference/expressions.html#index-948 . gen.la touche func. et gen.expr. de même produire un objet de générateur. Mais une gen.func ont mot clé yield , peut faire une pause, d'instruction et de, tous les de choses qu'un gen.expr n'a pas.
- La syntaxe de côté (l'un est une fonction, l'un est une expression), ils sont tous les deux générateurs. Merci pour les liens, mais je suis tout à fait conscient des différences. Les cheveux de fractionnement ne semble pas utile. Si elle vous rend heureux, cependant, garder à l'affichage. Malgré ma confusion sur le lines= avec et sans list, j'en ai un et un seul point. C'est, je préfère la fonction de la notation sur l'expression. C'est tout. J'ai été confondu par votre point de vue. Je ne suis plus confus. Je n'ai toujours rien beaucoup à dire. J'ai une préférence de la fonction sur l'expression. Que tout y est.
- Par ailleurs,je pense que la doc suivante est extrait s'applique à ces 2 types d'objets: «La différence entre un code objet et un objet de fonction, la fonction de l'objet contient une référence explicite à la fonction de variables globales, tandis qu'un code objet ne contient pas de contexte; de plus, l'argument par défaut, les valeurs sont stockées dans la fonction de l'objet, et non pas dans le code de l'objet (parce qu'ils représentent des valeurs calculées au moment de l'exécution). Contrairement à la fonction des objets, le code des objets sont immuables et ne contiennent pas de références (directement ou indirectement) à mutable objets.» docs.python.org/reference/datamodel.html
- Je préfère encore la fonction de la notation sur l'expression. C'est tout.
- Ce n'est pas la syntaxe,c'est le sens. Je préfère croire en la officiel doc qui semble faire une différence réelle entre la gen func un gen expr, même si je ne comprends pas tout tout ce qui est derrière la scène. Oui, je suis intéressé dans les coulisses des mécanismes, même si c'est dur à comprendre pour moi. Vous ne devez pas appeler que les cheveux de fractionnement. Ce n'est pas une question de notation selon moi, c'est sur les implémentations sous-jacentes des objets.
- Mais il semble que nous avons des intérêts divergents. Je suis intéressé par la comparaison d'options lors de votre dernière assertion est une préférence argument selon lequel il n'y a plus de golf, ni porc à la justifier. C'est votre droit de le faire, mais pas une raison pour se moquer de moi au sujet d'être heureux à l'étude de Python au lieu de C++ ou de Base.
- De mon côté c'est mon droit comme pour l'étude de la les entrailles de Python et de continuer à penser il n'y a aucune raison rationnelle pour se qualifier nonblank_lines() un meilleur outil que les autres. J'ai le regret est entré dans un débat où il y a moins de savoir que je l'ai cru. Je pourrais en dire plus mais il est préférable pour moi de terminer. Je vous remercie pour vos réponses.
- La raison rationnelle pour préférant la fonction est parce que c'est une fonction. Il est compatible avec la programmation fonctionnelle. Il permet négligeable composition dans le cadre de la construction d'une plus grande fonction de petites fonctions. C'est la raison rationnelle pourquoi je préfère fonctions.
- Je vous remercie, mais je veux arrêter. En fait j'ai l'impression de ne pas avoir la même logique et les motivations que vous. Par exemple, justifier un choix dans un problème particulier par une raison générale que la programmation fonctionnelle, je ne sais pas quoi penser. Donc je n'ai pas de satisfaction à argumenter d'une façon que je ne comprends pas les affirmations et dans lequel je suis censé être dans la mauvaise. Je ne pense pas qu'il puisse y avoir une fin à un débat.
- raison générale que la programmation fonctionnelle" est la seule raison pour laquelle j'ai. Il est rationnel. C'est ma raison. Ce que tu veux de plus? De la magie?
InformationsquelleAutor aaronasterling
17

Vous pouvez utiliser la liste de compréhension:
```
with open("names", "r") as f:
    names_list = [line.strip() for line in f if line.strip()]
```
Mise à jour: Retiré inutile readlines().

Pour éviter l'appel de line.strip() deux fois, vous pouvez utiliser un générateur:
```
names_list = [l for l in (line.strip() for line in f) if l]
```
- Sympa, mais il fait des appels strip() deux fois sur chaque ligne.
InformationsquelleAutor Felix Kling
7

Si vous le souhaitez, vous pouvez juste mettre ce que vous aviez dans une compréhension de liste:

names_list = [line for line in open("names.txt", "r").read().splitlines() if line]

ou
```
all_lines = open("names.txt", "r").read().splitlines()
names_list = [name for name in all_lines if name]
```
splitlines() a déjà retiré les fins de ligne.

Je ne pense pas que ceux qui sont aussi claires que juste en boucle explicitement que:
```
names_list = []
with open('names.txt', 'r') as _:
    for line in _:
        line = line.strip()
        if line:
            names_list.append(line)
```
Edit:

Bien que, filtre semble tout à fait lisible et concis:

names_list = filter(None, open("names.txt", "r").read().splitlines())
- J'ai essayé presque chaque chose sur cette page, et votre première ligne a parfaitement fonctionné.
- Oh merci, j'ai essayé de faire splitlines().filtre plutôt que de filtre(splitlines())
- Merci beaucoup, votre réponse pour moi est le meilleur!
InformationsquelleAutor Sean

Lorsqu'un traitement de texte doit être fait simplement en extraire des données, j'ai toujours penser d'abord à la regexes, parce que:

autant que je sache, regexes avoir été inventé pour que
itération sur les lignes apparaît maladroit pour moi: il consiste essentiellement à rechercher les retours à la ligne, puis de rechercher les données à extraire dans chaque ligne; cela fait deux recherches au lieu d'un seul avec une regex
façon de rassembler les regexes jouer, c'est facile; seulement l'écriture d'une expression rationnelle de la chaîne afin d'être compilées dans un objet regex est parfois dur, mais dans ce cas, le traitement avec une itération sur les lignes va être compliqué, trop

Pour le problème évoqué ici, une regex solution est rapide et facile à écrire:

import re
names = re.findall('\S+',open(filename).read())

J'ai comparé les vitesses de plusieurs solutions:

import re
from time import clock
A,AA,B1,B2,BS,reg = [],[],[],[],[],[]
D,Dsh,C1,C2 = [],[],[],[]
F1,F2,F3  = [],[],[]
def nonblank_lines(f):
for l in f:
line = l.rstrip()
if line:  yield line
def short_nonblank_lines(f):
for l in f:
line = l[0:-1]
if line:  yield line
for essays in xrange(50):
te = clock()
with open('raa.txt') as f:
names_listA = [line.strip() for line in f if line.strip()] # Felix Kling
A.append(clock()-te)
te = clock()
with open('raa.txt') as f:
names_listAA = [line[0:-1] for line in f if line[0:-1]] # Felix Kling with line[0:-1]
AA.append(clock()-te)
#-------------------------------------------------------
te = clock()
with open('raa.txt') as f_in:
namesB1 = [ name for name in (l.strip() for l in f_in) if name ] # aaronasterling without list()
B1.append(clock()-te)
te = clock()
with open('raa.txt') as f_in:
namesB2 = [ name for name in (l[0:-1] for l in f_in) if name ] # aaronasterling without list() and with line[0:-1]
B2.append(clock()-te)
te = clock()
with open('raa.txt') as f_in:
namesBS = [ name for name in f_in.read().splitlines() if name ] # a list comprehension with read().splitlines()
BS.append(clock()-te)
#-------------------------------------------------------
te = clock()
with open('raa.txt') as f:
xreg = re.findall('\S+',f.read()) #  eyquem
reg.append(clock()-te)
#-------------------------------------------------------
te = clock()
with open('raa.txt') as f_in:
linesC1 = list(line for line in (l.strip() for l in f_in) if line) # aaronasterling
C1.append(clock()-te)
te = clock()
with open('raa.txt') as f_in:
linesC2 = list(line for line in (l[0:-1] for l in f_in) if line) # aaronasterling  with line[0:-1]
C2.append(clock()-te)
#-------------------------------------------------------
te = clock()
with open('raa.txt') as f_in:
yD = [ line for line in nonblank_lines(f_in)  ] # aaronasterling  update
D.append(clock()-te)
te = clock()
with open('raa.txt') as f_in:
yDsh = [ name for name in short_nonblank_lines(f_in)  ] # nonblank_lines with line[0:-1]
Dsh.append(clock()-te)
#-------------------------------------------------------
te = clock()
with open('raa.txt') as f_in:
linesF1 = filter(None, (line.rstrip() for line in f_in)) # aaronasterling update 2
F1.append(clock()-te)
te = clock()
with open('raa.txt') as f_in:
linesF2 = filter(None, (line[0:-1] for line in f_in)) # aaronasterling update 2 with line[0:-1]
F2.append(clock()-te)
te = clock()
with open('raa.txt') as f_in:
linesF3 =  filter(None, f_in.read().splitlines()) # aaronasterling update 2 with read().splitlines()
F3.append(clock()-te)
print 'names_listA == names_listAA==namesB1==namesB2==namesBS==xreg\n  is ',\
names_listA == names_listAA==namesB1==namesB2==namesBS==xreg
print 'names_listA == yD==yDsh==linesC1==linesC2==linesF1==linesF2==linesF3\n  is ',\
names_listA == yD==yDsh==linesC1==linesC2==linesF1==linesF2==linesF3,'\n\n\n'
def displ((fr,it,what)):  print fr + str( min(it) )[0:7] + '   ' + what
map(displ,(('* ', A,    '[line.strip() for line in f if line.strip()]               * Felix Kling\n'),
('  ', B1,   '    [name for name in (l.strip() for l in f_in) if name ]    aaronasterling without list()'),
('* ', C1,   'list(line for line in (l.strip() for l in f_in) if line)   * aaronasterling\n'),          
('* ', reg,  're.findall("\S+",f.read())                                 * eyquem\n'),
('* ', D,    '[ line for line in       nonblank_lines(f_in)  ]           * aaronasterling  update'),
('  ', Dsh,  '[ line for line in short_nonblank_lines(f_in)  ]             nonblank_lines with line[0:-1]\n'),
('* ', F1 ,  'filter(None, (line.rstrip() for line in f_in))             * aaronasterling update 2\n'),
('  ', B2,   '    [name for name in (l[0:-1]   for l in f_in) if name ]    aaronasterling without list() and with line[0:-1]'),
('  ', C2,   'list(line for line in (l[0:-1]   for l in f_in) if line)     aaronasterling  with line[0:-1]\n'),
('  ', AA,   '[line[0:-1] for line in f if line[0:-1]  ]                   Felix Kling with line[0:-1]\n'),
('  ', BS,   '[name for name in f_in.read().splitlines() if name ]        a list comprehension with read().splitlines()\n'),
('  ', F2 ,  'filter(None, (line[0:-1] for line in f_in))                  aaronasterling update 2 with line[0:-1]'),
('  ', F3 ,  'filter(None, f_in.read().splitlines()                        aaronasterling update 2 with read().splitlines()'))
)

Solution avec la regex est simple et soigné. Cependant, il n'est pas parmi les plus rapides.
La solution de aaronasterling avec filtre() est surprisigly rapide pour moi (je n'étais pas au courant de ce filtre particulier()'s de vitesse) et les temps de solutions optimisées d'aller vers le bas jusqu'à 27 % de plus de temps. Je me demande ce qui fait le miracle du filtre-splitlines association:

names_listA == names_listAA==namesB1==namesB2==namesBS==xreg
is  True
names_listA == yD==yDsh==linesC1==linesC2==linesF1==linesF2==linesF3
is  True 
* 0.08266   [line.strip() for line in f if line.strip()]               * Felix Kling
0.07535       [name for name in (l.strip() for l in f_in) if name ]    aaronasterling without list()
* 0.06912   list(line for line in (l.strip() for l in f_in) if line)   * aaronasterling
* 0.06612   re.findall("\S+",f.read())                                 * eyquem
* 0.06486   [ line for line in       nonblank_lines(f_in)  ]           * aaronasterling  update
0.05264   [ line for line in short_nonblank_lines(f_in)  ]             nonblank_lines with line[0:-1]
* 0.05451   filter(None, (line.rstrip() for line in f_in))             * aaronasterling update 2
0.04689       [name for name in (l[0:-1]   for l in f_in) if name ]    aaronasterling without list() and with line[0:-1]
0.04582   list(line for line in (l[0:-1]   for l in f_in) if line)     aaronasterling  with line[0:-1]
0.04171   [line[0:-1] for line in f if line[0:-1]  ]                   Felix Kling with line[0:-1]
0.03265   [name for name in f_in.read().splitlines() if name ]        a list comprehension with read().splitlines()
0.03638   filter(None, (line[0:-1] for line in f_in))                  aaronasterling update 2 with line[0:-1]
0.02198   filter(None, f_in.read().splitlines()                        aaronasterling update 2 with read().splitlines()

Mais ce problème est particulier, le plus simple de tous: un seul nom dans chaque ligne. Si les solutions ne sont que des jeux avec des lignes, des splitings et [0:-1] les coupures.

Au contraire, la regex n'a pas d'importance avec les lignes, c'carrément trouve les données souhaitées: je considère que c'est une façon plus naturelle de la résolution, l'application des plus simples aux plus complexes, et par conséquent, est souvent le moyen d'être utilisés dans les traitements de textes.

MODIFIER

J'ai oublié de dire que j'utilise Python 2.7 et j'ai mesuré les temps ci-dessus avec un fichier contenant plus de 500 fois la chaîne suivante

SMITH
JONES
WILLIAMS
TAYLOR
BROWN
DAVIES
EVANS
WILSON
THOMAS
JOHNSON
ROBERTS
ROBINSON
THOMPSON
WRIGHT
WALKER
WHITE
EDWARDS
HUGHES
GREEN
HALL
LEWIS
HARRIS
CLARKE
PATEL
JACKSON
WOOD
TURNER
MARTIN
COOPER
HILL
WARD
MORRIS
MOORE
CLARK
LEE
KING
BAKER
HARRISON
MORGAN
ALLEN
JAMES
SCOTT
PHILLIPS
WATSON
DAVIS
PARKER
PRICE
BENNETT
YOUNG
GRIFFITHS
MITCHELL
KELLY
COOK
CARTER
RICHARDSON
BAILEY
COLLINS
BELL
SHAW
MURPHY
MILLER
COX
RICHARDS
KHAN
MARSHALL
ANDERSON
SIMPSON
ELLIS
ADAMS
SINGH
BEGUM
WILKINSON
FOSTER
CHAPMAN
POWELL
WEBB
ROGERS
GRAY
MASON
ALI
HUNT
HUSSAIN
CAMPBELL
MATTHEWS
OWEN
PALMER
HOLMES
MILLS
BARNES
KNIGHT
LLOYD
BUTLER
RUSSELL
BARKER
FISHER
STEVENS
JENKINS
MURRAY
DIXON
HARVEY

Un couple de points. On n'aurait jamais écrire [line for line in generator()], on pourrait simplement écrire list(generator()). Essayez de travailler avec des objets internes à chaque fois que possible. Ils sont écrits en C et tout le monde sait ce qu'ils font. Aussi, j'ai été appeler str.rstrip pas str.split. Je ne sais pas si il y aura un gain de performance. Enfin, filter(None, ....) est si rapide, car il est un condensé de toute la logique dans C.

InformationsquelleAutor eyquem

0

@S. Lott

Le code suivant traite les lignes une à une heure et produit un résultat qui n'est pas désireux de mémoire:
```
filename = 'english names.txt'
with open(filename) as f_in:
lines = (line.rstrip() for line in f_in)
lines = (line for line in lines if line)
the_strange_sum = 0
for l in lines:
the_strange_sum += 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.find(l[0])
print the_strange_sum
```
De sorte que le générateur de ligne.rstrip() à la ligne dans f_in) est tout à fait le même acceptable que la nonblank_lines() fonction.
- Pas de . Si je test avec des types d'impression(lignes), j'obtiens <type de "générateur" > . Donc, les lignes n'est pas un objet contenant des données, avoir une petite ou de grande taille. Et lignes = (ligne.rstrip() à la ligne dans f_in) n'a pas mis tout seul dans la mémoire, il offre la possibilité d'être réitéré. Mon code ci-dessus n'est pas de mettre tout le fichier en mémoire, il se contente d'enregistrer un nombre entier dans la the_strange_sum objet qui vit dans la mémoire. Il semble que nous n'avons pas comprendre les mots de la même.
- D'accord. Je ne pouvais pas comprendre votre point jusqu'à ce que vous avez inclus <type de "générateur" >.
InformationsquelleAutor eyquem
0

Ce sujet LineSentence module, il va ignorer ces lignes:

Bases: objet

Format Simple: une phrase = une ligne; les mots déjà prétraitées et
séparés par des espaces.

source peut être une chaîne ou un objet de fichier. Clip le fichier à l'
les premières lignes de limite (ou pas coupés si la limite n'est, par défaut).
```
from gensim.models.word2vec import LineSentence
text = LineSentence('text.txt')
```
InformationsquelleAutor Rocketq
0

Je pense qu'il y a une solution simple qui j'ai récemment utilisé après avoir donc beaucoup de réponses ici.
```
with open(file_name) as f_in:   
for line in f_in:
if len(line.split()) == 0:
continue
```
Cela fait exactement le même travail, en ignorant tous les vides de ligne.

InformationsquelleAutor a_ran
0

Pourquoi êtes-vous tous d'aller à la dure?
```
with open("myfile") as myfile:
nonempty = filter(str.rstrip, myfile)
```
Convertir non vides dans une liste si vous avez l'envie de le faire, bien que je vous suggère fortement de garder non vide d'un générateur comme il est en Python 3.x

En Python 2.x vous pouvez utiliser itertools.ifilter de faire votre appel d'offres à la place.

InformationsquelleAutor Bharel

Vous devez vous connecter pour publier un commentaire.

Mise à jour:

mise à jour 2: