Conseils pour créer de petits outils avec python

Voici quelques conseils à garder à l'esprit lorsque vous créez vos propres petits outils.

Quand vous commencez à écrire, si vous pensez "je le jette quand même" et que vous commencez à écrire, il sera utilisé pendant longtemps ou à divers endroits, donc si vous faites attention, ce sera plus facile plus tard. Je pense qu'il existe une autre façon de développer des logiciels à grande échelle.

Faire de la routine principale une fonction

Le nom de la fonction peut être n'importe quoi, mais comme passe-temps, je prépare une fonction nommée main () et j'y écris toutes les routines principales.

#!/usr/bin/env python

def main():
    print('hello, hello, hello!')

if __name__ == '__main__': main()

Si vous regardez le petit exemple de code de python, le code d'exécution est écrit en solide à l'extérieur de la fonction. Bien sûr, cela fonctionne toujours, mais les deux points suivants peuvent être gênants plus tard.

1. Il est plein de variables globales et la gestion ne peut pas suivre: Si vous commencez par "C'est un petit script de toute façon", même si vous avez une bonne vue au début, vous perdrez progressivement la trace de l'endroit et du nom de variable que vous utilisez. Si vous pensez qu'il s'agit d'un script particulièrement petit et que vous donnez des noms de variables de manière lâche, vous pouvez accidentellement utiliser le même nom de variable dans un autre but.
2. Il est exécuté lors de la lecture de l'extérieur: Lorsque vous voulez utiliser la classe définie dans ce code à l'extérieur, si vous lisez de l'extérieur avec l'instruction ʻimport` etc., la partie en dehors de la fonction est exécutée Cela finira. Vous pouvez encapsuler une telle partie dans une fonction plus tard, mais vous pouvez également envelopper une partie qui doit être exécutée globalement (par exemple, la définition d'une variable globale utilisée comme constante) pour le débogage. Cela a tendance à prendre beaucoup de temps perdu

Pour éviter cela, poussez tous les traitements, y compris les variables, dans main () et mettez une instruction conditionnelle de `name == '__ main __' 'afin que la routine principale ne soit pas exécutée lorsqu'elle est lue de l'extérieur. Il est.

Gérez l'environnement d'exécution à l'aide de virtualenv

$ pip install virtualenv
$ virtualenv venv
$ source venv/bin/activate

virtualenv est un outil de séparation d'environnement d'exécution bien connu en python. Il existe divers articles d'explication sur la façon d'utiliser virtualenv, veuillez donc vous y référer, mais j'essaie d'utiliser virtualenv autant que possible, même lorsque vous créez de petits outils. Les raisons sont les suivantes.

1. (Dans de rares cas) Je fais parfois des allers-retours entre python2 et python3, donc je veux m'assurer que cela fonctionne avec une version fixe pour chaque projet.
2. Assurez-vous de connaître le package utilisé dans le projet. Si vous pouvez enregistrer la liste des packages de spécifications sous le nom pip freeze> requirements.txt en ne la mélangeant pas avec l'ensemble de l'environnement, vous pouvez passer à un autre environnement (par exemple, un serveur qui envoie des analyses depuis votre PC toute la nuit). Pour être fluide lors du déplacement

Gérer les paramètres avec argparse

Lors de l'écriture d'un outil ou d'un script d'écriture, vous pouvez avoir une variable fixe pour transmettre une valeur fixe, mais si possible, utilisez ʻargparse` pour l'obtenir à partir de la ligne de commande.

#!/usr/bin/env python

import argparse

def main():
    #Créer un analyseur
    psr = argparse.ArgumentParser()
    # -w / --Ajout d'une option appelée mot. La valeur par défaut est'hello! '
    psr.add_argument('-w', '--word', default='hello! ')
    # -s / --Ajout d'une option appelée size, la valeur par défaut est 5 et le type est int
    psr.add_argument('-s', '--size', default=5, type=int)
    #Analysez les arguments de la ligne de commande et placez-les dans args. Quitter s'il y a une erreur
    args = psr.parse_args()
    print(args.word * args.size)

if __name__ == '__main__': main()

C'est certes un peu fastidieux par rapport à l'écriture de variables, mais d'un autre côté, lorsque vous devez jouer avec des paramètres ou changer le fichier pour lire des données, vous pouvez spécifier avec des arguments de ligne de commande = code lui-même Vous n'avez pas à vous en soucier, c'est donc très pratique pour les essais et les erreurs. Si vous spécifiez une valeur pour default, vous n'avez pas à la spécifier une par une.

> python t3.py -s 6
hello! hello! hello! hello! hello! hello!
> python t3.py -s 2
hello! hello!
> python t3.py -w 'hoge '
hoge hoge hoge hoge hoge

Afficher la progression avec tqdm

En attendant le traitement en boucle des dizaines de milliers de fois avec l'instruction for, jusqu'où a-t-il progressé maintenant? J'écris parfois du code comme ʻif i% 1000 == 0: print ('now =', i) parce que je veux le confirmer, mais utiliser la bibliothèque pour cela est plus facile et plus riche. Vous pouvez obtenir des informations. Personnellement, j'utilise une bibliothèque appelée tqdm`.

#!/usr/bin/env python

from tqdm import tqdm
import time

def main():
    for i in tqdm(range(100)):
        time.sleep(0.02)

if __name__ == '__main__': main()

En utilisant cela, vous pouvez voir combien de cas ont été traités maintenant, combien de cas ont été traités par seconde et si la fin est connue, quel pourcentage a été traité. Il est facile à utiliser car il entoure simplement l'itérateur comme tqdm (iter (...)).

Préparer une fonction à enregistrer

Lors de l'écriture d'un petit script, la progression du traitement et le résultat sont imprimés par impression, mais je voulais l'écrire dans un fichier au cas où je voudrais entrer l'heure au milieu ou le résultat à la sortie standard coulé. Je viendrai. À l'origine, cela peut être une bonne idée d'utiliser le module logging, mais dans le cas d'un script que vous écrivez vous-même, c'est plus rapide et il peut être efficace de l'écrire vous-même, donc le suivant` log () Dans de nombreux cas, une fonction comme ʻest préparée.

t5.py

#!/usr/bin/env python

import datetime

def log(*args):
    msg = ' '.join(map(str, [datetime.datetime.now(), '>'] + list(args)))
    print(msg)
    with open('log.txt', 'at') as fd: fd.write(msg + '\n')

def main():
    log('generated', 5, 'items')

if __name__ == '__main__': main()

$ python t5.py
2017-09-04 12:39:38.894456 > generated 5 items
$ cat log.txt
2017-09-04 12:39:38.894456 > generated 5 items

en conclusion

Les astuces du type à écrire dans le code sont rassemblées dans gist.

Si vous avez d'autres trucs comme "Il y a des trucs comme ça!", Faites-le moi savoir.