Discussion :

[aspire]

bonjour

pourquoi la condition du while dans le code suivant (typique en java) ne fonctionne pas en python ???

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
of1 = open("monfichier.txt", 'r')
ligne=""
while ((ligne = of1.readline())!=""):
     print ligne
of1.close()

je pense que l'affection ne marche pas, pourquoi ?
sinon comment raccourcir ce code (si c'est possible):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
while 1:
    ligne1 = of1.readline()
    print ligne1
    if ligne1 == ""
        break

merci

[fred1599]

Je fais pas de java et d'ailleurs oublie le java pour faire du python.

Pour lire toutes les lignes il y a plein de solutions possibles, mais en ce qui me concerne, j'oublie les boucles while.

Voilà une des solutions que je préfère

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
with open('monfichier.txt', 'r') as f:
    lignes = [ligne.strip('\n') for ligne in f.readlines()]
    print('\n'.join(lignes))

[mont29]

C’est vrai que les constructions comme while (a = b) not None: (qui fonctionnent aussi en C, si je ne m’abuse) manquent un peu à python… En voici un équivalent*:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
with open("monfichier.txt", 'r') as of1:
    ligne = of1.readline()
    while ligne:
        print ligne
        ligne = of1.readline()
# Non need for of1.close() here, the context manager (with statement) takes care of that!

[aspire]

merci fred
cette version me plait mieux : for ... in et readlines qui retourne une liste
Mais
Est-elle performante pour des fichiers importants puisqu'on charge tout en une fois ?
Le passage java --> python n'est pas toujours simple, surtout pour la syntaxe avec des ":" partout mais le pire c'est l'indentation !!! faut que je trouve un editeur mieux que idle

[mont29]

Eheh*! Collision*!

Mais oui, en cas de très gros fichier (plusieurs Mo et plus), la version avec while, qui ne charge pas tout d’un coup, sera très probablement plus performante (et moins consommatrice en mémoire).

Après, tout dépend de ce que tu veux faire exactement…

[wiztricks]

pour info:

Eheh*! Collision*!

Mais oui, en cas de très gros fichier (plusieurs Mo et plus), la version avec while, qui ne charge pas tout d’un coup, sera très probablement plus performante (et moins consommatrice en mémoire).

Après, tout dépend de ce que tu veux faire exactement…

readlines permet une lecture par "chunks" de sizehint:

f.readlines() returns a list containing all the lines of data in the file. If given an optional parameter sizehint, it reads that many bytes from the file and enough more to complete a line, and returns the lines from that. This is often used to allow efficient reading of a large file by lines, but without having to load the entire file in memory. Only complete lines will be returned.

- W

[aspire]

merci pour toutes ces infos
je ne connaissais pas ce parametre de readlines qui permet une lecture par morceau (moins d'espace mais peut etre plus de temps)
Bon toujours dans les fichiers je vais attaquer le décode utf-8...souhaitez moi bonne chance

@mont29: AÏe, en plein dans l'oeil ... la collision

[Sve@r]

surtout pour la syntaxe avec des ":" partout

Salut
Pas partout, uniquement
1) dans les définitions de fonctions et de classes
2) dans les structures de travail (if, for, while)

mais le pire c'est l'indentation !!! faut que je trouve un editeur mieux que idle

gvim sous Linux ou notepad++ sous Windows et Linux.
Tu as aussi eric mais j'ai eu qq soucis (il plante subitement). Ou alors eclipse...

Sinon concernant la lecture des fichiers textes, tu as aussi ceci

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
f=open("fichier", "r")
for ligne in f:
    print ligne
# for
f.close()

sinon ton premier code donné en début de ce post est le plus simple. Toutefois tu as un mot clef "True" plus parlant que "1"...

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
f=open("fichier", "r")
while True:
    ligne=f.readline()
    if ligne == "": break
    print ligne
# for
f.close()

[afranck64]

Si tu développes sous Win32, alors tu pourrais te servir de PyScripter que je trouve sympa et trés bien.

[aspire]

merci pour tous ces conseils ... et ces syntaxes
Je vais tester ces éditeurs...
avec une préférence pour Eclipse, venant du monde Java, mais j'ai peur d’être déçu étant habitué à un super confort d'utilisation (debug,complétion,test...)

