Suite

Utilisation d'un bloc de code de fonction défini avec Python dans ArcGIS


J'exécute un calcul de champ dans un script Python dans ArcGIS. Dans ce calcul de champ, j'appelle une fonction définie dans un bloc de code.

Voici le dialogue que j'ai lancé et qui fonctionne :

Cela a fonctionné. Cependant, je n'arrive pas à traduire ceci dans mon code Python :

Voici le code :

#Calculer l'expression YSLB = "output(!MTH_BRNT!,!YR_BRNT!,!YSLB!)" code_block = "def output(MTH_BRNT,YR_BRNT,YSLB):/n mois = str(month_val)/n month_current = int(month) /n month_fire = int(MTH_BRNT)/n year = str(high_year)/n year_current = int(year)/n year_fire = int(YR_BRNT)/n Mc = (12*(year_current-1)) + month_current/n Mf = (12*(year_fire-1)) + month_fire/n return (Mc-Mf)/12" arcpy.CalculateField_management(fuel_age_out,"YSLB",expression,"PYTHON_9.3",code_block)

J'ai déjà rencontré ce problème. Essayez d'utiliser """ au lieu de " au-dessus de l'expression.

Sinon, essayez celui-ci :

code_block = """def output(MTH_BRNT,YR_BRNT,YSLB): month = str(month_val) month_current = int(month)/n month_fire = int(MTH_BRNT) year = str(high_year)/n year_current = int(year) year_fire = int(YR_BRNT) Mc = (12*(year_current-1)) + month_current Mf = (12*(year_fire-1)) + month_fire return (Mc-Mf)/12"""

parfois python ne reconnaît pas le


En Python, un bloc est une fonctionnalité syntaxique (une indentation sous les instructions d'ouverture de bloc comme if ou def) et non un objet. La fonctionnalité que vous attendez peut être une fermeture (qui peut accéder à des variables en dehors du bloc), que vous pouvez réaliser en utilisant des fonctions internes, mais n'importe quel appelable peut être utilisé. En raison du fonctionnement de lambda en Python, la définition de fonction en ligne que vous avez montrée avec do |arg| est limité à une seule expression.

Voici une réécriture approximative de votre exemple de code en Python.

Une variante utilise une boucle for pour indiquer clairement que la boucle est finie :

Fréquemment, lorsque vous passez des callables comme celui-ci, vous aurez déjà la fonction que vous voulez disponible quelque part et vous n'aurez pas besoin de la redéfinir. Par exemple, les méthodes sur les objets (méthodes liées) sont des callables parfaitement valides.


Méthodes

Marque le paramètre comme ayant une erreur (un X rouge) avec le message fourni. Les outils ne s'exécutent pas si l'un des paramètres comporte une erreur.

Marque le paramètre comme ayant un avertissement (un triangle jaune) avec le message fourni. Contrairement aux erreurs, les outils s'exécutent avec des messages d'avertissement.

setIDMessage(messageType : chaîne, messageID : chaîne, , )

Vous permet de définir un message système. Les arguments sont les mêmes que la fonction AddIDMessage.

Efface tout texte de message et définit le statut sur informatif (pas d'erreur ni d'avertissement).

Renvoie true si le paramètre contient une erreur.

Renvoie true si le paramètre contient un avertissement.

Renvoie vrai si l'outil est en cours de validation dans un modèle et que la valeur d'entrée est la sortie d'un autre outil du modèle.

Propriétés

Sens d'entrée/sortie du paramètre.

Chaîne : "Obligatoire", "Facultatif", "Dérivé"

Une liste d'index de chaque paramètre dépendant.

La valeur du paramètre.

False si le paramètre n'est pas disponible.

True si l'utilisateur a modifié la valeur.

Vrai si la routine de validation interne a vérifié le paramètre.

La catégorie du paramètre.

Le schéma de l'ensemble de données de sortie.

Le filtre à appliquer aux valeurs du paramètre.

Le chemin d'accès à un fichier de couche ( .lyr ) utilisé pour dessiner la sortie.

Le message à afficher à l'utilisateur. Voir SetErrorMessage et SetWarningMessage ci-dessus.

ParamètreDépendances

Vous définissez généralement des dépendances de paramètres à utiliser par l'objet Schema. Il existe deux cas où les dépendances peuvent déjà être définies dans la méthode getParameterInfo de l'outil.

  • Pour un paramètre d'ensemble de données de sortie dont le type est Dérivé, la dépendance est l'index du paramètre à partir duquel dériver la sortie.
  • Pour certains types de données d'entrée, la dépendance est l'index du paramètre contenant les informations utilisées par le contrôle, comme indiqué dans le tableau ci-dessous.

La table contenant les champs.

Élément INFO ou expression INFO

La table INFO contenant les éléments.

La couverture contenant les caractéristiques.

Unités de surface ou unités linéaires

Un jeu de données géographiques utilisé pour déterminer les unités par défaut.

Un espace de travail utilisé pour déterminer le système de coordonnées par défaut.

Paramètres de hiérarchie Network Analyst

Le jeu de données réseau contenant des informations de hiérarchie.

Tableau des valeurs géostatistiques

La couche d'analyse contenant les tables.

paramètreDependencies est équivalent au paramètre Obtenu à partir de l'assistant de l'outil de script.

Les dépendances sont généralement définies dans la méthode getParameterInfo :

Valeur

Il s'agit de la valeur du paramètre que l'utilisateur a saisie ou que vous avez définie par programmation. Vous pouvez définir la valeur dans la méthode getParameterInfo, auquel cas elle sert de valeur par défaut initiale pour le paramètre. Vous pouvez également définir la valeur dans updateParameters en réponse à l'entrée de l'utilisateur, comme indiqué ci-dessous.

La propriété value d'un paramètre renvoie un objet, sauf si le paramètre n'est pas renseigné, auquel cas la valeur renvoie None . Pour éviter qu'un paramètre ne soit renseigné, utilisez une vérification if avant d'utiliser sa valeur.

L'extrait de code ci-dessous teste si la valeur est égale à la chaîne « Get Spatial Weights From File ». Ce test fonctionne car le type de données du paramètre est une chaîne.

Comme un objet Value ne prend pas en charge la manipulation de chaîne, utilisez la propriété value de l'objet Value chaque fois qu'une chaîne doit être manipulée ou analysée. L'exemple de code utilise la méthode os.path.dirname pour renvoyer le répertoire à partir d'un ensemble de données.

À l'exception de Describe , n'utilisez pas de méthodes qui prennent un chemin de catalogue, tel que ListFields , dans la validation. L'ensemble de données peut ne pas exister lorsque votre outil est validé dans ModelBuilder, et la méthode peut échouer ou donner des résultats inattendus.

Dans le cas particulier de ListFields , la propriété field de l'objet Describe fournira les informations équivalentes.

Ne définissez pas de valeur de paramètre dans updateMessages() car la valeur ne sera pas validée par la routine de validation interne.

Altéré

modifié est vrai si l'utilisateur a modifié la valeur d'un paramètre, en entrant un chemin de sortie, par exemple. Une fois qu'un paramètre a été modifié, il reste modifié jusqu'à ce que l'utilisateur vide (efface) la valeur, auquel cas il redevient inchangé. La modification par programmation d'une valeur avec un code de validation ne modifie pas l'état modifié. Autrement dit, si vous définissez une valeur pour un paramètre, l'état modifié du paramètre ne change pas.

modifié est utilisé pour déterminer si vous pouvez modifier la valeur d'un paramètre. Par exemple, supposons qu'un outil possède un paramètre de classe d'entités et un paramètre de mot-clé. Si la classe d'entités contient des points ou des polygones, les mots-clés sont ROUGE, VERT et BLEU, et si lignes, ORANGE, JAUNE, VIOLET et BLANC.

Supposons que l'utilisateur entre une classe d'entités points. Si le paramètre de mot-clé n'est pas modifié, vous définissez la valeur sur ROUGE, car il s'agit de la valeur par défaut.

Si une classe d'entités linéaires est entrée, vous définissez la valeur par défaut sur ORANGE tant que le paramètre de mot-clé n'est pas modifié.

Cependant, si le paramètre de mot-clé a été modifié par l'utilisateur (c'est-à-dire que le mot-clé est défini sur VERT), vous ne devez pas réinitialiser le mot-clé — l'utilisateur a fait son choix (VERT) et vous ne connaissez pas son intention — il peuvent changer la classe d'entités pour que GREEN soit valide ou ils peuvent changer le mot-clé (en VIOLET, par exemple). Étant donné que GREEN n'est pas membre de l'ensemble de mots-clés que vous avez créés pour les lignes, la validation interne signale une erreur au paramètre. L'utilisateur a deux options à ce stade : modifier la classe d'entités en entrée ou modifier le mot-clé.

A été validé

hasBeenValidated est false si la valeur d'un paramètre a été modifiée par l'utilisateur depuis le dernier appel de updateParameters et de validation interne. Une fois la validation interne appelée, le géotraitement définit automatiquement hasBeenValidated sur true pour chaque paramètre.

hasBeenValidated est utilisé pour déterminer si l'utilisateur a modifié une valeur depuis le dernier appel à updateParameters . Vous pouvez utiliser ces informations pour décider si vous souhaitez effectuer votre propre vérification du paramètre.


Flux de contrôle en Python

L'une des caractéristiques les plus distinctives de Python est son utilisation de l'indentation pour marquer des blocs de code. Considérez l'instruction if de notre simple programme de vérification de mot de passe :

Les lignes print('Connexion . ') et print('Mot de passe incorrect.') sont deux séparés blocs de code. Ceux-ci ne font qu'une seule ligne, mais Python vous permet d'écrire des blocs de code composés d'un nombre quelconque d'instructions.

Pour indiquer un bloc de code en Python, vous devez indenter chaque ligne du bloc du même montant. Les deux blocs de code de notre exemple d'instruction if sont tous deux indentés de quatre espaces, ce qui est une quantité typique d'indentation pour Python.

Dans la plupart des autres langages de programmation, l'indentation n'est utilisée que pour rendre le code joli. Mais en Python, il est nécessaire pour indiquer à quel bloc de code appartient une instruction. Par exemple, la finale print('Tout est fait !') est ne pas en retrait, tout comme ne pas partie du bloc else.

Les programmeurs familiers avec d'autres langages se hérissent souvent à l'idée que l'indentation est importante : de nombreux programmeurs aiment la liberté de formater leur code à leur guise. Cependant, les règles d'indentation Python sont assez simples et la plupart des programmeurs utilisent déjà l'indentation pour rendre leur code lisible. Python pousse simplement cette idée un peu plus loin et donne un sens à l'indentation.

  • IDLE est conçu pour indenter automatiquement le code pour vous. Par exemple, appuyer sur Retour après avoir tapé le : dans un en-tête if indente automatiquement le curseur sur la ligne suivante.
  • La quantité d'indentation est importante : un espace manquant ou supplémentaire dans un bloc Python peut provoquer une erreur ou un comportement inattendu. Les instructions dans le même bloc de code doivent être indentées au même niveau.

Si/elif-déclarations

Une instruction if/elif est une instruction if généralisée avec plusieurs conditions. Il est utilisé pour prendre des décisions complexes. Par exemple, supposons qu'une compagnie aérienne propose les tarifs de billets « enfants » suivants : les enfants de 2 ans ou moins voyagent gratuitement, les enfants de plus de 2 ans mais de moins de 13 ans paient un tarif enfant tarif adulte. Le programme suivant détermine combien un passager doit payer :

Une fois que Python obtient âge de l'utilisateur, il entre l'instruction if/elif et vérifie chaque condition l'une après l'autre dans l'ordre où elles sont données. Donc d'abord il vérifie si âge est inférieur à 2, et si c'est le cas, cela indique que le vol est libre et sort de la condition elif. Si âge n'est pas inférieur à 2, alors il vérifie la prochaine condition elif pour voir si âge est compris entre 2 et 13. Si c'est le cas, il imprime le message approprié et sort de l'instruction if/elif. Si ni la condition if ni la condition elif ne sont Vrai, puis il exécute le code dans le bloc else.

  • elif est l'abréviation de sinon si, et vous pouvez utiliser autant de blocs elif que nécessaire.
  • Comme d'habitude, chacun des blocs de code dans une instruction if/elif doit être systématiquement indenté du même montant. Python a non seulement besoin de cette indentation pour pouvoir reconnaître les blocs de code, mais l'indentation cohérente permet aux utilisateurs de reconnaître facilement les conditions if/elif et leurs blocs de code correspondants.
  • Comme pour une instruction if normale, le bloc else est facultatif. Dans une déclaration if/elif avec un bloc else, exactement un des blocs if/elif seront exécutés. S'il n'y a pas de bloc else, alors il est possible qu'aucune des conditions ne soit Vrai, auquel cas aucun des blocs if/elif n'est exécuté.
  • Une instruction if/elif doit avoir exactement un if-block, zéro ou plusieurs elif-blocks, et zéro ou un else-blocks.

Expressions conditionnelles

Python a un opérateur logique de plus que certains programmeurs aiment (et d'autres n'en ont pas !). Il s'agit essentiellement d'une notation abrégée pour les instructions if qui peuvent être utilisées directement dans les expressions. Considérez ce code :

L'expression à droite de = dans la deuxième ligne est appelé un expression conditionnelle, et il évalue soit 'beurk' ou alors 'Miam'. Cela équivaut à ce qui suit :

Les expressions conditionnelles sont généralement plus courtes que les instructions if/else correspondantes, bien qu'elles ne soient pas aussi flexibles ou faciles à lire. En général, vous devriez les utiliser lorsqu'ils simplifient votre code.


7 réponses 7

Il est difficile de voir d'après votre message quel est le problème, mais un if-else est formaté comme suit

C'est-à-dire que l'autre doit être au même niveau comme le si correspondant.

Parfois, lorsque votre éditeur fait une indentation automatique pour vous et que vous modifiez manuellement, les choses peuvent également se gâter, vous devrez donc comprendre comment votre éditeur gère les indentations (par exemple, utilise-t-il toujours des tabulations ou des espaces ?, que se passe-t-il si vous appuyez sur retour etc).

Aussi, méfiez-vous du mélange des tabulations et des espaces, cela posera aussi des problèmes (difficile à repérer car les deux sont "invisibles")

Le else doit être au même niveau d'indentation que le if avec lequel il est couplé :

Même si votre éditeur procède à l'indentation automatique pour vous, vous devez toujours annuler l'indentation pour que le code soit syntaxiquement correct.

Obtenir l'indentation correcte n'est pas vraiment un problème Python mais plutôt un problème avec l'éditeur que vous utilisez pour votre code source.

La plupart des éditeurs qui comprennent Python ajouteront correctement un niveau d'indentation après deux points (comme vous le voyez). Comme vous pouvez avoir autant d'instructions que vous le souhaitez dans ce bloc de code, l'éditeur n'a aucun moyen de savoir quand "outdent"er la ligne suivante pour le else .

Vous devez dire à l'éditeur de dépasser cette ligne en appuyant sur retour arrière ou sur Maj + Tab sur la ligne avant de commencer à taper.

Si vous insérez la partie else après l'écriture du reste du code, assurez-vous absolument que les caractères que vous utilisez pour indenter sont les mêmes que pour l'instruction if. Si l'instruction if est indentée avec des espaces, utilisez le même nombre d'espaces pour else . Si l'instruction if est indentée avec une ou plusieurs tabulations, utilisez le même nombre de tabulations pour l'instruction else. Ne mélangez pas les espaces et les tabulations pour l'indentation.

Ne présumez pas que simplement parce que les lignes "ont l'air" comme si elles étaient en retrait de la même manière qu'elles sommes en retrait de la même manière. On peut utiliser des espaces et on peut utiliser des tabulations (ou une combinaison).


3 réponses 3

Les listes noires simples sont la pire façon de corriger une vulnérabilité. Ils créeront beaucoup de faux positifs et tout attaquant déterminé trouvera généralement un moyen de les contourner.

Les pare-feu d'applications Web en sont un bon exemple. Les règles de détection qu'ils emploient sont bien plus compliquées que votre liste noire simpliste, mais elles n'attrapent pas tout, et de temps en temps, des contournements surviennent pour des choses qu'ils sommes censé attraper.

Je ne vois aucune possibilité d'y échapper.

Ou alors vous pensez. Vous n'avez pas regardé assez longtemps.

Cela navigue directement à travers votre filtre. Il appelle la fonction exec() qui continue ensuite à imprimer 'pwned'.

Vous pouvez maintenant modifier votre liste noire pour l'attraper également, mais quelqu'un d'autre proposera un autre moyen.

99% du temps, je vois quelqu'un utiliser quelque chose comme exec ou eval , c'est complètement inutile. Si vous pouvez éviter d'utiliser exec , faites-vous plaisir et débarrassez-vous de cette vulnérabilité en attente d'être exploitée. Si, toutefois, vous êtes absolument besoin pour utiliser exec , puis faites comme @amon suggéré dans les commentaires : Créez un nouveau tube, fork et supprimez autant de privilèges que possible dans l'enfant, puis exécutez le code. Utilisez le canal pour communiquer entre les processus enfant et parent. Ou bac à sable comme l'a suggéré Steffen Ullrich.


7 exemples de fonctions Python avec paramètres, retours et types de données

Les fonctions sont des extraits de code dans un bloc auquel un nom est attribué. Il prend une entrée, effectue un calcul ou une action et renvoie la sortie.

Les fonctions améliorent la réutilisabilité du code.

Dans ce didacticiel, nous aborderons les exemples suivants :

  1. Exemple de fonction Python de base
  2. Fonctions Python intégrées
  3. Fonctions Python définies par l'utilisateur
  4. Paramètres de fonction Python
  5. Fonction Python Nombre de paramètres inconnu
  6. Valeur de retour de la fonction Python
  7. Type de données pour les paramètres et la valeur de retour

1. Exemple de fonction Python de base

Voici un exemple de fonction python qui prend deux paramètres, calcule la somme et renvoie la valeur calculée.

Il existe deux grandes catégories de fonctions dans Python : les fonctions intégrées et les fonctions définies par l'utilisateur.

2. Fonctions Python intégrées

De nombreuses fonctions sont fournies avec Python, lorsqu'il est installé. L'utilisateur n'a pas à se soucier des définitions des fonctions. print() est l'une des fonctions intégrées les plus couramment utilisées dans Python.

D'autres exemples de telles fonctions sont : len(), str(), int(), abs(), sum(), etc.

Toutes les fonctions intégrées prises en charge par Python3 sont ici.

3. Fonctions Python définies par l'utilisateur

Les fonctions définies par l'utilisateur sont déclarées à l'aide du mot-clé def. Le mot-clé doit être suivi du nom de la fonction.

Dans cette fonction, le montant final est calculé en appliquant un intérêt simple au principal. calculate_si_amount est le nom de la fonction. principal, taux et temps sont les paramètres et la fonction renvoie les données calculées.

Il n'est pas nécessaire qu'une fonction accepte des paramètres et renvoie des valeurs. Il peut soit faire les deux, soit l'un d'eux, soit aucun. Vous trouverez ci-dessous un exemple de fonction qui ne prend aucun paramètre mais renvoie des données.

4. Paramètres de la fonction Python

Une fonction peut avoir des paramètres par défaut.

Dans cette fonction, si l'utilisateur ne donne pas le deuxième paramètre b, il suppose qu'il est 10, mais fournir le premier paramètre est nécessaire.

5. Fonction Python Nombre inconnu de paramètres

REMARQUE : S'il y a, disons, 4 paramètres dans une fonction et qu'une valeur par défaut est définie pour le 2e, alors le 3e et le 4e paramètre doivent également recevoir une valeur par défaut.

Si le nombre de paramètres auxquels une fonction doit s'attendre est inconnu, alors *args est ajouté à la définition de la fonction comme l'un des paramètres. Ce paramètre attend un tuple. L'astérisque (*) est important ici. Le nom args est juste une convention. On peut lui donner n'importe quel autre nom.

De même, **kwargs attend un dictionnaire comme paramètre.

L'extrait de code ci-dessus fait référence à la boucle for. Reportez-vous à ceci pour plus de détails : 12 exemples de commandes Python For Loop essentielles

6. Valeur de retour de la fonction Python

Python permet à la fonction de renvoyer plusieurs valeurs.

Ici, deux valeurs sont renvoyées. Lorsque cette fonction est appelée, les valeurs de retour sont stockées dans deux variables, simultanément.

REMARQUE : si une fonction ne renvoie rien, elle renvoie implicitement None.

7. Type de données pour les paramètres et la valeur de retour

La définition des types de données pour les paramètres de fonction et la valeur de retour peut être utilisée pour informer l'utilisateur des attentes des fonctions.

La définition de la fonction indique qu'elle a besoin d'un paramètre de type int et renverra deux valeurs de type int et list respectivement.


L'utilisation des ressources¶

Ces fonctions sont utilisées pour récupérer des informations sur l'utilisation des ressources :

Cette fonction renvoie un objet qui décrit les ressources consommées soit par le processus en cours, soit par ses enfants, comme spécifié par le qui paramètre. Le qui doit être spécifié à l'aide de l'une des constantes RUSAGE_* décrites ci-dessous.

Les champs de la valeur de retour décrivent chacun comment une ressource système particulière a été utilisée, par ex. le temps d'exécution est en mode utilisateur ou le nombre de fois où le processus a été extrait de la mémoire principale. Certaines valeurs dépendent du top d'horloge interne, par ex. la quantité de mémoire utilisée par le processus.

Pour une compatibilité descendante, la valeur de retour est également accessible sous la forme d'un tuple de 16 éléments.

Les champs ru_utime et ru_stime de la valeur de retour sont des valeurs à virgule flottante représentant respectivement le temps passé à exécuter en mode utilisateur et le temps passé à exécuter en mode système. Les valeurs restantes sont des nombres entiers. Consultez le getusage(2) page de manuel pour des informations détaillées sur ces valeurs. Un bref résumé est présenté ici :


Utilisation d'un bloc de code de fonction défini avec Python dans ArcGIS - Systèmes d'information géographique

Se préparer à la technologie entretiens ?

Apprendre des meilleurs
instructeurs sur le terrain.


Cette page vous guidera sur la façon de déchiffrer n'importe quel entretien de programmation python, notamment :

1. Questions d'entretien Python dans le monde réel posées dans des entreprises comme Microsoft, Google, Amazon et comment y répondre (ce qui vous fait gagner du temps de préparation à l'entretien).

2. Problèmes de pratique Python que vous pouvez résoudre tout de suite.

1. Qu'est-ce que Python ?

Python est un langage de programmation généraliste interprété de haut niveau. Étant un langage à usage général, il peut être utilisé pour créer presque n'importe quel type d'application avec les bons outils/bibliothèques. De plus, python prend en charge les objets, les modules, les threads, la gestion des exceptions et la gestion automatique de la mémoire qui aident à modéliser des problèmes du monde réel et à créer des applications pour résoudre ces problèmes.

2. Quels sont les avantages d'utiliser Python ?

Python est un langage de programmation à usage général doté d'une syntaxe simple et facile à apprendre qui met l'accent sur la lisibilité et réduit donc le coût de maintenance du programme. De plus, le langage est capable de scripter, entièrement open source et prend en charge des packages tiers encourageant la modularité et la réutilisation du code.
Ses structures de données de haut niveau, combinées au typage dynamique et à la liaison dynamique, attirent une vaste communauté de développeurs pour le développement et le déploiement rapides d'applications.

3. Qu'est-ce qu'un langage à typage dynamique ?

Avant de comprendre ce qu'est un langage à typage dynamique, nous devons apprendre ce qu'est le typage. Dactylographie fait référence à la vérification de type dans les langages de programmation. Dans un fortement typé langage, tel que Python, "1" + 2 entraînera une erreur de type, car ces langages ne permettent pas "type-coercition" (conversion implicite des types de données). D'autre part, un faiblement typé langage, tel que Javascript, affichera simplement "12" à la suite.

  • Statique - Les types de données sont vérifiés avant l'exécution.
  • Dynamique - Les types de données sont vérifiés pendant l'exécution.

4. Qu'est-ce qu'une langue interprétée ?

Une Interprété le langage exécute ses instructions ligne par ligne. Des langages tels que Python, Javascript, R, PHP et Ruby sont d'excellents exemples de langages interprétés. Les programmes écrits dans un langage interprété s'exécutent directement à partir du code source, sans étape de compilation intermédiaire.

5. Qu'est-ce que la PEP 8 et pourquoi est-elle importante ?

PEP signifie Proposition d'amélioration Python. Un PEP est un document de conception officiel fournissant des informations à la communauté Python ou décrivant une nouvelle fonctionnalité pour Python ou ses processus. PPE 8 est particulièrement important car il documente les directives de style pour le code Python. Apparemment, contribuer à la communauté open source Python vous oblige à suivre ces directives de style sincèrement et strictement.

6. Comment la mémoire est-elle gérée en Python ?

La gestion de la mémoire en Python est gérée par le Gestionnaire de mémoire Python. La mémoire allouée par le gestionnaire se présente sous la forme d'un espace de stockage privé dédié à Python. Tous les objets Python sont stockés dans ce tas et étant privé, il est inaccessible au programmeur. Cependant, python fournit certaines fonctions API de base pour travailler sur l'espace de tas privé.
De plus, Python dispose d'un ramasse-miettes intégré pour recycler la mémoire inutilisée pour l'espace de tas privé.

7. Que sont les espaces de noms Python ? Pourquoi sont-ils utilisés ?

  • Espace de noms local inclut des noms locaux à l'intérieur d'une fonction. l'espace de noms est temporairement créé pour un appel de fonction et est effacé lorsque la fonction revient.
  • Espace de noms global inclut les noms de divers packages/modules importés qui sont utilisés dans le projet en cours. Cet espace de noms est créé lorsque le package est importé dans le script et dure jusqu'à l'exécution du script.
  • Espace de noms intégré inclut des fonctions intégrées du noyau Python et des noms intégrés pour divers types d'exceptions.

8. Qu'est-ce que la portée en Python ?

  • UNE portée locale fait référence aux objets locaux disponibles dans la fonction courante.
  • UNE portée mondiale fait référence aux objets disponibles lors de l'exécution du code depuis leur création.
  • UNE portée au niveau du module fait référence aux objets globaux du module courant accessibles dans le programme.
  • Une portée la plus externe fait référence à tous les noms intégrés appelables dans le programme. Les objets de cette étendue sont recherchés en dernier pour trouver le nom référencé.

9. Qu'est-ce que la résolution de portée en Python ?

  • Les modules Python à savoir 'math' et 'cmath' ont beaucoup de fonctions qui leur sont communes - log10() , acos() , exp() etc. Pour résoudre cette amiguïté, il est nécessaire de les préfixer avec leur module, comme math.exp() et cmath.exp() .
  • Considérez le code ci-dessous, un objet temp a été initialisé à 10 globalement, puis à 20 lors de l'appel de fonction. Cependant, l'appel de fonction n'a pas modifié la valeur de temp globalement. Ici, nous pouvons observer que Python trace une ligne claire entre les variables globales et locales en traitant leurs deux espaces de noms comme des identités distinctes.

Ce comportement peut être remplacé à l'aide du mot clé global à l'intérieur de la fonction, comme illustré dans l'exemple suivant :

10. Que sont les décorateurs en Python ?

Décorateurs en Python sont essentiellement des fonctions qui ajoutent des fonctionnalités à une fonction existante en Python sans modifier la structure de la fonction elle-même. Ils sont représentés par le @decorator_name en Python et sont appelés de manière ascendante. Par exemple:

La beauté des décorateurs réside dans le fait qu'en plus d'ajouter des fonctionnalités à la sortie de la méthode, ils peuvent même accepter les arguments pour les fonctions et peut encore modifier ces arguments avant de les transmettre à la fonction elle-même. Le fonction imbriquée interne, c'est-à-dire la fonction « wrapper », joue ici un rôle important. Il est mis en œuvre pour faire respecter encapsulation et ainsi, se tenir caché de la portée globale.

11. Que sont les listes et les tuples ? Quelle est la principale différence entre les deux ?

Listes et Tuples sont tous les deux types de données de séquence qui peut stocker une collection d'objets en Python. Les objets stockés dans les deux séquences peuvent avoir différents types de données. Les listes sont représentées par crochets ['sara', 6, 0.19] , tandis que les tuples sont représentés avec parenthèses (« ansh », 5, 0,97) .
Mais quelle est la vraie différence entre les deux ? La principale différence entre les deux est que tandis que les listes sont modifiables, tuples d'autre part sont immuables objets. Cela signifie que les listes peuvent être modifiées, ajoutées ou découpées à la volée, mais les tuples restent constants et ne peuvent être modifiés de quelque manière que ce soit. Vous pouvez exécuter l'exemple suivant sur Python IDLE pour confirmer la différence :

12. Que sont les compréhensions Dic et List ?

Les compréhensions Python, comme les décorateurs, sont sucre syntaxique des constructions qui aident build modifié et filtré listes, dictionnaires ou ensembles à partir d'une liste, d'un dictionnaire ou d'un ensemble donné. L'utilisation de compréhensions permet d'économiser beaucoup de temps et de code qui peut être considérablement plus détaillé (contenant plus de lignes de code). Voyons quelques exemples, où les compréhensions peuvent être vraiment bénéfiques :

  • Effectuer des opérations mathématiques sur toute la liste
  • Effectuer des opérations de filtrage conditionnel sur toute la liste
  • Combiner plusieurs listes en une seule
    Les compréhensions permettent plusieurs itérateurs et peuvent donc être utilisées pour combiner plusieurs listes en une seule.
  • Aplatir une liste multidimensionnelle
    Une approche similaire d'itérateurs imbriqués (comme ci-dessus) peut être appliquée pour aplatir une liste multidimensionnelle ou travailler sur ses éléments internes.

Noter: Les compréhensions de liste ont le même effet que la méthode map dans d'autres langues. Ils suivent le notation de constructeur d'ensemble mathématique plutôt que de mapper et filtrer les fonctions en Python.

13. Quels sont les types de données intégrés courants dans Python ?

Il existe plusieurs types de données intégrés dans Python. Bien que Python n'exige pas que les types de données soient définis explicitement lors des déclarations de variables, des erreurs de type sont susceptibles de se produire si la connaissance des types de données et leur compatibilité les uns avec les autres sont négligées. Python fournit des fonctions type() et isinstance() pour vérifier le type de ces variables. Ces types de données peuvent être regroupés dans les catégories suivantes :

  • Aucun Type
    Le mot-clé None représente les valeurs nulles en Python. L'opération d'égalité booléenne peut être effectuée à l'aide de ces objets NoneType.
    Nom du coursLa description
    AucunTypeReprésente le NUL valeurs en Python

  • Types numériques
    Il existe trois types numériques distincts - entiers, nombres à virgule flottante, et nombres complexes. Aditionellement, booléens sont un sous-type d'entiers.
    Nom du coursLa description
    entierStocke les littéraux entiers, y compris les nombres hexadécimaux, octaux et binaires sous forme d'entiers
    flotterStocke les littéraux contenant des valeurs décimales et/ou un signe exposant sous forme de nombres à virgule flottante
    complexeStocke un nombre complexe sous la forme (A + Bj) et possède des attributs : réel et imag
    boolStocke la valeur booléenne (True ou False)
    Noter: La bibliothèque standard comprend également fractions stocker des nombres rationnels et décimal pour stocker des nombres à virgule flottante avec une précision définie par l'utilisateur.

14. Qu'est-ce que lambda en Python ? Pourquoi est-il utilisé ?

  • Affectation de fonctions lambda à une variable
  • Envelopper des fonctions lambda dans une autre fonction

15. Qu'est-ce que pass en Python ?

Le mot-clé pass représente une opération nulle en Python. Il est généralement utilisé dans le but de remplir des blocs de code vides qui peuvent s'exécuter pendant l'exécution mais n'ont pas encore été écrits. Sans le passer dans le code suivant, nous pouvons rencontrer des erreurs lors de l'exécution du code.

16. Comment copier un objet en Python ?

En Python, l'instruction d'affectation ( = opérateur) ne copie pas les objets. Au lieu de cela, il crée une liaison entre l'objet existant et le nom de la variable cible. Pour créer des copies d'un objet en Python, nous devons utiliser le copie module. De plus, il existe deux manières de créer des copies pour l'objet donné en utilisant le copie module -

  • Copie superficielle est une copie au niveau du bit d'un objet. L'objet copié créé possède une copie exacte des valeurs de l'objet d'origine. Si l'une des valeurs est une référence à d'autres objets, seules les adresses de référence de celui-ci sont copiées.
  • Copie profonde copie toutes les valeurs de manière récursive de la source à l'objet cible, c'est-à-dire qu'il duplique même les objets référencés par l'objet source.

17. Quelle est la différence entre xrange et range en Python ?

xrange() et gamme() sont assez similaires en termes de fonctionnalités. Ils génèrent tous les deux une séquence d'entiers, à la seule différence que range() renvoie un liste Python, tandis que xrange() renvoie un objet xrange.

Alors, comment cela fait-il une différence ? C'est certainement le cas, car contrairement à range(), xrange() ne génère pas de liste statique, il crée la valeur à la volée. Cette technique est couramment utilisée avec un type d'objet générateurs et a été qualifié de " céder ".

Rendement est crucial dans les applications où la mémoire est une contrainte. La création d'une liste statique comme dans range() peut entraîner une erreur de mémoire dans de telles conditions, tandis que xrange() peut la gérer de manière optimale en utilisant juste assez de mémoire pour le générateur (beaucoup moins en comparaison).

Noter: xrange a été obsolète à partir de Python 3.x. Maintenant, range fait exactement la même chose que xrange faisait dans Python 2.x, car il était bien mieux d'utiliser xrange() que la fonction range() d'origine dans Python 2.x.

18. Que sont les modules et packages en Python ?

Les packages Python et les modules Python sont deux mécanismes qui permettent programmation modulaire en Python. La modularisation a plusieurs avantages -

  • Simplicité: Travailler sur un seul module vous aide à vous concentrer sur une partie relativement petite du problème à résoudre. Cela rend le développement plus facile et moins sujet aux erreurs.
  • Maintenabilité : Les modules sont conçus pour imposer des limites logiques entre différents domaines de problèmes. S'ils sont écrits d'une manière qui réduit l'interdépendance, il est moins probable que des modifications dans un module puissent avoir un impact sur d'autres parties du programme.
  • Réutilisabilité : Les fonctions définies dans un module peuvent être facilement réutilisées par d'autres parties de l'application.
  • Portée : Les modules définissent généralement un espace de noms, ce qui permet d'éviter toute confusion entre les identifiants d'autres parties du programme.

Modules, en général, sont simplement des fichiers Python avec une extension .py et peuvent avoir un ensemble de fonctions, de classes ou de variables définies et implémentées. Ils peuvent être importés et initialisés une fois à l'aide de l'instruction import. If partial functionality is needed, import the requisite classes or functions using from foo import bar .

Packages allow for hierarchial structuring of the module namespace using dot notation. As, modules help avoid clashes between global variable names, in a similary manner, paquets help avoid clashes between module names.
Creating a package is easy since it makes use of the system's inherent file structure. So just stuff the modules into a folder and there you have it, the folder name as the package name. Importing a module or its contents from this package requires the package name as prefix to the module name joined by a dot.

Noter: You can technically import the package as well, but alas, it doesn't import the modules within the package to the local namespace, thus, it is practically useless.

19. What are global, protected and private attributes in Python?

  • Global variables are public variables that are defined in the global scope. To use the variable in the global scope inside a function, we use the global keyword.
  • Protected attributes are attributes defined with a underscore prefixed to their identifier eg. _sara. They can still be accessed and modified from outside the class they are defined in but a responsible developer should refrain from doing so.
  • Privé attributes are attributes with double underscore prefixed to their identifier eg. __ansh. They cannot be accessed or modified from the outside directly and will result in an AttributeError if such an attempt is made.

20. What is self in Python?

Soi is a keyword in Python used to define an instance or an object of a class. In Python, it is explicity used as the first paramter, unlike in Java where it is optional. It helps in disinguishing between the methods and attributes of a class from its local variables.

21. What is __init__?

__init__ is a contructor method in Python and is automatically called to allocate memory when a new object/instance is created. All classes have a __init__ method associated with them. It helps in distinguishing methods and attributes of a class from local variables.

22. What is break, continue and pass in Python?

Casser The break statement terminates the loop immediately
and the control flows to the statement after the body of the loop.
Continuer The continue statement terminates the current iteration of the statement,
skips the rest of the code in the current iteration and the control flows to the next iteration of the loop.
Passer As explained above, pass keyword in Python is generally used to fill-up empty blocks
and is similar to an empty statement represented by a semi-colon in languages such as Java, C++, Javascript etc.

23. What is pickling and unpickling?

Python library offers a feature - serialization out of the box. Serializing a object refers to transforming it into a format that can be stored, so as to be able to deserialize it later on, to obtain the original object. Here, the cornichon module comes into play.

Décapage
Pickling is the name of the serialization process in Python. Any object in Python can be serialized into a byte stream and dumped as a file in the memory. The process of pickling is compact but pickle objects can be compressed further. Moreover, pickle keeps track of the objects it has serialized and the serialization is portable across versions.
The function used for the above process is pickle.dump() .

Unpickling
Unpickling is the complete inverse of pickling. It deserializes the byte stream to recreate the objects stored in the file, and loads the object to memory.
The function used for the above process is pickle.load() .

Noter: Python has another, more primitive, serialization module called marshall, which exists primarily to support .pyc files in Python and differs significantly from pickle.

24. What are generators in Python?

Generators are functions that return an iterable collection of items, one at a time, in a set manner. Generators, in general, are used to create iterators with a different approach. They employ the use of yield keyword rather than return to return a generator object.
Let's try and build a generator for fibonacci numbers -

25. What is PYTHONPATH in Python?

PYTHONPATH is an environment variable which you can set to add additional directories where Python will look for modules and packages. This is especially useful in maintaining Python libraries that you do not wish to install in the global default location.


You should consider adding a main function to your project. This is usually done through the introduction of:

This allows for me to import your project and not have it automatically execute the game function at the bottom. Increasing re-usability.

1 For instance, It may be the project defaults to "" , but you need to print out " Hi " with the quotes, so print('" Hi "') may be chosen.

In addition to another answer I will add these places to improve (I will not repeat all things from that answer, my answer is just an addition):

1. Code inconsistency

You have several places in your code where your code is inconsistent

Both functions are checking collisions but one returns integer (0/1) and another - boolean (True/False).

For head you convert X*block_size to int (it is unnecessary anyway). For body you don't do it.

I recommend you to always check your code for possible inconsistency.

2. Names inconsistency

I moved it to an another point because it is not about how your code works - it is about how another programmers will read your code.

You use three different namings for direction entity:

Il est loin better to use consistent variable names. If you are using different direction variables, get them names with only one word for directions. Here is the example:

3. Small code improvements

Sometimes you look at your code and think: "Hmmm, it is working but looks not good". Often in these cases you can slightly reorganize your code to make it a bit better :)

This line of code is correct too but it is hard to read:

But it will be far better to read if you will change it to:

or even this (sometimes I use it for really long if's):

You never read size , and Python Lists already know their own length in case you did need it.

You're just duplicating functionality that List already gives you by manually keeping size in sync with the list length.

Separate game logic from screen rendering details

You keep snake coordinates scaled by pixels. This seems to complicate your code everywhere with block_size instead of 1 I suspect it would be easier to keep snake coordinates in units of blocks, and only scale to pixels for drawing purposes.

par exemple. then your outer-wall check could be something like s.head[0] >= bg_width instead of
s.head[0] > bg_width-block_size .

1 is special for integers because it's the difference between > and >=

I like your add_to_tail idea of putting multiple snake segments in the same place initially, so move on future turns actually makes the snake longer on screen. That high-level design might be worthy of a comment.

The other option would be a "future growth" counter that you check (and decrement) every move to decide whether to remove the last tail block. (That's what I was expecting because I hadn't thought of your idea). Your way is more efficient and will still work if you want food to cause multiple segments of growth. You can still do them all when the food is eaten.

Keeping a separate head : I'm not sure this is helping you. Functions that want to look at the first segment can do head = snake_.body[0] .

I don't understand why move needs to do this:

when it looks to me like inserting the modified head as a new first element will already create that condition. So either this is redundant (and confusing), or else it's extra work that you wouldn't need to do if you didn't redundantly keep the head coordinates in 2 places. (Front of the List, and in its own object.)

This should be an enum or integer, not a string. String compares are fairly cheap, but not as cheap as integers. There's no reason that a direction needs to be an arbitrary string when it can take only 1 of 4 possible values. A string isn't making your code any easier to read.

You probably still want the if/elif chain to turn a direction into an x or y offset, but another option for an integer would be a lookup table of [-1, 0] , [1, 0] etc. so you look up the x and y offsets for the given direction and just add them to the head's x and y coordinates without any conditionals.

Or direction could actually être an XY vector, removing the lookup step.

But that might complicate change_dir . Or give you a different implementation: to check for reversing direction: if new_dir + old_dir == [0,0] then you tried to double back. Otherwise you pouvez set dir = new_dir .

I like your design for having the keyboard-input just call change_dir to check the game-logic of that input. That works very cleanly, and would still work if left was defined as [-1, 0] instead of "LEFT" .