Suite

Quelles sont les causes AttributeError : l'objet 'module' n'a pas d'attribut 'da' ?

Quelles sont les causes AttributeError : l'objet 'module' n'a pas d'attribut 'da' ?


J'ai un fichier de formes "selected_polygons.shp" qui contient 2000 polygones. Je voudrais sélectionner chaque polygone contenu dans le shapefile en utilisant un curseur de recherche afin d'appliquer la fonction "CostDistance" pour chaque polygone.

Voici mon code :

importer arcpy depuis arcpy importer env depuis arcpy.sa importer * arcpy.CheckOutExtension("Spatial") arcpy.env.overwriteOutput = True arcpy.env.workspace = "C:UsersLCP" arcpy.env.extent = "costs. tif" avec arcpy.da.SearchCursor("selected_polygons.shp",("*")) comme rowsInPatches_start : pour rowStart dans rowsInPatches_start : ID_patch_start = rowStart.getValue("GRIDCODE") ## Définir l'expression SQL pour la fonction Select Layer By Attribut expressionForSelectInPatches_start = "GRIDCODE=%s" % (ID_patch_start) # Processus : Sélectionner une couche par attribut dans Patches_start arcpy.MakeFeatureLayer_management("selected_patches.shp", "Selected_patch_start", expressionForSelectInPatches_start) # Processus : Distance de coût outCosttanceDist" , "costs.tif", "", "outCostLink.tif") # Enregistre la sortie outCostDist.save("outCostDist.tif")

Le problème est que j'obtiens un message d'erreur lorsque j'utilise :

avec arcpy.da.SearchCursor("selected_polygons.shp",("*")) comme rowsInPatches_start :

Voici mon message d'erreur :

AttributeError : l'objet 'module' n'a pas d'attribut 'da'

LedaLe module ne fonctionne que dans les versions supérieures à 10.1 dans ArcGIS. Si vous essayez d'exécuter un code python en utilisantdadans ArcGIS 10 ou inférieur, vous obtiendrez l'erreur ci-dessous :

AttributeError : l'objet 'module' n'a pas d'attribut 'da'

Si vous exécutez le code dans la bonne version, il devrait se résoudre tout seul. Si vous n'avez accès qu'à 10, utilisez learcpy.searchcursoret adaptez votre code. Penn State a une bonne ressource pour utiliser les curseurs de recherche et les différences entre 10 et 10.1 .

3.2.2 Lecture des enregistrements


Vous faites quelques erreurs qui déroutent vraiment l'interpréteur Python, bien qu'il semble que vous ayez probablement lu cette documentation, qui contient du code complètement cassé. Je pense qu'il est peu probable que le code ait été testé avant d'être publié, car il y a quelques erreurs :

Vous ne pouvez pas déclarer une variable avec le même nom qu'un module que vous importez.

Cette ligne redéclare le module firebase en tant que variable de type FirebaseApplication . En d'autres termes, vous vous empêchez d'accéder à ce que vous avez essayé d'importer plus tard, avec la ligne firebase.Authentification

Vous n'importez pas correctement le module firebase si vous souhaitez utiliser la méthode ci-dessus. Tu devrais plutôt seulement utilisez from firebase import firebase si vous avez l'intention de référencer les classes en tant que firebase.FirebaseApplication (et ainsi de suite).

Jetez un œil à l'exemple donné dans le répertoire examples/ de leur référentiel. Cela montre la méthode d'importation et l'utilisation correctes.


2 réponses 2

La fonction pd.read_csv() est déjà un DataFrame et donc ce type d'objet ne prend pas en charge l'appel de .to_dataframe() .

Vous pouvez vérifier le type de votre variable ds en utilisant print(type(ds)) , vous verrez qu'il s'agit d'un type pandas DataFrame.

D'après ce que j'ai compris. Vous chargez Loanapp_c.csv dans DS en utilisant ce code :

ds ici est un objet DataFrame. Ce que vous faites, c'est appeler to_dataframe sur un objet qui est déjà un DataFrame.


est-ce que ton code ressemble à ça !

Ce n'est probablement pas la réponse à cette question, mais avec mon problème, c'était le premier site Web que j'ai trouvé. Je souhaite donc documenter mon cas pour les futurs utilisateurs qui pourraient avoir le même problème.

Il s'est avéré que seaborn 0.11 a introduit le displot, alors que j'ai utilisé seaborn 0.10.

Nouvelles fonctions de traçage