[tyrtamos]

Bonjour,

Eclipse + pydev est très adapté à Python! Avec mise en couleur, contrôle de syntaxe en temps réel, complétion (y compris avec PyQt4), encodage, etc..., Avec l'avantage de pouvoir l'utiliser à l'identique sous Windows et sous Linux.

Je n'utilise plus que ça pour mes projets! Avec, en complément, pyScripter (Windows) ou idle pour tester quelques lignes de code quand c'est nécessaire.

[afranck64]

debug,complétion,test...

Ca ne change quasiment pas.

[fred1599]

Voilà j'ai trouvé le texte en ce qui concerne le choix entre readline ou readlines pour lire tout un fichier

" The difference between .readline() and .readlines() is that the latter, like .read(), reads in an entire file at once. .readlines() automatically parses the read contents into a list of lines, thereby enabling the for ... in ... construct common in Python. Using .readline() reads in just a single line from a file at a time, and is generally much slower than .readlines(). Really the only reason to use the .readline() version is if you expect to read very large files that might exceed available memory."

Juste pour la culture

Maintenant certains disent que cette méthode (ci-dessous) est plus efficace

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
with open('monfichier.txt', 'r') as f:
    for line in iter(f):
        print line

[PauseKawa]

Bonjour,

Avis perso:

L'iter explicite (for line in iter(f)) dois jouer au niveau rapidité, suivant la taille de l'objet. A voir en fait.
Par contre l'utilisation de with est une commodité (__enter__/__exit__ vs close()) (et while <ce qui est attendu> a une utilité tout autre que de remplacer for pour une itération).
Au niveau performance:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
import time
 
def foo1():
    with open('mots.txt', 'r') as f:
        for ligne in iter(f):
            l = ligne
 
def foo2():
    f=open("mots.txt", "r")
    while True:
        ligne=f.readline()
        if ligne == "":
            break
        l = ligne
    f.close()
 
def foo3():
    f = open("mots.txt", "r")
    for ligne in iter(f):
        l = ligne
    f.close()
 
def foo4():
    f=open("mots.txt", "r")
    for ligne in f.readlines():
        l = ligne
    f.close()
 
def foo5():
    f=open("mots.txt", "r")
    for ligne in f:
        l = ligne
    f.close()
 
def foo6():
    with open('mots.txt', 'r') as f:
        while True:
            ligne=f.readline()
            if ligne == "":
                break
            l = ligne
 
ts = time.time()
foo1()
print("foo1 : {} sec".format(time.time()-ts))
ts = time.time()
foo2()
print("foo2 : {} sec".format(time.time()-ts))
ts = time.time()
foo3()
print("foo3 : {} sec".format(time.time()-ts))
ts = time.time()
foo4()
print("foo4 : {} sec".format(time.time()-ts))
ts = time.time()
foo5()
print("foo5 : {} sec".format(time.time()-ts))
ts = time.time()
foo6()
print("foo6 : {} sec".format(time.time()-ts))

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
foo1 : 0.0450088977814 sec
foo2 : 0.0683059692383 sec
foo3 : 0.0332419872284 sec
foo4 : 0.0440897941589 sec
foo5 : 0.0392510890961 sec
foo6 : 0.0744779109955 sec

Au niveau tuyauterie interne for fait un GET_ITER alors qu'avec iter() nous avons un LOAD_GLOBAL du buil-in. Une paille.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
import dis
print('________foo1________')
dis.dis(foo1)
print('________foo3________')
dis.dis(foo3)
print('________foo5________')
dis.dis(foo5)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
________foo1________
  4           0 LOAD_GLOBAL              0 (open) 
              3 LOAD_CONST               1 ('mots.txt') 
              6 LOAD_CONST               2 ('r') 
              9 CALL_FUNCTION            2 
             12 DUP_TOP              
             13 LOAD_ATTR                1 (__exit__) 
             16 STORE_FAST               0 (_[2]) 
             19 LOAD_ATTR                2 (__enter__) 
             22 CALL_FUNCTION            0 
             25 STORE_FAST               1 (_[1]) 
             28 SETUP_FINALLY           42 (to 73) 
             31 LOAD_FAST                1 (_[1]) 
             34 DELETE_FAST              1 (_[1]) 
             37 STORE_FAST               2 (f) 

  5          40 SETUP_LOOP              26 (to 69) 
             43 LOAD_GLOBAL              3 (iter) 
             46 LOAD_FAST                2 (f) 
             49 CALL_FUNCTION            1 
             52 GET_ITER             
        >>   53 FOR_ITER                12 (to 68) 
             56 STORE_FAST               3 (ligne) 

  6          59 LOAD_FAST                3 (ligne) 
             62 STORE_FAST               4 (l) 
             65 JUMP_ABSOLUTE           53 
        >>   68 POP_BLOCK            
        >>   69 POP_BLOCK            
             70 LOAD_CONST               0 (None) 
        >>   73 LOAD_FAST                0 (_[2]) 
             76 DELETE_FAST              0 (_[2]) 
             79 WITH_CLEANUP         
             80 END_FINALLY          
             81 LOAD_CONST               0 (None) 
             84 RETURN_VALUE         
