Suite

Utiliser Python pour compter les enregistrements et afficher la différence dans ArcGIS Desktop ?

Utiliser Python pour compter les enregistrements et afficher la différence dans ArcGIS Desktop ?


J'essaie de trouver un exemple de script python pour ArcGIS 10.1 qui obtiendra le décompte d'une classe d'entités (FC) dans mon ArcSDE et obtiendra le décompte d'un FC dans une mise à jour de géodatabase de fichier entrant, puis écrira la différence dans un fichier journal . Nous recevons des mises à jour mensuelles d'un fournisseur. Par exemple, les puits FC et veulent pouvoir comparer les comptes d'enregistrements et les différences de log (a-b=C). En ce moment, j'ai un script qui enregistrera l'heure de début, obtiendra le nombre, tronquera, ajoutera, reconstruira l'index.


Voici une ligne pour obtenir le nombre d'enregistrements dans un FC ou une table spécifique :

count = sum(1 pour la ligne dans arcpy.da.SearchCursor(r'C:PATHTOFC', ['[email protected]']))

Vous pouvez essayer GetCount_management.

importer arcpy depuis arcpy importer env env.workspace = "C:/Path/to.gdb" count = int(arcpy.GetCount_management("FC").getOutput(0))

J'ai écrit un script qui utilise l'outil de comparaison de fonctionnalités entre deux bases de données comme moyen de les comparer. Il affichera non seulement le nombre de classes d'entités si elles ont changé, mais il renverra également tout changement d'attribution, de géométrie, de référence spatiale ou de schéma. Je suis nouveau dans ce domaine aussi, donc si quelqu'un a des améliorations, faites-le moi savoir s'il vous plaît.

importer arcpy depuis os importer mkdir depuis Shutil importer rmtree def compare(): old = arcpy.GetParameterAsText(0) old_path = old + '' arcpy.env.workspace = old old_fds = arcpy.ListDatasets() new = arcpy.GetParameterAsText (1) arcpy.env.workspace = new new_path = new + '' new_fds = arcpy.ListDatasets() pour old_fd, new_fd dans zip(old_fds, new_fds): old_fcs = arcpy.ListFeatureClasses(feature_dataset = old_fd) new_fcs = arcpy .ListFeatureClasses(feature_dataset = new_fd) base = old_path + old_fd + '' test = new_path + new_fd + '' pour old_fc, new_fc dans zip(old_fcs, new_fcs): base_features = base + old_fc test_features = test_field + new_fc = 'OBJECTID' compare_type = 'ALL' xy_tolerance = '0.001 PIED' m_tolerance = 0 z_tolerance = 0 attribute_tolerance ="omit_field ="continue_compare = 'CONTINUE_COMPARE' compare_file = scratch_dir + '\_' + new_fc + 'res .FeatureCompare_management(base_features, test_features, sort_field, compare_type,", xy_tolerance, m_tolerance, z_tolerance, attribute_tolerance, omit_field, continue_compare, compare_file) in_rows = scratch_dir + '' + new_fc + '.txt' out_path = scratch_dir out_name = new_fc + '.dbf' dbfs = arcpy.TableToTable_conversion, out_path (in_rows) dans dbfs : field = 'FEATURECL' newfield = arcpy.AddField_management(dbf, field, 'TEXT',",", 100) cursor = arcpy.UpdateCursor(newfield) pour la ligne dans le curseur : row.setValue(field, new_fc) curseur .updateRow(row) def listmerge(): arcpy.env.workspace = scratch_dir listTable = arcpy.ListTables('*.dbf', 'dBASE') arcpy.Merge_management(listTable, final_dir + '' + "output.dbf ") rmtree(scratch_dir) output_dir = arcpy.GetParameterAsText(2) scratch_dir = output_dir + '' + "scratch" final_dir = output_dir + '' + "output" mkdir(scratch_dir) mkdir(final_dir) compare() ()

Transformation géographique : WGS_1984_(ITRF00)_To_NAD_1983 vs NAD_1983_To_WGS_1984_1 (et autres)