Premièrement, trois nouvelles fonctions, displot(), histplot() et ecdfplot() ont été ajoutées (#2157, #2125, #2141).

.

API d'obsolescence

Enfin, la fonction distplot() est désormais formellement dépréciée. Ses fonctionnalités ont été subsumées par displot() et histplot(). Des efforts ont été faits pour faire évoluer progressivement distplot() en ajoutant les fonctionnalités de displot() et en gérant la rétrocompatibilité, mais cela s'est avéré trop difficile. La similitude des noms causera probablement une certaine confusion lors de la transition, ce qui est regrettable.


Cela devrait résoudre votre problème:

Execute renvoie une instance de tâche. Le travail a un résultat, job.result(), et vous obtenez des décomptes à partir des résultats, c'est-à-dire job.result().get_counts()

J'ai résolu ce problème en modifiant le code en .

Lorsque j'utilise une variable compte pour stocker la sortie, je suis capable de la tracer mais incapable d'exécuter le code de la question. Tout le code va comme ça.


2 réponses 2

C'est un effet secondaire de la façon dont vous importez.

à partir de bpy, importez les données en tant que bpy_data importe les données bpy_struct lorsque le fichier py est chargé, comme une copie locale (pas un alias). Cela se produit lors de l'enregistrement de l'addon, ainsi bpy_data sera et restera comme :

En revanche, l'importation de bpy et une utilisation ultérieure de bpy.data accèdent aux données au moment où vous les utilisez réellement. C'est _RestrictData au moment de l'inscription, mais plus tard ce sera

Vous devez modifier vos importations de

de . importer. comme . ne doit être utilisé que si le module ou la fonction importé en écrase un autre.

L'objet _RestrictData indique que vous essayiez d'accéder à des éléments dans bpy.data.(. ) avant ( blender est prêt )

Je ne connais pas les détails techniques mais je sais que cela se produit au démarrage si vous accédez à bpy.data avant de vous inscrire ()

La première fois que Blender lit le script, c'est juste pour rassembler bl_info et s'assurer que register() est défini dans le script.

Après cette lecture du fichier, Blender peut avoir d'autres scripts à analyser et il passe donc à l'analyse du reste des fichiers dans addons/startup.


AttributeError : l'objet 'str' n'a pas d'attribut 'mois' Processus terminé avec le code de sortie 1

Oct Full s'est déroulé, échec et n'est pas encore terminé : Oct full run, failed & n'a pas encore été terminé signifie - "LastFullStartTime" - contient la date du mois en cours et non vide && "LastFullResult" - Failed && "statut
code" - supérieur à 1

Oct Full n'a pas encore été exécuté : Oct Full n'a pas été exécuté signifie - "LastFullStartTime" - vide ou date antérieure au mois en cours

Oct full run réussi - Oct full run réussi signifie - "LastFullStartTime" - contient la date du mois en cours &&
« DernierRésultat Complet » - succès

Grand Total Grand Total signifie - Le nombre de BackupPolicyID pour chaque cellule distincte doit être idéalement égal à plus de 3 colonnes (1+2+3=4)

Taux de réussite pour une exécution complète en octobre Le taux de réussite pour une exécution complète en octobre signifie - Au-dessus de la colonne1/(colonne1+colonne3) en pourcentage

Taux de réussite de la sauvegarde complète Le taux de réussite de la sauvegarde complète signifie – Au-dessus de la colonne1/(colonne1+colonne2+colonne3) en pourcentage

Pourcentage de couverture de sauvegarde Pourcentage de couverture de sauvegarde signifie – Au-dessus (colonne1+colonne3)/colonne4


Cette erreur indique que la valeur est un tuple et non une chaîne comme vous pourriez vous y attendre. Cela indique un problème avec votre application.

Ici, le problème est que fetchone() renvoie un tuple unique. Vous devriez changer à partir de cette ligne :

à ceci (notez la virgule après la valeur ):

Mais pourquoi fetchone() renvoie-t-il un tuple au lieu d'une chaîne ? Parce que vous pouvez SELECTIONNER plusieurs colonnes. Considérons par exemple l'instruction SQL suivante :

Dans ce cas, fetchone() renverra un triplet.

En écrivant value, = fetchone(), vous dites à Python que vous attendez un tuple unique et que vous voulez que cet élément unique soit placé dans value . Si vous vous attendiez au triplet, vous auriez utilisé column_a, column_b, column_c = resulsts.fetchone() .

C'est la raison pour laquelle vous devriez préférer value à fetchone()[0] .

Astuce bonus : J'ai remarqué que vous utilisez Python 3. Dans ce cas, vous pouvez écrire :


Sys — Paramètres et fonctions spécifiques au système¶

Ce module donne accès à certaines variables utilisées ou maintenues par l'interpréteur et à des fonctions qui interagissent fortement avec l'interpréteur. Il est toujours disponible.

Sur les systèmes POSIX où Python a été construit avec le script de configuration standard, celui-ci contient les indicateurs ABI spécifiés par PEP 3149.

Modifié dans la version 3.8 : les drapeaux par défaut sont devenus une chaîne vide (le drapeau m pour pymalloc a été supprimé).

Ajouter l'appelable accrocher à la liste des hooks d'audit actifs pour le (sous-)interprète actuel.

Lorsqu'un événement d'audit est déclenché via la fonction sys.audit(), chaque hook sera appelé dans l'ordre dans lequel il a été ajouté avec le nom de l'événement et le tuple d'arguments. Les hooks natifs ajoutés par PySys_AddAuditHook() sont appelés en premier, suivis des hooks ajoutés dans le (sous)interpréteur actuel. Les hooks peuvent alors enregistrer l'événement, lever une exception pour abandonner l'opération ou terminer complètement le processus.

L'appel de sys.addaudithook() déclenchera lui-même un événement d'audit nommé sys.addaudithook sans argument. Si des hooks existants lèvent une exception dérivée de RuntimeError , le nouveau hook ne sera pas ajouté et l'exception supprimée. Par conséquent, les appelants ne peuvent pas supposer que leur crochet a été ajouté à moins qu'ils ne contrôlent tous les crochets existants.

Consultez le tableau des événements d'audit pour tous les événements déclenchés par CPython, et PPE 578 pour la discussion sur la conception originale.

Modifié dans la version 3.8.1 : les exceptions dérivées d'Exception mais pas RuntimeError ne sont plus supprimées.

Détails de l'implémentation de CPython : Lorsque le traçage est activé (voir settrace() ), les hooks Python ne sont tracés que si l'appelable a un membre __cantrace__ défini sur une valeur vraie. Sinon, les fonctions de trace ignoreront le hook.

La liste des arguments de ligne de commande transmis à un script Python. argv[0] est le nom du script (cela dépend du système d'exploitation s'il s'agit d'un chemin d'accès complet ou non). Si la commande a été exécutée à l'aide de l'option de ligne de commande -c de l'interpréteur, argv[0] est défini sur la chaîne '-c' . Si aucun nom de script n'a été transmis à l'interpréteur Python, argv[0] est la chaîne vide.

Pour parcourir l'entrée standard, ou la liste des fichiers donnée sur la ligne de commande, consultez le module fileinput.

Sous Unix, les arguments de ligne de commande sont passés par octets depuis le système d'exploitation. Python les décode avec l'encodage du système de fichiers et le gestionnaire d'erreurs « surrogateescape ». Lorsque vous avez besoin des octets d'origine, vous pouvez l'obtenir par [os.fsencode(arg) for arg in sys.argv] .

Déclenchez un événement d'audit et déclenchez tous les hooks d'audit actifs. un événement est une chaîne identifiant l'événement, et arguments peut contenir des arguments facultatifs avec plus d'informations sur l'événement. Le nombre et les types d'arguments pour un événement donné sont considérés comme une API publique et stable et ne doivent pas être modifiés entre les versions.

Par exemple, un événement d'audit est nommé os.chdir . Cet événement a un argument appelé chemin qui contiendra le nouveau répertoire de travail demandé.

sys.audit() appellera les hooks d'audit existants, en passant le nom de l'événement et les arguments, et relancera la première exception de n'importe quel hook. En général, si une exception est levée, elle ne doit pas être gérée et le processus doit être terminé le plus rapidement possible. Cela permet aux implémentations de hook de décider comment répondre à des événements particuliers : elles peuvent simplement enregistrer l'événement ou annuler l'opération en levant une exception.

Les hooks sont ajoutés à l'aide des fonctions sys.addaudithook() ou PySys_AddAuditHook().

L'équivalent natif de cette fonction est PySys_Audit() . L'utilisation de la fonction native est préférable lorsque cela est possible.

Consultez le tableau des événements d'audit pour tous les événements déclenchés par CPython.

Défini au démarrage de Python, avant l'exécution de site.py, à la même valeur que exec_prefix . S'il ne s'exécute pas dans un environnement virtuel, les valeurs resteront les mêmes si site.py découvre qu'un environnement virtuel est en cours d'utilisation, les valeurs de préfixe et exec_prefix seront modifiées pour pointer vers l'environnement virtuel, tandis que base_prefix et base_exec_prefix resteront pointés à l'installation Python de base (celle à partir de laquelle l'environnement virtuel a été créé).

Défini au démarrage de Python, avant l'exécution de site.py, à la même valeur que prefix . S'il ne s'exécute pas dans un environnement virtuel, les valeurs resteront les mêmes si site.py découvre qu'un environnement virtuel est en cours d'utilisation, les valeurs de préfixe et exec_prefix seront modifiées pour pointer vers l'environnement virtuel, tandis que base_prefix et base_exec_prefix resteront pointés à l'installation Python de base (celle à partir de laquelle l'environnement virtuel a été créé).

Un indicateur de l'ordre des octets natifs. Cela aura la valeur « big » sur les plateformes big-endian (octet le plus significatif en premier) et « little » sur les plateformes little-endian (octet le moins significatif en premier).