________foo3________
 18           0 LOAD_GLOBAL              0 (open) 
              3 LOAD_CONST               1 ('mots.txt') 
              6 LOAD_CONST               2 ('r') 
              9 CALL_FUNCTION            2 
             12 STORE_FAST               0 (f) 

 19          15 SETUP_LOOP              26 (to 44) 
             18 LOAD_GLOBAL              1 (iter) 
             21 LOAD_FAST                0 (f) 
             24 CALL_FUNCTION            1 
             27 GET_ITER             
        >>   28 FOR_ITER                12 (to 43) 
             31 STORE_FAST               1 (ligne) 

 20          34 LOAD_FAST                1 (ligne) 
             37 STORE_FAST               2 (l) 
             40 JUMP_ABSOLUTE           28 
        >>   43 POP_BLOCK            

 21     >>   44 LOAD_FAST                0 (f) 
             47 LOAD_ATTR                2 (close) 
             50 CALL_FUNCTION            0 
             53 POP_TOP              
             54 LOAD_CONST               0 (None) 
             57 RETURN_VALUE         
________foo5________
 30           0 LOAD_GLOBAL              0 (open) 
              3 LOAD_CONST               1 ('mots.txt') 
              6 LOAD_CONST               2 ('r') 
              9 CALL_FUNCTION            2 
             12 STORE_FAST               0 (f) 

 31          15 SETUP_LOOP              20 (to 38) 
             18 LOAD_FAST                0 (f) 
             21 GET_ITER             
        >>   22 FOR_ITER                12 (to 37) 
             25 STORE_FAST               1 (ligne) 

 32          28 LOAD_FAST                1 (ligne) 
             31 STORE_FAST               2 (l) 
             34 JUMP_ABSOLUTE           22 
        >>   37 POP_BLOCK            

 33     >>   38 LOAD_FAST                0 (f) 
             41 LOAD_ATTR                1 (close) 
             44 CALL_FUNCTION            0 
             47 POP_TOP              
             48 LOAD_CONST               0 (None) 
             51 RETURN_VALUE

Et pour foo6 c'est du breakdance

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 36           0 LOAD_GLOBAL              0 (open) 
              3 LOAD_CONST               1 ('mots.txt') 
              6 LOAD_CONST               2 ('r') 
              9 CALL_FUNCTION            2 
             12 DUP_TOP              
             13 LOAD_ATTR                1 (__exit__) 
             16 STORE_FAST               0 (_[2]) 
             19 LOAD_ATTR                2 (__enter__) 
             22 CALL_FUNCTION            0 
             25 STORE_FAST               1 (_[1]) 
             28 SETUP_FINALLY           53 (to 84) 
             31 LOAD_FAST                1 (_[1]) 
             34 DELETE_FAST              1 (_[1]) 
             37 STORE_FAST               2 (f) 
 
 37          40 SETUP_LOOP              37 (to 80) 
 
 38     >>   43 LOAD_FAST                2 (f) 
             46 LOAD_ATTR                3 (readline) 
             49 CALL_FUNCTION            0 
             52 STORE_FAST               3 (ligne) 
 
 39          55 LOAD_FAST                3 (ligne) 
             58 LOAD_CONST               3 ('') 
             61 COMPARE_OP               2 (==) 
             64 POP_JUMP_IF_FALSE       71 
 
 40          67 BREAK_LOOP           
             68 JUMP_FORWARD             0 (to 71) 
 
 41     >>   71 LOAD_FAST                3 (ligne) 
             74 STORE_FAST               4 (l) 
             77 JUMP_ABSOLUTE           43 
        >>   80 POP_BLOCK            
             81 LOAD_CONST               0 (None) 
        >>   84 LOAD_FAST                0 (_[2]) 
             87 DELETE_FAST              0 (_[2]) 
             90 WITH_CLEANUP         
             91 END_FINALLY          
             92 LOAD_CONST               0 (None) 
             95 RETURN_VALUE