Je travaille récemment sur des ensembles de données liés aux stations de comptage de trafic. Il y avait deux fichiers de formes, l'un correspond aux emplacements sur lesquels nous travaillerons à l'automne et l'autre à tous les enregistrements de stations dans la base de données. Les deux étaient dans le GCS WGS_1984 mais n'étaient pas projetés dans un système de coordonnées projetées (PCS). Je les ai donc projetés dans NAD_1983_StatePlane_OHIO_South. Cependant, après projection, les points des deux couches n'étaient pas au même endroit (seulement une légère différence, mais comme ils ont la même latitude et longitude, cela ne devrait pas arriver). J'ai donc réexécuté les outils du projet et constaté que l'un d'eux utilisait la transformation WGS_1984_(ITRF00)_To_NAD_1983 et l'autre utilisait la transformation NAD_1983_To_WGS_1984_1, par défaut. Celui avec la transformation WGS_1984_(ITRF00)_To_NAD_1983 n'a pas changé les emplacements des points. Mais l'autre transformation, NAD_1983_To_WGS_1984_1, déplacerait légèrement les points. Et j'ai aussi trouvé qu'il y avait aussi d'autres transformations, comme NAD_1983_To_WGS_1984_5, NAD_1983_To_WGS_1984_4. Je suis juste curieux de savoir quelles sont les différences entre ces transformations ? Et pourquoi l'outil de projet a sélectionné WGS_1984_(ITRF00)_To_NAD_1983 pour l'un mais en a utilisé un autre pour l'autre shapefile. J'ai vérifié les références spatiales des deux fichiers de formes et j'ai pensé qu'elles étaient identiques.


Ce diff vous donne le contexte - les lignes environnantes pour vous aider à comprendre en quoi le fichier est différent. Vous pouvez voir "chat" ici deux fois, car il a été supprimé sous "chien" et ajouté au-dessus.

Vous pouvez utiliser n=0 pour supprimer le contexte.

Mais maintenant, il est plein de lignes "@@" vous indiquant la position dans le fichier qui a changé. Supprimons les lignes supplémentaires pour le rendre plus lisible.

Maintenant, que voulez-vous qu'il fasse ? Si vous ignorez toutes les lignes supprimées, vous ne verrez pas que "chien" a été supprimé. Si vous êtes content de montrer les ajouts au fichier, alors vous pouvez faire ceci :

Vous pouvez probablement dire maintenant qu'il existe différentes manières d'"imprimer les différences" de deux fichiers, vous devrez donc être très précis si vous voulez plus d'aide.


Maintenir une image de fonctionnement commune

Découvrez comment la ville de Chapel Hill, en Caroline du Nord, a utilisé les tableaux de bord ArcGIS pour créer un ensemble de tableaux de bord informatifs qui rationalisent les opérations au centre des opérations d'urgence.

Maintenir une image de fonctionnement commune Réduire le risque de criminalité Améliorer la connaissance de la situation Améliorer la sécurité des chemins de fer croates Rationalisation des opérations gouvernementales Accélérer la reprise après sinistre


Calculs

Les statistiques récapitulatives sont calculées pour chaque champ de la couche en entrée. Les champs auront une sortie de statistiques différente selon le type de champ. L'exemple de profondeur de sol suivant décrit comment les statistiques sont calculées pour chaque type de champ :

Ces exemples d'entités en entrée seront résumés et générés sous forme de statistiques calculées ci-dessous.


Organisation de l'outil

Les outils de géotraitement sont organisés de deux manières différentes. Tous les outils sont disponibles sous forme de fonctions sur ArcPy mais sont également disponibles dans des modules correspondant au nom d'alias de la boîte à outils. Bien que la plupart des exemples de l'aide montrent des outils organisés sous forme de fonctions disponibles à partir d'ArcPy, les deux approches sont également valables. L'approche que vous utiliserez dépendra de vos préférences personnelles et de vos habitudes de codage. Dans l'exemple suivant, l'outil GetCount est illustré en utilisant les deux approches.

Lorsque vous utilisez des outils dans des modules, vous souhaiterez parfois attirer l'attention sur la façon dont un module est identifié pour rendre votre script plus lisible. Dans ce cas, vous pouvez utiliser le formulaire de - import - as .

Les outils Spatial Analyst sont gérés différemment pour s'adapter à l'algèbre cartographique et ne sont disponibles que dans le module arcpy.sa et non en tant que fonctions sur ArcPy.


Conclusion

Félicitations, vous êtes arrivé à la fin de ce tutoriel !

Dans ce didacticiel, vous avez couvert de nombreux détails sur la segmentation client. Vous avez appris ce qu'est la segmentation client, le besoin de segmentation client, les types de segmentation, l'analyse RFM, la mise en œuvre de RFM à partir de zéro en python. En outre, vous avez abordé certains concepts de base des pandas, tels que la gestion des doublons, groupby et qcut() pour les bacs basés sur des échantillons de quantiles.

Espérons que vous pouvez maintenant utiliser la modélisation de sujet pour analyser vos propres ensembles de données. Merci d'avoir lu ce tutoriel !

Si vous souhaitez en savoir plus sur Python, suivez le cours d'introduction gratuite à Python pour la science des données de DataCmp.


Discussion

