Dovrei evitare di usare lo stile come 'per k, v in dict_sample.items ()'?

4

Oggi stavo visualizzando il codice del mio collega e ho visto una funzione come questa:

def manager_skill_tree_func(*args, **kwargs):
    """# manage_skill_tree: Initialize the manage skill tree
    """
    skill_tree0 = {}
    head = []
    tree_skill_list = {}
    manage_skill = globals()['manage_skill']

    for k, v in manage_skill.iteritems():
        if not k in skill_tree0:
            skill_tree0[k] = {}
        if v['tree'] not in tree_skill_list:
            tree_skill_list[v['tree']] = set([k])
        else:
            tree_skill_list[v['tree']].add(k)
        pre_k_list = v['pre_skill']
        if not pre_k_list:
            head.append(k)
        for pre_k in pre_k_list:
            pre_k = int(pre_k)
            if not pre_k in skill_tree0:
                skill_tree0[pre_k] = {}
            skill_tree0[pre_k][k] = skill_tree0[k]

    # Rest of the function is omitted here

Ci sono molti problemi di leggibilità in questo pezzo di codice, ma le mie attenzioni sono state per lo più tratte dall'istruzione for k, v in manage_skill.itermitems() . Questo tipo di affermazione è stata strongmente utilizzata nel progetto, sembra che al mio collega non piaccia specificare quale tipo di chiavi e valori stanno ottenendo da dict .

Per me, userò qualcosa come for index, arg_dict in dict_sample.iteritems() se la chiave è un numero e il valore è un altro dict e for employee_tuple in employee_info per specificare il tipo di elemento che otterrò tupla dall'elenco.

Penso che i nomi dovrebbero offrire un significato, nell'istruzione for pre_k in pre_k_list: del codice precedente, non ho informazioni su quale tipo di dati questo pre_k sia, eccetto che non si chiama ancora k .

Vorrei usare for k, v in sample_dict.items() o for i in sample_list solo quando la struttura era già menzionata ed è davvero ovvia, come:

import random
sample_dict = {}
for i in xrange(10):
    sample_dict[i] = random.choice([1,2,3])

for k,v in sample_dict.items():
    sample_dict[k] = k/v

Qual è la tua opinione su for k,v in unknown_structure_dict.iteritems() ?

PS: come regalo in più, ecco una valutazione di pylint di un file di grandi dimensioni per @jonrsharpe.

Una debole difesa per questo disastro:

  1. Il progetto dura per anni
  2. Scritto da molti programmatori (dai principianti ai veterani)
  3. Un sacco di modifiche ai requisiti, un sacco di hot-fix.
  4. Alcuni moduli o classi vengono caricati in fase di esecuzione.

Ad ogni modo, goditi questo:

+-----------------------------+------------+
|message id                   |occurrences |
+=============================+============+
|bad-whitespace               |1572        |
+-----------------------------+------------+
|bad-continuation             |479         |
+-----------------------------+------------+
|line-too-long                |303         |
+-----------------------------+------------+
|unused-argument              |99          |
+-----------------------------+------------+
|invalid-name                 |95          |
+-----------------------------+------------+
|no-member                    |65          |
+-----------------------------+------------+
|missing-docstring            |32          |
+-----------------------------+------------+
|redefined-outer-name         |31          |
+-----------------------------+------------+
|trailing-whitespace          |14          |
+-----------------------------+------------+
|unused-variable              |8           |
+-----------------------------+------------+
|global-variable-not-assigned |6           |
+-----------------------------+------------+
|fixme                        |6           |
+-----------------------------+------------+
|unnecessary-semicolon        |5           |
+-----------------------------+------------+
|bare-except                  |3           |
+-----------------------------+------------+
|eval-used                    |2           |
+-----------------------------+------------+
|too-many-locals              |1           |
+-----------------------------+------------+
|too-many-lines               |1           |
+-----------------------------+------------+
|superfluous-parens           |1           |
+-----------------------------+------------+
|multiple-statements          |1           |
+-----------------------------+------------+
|empty-docstring              |1           |
+-----------------------------+------------+



Global evaluation
-----------------
Your code has been rated at -47.74/10
    
posta Zen 16.03.2015 - 11:09
fonte

1 risposta

13

Sono d'accordo con te, e ad es. pylint lamenterebbe anche quei nomi (anche se puramente su una base di lunghezza).

for k, v in ... non fornisce al lettore alcuna informazione utile su ciò che dovrebbero aspettarsi di ottenere dal dizionario, il che rende il successivo codice più difficile da seguire. Ad esempio, è solo a if v['tree']... che si scopre che il valore è (presumibilmente!) Un dizionario. Questo richiede di guardare il codice in cui è costruito il dizionario per capire cosa dovrebbe esserci e significa che non puoi solo leggere e capire la funzione da sola (specialmente se la docstring è inutile).

Anche qualcosa di semplice:

for skill_name, skill_dict in manage_skill.iteritems():

renderebbe il codice più chiaro.

    
risposta data 16.03.2015 - 11:36
fonte

Leggi altre domande sui tag