Donc 'efficace' peut être pas mais lisible/élégante sans doute.

@+

[fred1599]

Salut PauseKawa,

Je suis content que tu es fais ces tests car j'avais un peu la flemme

Je suis surpris par ce iter(f), c'est tout de même le plus efficace.

Il faudrait voir sur un/de très gros fichier(s) afin de voir si l'ordre est toujours respecté.

En tout cas ce post devrait être mis en post-it car j'ai l'impression d'avoir vu cette question plus d'une centaine de fois.

Par contre on va parler technique un peu

Au niveau tuyauterie interne for fait un GET_ITER alors qu'avec iter() nous avons un LOAD_GLOBAL du buil-in. Une paille.

J'ai pas compris, une paille? Un problème?

En quoi LOAD_GLOBAL est plus efficace que GET_ITER, ou j'ai pas compris le sens de ta phrase?

Et pour foo6 c'est du breakdance

breakdance? Je ne vois pas où tu veux en venir.

Si tu peux m'expliquer, merci par avance,

Fred

[PauseKawa]

J'ai pas compris, une paille? Un problème?

Qu'importe ici le LOAD_GLOBAL: L'appel est unique et iter semble plus performant.

breakdance? Je ne vois pas où tu veux en venir.

Je parle de while et de son loop: Sans doute moins efficace que for dans le cas présent et pas vraiment à sa place ici.
Comme dit plus haut c'est un avis perso mais while a un intérêt tout autre que le simple

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
while True:
    break

(Et remplacer for.)
Oui, while est utilisable pour remplacer for. Lorsque l’étirable est modifié par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
>>> liste = [1, 2, 3, 4]
>>> for elem in liste:
...     liste.remove(elem)
... 
>>> liste
[2, 4]
>>> liste = [1, 2, 3, 4]
>>> while liste:
...     liste.pop()
... 
4
3
2
1
>>> liste
[]

[aspire]

Pour les tests de Kawa, j'ai qq questions et remarques:
1-le while semble tres long, mais quel type de fichier est utilisé en entrée (taille,type:texte,binaire...??) et peut-on trouver des indicateurs de perf (FLOPS,...) plus parlant que la sec.
2-le with ... as est juste un alias, une commodité qui n'apporte rien de plus
3- passer par un itérateur semble plus performant : la construction de l'objet optimise-t-il quelque chose ?
4-Ne serait-il pas plus significatif de faire le test sur une centaine d’occurrence, les temps de tests etant très proches ?

[PauseKawa]

Bonjour,

1-le while semble tres long, mais quel type de fichier est utilisé en entrée (taille,type:texte,binaire...??) et peut-on trouver des indicateurs de perf (FLOPS,...) plus parlant que la sec.

3 Questions en une.
while est plus long que for car il y a une condition. for tourne jusqu'au StopIteration sans se poser de question.
Le fichier est lu en mode texte ('r'). Pour du binaire vous avez 'rb'.
Une indication plus pointue (pas trop utile ici) ? Sans doute possible: j’attends vos propositions.

2-le with ... as est juste un alias, une commodité qui n'apporte rien de plus

La vous allez fâcher les adeptes des context manager (A voir sur le web)
C'est une commodité dans le cadre ou c'est lui qui gère l'__exit__() de l'objet: Dans le cadre d'open/close si un __exit__() non prévu survient le close() n'est pas fait.
Cela implique un 'contrôle' de l'objet, donc, sans doute, plus lent que l'explicite open/close.

4-Ne serait-il pas plus significatif de faire le test sur une centaine d’occurrence, les temps de tests etant très proches ?

Sans aucun doute. Sur la taille de l'objet traité aussi.

@+