comment ces deux variables sont-elles déballées?

Question

Grâce à des tutoriels que j'avais appris que vous pouvez définir deux variables dans la même déclaration, .: par exemple

In [15]: a, b = 'hello', 'hi!' 

In [16]: a 
Out[16]: 'hello' 

In [17]: b 
Out[17]: 'hi!' 

bien

comment cela s'applique ici?

fh, opened = cbook.to_filehandle(fname, 'w', return_opened = True) 

Je poussé plus loin:

In [18]: fh 
Out[18]: <open file 'attempt.csv', mode 'w' at 0xaac89d0> 

In [19]: opened 
Out[19]: True 

mon problème vient vraiment avec 'ouvert'. Normalement, si deux variables sont en train d'être définies, il y aurait une virgule et tout ce qui est défini ici sera défini comme «ouvert». Ce n'est pas le cas. Même avec ce problème imminent, 'ouvert' est égal à Vrai ce que je suppose est parce que 'return_opened = True'. Eh bien c'est bizarre parce que je ne me souviens pas dans un tutoriel que vous pourriez simplement ajouter un «retour» avant qu'une variable affecte cette variable.

Je joue avec elle un peu plus et je change le vrai False et j'obtiens ceci:

In [10]: fh, opened = cbook.to_filehandle(fname, 'w', return_opened = False) 
--------------------------------------------------------------------------- 
IOError         Traceback (most recent call last) 

/home/blahblahblah/Documents/Programming/EXERCISES/piece.py in <module>() 
----> 1 
     2 
     3 
     4 
     5 

IOError: [Errno 9] Bad file descriptor 

donc je suppose qu'il accepte seulement Faux.

Je suppose que je voudrais que quelqu'un puisse expliquer ce qui se passe ici.

Gracias amigos!

est ici le code entier:

if missingd is None: 
    missingd = dict() 

def with_mask(func): 
    def newfunc(val, mask, mval): 
     if mask: 
      return mval 
     else: 
      return func(val) 
    return newfunc 

formatd = get_formatd(r, formatd) 
funcs = [] 
for i, name in enumerate(r.dtype.names): 
    funcs.append(with_mask(csvformat_factory(formatd[name]).tostr)) 

fh, opened = cbook.to_filehandle(fname, 'w', return_opened=True) 
writer = csv.writer(fh, delimiter=delimiter) 
header = r.dtype.names 
writer.writerow(header) 

# Our list of specials for missing values 
mvals = [] 
for name in header: 
    mvals.append(missingd.get(name, missing)) 

ismasked = False 
if len(r): 
    row = r[0] 
    ismasked = hasattr(row, '_fieldmask') 

for row in r: 
    if ismasked: 
     row, rowmask = row.item(), row._fieldmask.item() 
    else: 
     rowmask = [False] * len(row) 
    writer.writerow([func(val, mask, mval) for func, val, mask, mval 
        in zip(funcs, row, rowmask, mvals)]) 
if opened: 
    fh.close() 

Answer 1

Comme dit @dcrosta, il n'y a rien de magique les noms de variables. Pour mieux voir ce qui se passe, essayez:

result = cbook.to_filehandle(fname, 'w', return_opened=True) 

et examiner result, type(result), etc: vous verrez que c'est un tuple (pourrait théoriquement être une liste ou une autre séquence, mais qui est peu probable) avec exactement deux éléments . result[0] sera un fichier ouvert, result[1] sera un bool. Très probablement, c'est parce que la fonction to_filehandle est codé avec une instruction return thefile, thebool -comme, comme dcrosta aussi émet l'hypothèse.

Ainsi, cette partie est « d'emballage » - deux choses sont emballés dans une valeur de retour, ce qui rend ce dernier un tuple avec deux articles. La partie "déballage" est la suivante:

fh, opened = result 

et la séquence de deux éléments est décompressée en deux variables. En faisant le déballage directement, vous êtes juste « découper l'intermédiaire », la variable I nommée ici result (pour le rendre plus facile pour vous d'examiner exactement ce résultat provient de cet appel de fonction, avant qu'il ne soit décompressé). Si vous savez à l'avance que vous obtiendrez toujours une séquence de deux éléments, et que vous n'avez pas besoin de la séquence en tant que telle, mais plutôt d'un nom séparé, vous pouvez aussi déballer immédiatement et enregistrer une "étape intermédiaire" - - c'est tout ce qu'on peut en dire!

Answer 2

Je pense que la fonction interne ressemble quelque chose comme ceci:

def to_filehandle(filename, mode, return_opened=False): 
    # do something to open the file and set opened 
    # to True if it worked, False otherwise 
    if return_opened: 
     return the_filehandle, opened 
    else: 
     return the_filehandle 

Il n'y a rien de spécial ou magique à propos de l'argument de mot-clé return_opened; c'est simplement changer le comportement de cette fonction particulière.

Answer 3

En Python, une fonction a plusieurs valeurs de retour. Dans ce cas, la fonction 'cbook.to_filehandle' renvoie les deux valeurs. A propos de l'erreur, je pense que nous ne pouvons pas en dire beaucoup à ce sujet jusqu'à ce que nous sachions ce que 'cbook.to_filehandle' suppose de faire ou de voir le code.

Answer 4

Avec l'affectation de tuple, le côté droit n'a pas besoin d'être un tuple explicite:

x = 1, 0 
a, b = x 

fait la même chose que:

a, b = 1, 0 

Si une fonction retourne un tuple, vous pouvez déballer avec affectation tuple:

def my_fn(): 
    return 1, 0 

a, b = my_fn() 

Answer 5

est déballer pas un processus magique: chaque tuple (par exemple, (1, 2, 3) est un tuple avec trois valeurs) peut être décompressé en trois valeurs. Mais le tuple lui-même est aussi une valeur, vous pouvez l'assigner à une variable ou le retourner d'une fonction:

x = (1, 2, 3) 
a, b, c = x 

# Or, for example : 
def function_returning_a_tuple(): 
    return (True, False) 

a, b = function_returning_a_tuple() 

Comme vous pouvez le comprendre maintenant, cbook.to_filehandle est seulement une fonction renvoyant un tuple de deux valeurs (file, opened).Il n'y a pas de magie derrière cela, rien sur return_something paramètres gérés différemment.