One place for hosting & domains

      sous

      Comment utiliser ps, kill et nice pour gérer des processus sous Linux


      Introduction


      Un serveur Linux, tout comme tous les autres ordinateurs que vous connaissez, exécute des applications. L’ordinateur considère cela comme des « processus ».

      Bien que Linux se chargera de la gestion de bas niveau et en coulisses du cycle de vie d’un processus, vous avez besoin de pouvoir interagir avec le système d’exploitation et à le gérer ainsi à un niveau supérieur.

      Dans ce guide, nous allons voir certains des aspects simples de la gestion de processus. Linux vous propose un vaste ensemble d’outils.

      Nous allons voir ces idées sur un Ubuntu 12.04 VPS. Cependant, toute distribution Linux moderne fonctionnera de manière similaire.


      top


      Afin de déterminer quels sont les processus en cours d’exécution sur votre serveur, la façon la plus simple consiste à exécuter la commande top :

      top***
      
      top - 15:14:40 up 46 min, 1 user, load average: 0.00, 0.01, 0.05 Tasks:  56 total,   1 running, 55 sleeping, 0 stopped, 0 zombie Cpu(s): 0.0%us, 0.0%sy,  0.0%ni,100.0%id, 0.0%wa,  0.0%hi,  0.0%si, 0.0%st Mem:   1019600k total,   316576k used,   703024k free, 7652k buffers Swap:        0k total,        0k used,        0k free,   258976k cached   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            1 root      20 0 24188 2120 1300 0.0 0.2   0:00.56 init     2 root 20   0 0 0 0 S 0 0.0 0:00.00 kthreadd     3 root      20 0 0    0 0 S 0.0 0.0 0:00.07 ksoftirqd/0     6 root RT 0 0    0 S  0.0  0.0   0:00.00 migration/0            7 root      RT   0     0 0    0 S  0.0  0.0   0:00.03 watchdog/0             8 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 cpuset                 9 root       0 -20     0    0    0 S  0.0  0.0   0:00.00 khelper               10 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kdevtmpfs
      

      Le premier morceau d’information vous donne les statistiques sur les systèmes, comme la charge du système et le nombre total de tâches.

      Vous pouvez facilement voir qu’il y a 1 processus en cours d’exécution et que 55 processus sont dormants (aka idle/n’utilisant pas les ressources du processeur).

      La partie inférieure comporte les processus en cours d’exécution et leurs statistiques d’utilisation.

      htop


      Vous disposez d’une version améliorée de top, appelée htop, dans les référentiels. Installez-la avec cette commande :

      sudo apt-get install htop
      

      Si nous exécutons la commande htop, l’affichage qui apparaîtra sera plus convivial :

      htop***
      
        Mem[|||||||||||           49/995MB]     Load average: 0.00 0.03 0.05   CPU[                          0.0%]     Tasks: 21, 3 thr; 1 running   Swp[                         0/0 Mo]     Uptime: 00:58:11   PID USER      PRI  NI  VIRT   RES   SHR S CPU% MEM%   TIME+  Command  1259 root       20   0 25660  1880  1368 R  0.0  0.2  0:00.06 htop     1 root       20   0 24188  2120  1300 S  0.0  0.2  0:00.56 /sbin/init   311 root       20   0 17224   636   440 S  0.0  0.1  0:00.07 upstart-udev-brid   314 root       20   0 21592  1280   760 S  0.0  0.1  0:00.06 /sbin/udevd --dae   389 messagebu  20   0 23808   688   444 S  0.0  0.1  0:00.01 dbus-daemon --sys   407 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.02 rsyslogd -c5   408 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   409 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.00 rsyslogd -c5   406 syslog     20   0  243M  1404  1080 S  0.0  0.1  0:00.04 rsyslogd -c5   553 root       20   0 15180   400   204 S  0.0  0.0  0:00.01 upstart-socket-br
      

      Vous pouvez en savoir plus sur la manière d’utiliser top et htop ici.


      top et htop vous offrent tous les deux une belle interface pour visualiser les processus en cours d’exécution, similaire à un gestionnaire de tâches graphique.

      Cependant, ces outils ne sont pas toujours suffisamment flexibles pour couvrir tous les scénarios correctement. Une commande puissante appelée ps est souvent utilisée pour répondre à ces problèmes.

      Lorsque vous appelez une commande sans arguments, la sortie peut manquer d’éclat :

      ps***
      
        PID TTY          TIME CMD  1017 pts/0    00:00:00 bash  1262 pts/0    00:00:00 ps
      

      Cette sortie affiche tous les processus associés à l’utilisateur et la session du terminal actuels. Cela est logique, car nous exécutons actuellement bash et ps avec ce terminal.

      Pour obtenir une image plus complète des processus sur ce système, nous pouvons exécuter ce qui suit :

      ps aux***
      
      USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND root         1  0.0  0.2  24188  2120 ?        Ss   14:28   0:00 /sbin/init root         2  0.0  0.0      0     0 ?        S    14:28   0:00 [kthreadd] root         3  0.0  0.0      0     0 ?        S    14:28   0:00 [ksoftirqd/0] root         6  0.0  0.0      0     0 ?        S    14:28   0:00 [migration/0] root         7  0.0  0.0      0     0 ?        S    14:28   0:00 [watchdog/0] root         8  0.0  0.0      0     0 ?        S<   14:28   0:00 [cpuset] root         9  0.0  0.0      0     0 ?        S<   14:28   0:00 [khelper] . . .
      

      Ces options indiquent à ps d’afficher les processus détenus par tous les utilisateurs (quel que soit le terminal auquel ils sont associés) sous un format convivial pour les utilisateurs.

      Pour avoir une vue en arborescencee, dans laquelle les relations hiérarchiques sont illustrées, nous pouvons exécuter la commande avec les options suivantes :

      ps axjf***
      
       PPID   PID  PGID   SID TTY      TPGID STAT   UID   TIME COMMAND     0     2     0     0 ?           -1 S        0   0:00 [kthreadd]     2     3     0     0 ?           -1 S        0   0:00  _ [ksoftirqd/0]     2     6     0     0 ?           -1 S        0   0:00  _ [migration/0]     2     7     0     0 ?           -1 S        0   0:00  _ [watchdog/0]     2     8     0     0 ?           -1 S<       0   0:00  _ [cpuset]     2     9     0     0 ?           -1 S<       0   0:00  _ [khelper]     2    10     0     0 ?           -1 S        0   0:00  _ [kdevtmpfs]     2    11     0     0 ?           -1 S<       0   0:00  _ [netns] . . .
      

      Comme vous pouvez le voir, le processus kthreadd est montré comme un parent du processus ksoftirqd/0 et les autres.

      Une remarque sur les identifiants de processus


      Dans les systèmes de type Linux et Unix, chaque processus se voit attribuer un process ID ou** PID**. Voici de quelle manière le système d’exploitation identifie et assure le suivi des processus.

      Vous pouvez rapidement obtenir le PID d’un processus en utilisant la commande pgrep :

      pgrep bash***
      
      1017
      

      Cette commande interrogera simplement l’ID du processus et la renverra.

      Le premier processus généré au démarrage, appelé init, se voit attribuer le PID de « 1 ».

      pgrep init***
      
      1
      

      Ce processus est ensuite chargé de générer tout autre processus sur le système. Les processus suivants se voient attribuer des numéros PID plus grands.

      Le parent d’un processus est le processus qui était chargé de le générer. Les processus parent disposent d’un PPID, que vous pouvez voir dans l’en-tête des colonnes dans de nombreuses applications de gestion de processus, dont top, htop et ps.

      Toute communication sur les processus entre l’utilisateur et le système d’exploitation implique, à un moment donné de l’opération, la traduction entre les noms de processus et le PID. C’est pour cette raison que les utilitaires vous indiquent le PID.

      Relations parent-enfant


      La création d’un processus enfant se fait en deux étapes : fork(), qui crée un nouvel espace d’adresse et copie les ressources que le parent possède via une copie-sur-écriture pour les rendre disponibles sur le processus enfant ; et exec(), qui charge un exécutable dans l’espace de l’adresse et l’exécute.

      Dans le cas où un processus enfant meurt avant son parent, l’enfant devient un zombie jusqu’à que le parent collecte les informations le concernant ou indique au noyau qu’il n’a pas besoin de ces informations Les ressources du processus enfant seront ensuite libérées. Cependant, si le processus parent meurt avant l’enfant, l’enfant sera adopté par l’init, bien qu’il puisse également être réattribué à un autre processus.


      Tous les processus de Linux répondent à des signals. Les signaux permettent d’indiquer aux programmes, au niveau du système d’exploitation, de s’arrêter ou de modifier leur comportement.


      La façon la plus courante de transmettre des signaux à un programme consiste à utiliser la commande kill.

      Comme vous pouvez vous y attendre, la fonctionnalité par défaut de cet utilitaire consiste à tenter de tuer un processus :

      <pre>kill <span class=“highlight”>PIDoftarget_process</span></pre>

      Cela envoie le signal TERM au processus. Le signal TERM indique au processus de bien vouloir se terminer. Cela permet au programme d’effectuer des opérations de nettoyage et de s’arrêter en douceur.

      Si le programme se comporte mal et ne se ferme pas lorsque le signal TERM est actionné, nous pouvons escalader le signal en passant le signal KILL :

      <pre>kill -KILL <span class=“highlight”>PIDoftarget_process</span></pre>

      Il s’agit d’un signal spécial que n’est pas envoyé au programme.

      Au lieu de cela, il est envoyé au noyau du système d’exploitation qui interrompt le processus. Vous pouvez l’utiliser pour contourner les programmes qui ignorent les signaux qui leur sont envoyés.

      Chaque signal est associé à un numéro que vous pouvez passer à la place du nom. Par exemple, vous pouvez passer « -15 » au lieu de « -TERM » et « -9 » au lieu de « -KILL ».


      Les signaux ne servent pas uniquement à fermer des programmes. Vous pouvez également les utiliser pour effectuer d’autres actions.

      Par exemple, de nombreux démons redémarrent lorsqu’un signal HUP ou de suspension leur est envoyé Apache est un programme qui fonctionne ainsi.

      <pre>sudo kill -HUP <span class=“highlight”>pidofapache</span></pre>

      La commande ci-dessus poussera Apache à recharger son fichier de configuration et à reprendre le contenu d’utilisation.

      Vous pouvez répertorier tous les signaux que vous pouvez envoyer avec kill en saisissant :

      kill -l***
      
      1) SIGHUP    2) SIGINT   3) SIGQUIT  4) SIGILL   5) SIGTRAP  6) SIGABRT  7) SIGBUS   8) SIGFPE   9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2 13) SIGPIPE 14) SIGALRM 15) SIGTERM . . .
      

      Bien que la façon classique d’envoyer des signaux consiste à utiliser des PIDS, il existe également des méthodes de le faire avec des noms de processus réguliers.

      La commande pkill fonctionne de manière pratiquement de la même manière que kill, mais elle fonctionne plutôt avec le nom d’un processus :

      pkill -9 ping
      

      La commande ci-dessus est l’équivalent de :

      kill -9 `pgrep ping`
      

      Vous pouvez utiliser la commande killall pour envoyer un signal à chaque instance d’un processus donné :

      killall firefox
      

      La commande ci-dessus enverra le signal TERM à chaque instance de firefox en cours d’exécution sur l’ordinateur.


      Il vous arrivera souvent de vouloir ajuster la priorité donnée aux processus dans un environnement de serveur.

      Certains processus peuvent être considérés comme critiques à la mission pour votre situation, tandis que d’autres peuvent être exécutés chaque fois qu’il y aura des ressources restantes.

      Linux contrôle la priorité par le biais d’une valeur appelée niceness.

      Les tâches hautement prioritaires sont considérées comme moins nice, car elles ne partagent pas également les ressources. Les processus faiblement prioritaires sont en revanche nice car ils insistent à prendre seulement des ressources minimales.

      Lorsque nous avons exécuté top au début de l’article, il y avait une colonne nommée « NI ». Il s’agit de la valeur nice du processus :

      top***
      
       Tasks:  56 total,   1 running,  55 sleeping,   0 stopped,   0 zombie Cpu(s):  0.0%us,  0.3%sy,  0.0%ni, 99.7%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st Mem:   1019600k total,   324496k used,   695104k free,     8512k buffers Swap:        0k total,        0k used,        0k free,   264812k cached   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND            1635 root      20   0 17300 1200  920 R  0.3  0.1   0:00.01 top                    1 root      20   0 24188 2120 1300 S  0.0  0.2   0:00.56 init                   2 root      20   0     0    0    0 S  0.0  0.0   0:00.00 kthreadd               3 root      20   0     0    0    0 S  0.0  0.0   0:00.11 ksoftirqd/0
      

      Les valeurs nice peuvent aller de « -19/-20  » (priorité la plus grande) à «19/20» (priorité la plus faible) en fonction du système.

      Pour exécuter un programme avec une certaine nice valeur, nous pouvons utiliser la commande nice :

      <pre>nice -n 15 <span class=“highlight”>commandtoexecute</span></pre>

      Elle fonctionne uniquement au démarrage d’un nouveau programme.

      Pour modifier la valeur nice d’un programme déjà en cours d’exécution, nous utilisons un outil appelé renice :

      <pre>renice 0 <span class=“highlight”>PIDtoprioritize</span></pre>

      Remarque : bien que nice fonctionne avec un nom de commande par nécessité, renice fonctionne en appelant le PID de processus

      Conclusion


      La gestion de processus est un sujet parfois difficile à comprendre pour les nouveaux utilisateurs car les outils utilisés sont différents de leurs homologues graphiques.

      Cependant, les idées sont familières et intuitives et deviennent naturelles avec un peu de pratique. Étant donné que les processus sont impliqués dans toutes les tâches que vous effectuez avec un système informatique, il est essentiel que vous appreniez à les contrôler efficacement.

      <div class=“author”>Par Justin Ellingwood</div>



      Source link

      Comment convertir des types de données sous Python 3


      Introduction

      Sous Python, les data types servent à classer un type de données particulier. Ils permettent également de déterminer les valeurs que vous pouvez attribuer au type en question et les opérations que vous pouvez effectuer sur celui-ci. Au moment de la programmation, vous aurez parfois besoin de convertir des valeurs d’un type à l’autre pour pouvoir manipuler les valeurs différemment. Par exemple, il vous arrivera parfois de devoir concaténer des valeurs numériques avec des chaînes de caractères ou d’ajouter une décimale à des chiffres initialisés comme des valeurs entières.

      Ce tutoriel vous guidera à travers le processus de conversion de types de données, notamment les chiffres, les chaines, les tuples et les listes et vous proposera des exemples qui vous permettront de vous familiariser avec différents cas d’utilisation.

      Conversion des types de chiffres

      Sous Python, il existe deux types de données de chiffre : les entiers et les chiffres à virgule ou décimaux. Lorsque vous travaillez sur le code d’une autre personne, il arrive parfois que vous ayez besoin de convertir un chiffre entier en décimal ou vice versa, ou que vous constatiez que vous avez utilisé un entier alors qu’en réalité vous avez besoin d’un décimal. Python intègre des méthodes qui vous permettent de facilement convertir les entiers en décimaux et les décimaux en entiers.

      Conversion des entiers en décimaux

      La méthode float() de Python vous permettra de convertir les entiers en décimaux. Pour utiliser cette fonction, ajoutez un chiffre entier à l’intérieur des parenthèses :

      float(57)
      

      Dans ce cas, nous allons convertir 57 en 57.0.

      Vous pouvez également l’utiliser avec une variable. Disons que f est égal à 57, puis imprimons le nouveau décimal :

      f = 57
      print(float(f))
      

      Output

      57.0

      En utilisant la fonction float(), nous pouvons convertir les entiers en décimaux.

      Conversion des décimaux en entiers

      Python intègre également une fonction pour convertir les décimaux en entiers : int ().

      La fonction int() fonctionne de la même manière que la fonction float() : vous pouvez ajouter un chiffre à virgule à l’intérieur des parenthèses pour le convertir en entier :

      int(390.8)
      

      Dans ce cas, nous allons convertir 390,8 en 390.

      Vous pouvez également l’utiliser avec des variables. Disons que b est égal à 125,0, et que c est égal à 390,8, puis imprimons les nouveaux décimaux :

      b = 125.0
      c = 390.8
      
      print(int(b))
      print(int(c))
      

      Output

      125 390

      Lorsque vous convertissez des décimaux en entiers avec la fonction int(), Python supprime la décimale et les chiffres restants après la virgule pour créer un entier. Même si nous voulions arrondir 390,8 à 391, Python ne pourrait pas le faire avec la fonction int().

      Numéros convertis par division

      Dans Python 3, les quotients correspondants sont convertis d’entiers en décimaux lorsque vous exécuter division bien que cela ne soit pas possible sous Python 2. Autrement dit, dans Python 3, lorsque vous divisez 5 par 2, vous obtenez un chiffre décimal (2,5) :

      a = 5 / 2
      print(a)
      

      Output

      2.5

      Sous Python 2, étant donné que vous avez à faire à deux entiers, vous obtiendrez un entier à la place : 5 / 2 = 2. Consultez notre tutoriel « Python 2 vs Python 3 : considérations pratiques » pour avoir de plus amples informations sur les différences qui existent entre Python 2 et Python 3.

      Conversion avec des chaînes de caractères

      Une chaine de caractères est une séquence d’un ou plusieurs caractères (lettres, chiffres, symboles). Les chaines de caractères sont une forme de données que l’on trouve couramment dans les programmes informatiques. Il nous arrivera parfois de devoir convertir des chaines de caractères en chiffres ou des chiffres en chaines de caractères, spécialement lorsque nous intégrons des données générées par les utilisateurs.

      Conversion de chiffres en chaînes de caractères

      Nous pouvons convertir des chiffres en chaines de caractères en utilisant la méthode str(). Nous allons transmettre un chiffre ou une variable dans les parenthèses de la méthode. Ensuite, cette valeur numérique sera convertie en une valeur de chaine de caractères.

      Concentrons-nous tout d’abord sur la conversion des entiers. Pour convertir l’entier 12 en une valeur de chaine de caractères, vous pouvez placer 12 dans la méthode str() :

      str(12)
      

      En exécutant str(12) dans le shell interactif de Python avec la commande python dans la fenêtre du terminal, vous obtiendrez le résultat suivant :

      Output

      '12'

      Les guillemets qui entourent le chiffre 12 signifient que le nombre n’est plus un entier mais qu’il est maintenant une valeur de chaine de caractères.

      En combinaison avec des variables, nous pouvons commencer à voir à quel point il peut être intéressant de convertir des entiers en chaines de caractères. Supposons que nous voulions faire un suivi du progrès de la programmation quotidienne d’un utilisateur et que nous saisissions le nombre de lignes de code qu’ils écrivent à la fois. Nous voudrions montrer ce feedback à l’utilisateur et imprimerions les valeurs de chaines de caractères et d’entiers en même temps :

      user = "Sammy"
      lines = 50
      
      print("Congratulations, " + user + "! You just wrote " + lines + " lines of code.")
      

      Lorsque nous exécutons ce code, nous obtenons l’erreur suivante :

      Output

      TypeError: Can't convert 'int' object to str implicitly

      Nous ne sommes pas en mesure de concaténer des chaines de caractères et des entiers dans Python. Nous devrons donc convertir les lines de variables en chaines de caractères :

      user = "Sammy"
      lines = 50
      
      print("Congratulations, " + user + "! You just wrote " + str(lines) + " lines of code.")
      

      Maintenant, lorsque nous exécutons le code, nous obtenons le résultat suivant qui félicite notre utilisateur du progrès qu’il a réalisé :

      Output

      Congratulations, Sammy! You just wrote 50 lines of code.

      Si nous cherchons à convertir un décimal en une chaine de caractères plutôt qu’un entier en chaine de caractères, nous devons suivre les mêmes étapes et le même format. Lorsque nous saisissons un décimal dans la méthode de str(), la valeur de chaine de caractères du décimal sera renvoyée. Nous pouvons utiliser soit la valeur du décimal en elle-même ou une variable :

      print(str(421.034))
      
      f = 5524.53
      print(str(f))
      

      Output

      421.034 5524.53

      Nous pouvons tester si elle est correcte en la concaténant avec une chaine de caractères :

      f = 5524.53
      print("Sammy has " + str(f) + " points.")
      

      Output

      Sammy has 5524.53 points.

      Nous pouvons avoir la certitude que notre décimal a été correctement converti en une chaine de caractères car la concaténation a été effectuée sans erreur.

      Conversion de chaines de caractères en chiffres

      Vous pouvez convertir des chaines de caractères en chiffres en utilisant les méthodes int() et float().

      Si votre chaine de caractères ne dispose pas de décimal, vous voudrez très probablement la convertir en un entier en utilisant la méthode int().

      Utilisons l’exemple de l’utilisateur Sammy qui garde un suivi des lignes de code écrites quotidiennement. Nous souhaiterions éventuellement manipuler ces valeurs avec des calculs afin de fournir des commentaires plus intéressants à l’utilisateur. Cependant, ces valeurs sont actuellement stockées dans des chaines de caractères :

      lines_yesterday = "50"
      lines_today = "108"
      
      lines_more = lines_today - lines_yesterday
      
      print(lines_more)
      

      Output

      TypeError: unsupported operand type(s) for -: 'str' and 'str'

      Étant donné que les deux valeurs numériques ont été stockées dans des chaines de caractères, une erreur nous a été renvoyée. L’opérande - pour les soustractions n’est un opérande valable pour deux valeurs de chaines de caractères.

      Modifions le code pour inclure la méthode int() qui convertira les chaines de caractères en entiers et faisons quelques calculs avec les valeurs qui étaient initialement des chaines de caractères.

      lines_yesterday = "50"
      lines_today = "108"
      
      lines_more = int(lines_today) - int(lines_yesterday)
      
      print(lines_more)
      

      Output

      58

      La variable lines_more est automatiquement un entier et égale à la valeur numérique 58 dans cet exemple.

      Nous pouvons également convertir les chiffres dans l’exemple ci-dessus en valeurs décimales en utilisant la méthode float() à la place de la méthode int(). Au lieu de recevoir le résultat de 58, nous obtiendrons le résultat de 58.0, un chiffre décimal.

      L’utilisateur Sammy gagne des points en valeurs décimales

      total_points = "5524.53"
      new_points = "45.30"
      
      new_total_points = total_points + new_points
      
      print(new_total_points)
      

      Output

      5524.5345.30

      Dans ce cas, il est possible d’utiliser l’opérande + avec deux chaines de caractères, mais il concatène deux chaines de caractères au lieu d’additionner deux valeurs numériques. Notre résultat est donc inhabituel car il se contente juste de placer les deux valeurs l’une à côté de l’autre.

      Nous allons devoir convertir ces chaines de caractères en décimaux avant d’effectuer un calcul avec la méthode float() :

      total_points = "5524.53"
      new_points = "45.30"
      
      new_total_points = float(total_points) + float(new_points)
      
      print(new_total_points)
      

      Output

      5569.83

      Maintenant que nous avons converti les deux chaines de caractères en décimaux, nous obtenons le résultat anticipé qui additionne 45.30 et 5524.53.

      Si nous essayons de convertir une valeur de chaines de caractères avec des décimaux en un entier, nous obtiendrons une erreur :

      f = "54.23"
      print(int(f))
      

      Output

      ValueError: invalid literal for int() with base 10: '54.23'

      Si nous plaçons une valeur décimale dans une chaîne de caractères dans la méthode int(), nous obtiendrons une erreur car elle ne se convertira pas en un entier.

      En effet, en convertissant des chaines de caractères en chiffres, nous pouvons rapidement modifier le type de données avec lequel nous travaillons et effectuer des calculs sur des valeurs numériques qui ont été initialement saisies en tant que chaines de caractères.

      Conversion des tuples en listes

      Vous pouvez utiliser les méthodes list() et tuple() pour convertir les valeurs qui leur ont été transmises en type de données de liste et tuple respectivement. Sous Python :

      • une list est une séquence d’éléments ordonnés et altérables entre crochets [ ].
      • un tuple est une séquence d’éléments immuables et ordonnés entre parenthèses ( ).

      Conversion des tuples

      Commençons par convertir une liste en un tuple. Étant donné qu’il s’agit d’un type de données immuable, la conversion d’une liste en tuple peut permettre une optimisation substantielle aux programmes que nous créons. Lorsque nous utilisons la méthode tuple(), le système renverra la version tuple de la valeur qui lui a été soumise.

      print(tuple(['pull request', 'open source', 'repository', 'branch']))
      

      Output

      ('pull request', 'open source', 'repository', 'branch')

      Nous voyons qu’un tuple est imprimé dans le résultat car les éléments sont maintenant entre parenthèses et non entre crochets.

      Utilisons tuple() avec une variable qui représente une liste :

      sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']
      print(tuple(sea_creatures))
      

      Output

      ('shark', 'cuttlefish', 'squid', 'mantis shrimp')

      À nouveau, nous voyons que la valeur de liste est modifiée en une valeur de tuple, indiquée par les parenthèses. Nous pouvons convertir tout type itérable en tuple, notamment des chaines de caractères :

      print(tuple('Sammy'))
      

      Output

      ('S', 'a', 'm', 'm', 'y')

      Étant donné que nous pouvons itérer des chaines de caractères, nous pouvons les convertir en tuples en utilisant la méthode tuple(). Cependant, en utilisant des types de données qui ne sont pas itérables, comme des entiers et des décimaux, nous obtiendrons une erreur de type :

      print(tuple(5000))
      

      Output

      TypeError: 'int' object is not iterable

      Bien qu’il soit possible de convertir l’entier en une chaîne de caractères et de le convertir ensuite en tuple, comme dans tuple(str(5000)), il est préférable d’opter pour un code lisible plutôt que des conversions compliquées.

      Conversion en listes

      Il est possible de convertir des valeurs, en particulier des tuples, en listes si vous avez besoin d’une version altérable de cette valeur.

      Nous allons utiliser la méthode list() pour convertir le tuple suivant en une liste. Étant donné que la syntaxe de création d’une liste utilise des parenthèses, veillez à bien inclure les parenthèses de la méthode list(), et dans le cas présent de la méthode print() également :

      print(list(('blue coral', 'staghorn coral', 'pillar coral')))
      

      Output

      ['blue coral', 'staghorn coral', 'pillar coral']

      Les crochets signalent qu’une liste a été renvoyée à partir de la valeur du tuple initialement transmise en utilisant la méthode list().

      Pour rendre le code plus lisible, nous pouvons supprimer l’une des paires de parenthèses en utilisant une variable :

      coral = ('blue coral', 'staghorn coral', 'pillar coral')
      list(coral)
      

      Si nous imprimons list(coral), nous obtiendrons le même résultat que celui ci-dessus.

      Tout comme les tuples, vous pouvez convertir des chaines de caractères en listes :

      print(list('shark'))
      

      Output

      ['s', 'h', 'a', 'r', 'k']

      Ici, la chaine de caractères 'shark' a été convertie en une liste, donnant une version altérable de la valeur d’origine.

      Conclusion

      Au cours de ce tutoriel sur Python, vous avez vu comment convertir plusieurs des importants types de données natives en d’autres types de données, en utilisant principalement des méthodes intégrées. Maintenant que vous savez convertir des types de données sous Python, vous disposez d’une plus grande flexibilité pour écrire vos programmes.



      Source link

      Comment lire et configurer les variables d’environnement et de shell sous Linux


      Introduction

      Au cours d’une interaction avec votre serveur via une session shell, shell compile de nombreuses informations pour déterminer son comportement et accéder aux ressources. Certains de ces réglages se font dans les paramètres de configuration, d’autres doivent être saisis par l’utilisateur.

      Le shell assure notamment le suivi de tous ces paramètres et ces détails par le biais d’une zone qu’il gère, appelée environnement. L’environnement est une zone que le shell construit à chaque fois qu’il démarre une session qui contient des variables définissant les propriétés du système.

      Dans ce guide, nous allons voir de quelle manière interagir avec l’environnement, lire ou configurer les variables d’environnement et de shell de manière interactive et via les fichiers de configuration.

      Chaque fois qu’une session shell est lancée, un processus est mis en place pour collecter et rassembler les informations qui devraient être à la disposition du processus shell et de ses processus enfant. Il obtient les données de ces paramètres à partir d’un grand nombre de fichiers et paramètres différents qui se trouvent sur le système.

      L’environnement fournit un moyen par lequel le processus shell peut obtenir ou configurer les paramètres et, à son tour, les transmettre à ses processus enfant.

      L’environnement est implémenté en tant que chaînes qui représentent des paires de valeurs clé. Si la transmission comporte plusieurs valeurs, elles sont généralement séparées par un :. Chaque paire ressemblera généralement à ceci :

      KEY=value1:value2:...
      

      Si la valeur contient un white-space significatif, des guillemets sont utilisés :

      KEY="value with spaces"
      

      Dans ces scénarios, les clés sont des variables. Elles peuvent être de deux types différents : les variables d’environnement ou les variables de shell.

      Les variables d’environnement sont des variables qui sont définies pour le shell en cours d’utilisation et héritées par tous les shells ou processus enfant. Les variables d’environnement servent à transmettre des informations dans les processus qui se déclenchent depuis le shell.

      Les variables de shell sont des variables qui sont exclusivement contenues dans le shell dans lequel elles ont été configurées ou définies. Elles sont couramment utilisées pour garder un suivi des données éphémères, comme le répertoire actuellement utilisé.

      Par convention, ces types de variables sont généralement définis par des majuscules. Cela aide les utilisateurs à distinguer les variables d’environnement dans d’autres contextes.

      Impression des variables de shell et d’environnement

      Chaque session de shell garde une trace de ses propres variables de shell et d’environnement. Nous pouvons y accéder de différentes façons.

      Nous pouvons voir une liste de toutes nos variables d’environnement en utilisant les commandes env ou printenv. Dans leur état par défaut, elles devraient fonctionner exactement de la même manière :

      Output

      SHELL=/bin/bash TERM=xterm USER=demouser LS_COLORS=rs=0:di=01;34:ln=01;36:mh=00:pi=40;33:so=01;35:do=01;35:bd=40;33;01:cd=40;33;01:or=40;31;01:su=37;41:sg=30;43:ca:... MAIL=/var/mail/demouser PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games PWD=/home/demouser LANG=en_US.UTF-8 SHLVL=1 HOME=/home/demouser LOGNAME=demouser LESSOPEN=| /usr/bin/lesspipe %s LESSCLOSE=/usr/bin/lesspipe %s %s _=/usr/bin/printenv

      Ceci est assez typique pour la sortie à la fois de printenv et env. La différence entre les deux commandes ne se voit que dans leur fonctionnalité plus spécifique. Par exemple, avec printenv, vous pouvez demander les valeurs de variables individuelles :

      Output

      /bin/bash

      En revanche, env vous permet de modifier l'environnement dans lequel les programmes s'exécutent en transmettant un ensemble de définitions de variables par le biais d'une commande, de la manière suivante :

      • env VAR1="value" command_to_run command_options

      Étant donné que, comme nous l'avons appris précédemment, les processus enfant héritent généralement des variables d'environnement du processus parent, vous pouvez remplacer les valeurs ou ajouter des variables supplémentaires à l'enfant.

      Comme vous pouvez le constater à partir du résultat de notre commande printenv, de nombreuses variables d'environnement sont configurées par les fichiers et les processus de notre système sans rien à saisir.

      Ces dernières montrent les variables d'environnement, mais comment consulter les variables de shell ?

      Pour cela, vous pouvez utiliser la commande set. Si nous saisissons set sans aucun autre paramètre, nous obtiendrons une liste de toutes les variables de shell, variables d'environnement, variables locales et fonctions de shell :

      Output

      BASH=/bin/bash BASHOPTS=checkwinsize:cmdhist:expand_aliases:extglob:extquote:force_fignore:histappend:interactive_comments:login_shell:progcomp:promptvars:sourcepath BASH_ALIASES=() BASH_ARGC=() BASH_ARGV=() BASH_CMDS=() . . .

      On se retrouve généralement avec une énorme liste. Il est vivement conseillé de les intégrer dans un programme de pagination afin de pouvoir traiter la quantité de résultats obtenus plus facilement :

      La quantité d'informations supplémentaires que nous recevons est quelque peu déroutante. Nous n'avons probablement pas à connaître toutes les fonctions de bash configurées, par exemple.

      Nous pouvons nettoyer le résultat en spécifiant que set devrait s'exécuter en mode POSIX, ce qui n'imprimera pas les fonctions de shell. Nous pouvons l'exécuter dans un sous-shell pour qu'il ne change pas notre environnement actuel :

      Vous obtiendrez ainsi une liste de toutes les variables d'environnement et de shell configurées.

      Nous pouvons tenter de comparer ce résultat avec celui obtenu avec les commandes env ou printenv afin d'obtenir une liste des variables de shell uniquement, mais cela risque d'être imparfait en raison des différentes façons dont ces commandes renverront les informations :

      • comm -23 <(set -o posix; set | sort) <(env | sort)

      Il est probable que la liste contienne encore quelques variables d'environnement, car la commande set déclenche les valeurs citées, tandis que les commandes printenv et env ne citent pas les valeurs des chaînes de caractères.

      Cela devrait vous donner une bonne idée des variables d'environnement et de shell qui se trouvent dans votre session.

      Ces variables sont utilisées pour toute sorte de choses. Elles vous offrent une alternative pour configurer des valeurs persistantes pour la session entre les processus, sans avoir à écrire les modifications sur un fichier.

      Variables d'environnement et de shell communes

      Certaines variables d'environnement et de shell sont très utiles et souvent référencées. Voici quelques variables d'environnement communes que vous allez rencontrer :

      • SHELL : cette variable décrit le shell qui interprétera les commandes que vous saisissez. Dans la plupart des cas, il s'agira de bash par défaut, mais d'autres valeurs peuvent être configurées si vous préférez utiliser d'autres options.
      • TERM : cette variable spécifie le type de terminal à émuler à l'exécution du shell. Il est possible d'émuler différents terminaux de matériel pour différentes exigences d'exploitation. Cependant, de manière générale, vous n'aurez pas à vous soucier de cela.
      • USER : l'utilisateur actuellement connecté.
      • PWD : le répertoire de travail en cours d'exécution.
      • OLDPWD : le précédent répertoire utilisé. Il est conservé par le shell afin de pouvoir revenir au précédent répertoire en exécutant cd-.
      • LS_COLORS : cette variable définit les codes de couleurs qui vous servent à ajouter une couleur aux résultats obtenus avec la commande ls. Elle vous permet de distinguer les différents types de fichiers et donne de plus amples informations à l'utilisateur en un coup d'œil.
      • MAIL : le chemin vers la boîte de réception de l'utilisateur en cours.
      • PATH : une liste des répertoires que le système vérifiera lorsque vous recherchez des commandes. Lorsqu'un utilisateur saisit une commande, le système vérifiera les répertoires dans cet ordre pour l'exécutable.
      • LANG : les paramètres actuels de langue et de localisation, y compris le codage de caractères.
      • HOME : le répertoire d'accueil de l'utilisateur actuellement connecté.
      • _ : la plus récente des précédentes commandes exécutées.

      En plus de ces variables d'environnement, vous verrez souvent les variables de shell suivantes :

      • BASHOPTS : la liste des options qui ont été utilisées lorsque bash a été exécuté. Cette variable peut s'avérer utile pour savoir si l'environnement de shell fonctionne de la manière dont vous le souhaitez.
      • BASH_VERSION : la version de bash en cours d'exécution, dans un format lisible par l'humain.
      • BASH_VERSINFO : la version de bash en cours d'exécution, dans un format lisible par une machine.
      • COLUMNS : le nombre de colonnes larges qui servent à dessiner le résultat à l'écran.
      • DIRSTACK : la pile des répertoires qui sont disponibles avec les commandes pushd et popd.
      • HISTFILESIZE : le nombre de lignes d'historique de commande enregistrées dans un fichier.
      • HISTSIZE : le nombre de lignes d'historique de commandes autorisées en mémoire.
      • HOSTNAME :le nom d'hôte de l'ordinateur du moment.
      • IFS : le séparateur de champ interne utilisé pour séparer les entrées sur la ligne de commande. Un espace est utilisé par défaut.
      • PS1 : la configuration de l'invite de la commande principale. Cette variable sert à définir à quoi ressemble votre invite lorsque vous commencez une session de shell. La variable PS2 permet de déclarer des invites secondaires lorsqu'une commande s'étend sur plusieurs lignes.
      • SHELLOPTS : les options de shell qui peuvent être configurées avec l'option set.
      • UID : l'IUD de l'utilisateur actuellement connecté.

      Configuration des variables de shell et d'environnement

      Pour vous aider à mieux comprendre la différence entre les variables de shell et les variables d'environnement et vous présenter la syntaxe à utiliser pour ces variables, nous allons faire une petite démonstration.

      Création de variables de shell

      Nous allons commencer par configurer une variable de shell dans notre session en cours. Ceci est facile à réaliser, nous n'avons qu'à spécifier un nom et une valeur. Nous allons adhérer à la convention qui consiste à utiliser uniquement des majuscules pour le nom de la variable et à la configurer sur une chaîne simple.

      Ici, nous avons utilisé des guillemets, car la valeur de notre variable contient un espace. De plus, nous avons utilisé des guillemets simples, car le point d'exclamation est un caractère spécial dans le shell bash qui se développe généralement en historique bash si on n'en sort pas ou s'il n'est pas mis entre des guillemets simples.

      Nous disposons maintenant d'une variable de shell. Cette variable est disponible dans notre session en cours, mais elle ne sera pas transmise aux processus enfant.

      Nous pouvons voir cela en recherchant notre nouvelle variable dans le résultat de set :

      Output

      TEST_VAR='Hello World!'

      Nous pouvons vérifier s'il ne s'agit pas d'une variable d'environnement en essayant la même méthode avec printenv :

      Aucun résultat ne devrait être renvoyé.

      Utilisons cela comme une opportunité de présenter un moyen d'accéder à la valeur de toute variable de shell ou d'environnement.

      Output

      Hello World!

      Comme vous pouvez le voir, vous faites référence à la valeur d'une variable en la faisant précéder d'un signe $. Le shell considère que cela signifie qu'il devrait substituer la valeur de la variable lorsqu'il la rencontre.

      Nous disposons donc maintenant d'une variable de shell. Elle ne devrait être transmise à aucun processus enfant. Nous pouvons générer un shell bash new à partir de notre shell actuel pour le démontrer :

      Si nous saisissons bash pour générer un shell enfant, puis tentons d'accéder ensuite au contenu de la variable, aucun résultat ne sera renvoyé. C'est ce à quoi nous nous attendions.

      Revenont à notre shell d'origine en saisissant exit :

      Création de variables d'environnement

      Maintenant, transformons notre variable de shell en variable d'environnement. Pour se faire, il faut exporter la variable. La commande qui permet de le faire se nomme à juste titre :

      Cela permettra de transformer notre variable en variable d'environnement. Nous pouvons vérifier cela en contrôlant à nouveau notre liste d'environnements :

      Output

      TEST_VAR=Hello World!

      Cette fois, notre variable s'affiche. Recommençons notre expérience avec notre shell enfant :

      Output

      Hello World!

      Super ! Notre shell enfant a reçu la variable définie par son parent. Avant de quitter ce shell enfant, essayons d'exporter une autre variable. Nous pouvons configurer les variables d'environnement en une seule étape, comme suit :

      • export NEW_VAR="Testing export"

      Vérifiez qu'elle est bien exportée en tant que variable d'environnement :

      Output

      NEW_VAR=Testing export

      Maintenant, retournons dans notre shell d'origine :

      Voyons si notre nouvelle variable est disponible :

      Aucun résultat n'est renvoyé.

      En effet, les variables d'environnement ne sont transmises qu'aux processus enfant. Il n'existe pas de moyen intégré de configurer les variables d'environnement du shell parent. Ce qui est une bonne chose dans la plupart des cas. Cela empêche également les programmes de modifier l'environnement d'exploitation à partir duquel ils ont été appelés.

      La variable NEW_VAR a été configurée comme une variable d'environnement dans notre shell enfant. Cette variable serait disponible pour elle-même et tous ses shells et processus enfant. Lorsque nous sommes revenus à notre shell principal, cet environnement a été détruit.

      Rétrogradation et annulation des variables

      Notre variable TEST-VAR est toujours définie comme une variable d'environnement. Nous pouvons la reconvertir en une variable de shell en saisissant :

      Il ne s'agit plus d'une variable d'environnement :

      Cependant, il s'agit toujours d'une variable deshell :

      Output

      TEST_VAR='Hello World!'

      Si nous voulons annuler complètement une variable, qu'elle soit de shell ou d'environnement, nous pouvons le faire avec la commande unset :

      Nous pouvons vérifier qu'elle n'est plus configurée :

      Aucun résultat n'est renvoyé car la variable a été annulée.

      Configuration de variables d'environnement à la connexion

      Nous avons déjà mentionné que de nombreux programmes utilisent des variables d'environnement pour décider des spécificités de l'utilisation de ces variables. Nous ne voulons pas avoir à configurer d'importantes variables à chaque fois que nous lançons une nouvelle session shell. Nous avons d'ailleurs déjà vu combien de variables sont déjà configurées lors de la connexion. Alors, de quelle manière créer et configurer des variables automatiquement ?

      Il s'agit en fait d'un problème plus complexe qu'il n'y paraît initialement, en raison des nombreux fichiers de configuration que le shell bash doit lire en fonction de la manière dont il est démarré.

      La différence entre les sessions de shell Login, Non-Login, Interactive et Non-Interactive

      Le shell bash lit différents fichiers de configuration en fonction de la façon dont la session est lancée.

      Il existe une manière de distinguer les différentes sessions qui consiste à établir si le shell est généré comme une session de login ou non-login.

      Un shell de login est une session de shell qui commence par l'authentification de l'utilisateur. Si vous vous connectez à une session via un terminal ou SSH et que vous vous authentifiez, votre session sera considérée comme un shell de login.

      Si vous démarrez une nouvelle session shell à partir de votre session authentifiée, comme nous l'avons fait en appelant la commande bash à partir du terminal, une session shell de non-login sera lancée. Vos données d'authentification ne vous ont pas été demandées lorsque vous avez démarré votre shell enfant.

      On peut également noter une autre distinction qui consiste à déterminer si une session de shell est interactive ou non-interactive.

      Une session shell interactive est une session shell qui est rattachée à un terminal. Une session shell non-interactive est une session qui n'est pas rattachée à une session de terminal.

      Donc, chaque session shell est classée comme étant de login ou non-login et interactive ou non-interactive.

      Une session normale qui commence par SSH est généralement une session shell de login interactive. Un script exécuté à partir de la ligne de commande est généralement exécuté dans une session shell non-interactive et non-login. Une session de terminal peut être une combinaison de ces deux propriétés.

      Que la session soit classée comme un shell de login ou non-login a des implications sur les fichiers à lire pour initialiser la session de shell.

      Une session lancée par comme une session de login lira les détails de configuration tout d'abord à partir du fichier /etc/profile. Ensuite, elle recherchera le premier fichier de configuration de shell de login qui se trouve dans le répertoire d'accueil de l'utilisateur pour obtenir des détails de configuration spécifiques.

      Elle lit le premier fichier qu'elle peut trouver sur ~/.bash_profile, ~/.bash_login et ~/.profile, et ne lit aucun autre fichier.

      En revanche, une session définie comme un shell de non-login lira le fichier /etc/bash.bashrc puis ~/.bashrc spécifique à l'utilisateur pour créer son environnement.

      Les shells non-interactifs lisent la variable d'environnement appelée BASH_ENV et lisent le fichier spécifié pour définir le nouvel environnement.

      Implémentation de variables d'environnement

      Comme vous pouvez le voir, il existe un grand nombre de fichiers différents que nous devrons généralement consulter pour placer nos paramètres.

      Cela permet une grande flexibilité et nous sera d'une grande utilité dans des situations spécifiques, lorsque nous souhaiterons avoir certains paramètres dans un shell de login et d'autres paramètres dans un shell de non-login. Cependant, la plupart du temps nous voudrons avoir les mêmes paramètres dans les deux situations.

      Heureusement, la plupart des distributions Linux configurent les fichiers de configuration de login pour obtenir les fichiers de configuration de non-login. Cela signifie que vous pouvez configurer les variables d'environnement que vous souhaitez avoir dans les deux à l'intérieur des fichiers de configuration de non-login. Ils seront ensuite lus dans les deux scénarios.

      Nous configurerons généralement des variables d'environnement spécifiques à l'utilisateur et souhaiterons que nos réglages soient disponibles dans les deux shells, de login et de non-login. Cela signifie que l'endroit où configurer ces variables se trouve dans le fichier ~/.bashrc.

      Maintenant, ouvrez ce fichier :

      Il est probable qu'il contienne déjà un certain nombre de données. La plupart des définitions ici servent à la configuration des options bash, qui ne sont pas liées à des variables d'environnement. Vous pouvez configurer les variables d'environnement comme vous le feriez avec la ligne de commande suivante :

      Toute nouvelle variable d'environnement peut être ajoutée n'importe où dans le fichier ~/.bashrc tant qu'elle n'est pas placée au milieu d'une autre commande ou pour une boucle. Ensuite, nous pouvons sauvegarder et fermer le fichier. La prochaine fois que vous lancerez une session de shell, la déclaration de votre variable d'environnement sera lue et transmise à l'environnement shell. Vous pouvez forcer votre session actuelle à lire le fichier en saisissant ce qui suit :

      Si vous devez configurer des variables à l'échelle du système, vous devriez éventuellement envisager de les ajouter à /etc/profile, /etc/bash.bashrc, ou /etc/environment.

      Conclusion

      Les variables d'environnement et de shell sont toujours présentes dans votre session shell et peuvent s'avérer très utiles. Il s'agit d'un moyen intéressant pour un processus parent de paramétrer les détails de configuration de ses processus enfant et de configurer des options en-dehors des fichiers.

      Ce qui peut être très avantageux dans des situations spécifiques. Par exemple, certains mécanismes de déploiement dépendent des variables d'environnement pour configurer les données d'authentification. Ceci est utile, car vous n'avez pas besoin de la conserver dans des fichiers qui pourraient être vus par des tiers.

      Il existe de nombreux autres scénarios, plus banals, mais plus courants, dans lesquels vous devrez lire ou modifier l'environnement de votre système. Avec ces outils et ces techniques, vous disposez d'une bonne base pour apporter ces modifications et les utiliser correctement.



      Source link