Un tuple de chaînes donnant les noms de tous les modules qui sont compilés dans cet interpréteur Python. (Ces informations ne sont disponibles d'aucune autre manière — modules.keys() ne répertorie que les modules importés.)

sys. call_tracing ( fonction, arguments ) ¶

Appelez func(*args) , pendant que le traçage est activé. L'état de suivi est enregistré et restauré par la suite. Ceci est destiné à être appelé à partir d'un débogueur à partir d'un point de contrôle, pour déboguer récursivement un autre code.

Une chaîne contenant le copyright relatif à l'interpréteur Python.

Videz le cache de type interne. Le cache de type est utilisé pour accélérer les recherches d'attributs et de méthodes. Utiliser la fonction seulement pour supprimer les références inutiles lors du débogage des fuites de référence.

Cette fonction doit être utilisée uniquement à des fins internes et spécialisées.

Renvoie un dictionnaire mappant l'identifiant de chaque thread au cadre de pile le plus haut actuellement actif dans ce thread au moment où la fonction est appelée. Notez que les fonctions du module traceback peuvent construire la pile d'appels à partir d'un tel cadre.

C'est très utile pour déboguer les interblocages : cette fonction ne nécessite pas la coopération des threads bloqués, et les piles d'appels de ces threads sont gelées tant qu'elles restent bloquées. La trame renvoyée pour un thread non bloqué peut n'avoir aucune relation avec l'activité actuelle de ce thread au moment où le code appelant examine la trame.

Cette fonction doit être utilisée uniquement à des fins internes et spécialisées.

Déclenche un événement d'audit sys._current_frames sans argument.

Cette fonction de crochet est appelée par le point d'arrêt intégré() . Par défaut, il vous place dans le débogueur pdb, mais il peut être défini sur n'importe quelle autre fonction afin que vous puissiez choisir le débogueur utilisé.

La signature de cette fonction dépend de ce qu'elle appelle. Par exemple, la liaison par défaut (par exemple pdb.set_trace() ) n'attend aucun argument, mais vous pouvez la lier à une fonction qui attend des arguments supplémentaires (positionnel et/ou mot-clé). La fonction intégrée breakpoint() transmet ses *args et **kws directement. Tout ce que breakpointhooks() renvoie est renvoyé par breakpoint() .

L'implémentation par défaut consulte d'abord la variable d'environnement PYTHONBREAKPOINT . Si cela est défini sur "0", cette fonction retourne immédiatement, c'est-à-dire qu'il s'agit d'un no-op. Si la variable d'environnement n'est pas définie ou est définie sur la chaîne vide, pdb.set_trace() est appelé. Sinon, cette variable doit nommer une fonction à exécuter, en utilisant la nomenclature d'importation pointée de Python, par ex. package.sous-package.module.fonction . Dans ce cas, package.subpackage.module serait importé et le module résultant doit avoir un appelable nommé function() . Ceci est exécuté, en passant *args et **kws , et quel que soit le retour de fonction(), sys.breakpointhook() retourne à la fonction intégrée breakpoint().

Notez que si quelque chose ne va pas lors de l'importation de l'appelable nommé par PYTHONBREAKPOINT , un RuntimeWarning est signalé et le point d'arrêt est ignoré.

Notez également que si sys.breakpointhook() est remplacé par programme, PYTHONBREAKPOINT est ne pas consulté.

Imprimez des informations de bas niveau sur stderr sur l'état de l'allocateur de mémoire de CPython.

Si Python est configuré avec -pydebug, il effectue également des vérifications de cohérence internes coûteuses.

Détails de l'implémentation de CPython : Cette fonction est spécifique à CPython. Le format de sortie exact n'est pas défini ici et peut changer.

Entier spécifiant le handle de la DLL Python.

Si valeur n'est pas None , cette fonction imprime repr(value) dans sys.stdout et enregistre valeur dans builtins._ . Si repr(value) n'est pas encodable en sys.stdout.encoding avec le gestionnaire d'erreurs sys.stdout.errors (qui est probablement 'strict' ), encodez-le en sys.stdout.encoding avec le gestionnaire d'erreurs 'backslashreplace'.

sys.displayhook est appelé sur le résultat de l'évaluation d'une expression entrée dans une session Python interactive. L'affichage de ces valeurs peut être personnalisé en affectant une autre fonction à un argument à sys.displayhook .

Modifié dans la version 3.2 : utilisez le gestionnaire d'erreurs 'backslashreplace' sur UnicodeEncodeError .

Si cela est vrai, Python n'essaiera pas d'écrire des fichiers .pyc lors de l'importation de modules source. Cette valeur est initialement définie sur True ou False en fonction de l'option de ligne de commande -B et de la variable d'environnement PYTHONDONTWRITEBYTECODE, mais vous pouvez la définir vous-même pour contrôler la génération du fichier de bytecode.

Si cela est défini (pas None ), Python écrira les fichiers bytecode-cache .pyc dans (et les lira à partir de) une arborescence de répertoires parallèle enracinée dans ce répertoire, plutôt qu'à partir des répertoires __pycache__ dans l'arborescence du code source. Tous les répertoires __pycache__ dans l'arborescence du code source seront ignorés et les nouveaux fichiers .pyc écrits dans le préfixe pycache. Ainsi, si vous utilisez compileall comme étape de pré-construction, vous devez vous assurer de l'exécuter avec le même préfixe pycache (le cas échéant) que vous utiliserez lors de l'exécution.

Un chemin relatif est interprété par rapport au répertoire de travail courant.

Cette valeur est initialement définie en fonction de la valeur de l'option de ligne de commande -X pycache_prefix=PATH ou de la variable d'environnement PYTHONPYCACHEPREFIX (la ligne de commande est prioritaire). Si ni l'un ni l'autre n'est défini, il s'agit de None .

Cette fonction imprime un suivi et une exception donnés à sys.stderr .

Lorsqu'une exception est levée et non interceptée, l'interpréteur appelle sys.excepthook avec trois arguments, la classe d'exception, l'instance d'exception et un objet de trace. Dans une session interactive, cela se produit juste avant que le contrôle ne soit renvoyé à l'invite dans un programme Python, cela se produit juste avant la fin du programme. La gestion de ces exceptions de niveau supérieur peut être personnalisée en attribuant une autre fonction à trois arguments à sys.excepthook .

Déclenchez un événement d'audit sys.excepthook avec les arguments hook , type , value , traceback lorsqu'une exception non interceptée se produit. Si aucun crochet n'a été défini, crochet peut être Aucun . Si un hook lève une exception dérivée de RuntimeError, l'appel au hook sera supprimé. Sinon, l'exception du hook d'audit sera signalée comme non déclenchée et sys.excepthook sera appelé.

La fonction sys.unraisablehook() gère les exceptions impossibles à lever et la fonction threading.excepthook() gère les exceptions levées par threading.Thread.run() .

Ces objets contiennent les valeurs d'origine de breakpointhook , displayhook , excepthook et unraisablehook au début du programme. Ils sont enregistrés afin que breakpointhook , displayhook et excepthook , unraisablehook puissent être restaurés au cas où ils seraient remplacés par des objets cassés ou alternatifs.

Nouveau dans la version 3.7 : __breakpointhook__

Nouveau dans la version 3.8 : __unraisablehook__

Cette fonction renvoie un tuple de trois valeurs qui donnent des informations sur l'exception actuellement gérée. Les informations renvoyées sont spécifiques à la fois au thread actuel et au frame de pile actuel. Si le cadre de pile actuel ne gère pas d'exception, les informations sont extraites du cadre de pile appelant, ou de son appelant, et ainsi de suite jusqu'à ce qu'un cadre de pile qui gère une exception soit trouvé. Ici, « gérer une exception » est défini comme « exécuter une clause except ». Pour tout cadre de pile, seules les informations sur l'exception actuellement gérée sont accessibles.

Si aucune exception n'est gérée n'importe où sur la pile, un tuple contenant trois valeurs None est renvoyé. Sinon, les valeurs renvoyées sont (type, value, traceback) . Leur signification est : taper obtient le type de l'exception gérée (une sous-classe de BaseException ) valeur obtient l'instance d'exception (une instance du type d'exception) retraçage obtient un objet traceback qui encapsule la pile d'appels au point où l'exception s'est produite à l'origine.