Si vous avez un programme externe qui compte les lignes d'un fichier, tel que wc -l sur les plates-formes de type Unix, vous pouvez bien sûr choisir de l'utiliser (par exemple, via os.popen() ). Cependant, il est généralement plus simple, plus rapide et plus portable de compter les lignes dans votre programme. Vous pouvez compter sur presque tous les fichiers texte d'une taille raisonnable, de sorte qu'il est possible de lire tout le fichier en mémoire en une seule fois. Pour tous ces fichiers normaux, la longueur du résultat de readlines vous donne le nombre de lignes de la manière la plus simple.

Si le fichier est plus volumineux que la mémoire disponible (disons, quelques centaines de mégaoctets sur un PC typique aujourd'hui), la solution la plus simple peut devenir lente, car le système d'exploitation a du mal à intégrer le contenu du fichier dans la mémoire virtuelle. Il peut même échouer, lorsque l'espace d'échange est épuisé et que la mémoire virtuelle ne peut plus aider. Sur un PC typique, avec 256 Mo de RAM et un espace disque virtuellement illimité, vous devez toujours vous attendre à de sérieux problèmes lorsque vous essayez de lire dans la mémoire des fichiers de, disons, 1 ou 2 Go, selon votre système d'exploitation (certains systèmes d'exploitation sont beaucoup plus plus fragiles que d'autres pour gérer les problèmes de mémoire virtuelle dans de telles conditions de charge excessive). Dans ce cas, la méthode xreadlines des objets fichiers, introduite dans Python 2.1, est généralement un bon moyen de traiter les fichiers texte ligne par ligne. En Python 2.2, vous pouvez faire encore mieux, en termes de clarté et de vitesse, en bouclant directement sur l'objet fichier :

Cependant, xreadlines ne renvoie pas de séquence, ni une boucle directement sur l'objet fichier, vous ne pouvez donc pas simplement utiliser len dans ces cas pour obtenir le nombre de lignes. Au lieu de cela, vous devez boucler et compter ligne par ligne, comme indiqué dans la solution.

Compter les caractères de fin de ligne lors de la lecture du fichier par octets, en morceaux de taille raisonnable, est l'idée clé de la troisième approche. C'est probablement le moins immédiatement intuitif, et ce n'est pas parfaitement multiplateforme, mais vous pouvez espérer qu'il est le plus rapide (par exemple, par analogie avec la recette 8.2 dans le Livre de recettes Perl ).

Cependant, n'oubliez pas que, dans la plupart des cas, les performances n'ont pas vraiment d'importance. Lorsque cela compte, le temps écoulé peut ne pas être ce que votre intuition vous dit qu'il est, vous ne devriez donc jamais faire confiance à votre intuition à ce sujet, au lieu de cela, toujours comparer et mesurer. Par exemple, j'ai pris un fichier syslog Unix typique de taille moyenne, un peu plus de 18 Mo de texte en 230 000 lignes :

et j'ai mis en place le script framework de benchmark suivant, bench.py ​​:

Tout d'abord, j'imprime les décomptes de lignes obtenus par toutes les méthodes, garantissant ainsi qu'il n'y a pas d'anomalie ou d'erreur (les tâches de comptage sont notoirement sujettes aux erreurs une par une). Ensuite, j'exécute chaque alternative 10 fois, sous le contrôle de la fonction de chronométrage timeo , et je regarde les résultats. Les voici:

Comme vous pouvez le voir, les différences de performances importent peu : une différence d'environ 10 % dans une tâche auxiliaire est quelque chose que vos utilisateurs ne remarqueront même jamais. Cependant, l'approche la plus rapide (pour mes circonstances particulières, un PC bon marché mais très récent exécutant une distribution Linux populaire, ainsi que cette référence spécifique) est l'humble technique de boucle sur chaque ligne, tandis que la plus lente est la technique ambitieuse qui compte les terminaisons de ligne par morceaux. En pratique, à moins que j'aie à me soucier de fichiers de plusieurs centaines de mégaoctets, j'utiliserais toujours l'approche la plus simple (c'est-à-dire la première présentée dans cette recette).


Utiliser Python pour compter les enregistrements et afficher la différence dans ArcGIS Desktop ? - Systèmes d'information géographique

Il peut y avoir de nombreux cas où vous souhaitez rechercher un système. Supposons que, lors de l'écriture d'un lecteur mp3, vous souhaitiez avoir tous les fichiers ‘.mp3’. Eh bien, voici comment le faire de manière simple.
Ce code recherche tous les dossiers du fichier en cours d'exécution. Si vous voulez d'autres types de fichiers, changez simplement l'extension.

os n'est pas une bibliothèque externe en python. Je pense donc que c'est la façon la plus simple et la meilleure de le faire.

Cet article est contribué par soumith kumar. Si vous aimez GeeksforGeeks et que vous souhaitez contribuer, vous pouvez également écrire un article en utilisant contribute.geeksforgeeks.org ou envoyer votre article à [email protected] Consultez votre article apparaissant sur la page principale GeeksforGeeks et aidez les autres Geeks.

Veuillez écrire des commentaires si vous trouvez quelque chose d'incorrect ou si vous souhaitez partager plus d'informations sur le sujet abordé ci-dessus.

Attention geek ! Renforcez vos fondations avec le Fondation de programmation Python Cours et apprenez les bases.

Pour commencer, vos préparatifs d'entretien Améliorez vos concepts de Structures de Données avec les Python DS Cours. Et pour commencer votre parcours d'apprentissage machine, rejoignez le Apprentissage automatique – Cours de base


Utiliser Python pour compter les enregistrements et afficher la différence dans ArcGIS Desktop ? - Systèmes d'information géographique

line_profiler et kernprof

AVIS : Il s'agit du référentiel officiel line_profiler. La version la plus récente de line-profiler sur pypi pointe vers ce référentiel. Le package line_profiler d'origine de @rkern n'est actuellement pas maintenu. Ce fork cherche simplement à maintenir le code d'origine afin qu'il continue de fonctionner dans les nouvelles versions de Python.

line_profiler est un module pour faire le profilage ligne par ligne des fonctions. kernprof est un script pratique pour exécuter line_profiler ou les modules cProfile ou profile de la bibliothèque standard Python, selon ce qui est disponible.

Ils sont disponibles sous licence BSD.

Les versions de line_profiler peuvent être installées à l'aide de pip :

Les versions sources et tous les binaires peuvent être téléchargés à partir du lien PyPI.

Pour consulter les sources de développement, vous pouvez utiliser Git :

Vous pouvez également télécharger les archives tar sources de n'importe quel instantané à partir de cette URL.

Les versions sources nécessiteront un compilateur C pour construire line_profiler. De plus, les extractions git nécessiteront également Cython >= 0.10. Les versions sources sur PyPI doivent contenir les sources C prégénérées, donc Cython ne devrait pas être requis dans ce cas.

kernprof est un script Python pur à fichier unique et ne nécessite pas de compilateur. Si vous souhaitez l'utiliser pour exécuter cProfile et non un profilage ligne par ligne, vous pouvez le copier manuellement dans un répertoire de votre PATH et éviter d'essayer de créer des extensions C.

Depuis le 25/04/2020, seuls les binaires Linux sont disponibles sur pypi. Si vous utilisez Windows et que vous ne pouvez pas créer à partir des sources, envisagez d'utiliser les roues win32 précompilées non officielles du profileur de ligne de Christoph Gohlke.

Les outils de profilage actuels pris en charge dans Python 2.7 et versions ultérieures ne synchronisent que les appels de fonction. C'est une bonne première étape pour localiser les points chauds dans son programme et c'est souvent tout ce qu'il faut faire pour optimiser le programme. Cependant, parfois, la cause du hotspot est en fait une seule ligne dans la fonction, et cette ligne peut ne pas être évidente en lisant simplement le code source. Ces cas sont particulièrement fréquents en calcul scientifique. Les fonctions ont tendance à être plus volumineuses (parfois en raison d'une complexité algorithmique légitime, parfois parce que le programmeur essaie toujours d'écrire du code FORTRAN), et une seule instruction sans appels de fonction peut déclencher de nombreux calculs lors de l'utilisation de bibliothèques comme numpy. cProfile ne fait que des appels de fonction explicites, pas des méthodes spéciales appelées à cause de la syntaxe. Par conséquent, une opération numpy relativement lente sur de grandes baies comme celle-ci,

est un hotspot qui n'est jamais ventilé par cProfile car il n'y a pas d'appel de fonction explicite dans cette instruction.

LineProfiler peut recevoir des fonctions à profiler, et il chronométrera l'exécution de chaque ligne individuelle à l'intérieur de ces fonctions. Dans un flux de travail typique, on ne se soucie que du minutage des lignes de quelques fonctions, car parcourir les résultats du minutage de chaque ligne de code serait écrasant. Cependant, LineProfiler doit être explicitement informé des fonctions à profiler. Le moyen le plus simple de commencer est d'utiliser le script kernprof.

kernprof va créer une instance de LineProfiler et l'insérer dans l'espace de noms __builtins__ avec le nom profile. Il a été écrit pour être utilisé comme décorateur, donc dans votre script, vous décorez les fonctions que vous souhaitez profiler avec @profile.

Le comportement par défaut de kernprof est de mettre les résultats dans un fichier binaire script_to_profile.py.lprof . Vous pouvez dire à kernprof d'afficher immédiatement les résultats formatés sur le terminal avec l'option [-v/--view]. Sinon, vous pouvez voir les résultats plus tard comme ceci :

Par exemple, voici les résultats du profilage d'une seule fonction à partir d'une version décorée du benchmark pystone.py (les deux premières lignes sont sorties de pystone.py, pas de kernprof) :

Le code source de la fonction est imprimé avec les informations de synchronisation pour chaque ligne. Il y a six colonnes d'informations.

  • # de ligne : le numéro de ligne dans le fichier.
  • Hits : le nombre de fois que cette ligne a été exécutée.
  • Temps : Le temps total passé à exécuter la ligne dans les unités de la minuterie. Dans les informations d'en-tête avant les tableaux, vous verrez une ligne « Unité de minuterie : » donnant le facteur de conversion en secondes. Il peut être différent sur différents systèmes.
  • Par Hit : Le temps moyen passé à exécuter la ligne une fois dans les unités de la minuterie.
  • % Temps : Le pourcentage de temps passé sur cette ligne par rapport au temps total enregistré passé dans la fonction.
  • Contenu de la ligne : le code source réel. Notez que cela est toujours lu à partir du disque lorsque les résultats formatés sont affichés, ne pas quand le code a été exécuté. Si vous avez modifié le fichier entre-temps, les lignes ne correspondront pas et le formateur peut même ne pas être en mesure de localiser la fonction à afficher.

Si vous utilisez IPython, il existe une implémentation d'une commande magique %lprun qui vous permettra de spécifier des fonctions à profiler et une instruction à exécuter. Il ajoutera également son instance LineProfiler dans le __builtins__, mais généralement, vous ne l'utiliserez pas comme ça.

Pour IPython 0.11+, vous pouvez l'installer en modifiant le fichier de configuration IPython

/.ipython/profile_default/ipython_config.py pour ajouter l'élément 'line_profiler' à la liste des extensions :

Pour obtenir de l'aide sur l'utilisation de %lprun, utilisez le mécanisme d'aide IPython standard :

Ces deux méthodes devraient être les manières les plus fréquentes au niveau utilisateur d'utiliser LineProfiler et seront généralement les plus simples. Cependant, si vous créez d'autres outils avec LineProfiler, vous devrez utiliser l'API. Il existe deux manières d'informer LineProfiler des fonctions à profiler : vous pouvez les passer en tant qu'arguments au constructeur ou utiliser la méthode add_function(f) après l'instanciation.

LineProfiler a les mêmes méthodes run(), runctx() et runcall() que cProfile.Profile ainsi que enable() et disable(). Il convient de noter, cependant, que enable() et disable() ne sont pas entièrement sûrs lorsqu'ils sont imbriqués. L'imbrication est courante lors de l'utilisation de LineProfiler comme décorateur. Afin de prendre en charge l'imbrication, utilisez enable_by_count() et disable_by_count(). Ces fonctions incrémenteront et décrémenteront un compteur et n'activeront ou désactiveront réellement le profileur que lorsque le décompte passera de ou à 0.

Après le profilage, la méthode dump_stats(filename) extraira les résultats dans le fichier donné. print_stats([stream]) imprimera les résultats formatés dans sys.stdout ou dans le flux que vous spécifiez. get_stats() retournera l'objet LineStats, qui ne contient que deux attributs : un dictionnaire contenant les résultats et l'unité de minuterie.

kernprof fonctionne également avec cProfile, son incarnation tierce lsprof ou le module de profil pur-Python selon ce qui est disponible. Il a quelques caractéristiques principales :

  • Encapsulation des préoccupations de profilage. Vous n'avez pas besoin de modifier votre script pour lancer le profilage et enregistrer les résultats. Sauf si vous souhaitez utiliser les fonctionnalités avancées de __builtins__, bien sûr.
  • Exécution de script robuste. De nombreux scripts nécessitent que des éléments tels que __name__, __file__ et sys.path soient définis par rapport à celui-ci. Une approche naïve de l'encapsulation utiliserait simplement execfile(), mais de nombreux scripts qui reposent sur ces informations échoueront. kernprof définira ces variables correctement avant d'exécuter le script.
  • Emplacement facile de l'exécutable. Si vous profilez une application installée sur votre PATH, vous pouvez simplement donner le nom de l'exécutable. Si kernprof ne trouve pas le script donné dans le répertoire courant, il le recherchera dans votre PATH.
  • Insertion du profileur dans __builtins__. Parfois, vous voulez juste profiler une petite partie de votre code. Avec l'argument [-b/--builtin], le profileur sera instancié et inséré dans votre __builtins__ avec le nom "profile". Comme LineProfiler, il peut être utilisé comme décorateur, ou activé/désactivé avec enable_by_count() et disable_by_count(), ou même comme gestionnaire de contexte avec l'instruction "with profile:".
  • Configuration du pré-profilage. Avec l'option [-s/--setup], vous pouvez fournir un script qui sera exécuté sans profilage avant d'exécuter le script principal. Ceci est généralement utile pour les cas où les importations de grandes bibliothèques comme wxPython ou VTK interfèrent avec vos résultats. Si vous pouvez modifier votre code source, l'approche __builtins__ peut être plus simple.

Les résultats du profil script_to_profile.py seront écrits par défaut dans script_to_profile.py.prof. Ce sera un fichier marshallé typique qui peut être lu avec pstats.Stats(). Ils peuvent être visualisés de manière interactive avec la commande :

Ces fichiers peuvent également être visualisés avec des outils graphiques tels que SnakeViz et convertis via pyprof2calltree pour s'exécuter sur kcachegrind et des applications compatibles.

Je n'ai pas réussi à trouver un nom significatif, alors je l'ai nommé d'après moi-même.

Pourquoi ne pas utiliser hotshot au lieu de line_profile ?

hotshot peut aussi faire des minutages ligne par ligne. Cependant, il est obsolète et peut disparaître de la bibliothèque standard. En outre, le traitement des résultats peut prendre beaucoup de temps alors que je souhaite une exécution rapide de mes flux de travail. hotshot paie ce temps de traitement afin de se rendre le moins possible intrusif pour le code qu'il profile. Le code qui effectue des opérations réseau, par exemple, peut même emprunter des chemins de code différents si le profilage ralentit trop l'exécution. Pour mes cas d'utilisation, et je pense ceux de beaucoup d'autres personnes, leur profilage ligne par ligne n'est pas beaucoup affecté par cette préoccupation.

Pourquoi ne pas autoriser l'utilisation de hotshot depuis kernprof.py ?

Je n'utilise pas hotshot, moi-même. J'accepterai cependant des contributions dans ce sens.

Les minutages ligne par ligne ne s'additionnent pas lorsqu'une fonction profilée en appelle une autre. Qu'est-ce qui se passe avec ça?

Disons que vous avez la fonction F() appelant la fonction G() et que vous utilisez LineProfiler sur les deux. Le temps total signalé pour G() est inférieur au temps signalé sur la ligne dans F() qui appelle G(). La raison en est que je suis raisonnablement intelligent (et peut-être trop intelligent) dans l'enregistrement des temps. Fondamentalement, j'essaie d'empêcher d'enregistrer le temps passé dans LineProfiler à faire toute la comptabilité pour chaque ligne. Chaque fois que la fonction de traçage de Python émet un événement de ligne (ce qui se produit juste avant qu'une ligne ne soit réellement exécutée), LineProfiler trouvera deux horodatages, un au début avant de faire quoi que ce soit (t_begin) et un aussi près de la fin que possible (t_end) . Presque toute la surcharge des structures de données de LineProfiler se produit entre ces deux moments.

Lorsqu'un événement de ligne arrive, LineProfiler trouve la fonction à laquelle il appartient. S'il s'agit de la première ligne de la fonction, nous enregistrons le numéro de ligne et tendre associé à la fonction. La prochaine fois que nous voyons un événement de ligne appartenant à cette fonction, nous prenons t_begin du nouvel événement et soustrayons l'ancien t_end pour trouver le temps passé dans l'ancienne ligne. Ensuite, nous enregistrons le nouveau t_end comme ligne active pour cette fonction. De cette façon, nous supprimons la plupart des frais généraux de LineProfiler des résultats. Enfin presque. Lorsqu'une fonction profilée F appelle une autre fonction profilée G, la ligne de F qui appelle G enregistre essentiellement le temps total passé à exécuter la ligne, qui comprend le temps passé à l'intérieur du profileur à l'intérieur de G.

La première fois que cette question a été posée, le questionneur avait l'appel de fonction G() dans le cadre d'une expression plus large, et il voulait essayer d'estimer combien de temps était passé dans la fonction par rapport au reste de l'expression. Ma réponse était que, même si je pouvais supprimer l'effet, cela pourrait toujours être trompeur. G() peut être appelé ailleurs, pas seulement à partir de la ligne appropriée dans F(). La solution de contournement serait de modifier le code pour le diviser en deux lignes, l'une affectant simplement le résultat de G() à une variable temporaire et l'autre avec le reste de l'expression.

Je suis ouvert aux suggestions sur la façon de rendre cela plus robuste. Ou de simples avertissements contre le fait d'essayer d'être intelligent.

Pourquoi mes compréhensions de liste ont-elles autant de résultats lorsque j'utilise le LineProfiler ?

LineProfiler enregistre la ligne avec la compréhension de liste une fois pour chaque itération de la compréhension de liste.

Pourquoi kernprof est-il distribué avec line_profiler ? Cela fonctionne uniquement avec cProfile, n'est-ce pas ?

En partie parce que kernprof.py est essentiel pour utiliser efficacement line_profiler, mais surtout parce que je suis paresseux et que je ne veux pas maintenir la surcharge de deux projets pour des modules aussi petits. Cependant, kernprof.py est un script Python pur et autonome qui peut être utilisé pour effectuer un profilage de fonction avec uniquement la bibliothèque standard Python. Vous pouvez le récupérer et l'installer tout seul sans line_profiler.

Ai-je besoin d'un compilateur C pour construire line_profiler ? kernprof.py ?

Vous avez besoin d'un compilateur C pour line_profiler. kernprof.py est un script Python pur et peut cependant être installé séparément.

Ai-je besoin de Cython pour construire line_profiler ?

Vous ne devriez pas avoir à le faire si vous construisez à partir d'une archive source publiée. Il doit déjà contenir les sources C générées. Si vous rencontrez des problèmes, cela peut être un bug, faites le moi savoir. Si vous construisez à partir d'un git checkout ou d'un instantané, vous aurez besoin de Cython pour générer les sources C. Vous aurez probablement besoin de la version 0.10 ou supérieure. Il y a un bogue dans certaines versions antérieures dans la façon dont il gère les pointeurs NULL PyObject*.

Depuis la version 3.0.0, de nombreuses roues Linux contenant les binaires sont disponibles sur pypi. Des travaux sont encore nécessaires pour publier les roues osx et win32. (Des relations publiques pour cela seraient utiles !)

De quelle version de Python ai-je besoin ?

line_profiler et kernprof ont été testés avec Python 3.5-3.9. Les anciennes versions de line_profiler prennent en charge les anciennes versions de Python.

cProfile utilise une structure de données « arbres tournants » soignée pour minimiser la surcharge de recherche et d'enregistrement des entrées. LineProfiler utilise des dictionnaires Python et des objets d'extension grâce à Cython. Cela a principalement commencé comme un prototype avec lequel je voulais jouer le plus rapidement possible, alors j'ai abandonné le vol des arbres en rotation pour le moment. Comme d'habitude, je l'ai fait fonctionner et il semble avoir des performances acceptables, donc je suis beaucoup moins motivé pour utiliser une stratégie différente maintenant. Peut-être plus tard. Contributions acceptées !


Les références

Mann, K.H. & Lazier, J.R. Dynamique des écosystèmes marins : interactions bio-physiques dans les océans. (John Wiley & Sons, 2013).

Minns, C. K. & Wichert, G. A. Un cadre pour définir les domaines de l'habitat du poisson dans le lac Ontario et son drainage. J. Grands Lacs Rés. 31, 6–27 (2005).

Håkanson, L. L'influence du vent, du fetch et de la profondeur de l'eau sur la distribution des sédiments dans le lac Vänern, en Suède. Pouvez. J. Terre Sci. 14, 397–412 (1977).

Burton, T. M., Uzarski, D. G. & Genet, J. A. Utilisation de l'habitat des invertébrés en relation avec le fetch et la zonation des plantes dans les terres humides côtières du nord du lac Huron. Santé et gestion des écosystèmes aquatiques 7 (2), 249-267, https://doi.org/10.1080/14634980490461614 (2004).

Marsh, W. M. & Marsh, B. D. Érosion éolienne et formation de dunes de sable sur les hautes falaises du lac Supérieur. Géogr. Anne 69A, 379–391 (1987).

Schwab, D. J., Beletsky, D. & Lou, J. Le panache de turbidité côtière de 1998 dans le lac Michigan. Sciences des estuaires, des côtes et des plateaux 50, 49–58 (2000).

Randall, R. G., Minns, C. K., Cairns, V. W. & Moore, J. E. La relation entre un indice de production de poisson et les macrophytes submergés et d'autres caractéristiques de l'habitat dans trois zones littorales des Grands Lacs. Pouvez. J.Aquat. Sci. 53, 35–44 (1996).

Cooper, M. J., Lamberti, G. A. & Uzarski, D. G. Tendances spatiales et temporelles des communautés d'invertébrés des terres humides côtières des Grands Lacs, en mettant l'accent sur la baie Saginaw du lac Huron. J. Grands Lacs Rés. 40, 168–182 (2014).

Keddy, P. A. Shoreline Vegetation in Ax Lake, Ontario : effets de l'exposition sur les schémas de zonage. Écologie 64, 331–344 (1983).

Yurista, P. M., Kelly, J. R. & Scharold, J.V. Grands Lacs nearshore-offshore : régions de qualité de l'eau distinctes. J. Grands Lacs Rés. 42, 375–385 (2016).

Beletsky, D., Hawley, N. & Rao, Y. R. Modélisation de la circulation estivale et de la structure thermique du lac Érié. J. de Géophys. Rés. Océans 118, 6238–6252, https://doi.org/10.1002/2013JC008854 (2013).

Shuter, B. J., Schlesinger, D. A. & Zimmerman, A. P. Prédicteurs empiriques des cycles annuels de température de l'eau de surface dans les lacs nord-américains. Pouvez. J. Poisson. Aquat. Sci. 40, 1838–1845 (1983).

Plattner, S., Mason, D. M., Leshkevich, G. A., Schwab, D. J. & Rutherford, E. S. Classification et prévision des upwellings côtiers dans le lac Michigan à l'aide d'images de température dérivées par satellite et de données de bouées. J. Grands Lacs Rés. 32, 63–76 (2006).

Vanderploeg, H. A., Liebig, J. R., Nalepa, T. F., Fahnenstiel, G. L. & Pothoven, S. A. Dreissena et la disparition de la prolifération printanière de phytoplancton dans le lac Michigan. J. Grands Lacs Rés. 36, 50-59, https://doi.org/10.1016/j.jglr.2010.04.005 (2010).

Uzarski, D.G., Burton, T.M. & Genet, J.A. Validation et performance d'un indice d'intégrité biotique des invertébrés pour les zones humides riveraines du lac Huron et du Michigan pendant une période de baisse du niveau du lac. Aquat. Écosystème. Santé 7, 269–288 (2004).

Clark, J.E. Dans Fonctions et valeurs des zones humides : l'état de nos connaissances (eds Greeson, P. E., Clark J. R. & Clark J. E. ) Zones humides d'eau douce : habitats pour les invertébrés aquatiques, les amphibiens, les reptiles et les poissons. Série de publications techniques TP79-2. (Association américaine des ressources en eau : Minneapolis, MN, 1978).

Jude, D. J. & Pappas, J. Utilisation des poissons des zones humides côtières des Grands Lacs. J. Grands Lacs Rés. 18, 651–692 (1992).

Wang, L. et al. Une classification spatiale et une base de données pour la gestion, la recherche et l'élaboration de politiques : Le cadre de l'habitat aquatique des Grands Lacs. J. Grands Lacs Rés. 41, 584–596 (2015).

Larson, G. & Schaetzl, R. Revue : origine et évolution des Grands Lacs. J. Grands Lacs Rés. 27, 518–546 (2001).

Waples, J. T. & Klump, J. V. Effets biophysiques d'un changement décennal de la direction des vents d'été sur les Grands Lacs laurentiens. Rés géophysique. Des lettres 29, 8 (2002).

Kalff, J. Limnologie : écosystèmes aquatiques intérieurs (Upper Saddle River, New Jersey, 2002).

Håkanson, L.A. Manuel de morphométrie des lacs (Berlin : Springer-Verlag, 1981).

Corps des ingénieurs de l'armée américaine (USACE). Manuel de protection du rivage. Centre de recherche en génie côtier : Fort Belvoir, Virginie, (1984).

Keddy, P. A. Quantifying intra-lac gradients of wave energy: interrelations of wave energy, substrat particule size and the shore plants in Ax Lake, Ontario. Botanique aquatique 14, 41–58 (1982).

Forsyth, D.K. et al. L'ensemble de données hydrographiques des Grands Lacs : bassins hydrographiques binationaux cohérents pour le bassin laurentien des Grands Lacs. Confiture. Ressource en eau. Comme 52, 1068–1088 (2016).

Anderson, E. J. & Schwab, D. J. Prédire le flux d'échange bidirectionnel oscillant dans le détroit de Mackinac. J. Grands Lacs Rés. 39, 663–671 (2013).

Finlayson, D. Récupération de Puget Sound : Seattle, Washington. Doctorat Diss. (Université de Washington, 2005).

Rohweder, J. et al. Application de modèles de fetch et de vagues pour des projets de réhabilitation et d'amélioration de l'habitat. Rapport ouvert de la Commission géologique des États-Unis 2008-1200, 43 p (2008).

Desai, A. R., Austin, J. A., Bennington, V. & McKinley, G. A. Des vents plus forts sur un grand lac en réponse à l'affaiblissement du gradient de température air-lac. Géosciences de la nature 2, 855-858, https://doi.org/10.1038/NGEO693 (2009).

Straskraba, M. In Le fonctionnement des écosystèmes d'eau douce (éd. LeCren, E. D. ) Les effets des variables physiques sur la production d'eau douce : analyses basées sur des modèles (Cambridge Univ. Press, Cambridge, 1980).

Citations de données

Mason, L.A., Riseng, C.M., Layman, A.J., & Jensen, R. Université du Michigan https://doi.org/10.7302/z22f7kn3 (2018)


Voir la vidéo: Python в ArcGIS - ТОП-10 самых востребованных функций,, Esri CIS