Une chaîne donnant le préfixe du répertoire spécifique au site où les fichiers Python dépendant de la plate-forme sont installés par défaut, il s'agit également de '/usr/local' . Cela peut être défini au moment de la construction avec l'argument --exec-prefix à la configurer scénario. Plus précisément, tous les fichiers de configuration (par exemple le fichier d'en-tête pyconfig.h) sont installés dans le répertoire exec_prefix /lib/python X.Y /config et les modules de bibliothèque partagée sont installés dans exec_prefix /lib/python X.Y /lib-dynload , où X.Y est le numéro de version de Python, par exemple 3.2 .

Si un environnement virtuel est en vigueur, cette valeur sera modifiée dans site.py pour pointer vers l'environnement virtuel. La valeur pour l'installation de Python sera toujours disponible, via base_exec_prefix .

Une chaîne donnant le chemin absolu du binaire exécutable pour l'interpréteur Python, sur les systèmes où cela a du sens. Si Python est incapable de récupérer le chemin réel vers son exécutable, sys.executable sera une chaîne vide ou None .

Sortez de Python. Ceci est implémenté en levant l'exception SystemExit, donc les actions de nettoyage spécifiées par les clauses finally des instructions try sont honorées et il est possible d'intercepter la tentative de sortie à un niveau externe.

L'argument optionnel argument peut être un entier donnant l'état de sortie (par défaut à zéro), ou un autre type d'objet. S'il s'agit d'un entier, zéro est considéré comme une « terminaison réussie » et toute valeur différente de zéro est considérée comme une « terminaison anormale » par les shells et autres. La plupart des systèmes exigent qu'il soit compris entre 0 et 127 et produisent des résultats indéfinis dans le cas contraire. Certains systèmes ont une convention pour attribuer des significations spécifiques à des codes de sortie spécifiques, mais ce sont généralement des programmes Unix sous-développés qui utilisent généralement 2 pour les erreurs de syntaxe de ligne de commande et 1 pour tous les autres types d'erreurs. Si un autre type d'objet est passé, None équivaut à passer zéro, et tout autre objet est imprimé sur stderr et entraîne un code de sortie de 1. En particulier, sys.exit("some error message") est un moyen rapide de quitter un programme lorsqu'une erreur se produit.

Étant donné que exit() lève finalement « seulement » une exception, il ne quittera le processus que lorsqu'il est appelé depuis le thread principal et l'exception n'est pas interceptée.

Modifié dans la version 3.6 : si une erreur se produit lors du nettoyage après que l'interpréteur Python a intercepté SystemExit (comme une erreur lors du vidage des données mises en mémoire tampon dans les flux standard), l'état de sortie passe à 120.

Le tuple nommé drapeaux expose l'état des indicateurs de ligne de commande. Les attributs sont en lecture seule.

Modifié dans la version 3.2 : Ajout de l'attribut quiet pour le nouveau drapeau -q.

Nouveau dans la version 3.2.3 : L'attribut hash_randomization.

Modifié dans la version 3.3 : Suppression de l'attribut division_warning obsolète.

Modifié dans la version 3.4 : Ajout d'un attribut isolé pour le drapeau isolé -I.

Modifié dans la version 3.7 : Ajout de l'attribut dev_mode pour le nouveau mode de développement Python et de l'attribut utf8_mode pour le nouveau drapeau -X utf8.

Un tuple nommé contenant des informations sur le type float. Il contient des informations de bas niveau sur la précision et la représentation interne. Les valeurs correspondent aux différentes constantes à virgule flottante définies dans le fichier d'en-tête standard float.h pour le langage de programmation 'C' voir section 5.2.4.2.2 de la norme ISO/IEC C 1999 [C99] , 'Caractéristiques des types flottants ', pour plus de détails.

différence entre 1,0 et la plus petite valeur supérieure à 1,0 qui est représentable comme un flottant

nombre maximum de chiffres décimaux pouvant être fidèlement représentés dans un flottant voir ci-dessous

float precision : le nombre de chiffres de base dans la mantisse d'un float

flottant fini positif maximum représentable

nombre entier maximal e tel que radix**(e-1) est un flottant fini représentable

nombre entier maximal e tel que 10**e est dans la gamme des flottants finis représentables

minimum représentable positif normalisé flotter

Utilisez math.ulp(0.0) pour obtenir le plus petit positif dénormalisé flotteur représentable.

nombre entier minimal e tel que radix**(e-1) est un flottant normalisé

nombre entier minimal e tel que 10**e est un flottant normalisé

base de représentation de l'exposant

constante entière représentant le mode d'arrondi utilisé pour les opérations arithmétiques. Cela reflète la valeur de la macro système FLT_ROUNDS au démarrage de l'interpréteur. Voir la section 5.2.4.2.2 de la norme C99 pour une explication des valeurs possibles et de leurs significations.

L'attribut sys.float_info.dig a besoin d'explications supplémentaires. Si s est une chaîne représentant un nombre décimal avec au plus sys.float_info.dig des chiffres significatifs, la conversion de s en nombre flottant et inversement récupérera une chaîne représentant la même valeur décimale :

Mais pour les chaînes avec plus de sys.float_info.dig chiffres significatifs, ce n'est pas toujours vrai :

Une chaîne indiquant comment la fonction repr() se comporte pour les flottants. Si la chaîne a la valeur 'short' alors pour un float fini x , repr(x) vise à produire une chaîne courte avec la propriété que float(repr(x)) == x . C'est le comportement habituel dans Python 3.1 et versions ultérieures. Sinon, float_repr_style a la valeur 'legacy' et repr(x) se comporte de la même manière que dans les versions de Python antérieures à 3.1.

Renvoie le nombre de blocs mémoire actuellement alloués par l'interpréteur, quelle que soit leur taille. Cette fonction est principalement utile pour le suivi et le débogage des fuites de mémoire. En raison des caches internes de l'interpréteur, le résultat peut varier d'un appel à l'autre, vous devrez peut-être appeler _clear_type_cache() et gc.collect() pour obtenir des résultats plus prévisibles.

Si une construction ou une implémentation Python ne peut pas raisonnablement calculer ces informations, getallocatedblocks() est autorisé à renvoyer 0 à la place.

Renvoie la version de l'API de génération d'Android sous forme d'entier.

Renvoie le nom de l'encodage de chaîne par défaut actuel utilisé par l'implémentation Unicode.

Renvoie la valeur actuelle des indicateurs utilisés pour les appels dlopen(). Les noms symboliques des valeurs de drapeau peuvent être trouvés dans le module os (constantes RTLD_xxx, par exemple os.RTLD_LAZY).

Renvoie le nom de l'encodage utilisé pour convertir entre les noms de fichiers Unicode et les noms de fichiers en octets. Pour une meilleure compatibilité, str doit être utilisé pour les noms de fichiers dans tous les cas, bien que la représentation des noms de fichiers sous forme d'octets soit également prise en charge. Les fonctions acceptant ou renvoyant des noms de fichiers doivent prendre en charge str ou bytes et être converties en interne dans la représentation préférée du système.

Cet encodage est toujours compatible ASCII.

os.fsencode() et os.fsdecode() doivent être utilisés pour s'assurer que le mode de codage et d'erreurs correct est utilisé.

En mode UTF-8, l'encodage est utf-8 sur n'importe quelle plate-forme.

Sur macOS, l'encodage est 'utf-8' .

Sous Unix, l'encodage est l'encodage de la locale.

Sous Windows, l'encodage peut être 'utf-8' ou 'mbcs' , selon la configuration de l'utilisateur.

Sur Android, l'encodage est 'utf-8' .

Sur VxWorks, l'encodage est 'utf-8' .

Modifié dans la version 3.2 : le résultat getfilesystemencoding() ne peut plus être None.

Modifié dans la version 3.6 : Windows n'est plus garanti de retourner 'mbcs' . Voir PPE 529 et _enablelegacywindowsfsencoding() pour plus d'informations.

Modifié dans la version 3.7 : renvoie « utf-8 » en mode UTF-8.

Renvoie le nom du mode d'erreur utilisé pour convertir entre les noms de fichiers Unicode et les noms de fichiers en octets. Le nom d'encodage est renvoyé par getfilesystemencoding() .

os.fsencode() et os.fsdecode() doivent être utilisés pour s'assurer que le mode de codage et d'erreurs correct est utilisé.

Renvoie le nombre de références du objet. Le nombre renvoyé est généralement supérieur à celui auquel vous pourriez vous attendre, car il inclut la référence (temporaire) en tant qu'argument de getrefcount() .

Renvoie la valeur actuelle de la limite de récursivité, la profondeur maximale de la pile de l'interpréteur Python. Cette limite empêche la récursivité infinie de provoquer un débordement de la pile C et le plantage de Python. Il peut être défini par setrecursionlimit() .

sys. getsizeof ( objet [ , défaut ] ) ¶

Renvoie la taille d'un objet en octets. L'objet peut être n'importe quel type d'objet. Tous les objets intégrés renverront des résultats corrects, mais cela n'a pas à être vrai pour les extensions tierces car il est spécifique à l'implémentation.

Seule la consommation de mémoire directement attribuée à l'objet est prise en compte, pas la consommation de mémoire des objets auxquels il se réfère.

Si donné, défaut sera renvoyé si l'objet ne fournit pas de moyen pour récupérer la taille. Sinon, une TypeError sera levée.

getsizeof() appelle la méthode __sizeof__ de l'objet et ajoute une surcharge supplémentaire au ramasse-miettes si l'objet est géré par le ramasse-miettes.

Voir la recette sizeof recursive pour un exemple d'utilisation de getsizeof() de manière récursive pour trouver la taille des conteneurs et tout leur contenu.

Renvoie l'« intervalle de changement de thread » de l'interpréteur, voir setswitchinterval() .

Renvoie un objet frame à partir de la pile des appels. Si entier optionnel profondeur est donné, renvoie l'objet frame que de nombreux appels en dessous du sommet de la pile. Si cela est plus profond que la pile d'appels, ValueError est levée. La valeur par défaut pour profondeur est zéro, renvoyant la trame au sommet de la pile d'appels.

Déclenche un événement d'audit sys._getframe sans argument.

Détails de l'implémentation de CPython : Cette fonction doit être utilisée uniquement à des fins internes et spécialisées. Il n'est pas garanti d'exister dans toutes les implémentations de Python.

Obtenez la fonction de profileur telle que définie par setprofile() .

Obtenez la fonction trace telle que définie par settrace() .

Détails de l'implémentation de CPython : La fonction gettrace() est destinée uniquement à l'implémentation de débogueurs, de profileurs, d'outils de couverture, etc. Son comportement fait partie de la plate-forme d'implémentation, plutôt que de la définition du langage, et peut donc ne pas être disponible dans toutes les implémentations Python.

Renvoie un tuple nommé décrivant la version de Windows en cours d'exécution. Les éléments nommés sont Majeur, mineur, construire, Plate-forme, service_pack, service_pack_minor, service_pack_major, suite_mask, type de produit et version_plateforme. service_pack contient une chaîne, version_plateforme un 3-uplet et toutes les autres valeurs sont des nombres entiers. Les composants sont également accessibles par leur nom, donc sys.getwindowsversion()[0] est équivalent à sys.getwindowsversion().major . Pour une compatibilité avec les versions antérieures, seuls les 5 premiers éléments sont récupérables par indexation.

Plate-forme sera 2 (VER_PLATFORM_WIN32_NT) .

type de produit peut être l'une des valeurs suivantes :

Le système est un poste de travail.

Le système est un contrôleur de domaine.

Le système est un serveur, mais pas un contrôleur de domaine.

Cette fonction encapsule la fonction Win32 GetVersionEx() voir la documentation Microsoft sur OSVERSIONINFOEX() pour plus d'informations sur ces champs.

version_plateforme renvoie la version majeure, la version mineure et le numéro de build du système d'exploitation actuel, plutôt que la version émulée pour le processus. Il est destiné à être utilisé dans la journalisation plutôt que pour la détection de fonctionnalités.

version_plateforme dérive la version de kernel32.dll qui peut être d'une version différente de la version du système d'exploitation. Veuillez utiliser le module de plate-forme pour obtenir une version précise du système d'exploitation.

Modifié dans la version 3.2 : modifié en un tuple nommé et ajouté service_pack_minor, service_pack_major, suite_mask, et type de produit.

Modifié dans la version 3.6 : Ajouté version_plateforme

Renvoie un asyncgen_hooks object, qui est similaire à un tuple nommé de la forme (firstiter, finalizer) , où premier litre et finaliseur sont censés être None ou des fonctions qui prennent un itérateur de générateur asynchrone comme argument, et sont utilisées pour planifier la finalisation d'un générateur asynchrone par une boucle d'événement.

New in version 3.6: See PEP 525 for more details.

This function has been added on a provisional basis (see PEP 411 for details.)

Get the current coroutine origin tracking depth, as set by set_coroutine_origin_tracking_depth() .

This function has been added on a provisional basis (see PEP 411 for details.) Use it only for debugging purposes.

A named tuple giving parameters of the numeric hash implementation. For more details about hashing of numeric types, see Hashing of numeric types .

width in bits used for hash values

prime modulus P used for numeric hash scheme

hash value returned for a positive infinity

hash value returned for a nan

multiplier used for the imaginary part of a complex number

name of the algorithm for hashing of str, bytes, and memoryview

internal output size of the hash algorithm

size of the seed key of the hash algorithm

Changed in version 3.4: Added algorithm, hash_bits et seed_bits

The version number encoded as a single integer. This is guaranteed to increase with each version, including proper support for non-production releases. For example, to test that the Python interpreter is at least version 1.5.2, use:

This is called hexversion since it only really looks meaningful when viewed as the result of passing it to the built-in hex() function. The named tuple sys.version_info may be used for a more human-friendly encoding of the same information.

More details of hexversion can be found at API and ABI Versioning .

An object containing information about the implementation of the currently running Python interpreter. The following attributes are required to exist in all Python implementations.

name is the implementation’s identifier, e.g. 'cpython' . The actual string is defined by the Python implementation, but it is guaranteed to be lower case.

version is a named tuple, in the same format as sys.version_info . It represents the version of the Python implementation. This has a distinct meaning from the specific version of the Python language to which the currently running interpreter conforms, which sys.version_info represents. For example, for PyPy 1.8 sys.implementation.version might be sys.version_info(1, 8, 0, 'final', 0) , whereas sys.version_info would be sys.version_info(2, 7, 2, 'final', 0) . For CPython they are the same value, since it is the reference implementation.

hexversion is the implementation version in hexadecimal format, like sys.hexversion .

cache_tag is the tag used by the import machinery in the filenames of cached modules. By convention, it would be a composite of the implementation’s name and version, like 'cpython-33' . However, a Python implementation may use some other value if appropriate. If cache_tag is set to None , it indicates that module caching should be disabled.

sys.implementation may contain additional attributes specific to the Python implementation. These non-standard attributes must start with an underscore, and are not described here. Regardless of its contents, sys.implementation will not change during a run of the interpreter, nor between implementation versions. (It may change between Python language versions, however.) See PEP 421 for more information.

The addition of new required attributes must go through the normal PEP process. Voir PEP 421 for more information.

A named tuple that holds information about Python’s internal representation of integers. The attributes are read only.

number of bits held in each digit. Python integers are stored internally in base 2**int_info.bits_per_digit

size in bytes of the C type used to represent a digit

When this attribute exists, its value is automatically called (with no arguments) when the interpreter is launched in interactive mode . This is done after the PYTHONSTARTUP file is read, so that you can set this hook there. The site module sets this .

Raises an auditing event cpython.run_interactivehook with the hook object as the argument when the hook is called on startup.

Enter chaîne de caractères in the table of “interned” strings and return the interned string – which is chaîne de caractères itself or a copy. Interning strings is useful to gain a little performance on dictionary lookup – if the keys in a dictionary are interned, and the lookup key is interned, the key comparisons (after hashing) can be done by a pointer compare instead of a string compare. Normally, the names used in Python programs are automatically interned, and the dictionaries used to hold module, class or instance attributes have interned keys.

Interned strings are not immortal you must keep a reference to the return value of intern() around to benefit from it.

Return True if the Python interpreter is shutting down , False otherwise.

These three variables are not always defined they are set when an exception is not handled and the interpreter prints an error message and a stack traceback. Their intended use is to allow an interactive user to import a debugger module and engage in post-mortem debugging without having to re-execute the command that caused the error. (Typical use is import pdb pdb.pm() to enter the post-mortem debugger see pdb module for more information.)

The meaning of the variables is the same as that of the return values from exc_info() above.

An integer giving the maximum value a variable of type Py_ssize_t can take. It’s usually 2**31 - 1 on a 32-bit platform and 2**63 - 1 on a 64-bit platform.

An integer giving the value of the largest Unicode code point, i.e. 1114111 ( 0x10FFFF in hexadecimal).

Changed in version 3.3: Before PEP 393, sys.maxunicode used to be either 0xFFFF or 0x10FFFF , depending on the configuration option that specified whether Unicode characters were stored as UCS-2 or UCS-4.

A list of meta path finder objects that have their find_spec() methods called to see if one of the objects can find the module to be imported. The find_spec() method is called with at least the absolute name of the module being imported. If the module to be imported is contained in a package, then the parent package’s __path__ attribute is passed in as a second argument. The method returns a module spec , or None if the module cannot be found.

The abstract base class defining the interface of finder objects on meta_path .

The concrete class which find_spec() should return instances of.

Changed in version 3.4: Module specs were introduced in Python 3.4, by PEP 451. Earlier versions of Python looked for a method called find_module() . This is still called as a fallback if a meta_path entry doesn’t have a find_spec() method.

This is a dictionary that maps module names to modules which have already been loaded. This can be manipulated to force reloading of modules and other tricks. However, replacing the dictionary will not necessarily work as expected and deleting essential items from the dictionary may cause Python to fail.

A list of strings that specifies the search path for modules. Initialized from the environment variable PYTHONPATH , plus an installation-dependent default.

As initialized upon program startup, the first item of this list, path[0] , is the directory containing the script that was used to invoke the Python interpreter. If the script directory is not available (e.g. if the interpreter is invoked interactively or if the script is read from standard input), path[0] is the empty string, which directs Python to search modules in the current directory first. Notice that the script directory is inserted before the entries inserted as a result of PYTHONPATH .

A program is free to modify this list for its own purposes. Only strings and bytes should be added to sys.path all other data types are ignored during import.

Module site This describes how to use .pth files to extend sys.path .

A list of callables that take a path argument to try to create a finder for the path. If a finder can be created, it is to be returned by the callable, else raise ImportError .

A dictionary acting as a cache for finder objects. The keys are paths that have been passed to sys.path_hooks and the values are the finders that are found. If a path is a valid file system path but no finder is found on sys.path_hooks then None is stored.

Changed in version 3.3: None is stored instead of imp.NullImporter when no finder is found.

This string contains a platform identifier that can be used to append platform-specific components to sys.path , for instance.

For Unix systems, except on Linux and AIX, this is the lowercased OS name as returned by uname -s with the first part of the version as returned by uname -r appended, e.g. 'sunos5' or 'freebsd8' , at the time when Python was built. Unless you want to test for a specific system version, it is therefore recommended to use the following idiom:

For other systems, the values are:

Changed in version 3.3: On Linux, sys.platform doesn’t contain the major version anymore. It is always 'linux' , instead of 'linux2' or 'linux3' . Since older Python versions include the version number, it is recommended to always use the startswith idiom presented above.

Changed in version 3.8: On AIX, sys.platform doesn’t contain the major version anymore. It is always 'aix' , instead of 'aix5' or 'aix7' . Since older Python versions include the version number, it is recommended to always use the startswith idiom presented above.

os.name has a coarser granularity. os.uname() gives system-dependent version information.

The platform module provides detailed checks for the system’s identity.

Name of the platform-specific library directory. It is used to build the path of standard library and the paths of installed extension modules.

It is equal to "lib" on most platforms. On Fedora and SuSE, it is equal to "lib64" on 64-bit platforms which gives the following sys.path paths (where X.Y is the Python major.minor version):

/usr/lib64/pythonX.Y/ : Standard library (like os.py of the os module)

/usr/lib64/pythonX.Y/lib-dynload/ : C extension modules of the standard library (like the errno module, the exact filename is platform specific)

/usr/lib/pythonX.Y/site-packages/ (always use lib , not sys.platlibdir ): Third-party modules

/usr/lib64/pythonX.Y/site-packages/ : C extension modules of third-party packages

A string giving the site-specific directory prefix where the platform independent Python files are installed by default, this is the string '/usr/local' . This can be set at build time with the --prefix argument to the configure script. The main collection of Python library modules is installed in the directory prefix /lib/python X.Y while the platform independent header files (all except pyconfig.h ) are stored in prefix /include/python X.Y , où X.Y is the version number of Python, for example 3.2 .

If a virtual environment is in effect, this value will be changed in site.py to point to the virtual environment. The value for the Python installation will still be available, via base_prefix .

Strings specifying the primary and secondary prompt of the interpreter. These are only defined if the interpreter is in interactive mode. Their initial values in this case are '>>> ' and '. '. If a non-string object is assigned to either variable, its str() is re-evaluated each time the interpreter prepares to read a new interactive command this can be used to implement a dynamic prompt.

Set the flags used by the interpreter for dlopen() calls, such as when the interpreter loads extension modules. Among other things, this will enable a lazy resolving of symbols when importing a module, if called as sys.setdlopenflags(0) . To share symbols across extension modules, call as sys.setdlopenflags(os.RTLD_GLOBAL) . Symbolic names for the flag values can be found in the os module ( RTLD_xxx constants, e.g. os.RTLD_LAZY ).

sys. setprofile ( profilefunc ) ¶

Set the system’s profile function, which allows you to implement a Python source code profiler in Python. See chapter The Python Profilers for more information on the Python profiler. The system’s profile function is called similarly to the system’s trace function (see settrace() ), but it is called with different events, for example it isn’t called for each executed line of code (only on call and return, but the return event is reported even when an exception has been set). The function is thread-specific, but there is no way for the profiler to know about context switches between threads, so it does not make sense to use this in the presence of multiple threads. Also, its return value is not used, so it can simply return None . Error in the profile function will cause itself unset.

Profile functions should have three arguments: frame, event, et arg. frame is the current stack frame. event is a string: 'call' , 'return' , 'c_call' , 'c_return' , or 'c_exception' . arg depends on the event type.

Raises an auditing event sys.setprofile with no arguments.

The events have the following meaning:

A function is called (or some other code block entered). The profile function is called arg is None .

A function (or other code block) is about to return. The profile function is called arg is the value that will be returned, or None if the event is caused by an exception being raised.

A C function is about to be called. This may be an extension function or a built-in. arg is the C function object.

A C function has returned. arg is the C function object.

A C function has raised an exception. arg is the C function object.

sys. setrecursionlimit ( limite ) ¶

Set the maximum depth of the Python interpreter stack to limite. This limit prevents infinite recursion from causing an overflow of the C stack and crashing Python.

The highest possible limit is platform-dependent. A user may need to set the limit higher when they have a program that requires deep recursion and a platform that supports a higher limit. This should be done with care, because a too-high limit can lead to a crash.

If the new limit is too low at the current recursion depth, a RecursionError exception is raised.

Changed in version 3.5.1: A RecursionError exception is now raised if the new limit is too low at the current recursion depth.

Set the interpreter’s thread switch interval (in seconds). This floating-point value determines the ideal duration of the “timeslices” allocated to concurrently running Python threads. Please note that the actual value can be higher, especially if long-running internal functions or methods are used. Also, which thread becomes scheduled at the end of the interval is the operating system’s decision. The interpreter doesn’t have its own scheduler.

Set the system’s trace function, which allows you to implement a Python source code debugger in Python. The function is thread-specific for a debugger to support multiple threads, it must register a trace function using settrace() for each thread being debugged or use threading.settrace() .

Trace functions should have three arguments: frame, event, et arg. frame is the current stack frame. event is a string: 'call' , 'line' , 'return' , 'exception' or 'opcode' . arg depends on the event type.

The trace function is invoked (with event set to 'call' ) whenever a new local scope is entered it should return a reference to a local trace function to be used for the new scope, or None if the scope shouldn’t be traced.

The local trace function should return a reference to itself (or to another function for further tracing in that scope), or None to turn off tracing in that scope.

If there is any error occurred in the trace function, it will be unset, just like settrace(None) is called.

The events have the following meaning:

A function is called (or some other code block entered). The global trace function is called arg is None the return value specifies the local trace function.

The interpreter is about to execute a new line of code or re-execute the condition of a loop. The local trace function is called arg is None the return value specifies the new local trace function. See Objects/lnotab_notes.txt for a detailed explanation of how this works. Per-line events may be disabled for a frame by setting f_trace_lines to False on that frame.

A function (or other code block) is about to return. The local trace function is called arg is the value that will be returned, or None if the event is caused by an exception being raised. The trace function’s return value is ignored.

An exception has occurred. The local trace function is called arg is a tuple (exception, value, traceback) the return value specifies the new local trace function.

The interpreter is about to execute a new opcode (see dis for opcode details). The local trace function is called arg is None the return value specifies the new local trace function. Per-opcode events are not emitted by default: they must be explicitly requested by setting f_trace_opcodes to True on the frame.

Note that as an exception is propagated down the chain of callers, an 'exception' event is generated at each level.

For more fine-grained usage, it’s possible to set a trace function by assigning frame.f_trace = tracefunc explicitly, rather than relying on it being set indirectly via the return value from an already installed trace function. This is also required for activating the trace function on the current frame, which settrace() doesn’t do. Note that in order for this to work, a global tracing function must have been installed with settrace() in order to enable the runtime tracing machinery, but it doesn’t need to be the same tracing function (e.g. it could be a low overhead tracing function that simply returns None to disable itself immediately on each frame).

For more information on code and frame objects, refer to The standard type hierarchy .

Raises an auditing event sys.settrace with no arguments.

CPython implementation detail: The settrace() function is intended only for implementing debuggers, profilers, coverage tools and the like. Its behavior is part of the implementation platform, rather than part of the language definition, and thus may not be available in all Python implementations.

Changed in version 3.7: 'opcode' event type added f_trace_lines and f_trace_opcodes attributes added to frames

Accepts two optional keyword arguments which are callables that accept an asynchronous generator iterator as an argument. Le firstiter callable will be called when an asynchronous generator is iterated for the first time. Le finalizer will be called when an asynchronous generator is about to be garbage collected.

Raises an auditing event sys.set_asyncgen_hooks_firstiter with no arguments.

Raises an auditing event sys.set_asyncgen_hooks_finalizer with no arguments.

Two auditing events are raised because the underlying API consists of two calls, each of which must raise its own event.

New in version 3.6: See PEP 525 for more details, and for a reference example of a finalizer method see the implementation of asyncio.Loop.shutdown_asyncgens in Lib/asyncio/base_events.py

This function has been added on a provisional basis (see PEP 411 for details.)

Allows enabling or disabling coroutine origin tracking. When enabled, the cr_origin attribute on coroutine objects will contain a tuple of (filename, line number, function name) tuples describing the traceback where the coroutine object was created, with the most recent call first. When disabled, cr_origin will be None.

To enable, pass a depth value greater than zero this sets the number of frames whose information will be captured. To disable, pass set depth to zero.

This setting is thread-specific.

This function has been added on a provisional basis (see PEP 411 for details.) Use it only for debugging purposes.

Changes the default filesystem encoding and errors mode to ‘mbcs’ and ‘replace’ respectively, for consistency with versions of Python prior to 3.6.

This is equivalent to defining the PYTHONLEGACYWINDOWSFSENCODING environment variable before launching Python.

New in version 3.6: See PEP 529 for more details.

File objects used by the interpreter for standard input, output and errors:

stdin is used for all interactive input (including calls to input() )

stdout is used for the output of print() and expression statements and for the prompts of input()

The interpreter’s own prompts and its error messages go to stderr .

These streams are regular text files like those returned by the open() function. Their parameters are chosen as follows:

The character encoding is platform-dependent. Non-Windows platforms use the locale encoding (see locale.getpreferredencoding() ).

On Windows, UTF-8 is used for the console device. Non-character devices such as disk files and pipes use the system locale encoding (i.e. the ANSI codepage). Non-console character devices such as NUL (i.e. where isatty() returns True ) use the value of the console input and output codepages at startup, respectively for stdin and stdout/stderr. This defaults to the system locale encoding if the process is not initially attached to a console.

The special behaviour of the console can be overridden by setting the environment variable PYTHONLEGACYWINDOWSSTDIO before starting Python. In that case, the console codepages are used as for any other character device.

Under all platforms, you can override the character encoding by setting the PYTHONIOENCODING environment variable before starting Python or by using the new -X utf8 command line option and PYTHONUTF8 environment variable. However, for the Windows console, this only applies when PYTHONLEGACYWINDOWSSTDIO is also set.

When interactive, the stdout stream is line-buffered. Otherwise, it is block-buffered like regular text files. The stderr stream is line-buffered in both cases. You can make both streams unbuffered by passing the -u command-line option or setting the PYTHONUNBUFFERED environment variable.

Changed in version 3.9: Non-interactive stderr is now line-buffered instead of fully buffered.

To write or read binary data from/to the standard streams, use the underlying binary buffer object. For example, to write bytes to stdout , use sys.stdout.buffer.write(b'abc') .

However, if you are writing a library (and do not control in which context its code will be executed), be aware that the standard streams may be replaced with file-like objects like io.StringIO which do not support the buffer attribute.

These objects contain the original values of stdin , stderr and stdout at the start of the program. They are used during finalization, and could be useful to print to the actual standard stream no matter if the sys.std* object has been redirected.

It can also be used to restore the actual files to known working file objects in case they have been overwritten with a broken object. However, the preferred way to do this is to explicitly save the previous stream before replacing it, and restore the saved object.

Under some conditions stdin , stdout and stderr as well as the original values __stdin__ , __stdout__ and __stderr__ can be None . It is usually the case for Windows GUI apps that aren’t connected to a console and Python apps started with pythonw.

A named tuple holding information about the thread implementation.

Name of the thread implementation:

  • 'nt' : Windows threads

  • 'pthread' : POSIX threads

  • 'solaris' : Solaris threads

Name of the lock implementation:

  • 'semaphore' : a lock uses a semaphore

  • 'mutex+cond' : a lock uses a mutex and a condition variable

  • None if this information is unknown

Name and version of the thread library. It is a string, or None if this information is unknown.

When this variable is set to an integer value, it determines the maximum number of levels of traceback information printed when an unhandled exception occurs. The default is 1000 . When set to 0 or less, all traceback information is suppressed and only the exception type and value are printed.

sys. unraisablehook ( unraisable, / ) ¶

Handle an unraisable exception.

Called when an exception has occurred but there is no way for Python to handle it. For example, when a destructor raises an exception or during garbage collection ( gc.collect() ).

Le unraisable argument has the following attributes:

exc_value: Exception value, can be None .

exc_traceback: Exception traceback, can be None .

err_msg: Error message, can be None .

objet: Object causing the exception, can be None .

The default hook formats err_msg et objet as: f': ' use “Exception ignored in” error message if err_msg is None .

sys.unraisablehook() can be overridden to control how unraisable exceptions are handled.

Storing exc_value using a custom hook can create a reference cycle. It should be cleared explicitly to break the reference cycle when the exception is no longer needed.

Storing objet using a custom hook can resurrect it if it is set to an object which is being finalized. Avoid storing objet after the custom hook completes to avoid resurrecting objects.

See also excepthook() which handles uncaught exceptions.

Raise an auditing event sys.unraisablehook with arguments hook , unraisable when an exception that cannot be handled occurs. The unraisable object is the same as what will be passed to the hook. If no hook has been set, hook may be None .

A string containing the version number of the Python interpreter plus additional information on the build number and compiler used. This string is displayed when the interactive interpreter is started. Do not extract version information out of it, rather, use version_info and the functions provided by the platform module.

The C API version for this interpreter. Programmers may find this useful when debugging version conflicts between Python and extension modules.

A tuple containing the five components of the version number: major, minor, micro, releaselevel, et serial. All values except releaselevel are integers the release level is 'alpha' , 'beta' , 'candidate' , or 'final' . The version_info value corresponding to the Python version 2.0 is (2, 0, 0, 'final', 0) . The components can also be accessed by name, so sys.version_info[0] is equivalent to sys.version_info.major and so on.

Changed in version 3.1: Added named component attributes.

This is an implementation detail of the warnings framework do not modify this value. Refer to the warnings module for more information on the warnings framework.

The version number used to form registry keys on Windows platforms. This is stored as string resource 1000 in the Python DLL. The value is normally the first three characters of version . It is provided in the sys module for informational purposes modifying this value has no effect on the registry keys used by Python.

A dictionary of the various implementation-specific flags passed through the -X command-line option. Option names are either mapped to their values, if given explicitly, or to True . Exemple:

CPython implementation detail: This is a CPython-specific way of accessing options passed through -X . Other implementations may export them through other means, or not at all.


1 respuesta 1

Claro que se pueden eliminar métodos en python. Un método no es más que un atributo y como indicas en la pregunta es una especie de "apuntador" al código de la función.

Una función es en el fondo un objeto (de un tipo especial "llamable") y el nombre de la función no es más que un símbolo que apunta a la función. Cuando borras ese símbolo con del simbolo , simplemente "rompes" la conexión que había entre ese símbolo y el objeto al que apuntaba. El objeto queda indefinido (que no es lo mismo que con valor None ), y un intento de acceder a ese símbolo dará error:

El símbolo f ha dejado de existir, pero el objeto (función) al que apuntaba quizás no. En particular, si tienes otro símbolo apuntando al mismo objeto, el objeto seguirá existiendo:

Como ves, del f no elimina la función en sí, sino sólo al símbolo f que apuntaba a la función. La función aún existe y puede ser llamada a través del símbolo g . Sólo cuando todos los símbolos que apuntaban a ese objeto desaparecen, el objeto es finalmente eliminado de memoria por el recolector de basura.


Voir la vidéo: Mikä on väkivaltaa? 22